def _createSessionObject(self, request):
"""Create or update Session object, returning SessionForm/request."""
user = endpoints.get_current_user()
if not user:
raise endpoints.UnauthorizedException("Authorization required")
user_id = getUserId(user)
if not request.websafeConferenceKey:
raise endpoints.BadRequestException("The session must belong to a valid conference.")
c_key = ndb.Key(urlsafe=request.websafeConferenceKey)
conf = c_key.get()
if conf.organizerUserId != user_id:
raise endpoints.UnauthorizedException(
"Only the conference organizer can\
create sessions in this conference."
)
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)[0]
s_key = ndb.Key(Session, s_id, parent=c_key)
data["key"] = s_key
Session(**data).put()
return self._copySessionToForm(s_key.get())
def _createSessionObject(self, request):
"""Create or update Session object, returning SessionForm/request."""
user = endpoints.get_current_user()
if not user:
raise endpoints.UnauthorizedException('Authorization required')
user_id = getUserId(user)
if not request.name:
raise endpoints.BadRequestException("Session 'name' field required")
# copy SessionForm/ProtoRPC Message into dict
data = {field.name: getattr(request, field.name) for field in request.all_fields()}
del data['websafeKey']
# del data['organizerDisplayName']
# add default values for those missing (both data model & outbound Message)
for df in DEFAULTS_SESSION:
if data[df] in (None, []):
data[df] = DEFAULTS_SESSION[df]
setattr(request, df, DEFAULTS_SESSION[df])
# Getting a TEMP conference key for the moment
q = Conference.query()
cons = q.get()
c_key = cons.key
s_id = Session.allocate_ids(size=1, parent=c_key)[0]
s_key = ndb.Key(Session, s_id, parent=c_key)
data['key'] = s_key
Session(**data).put()
return request
def _createSessionObject(self, request):
user = endpoints.get_current_user()
if not user:
raise endpoints.UnauthorizedException('Authorization required')
# copy request's fields to dictionary
data = {field.name: getattr(request, field.name) for field in
request.all_fields()}
# convert date and time strings to corresponding data types
data['date'] = datetime.strptime(data['date'], '%Y-%m-%d').date()
data['time'] = datetime.strptime(data['time'], '%H:%M').time()
c_key = ndb.Key(urlsafe=data['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
# delete extraneous fields
del data['websafeConferenceKey']
del data['websafeSessionKey']
# create Session object based on dictionary data and insert
Session(**data).put()
# set featured speaker
taskqueue.add(params={'speaker': request.speaker},
url='/tasks/set_featured_speaker')
return request
def _createSessionObject(self, request):
"""Create Session Object, returning SessionForm/request"""
user = endpoints.get_current_user()
user_id = getUserId(user)
#copy Session/ProtoRPC Message into dict
data = {field.name: getattr(request, field.name) for field in request.all_fields()}
#copy the websafe key
conf_key = request.confwebsafeKey
data['confwebsafeKey'] = conf_key
#change the date to Date format
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()
if data['duration']:
data['duration'] = float(data['duration'])
#generating session key by the Conference
c_key = ndb.Key(urlsafe=request.confwebsafeKey)
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
del data['sess_key']
#create session.. now
Session(**data).put()
taskqueue.add(params={'speaker': data['speaker'], 'confwebsafeKey': conf_key},
url='/tasks/set_featured_speaker',
method = 'GET')
return self._copySessionToForm(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')
user_id = getUserId(user)
# get existing conference
conf = ndb.Key(urlsafe=request.websafeConferenceKey).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 a create session.')
if not request.name:
raise BadRequestException("Session 'name' field required")
# generate Conference Key based on conference ID and Session
# ID based on Profile key get Conference key from ID
c_key = ndb.Key(Conference, request.websafeConferenceKey)
s_id = Session.allocate_ids(size=1, parent=c_key)[0]
s_key = ndb.Key(Session, s_id, parent=c_key)
# copy SessionForm/ProtoRPC Message into dict
sf = SessionForm()
data = {}
data['key'] = s_key
setattr(sf, 'sessionKey', s_key.urlsafe())
for field in sf.all_fields():
if hasattr(request, field.name):
attribute = getattr(request, field.name)
if field.name == 'date':
try:
datetime.strptime(attribute, "%Y-%m-%d")
except:
raise BadRequestException(
"Session 'date' format is 'yyyy-mm-dd'")
elif field.name == 'startTime':
try:
datetime.strptime(attribute, "%H:%M")
except:
raise BadRequestException(
"Session 'startTime' format is 'hh:mm' (24-hour clock)")
setattr(sf, field.name, attribute)
data[field.name] = attribute
del data["sessionKey"]
Session(**data).put()
taskqueue.add(params={'speaker': data['speaker']},
url='/tasks/update_featured_speaker')
return sf
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 _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")
user_id = getUserId(user)
if not request.sessionName:
raise endpoints.BadRequestException("Session 'name' field required")
# update existing conference
conf = ndb.Key(urlsafe=request.websafeConferenceKey).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.")
data = {field.name: getattr(request, field.name) for field in request.all_fields()}
wsck = data["websafeConferenceKey"]
p_key = ndb.Key(Conference, request.websafeConferenceKey)
c_id = Session.allocate_ids(size=1, parent=p_key)[0]
c_key = ndb.Key(Session, c_id, parent=p_key)
data["startTime"] = datetime.strptime(data["startTime"], "%H:%M:%S").time()
data["date"] = datetime.strptime(data["date"], "%Y-%m-%d").date()
data["key"] = c_key
data["websafeConferenceKey"] = request.websafeConferenceKey
speaker_name = data["speaker"]
# Query sessions by speaker and get all of the ones that are currently in the datastore and add them
# to the memcache
sessions_by_speaker = Session.query(
ndb.AND(Session.speaker == speaker_name, Session.websafeConferenceKey == request.websafeConferenceKey)
).fetch()
speaker_sessions = []
speaker_sessions = FEATURED_SPEAKER.format(
speaker_name, ",".join([session.sessionName for session in sessions_by_speaker])
)
print speaker_sessions
if len(sessions_by_speaker) >= 1:
# add the speaker and the sessions they are in into the memcache
self._speaker_to_memcache(speaker_sessions)
else:
print "this speaker has 0 sessions"
# add the new session data to datastore
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')
user_id = getUserId(user)
if not request.name:
raise endpoints.BadRequestException("Session 'name' field required")
# copy SessionForm/ProtoRPC Message into dict
data = {field.name: getattr(request, field.name) for field in request.all_fields()}
del data['websafeKey']
del data['websafeConferenceKey']
# convert dates/times from strings to Date/Time objects;
if data['duration']:
data['duration'] = datetime.strptime(data['duration'][:5], "%H:%M").time()
if data['date']:
data['date'] = datetime.strptime(data['date'][:10], "%Y-%m-%d").date()
if data['start']:
data['start'] = datetime.strptime(data['start'][:5], "%H:%M").time()
# generate Profile Key based on user ID and Session
# ID based on Profile key get Session 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
# creation of Session & return (modified) SessionForm
Session(**data).put()
return self._copySessionToForm(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')
user_id = getUserId(user)
if not request.name:
raise endpoints.BadRequestException("Session'name' field required")
# fetch and check conference
conf = ndb.Key(urlsafe=request.websafeConferenceKey).get()
# check that conference exists
if not conf:
raise endpoints.NotFoundException(
'Conference not found for key: %s' % request.websafeConferenceKey)
# check that user is owner
if user_id != conf.organizerUserId:
raise endpoints.ForbiddenException(
'You need to be the owner to add sessions.')
# copy SessionForm/ProtoRPC Message into dict
data = {field.name: getattr(request, field.name) for field in request.all_fields()}
# convert dates 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 object (date-independent)
if data['startTime']:
data['startTime'] = datetime.strptime(data['startTime'][:5], "%H:%M").time()
# make session key from conf key
p_key = conf.key
# allocate new session id with conf
s_id = Session.allocate_ids(size=1, parent=p_key)[0]
s_key = ndb.Key(Session, s_id, parent=p_key)
data['key'] = s_key
data['organizerUserId'] = user_id
del data['websafeConferenceKey']
del data['websafeKey']
Session(**data).put()
# Add to the task queue a task for setting cache
# Task will check if speaker is in more than one session
# If yes, will cache results
taskqueue.add(
params={
'confKey': p_key,
'speaker': data['speaker']
},
url='/tasks/set_featured_speaker'
)
return request
def _createSessionObject(self, request):
"""Create Session object from request and store in datastore."""
# Check that user logged in
user = endpoints.get_current_user()
if not user:
raise endpoints.UnauthorizedException('Authorization required')
user_id = getUserId(user)
# Get conference
urlkey = request.websafeConferenceKey
conf_key = ndb.Key(urlsafe=urlkey)
conf = conf_key.get()
# Check that conference exists
if not conf:
raise endpoints.NotFoundException(
'No conference found with key: %s' % urlkey)
# Check that logged in user is organizer
if user_id != conf.organizerUserId:
raise endpoints.ForbiddenException(
'Only the organizer can add sessions to the conference.')
# Every session must have a name
if not request.name:
raise endpoints.BadRequestException("Session 'name' field required")
# Copy SessionForm/ProtoRPC Message into dictionary
data = {field.name: getattr(request, field.name) for field in request.all_fields()}
# Prepare all data for SessionForm
del data['websafeConferenceKey']
del data['websafeKey']
del data['organizerDisplayName']
data['organizerUserId'] = user_id
# Convert dates from strings to DateTime objects
if data['date']:
data['date'] = datetime.strptime(data['date'][:10], "%Y-%m-%d").date()
# Convert time from strings to DateTime objects
if data['startTime']:
data['startTime'] = datetime.strptime(data['startTime'],"%H:%M:%S").time()
# Generate session id
session_id = Session.allocate_ids(size=1, parent=conf_key)[0]
# Generate session key with conference key as parent
session_key = ndb.Key(Session, session_id, parent=conf_key)
data['key'] = session_key
# Write to datastore
Session(**data).put()
# Make announcement for featured speaker via task queue.
speaker = data['speaker']
taskqueue.add(params={'speaker': speaker, 'websafeConferenceKey': urlkey}, url='/tasks/set_session_announcement')
return self._copySessionToForm(session_key.get())
def parseSession(self, request):
"""Parse a request into a Session and return it"""
# preload necessary data items
conferenceKey = request.websafeConferenceKey
conference = ndb.Key(urlsafe=conferenceKey).get()
if not conference:
raise endpoints.BadRequestException("Conference does not exist")
# copy SessionForm/ProtoRPC Message into dict
data = {field.name: getattr(request, field.name) for field in request.all_fields()}
del data['websafeKey']
del data['websafeConferenceKey']
# add default values for those missing (both data model & outbound Message)
for sessionDefault in SESSION_DEFAULTS:
if data[sessionDefault] in (None, []):
data[sessionDefault] = SESSION_DEFAULTS[sessionDefault]
setattr(request, sessionDefault, SESSION_DEFAULTS[sessionDefault])
# 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").date()
if data['time']:
data['time'] = datetime.strptime(data['time'][:5], "%H:%M").time()
# generate a session ID based on the parent conference
sessionId = Session.allocate_ids(size=1, parent=conference.key)[0]
# create a session key
sessionKey = ndb.Key(Session, sessionId, parent=conference.key)
data['key'] = sessionKey
data['conferenceId'] = conference.key.id()
session = Session(**data)
return session
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 _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")
# get and check conference
conf = ndb.Key(urlsafe=request.websafeConferenceKey).get()
if not conf:
raise endpoints.NotFoundException(
'No Conference found with key: %s' %
request.websafeConferenceKey)
# check that user owns conference
if user_id != conf.organizerUserId:
raise endpoints.ForbiddenException(
'Only the user can add sessions.')
# copy SessionForm/ProtoRPC Message into dict
data = {
field.name: getattr(request, field.name)
for field in request.all_fields()
}
del data['websafeKey']
del data['websafeConferenceKey']
# convert date from strings to Date object
if data['date']:
data['date'] = datetime.strptime(data['date'][:10],
"%Y-%m-%d").date()
# convert time from string to Time object
if data['startTime']:
data['startTime'] = datetime.strptime(data['startTime'][:5],
"%H-%M").time()
# generate Conference key based on Conference ID and Session
# ID based on Conference key get Session Key from ID
p_key = ndb.Key(Conference, conf.key.id())
c_id = Session.allocate_ids(size=1, parent=p_key)[0]
c_key = ndb.Key(Session, c_id, parent=p_key)
data['key'] = c_key
data['organizerUserId'] = user_id
Session(**data).put()
# check if speaker has other sessions; if so, add to memcache
sessions = Session.query(Session.speaker == data['speaker'],
ancestor=p_key)
if len(list(sessions)) > 1:
taskqueue.add(params={'speaker': data['speaker']},
url='/tasks/set_featured_speaker')
return request
def _createSessionObject(self, request):
"""Create Session object, return SessionForm/request."""
user = endpoints.get_current_user()
# check if logged on user - error if not
if not user:
raise endpoints.UnauthorizedException('Authorization required')
user_id = getUserId(user)
# ensure session has a name (name is a required field)
# return error if not
if not request.name:
raise endpoints.BadRequestException("Session 'name' field required (createSessionObject)")
# assign websafe conference key to variable to pass to task queue
wsck = request.websafeConferenceKey
# get the conference and conference key
conf = ndb.Key(urlsafe=wsck).get()
c_key = ndb.Key(urlsafe=request.websafeConferenceKey)
# copy ConferenceForm/ProtoRPC Message into dict
data = {field.name: getattr(request, field.name) for field in request.all_fields()}
del data['websafeConferenceKey']
del data['websafeKey']
# 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])
# assign data with to form to pass back
sf = SessionForm(**data)
# convert dates from strings to Date objects; set month based on start_date
if data['sessDate']:
data['sessDate'] = datetime.strptime(data['sessDate'][:10], "%Y-%m-%d").date()
if data['startTime']:
data['startTime'] = datetime.strptime(data['startTime'], "%H:%M").time()
# test that the current user is authorized to create sessions for this conference
if conf.organizerUserId != user_id:
raise endpoints.UnauthorizedException("Only the conference creator can add sessions.")
# create session id and session key
s_id = Session.allocate_ids(size=1, parent=c_key)[0]
s_key = ndb.Key(Session, s_id, parent=c_key)
data['key'] = s_key
# create Session
Session(**data).put()
# use queue to determine featured speaker
# sessions = Session.query(ancestor=c_key)
# push task to determine conference featured speaker
# pass this sessions speaker and conferences websafeConference key
# to handler DetermineFeaturedSpeakerHandler in main.py
taskqueue.add(params={'speaker': data['speaker'],
'wsck': wsck},
url='/tasks/determine_feature_speaker',method='GET'
)
# return (modified) SessionForm
return sf
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 _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 _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 createSession(self, request):
"""Create new session for a given conference"""
# get user id + auth check
user_id = self._getUserId()
# check for required fields
if not request.name:
raise endpoints.BadRequestException(
"Session 'name' field required")
if not request.date:
raise endpoints.BadRequestException(
"Session 'date' field required")
if not request.startTime:
raise endpoints.BadRequestException(
"Session 'startTime' field required")
# get the conference key using websafeConferenceKey
confKey, conf = ConferenceApi._getKeyAndEntityFromWebsafeKeyOfType(
request.websafeConferenceKey, Conference)
# check that user is session creator is also the creator of the conference
if user_id != conf.organizerUserId:
raise endpoints.ForbiddenException(
'Only creator of the conference can add sessions to it')
# check that speaker keys are valid
for speakerWebsafeKey in request.speakerKeys:
speakerKey, speaker = ConferenceApi._getKeyAndEntityFromWebsafeKeyOfType(
speakerWebsafeKey, Speaker)
# start building a data dictionary
data = {}
data['name'] = request.name
data['highlights'] = request.highlights
data['speakerKeys'] = request.speakerKeys
data['duration'] = request.duration
data['typeOfSession'] = request.typeOfSession.name
data['date'] = datetime.strptime(request.date[:10], '%Y-%m-%d').date()
data['startTime'] = datetime.strptime(
str(request.startTime)[:4], '%H%M').time()
# create a custom unique key, with the conference key as ancestor
s_id = Session.allocate_ids(size=1, parent=confKey)[0]
s_key = ndb.Key(Session, s_id, parent=confKey)
data['key'] = s_key
# write session object to datastore
session = Session(**data)
session.put()
# trigger a task to update featured speaker
taskqueue.add(params={
'websafeConferenceKey': request.websafeConferenceKey,
'websafeSpeakerKeys': '&'.join(request.speakerKeys)
},
url='/tasks/update_featured_speaker')
# return SessionForm
return self._copySessionToForm(session)
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')
user_id = getUserId(user)
if not request.name:
raise endpoints.BadRequestException('Sesssion "name" field required')
if not request.speaker:
raise endpoints.BadRequestException('Speaker field is required')
# get and check for conference
conference = ndb.Key(urlsafe=request.websafeConferenceKey).get()
if not conference:
raise endpoints.NotFoundException(
'No conference found with key: %s'\
% request.websafeConferenceKey)
# check that user is organizer
if user_id != conference.organizerUserId:
raise endpoints.ForbiddenException(
'Only the organizer can add sessions.')
# copy SessionForm/ProtoRPC Message into dict
data = {field.name: getattr(request, field.name) for field in request.all_fields()}
# convert dates 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 object (date-independent)
if data['startTime']:
data['startTime'] = datetime.strptime(data['startTime'][:5], "%H:%M").time()
# generate parent (Conference) Key
parent_key = ndb.Key(urlsafe=request.websafeConferenceKey)
# allocate new child (Sesssion) ID with parent_key as parent
child_id = Session.allocate_ids(size=1, parent=parent_key)[0]
# make child Key from ID
child_key = ndb.Key(Session, child_id, parent=parent_key)
data['key'] = child_key
data['organizerUserId'] = user_id
del data['websafeConferenceKey']
del data['websafeKey']
Session(**data).put()
# Add Task queue. Query for Sessions for speaker and ancestory
# key will be done on the Task rather than here
taskqueue.add(
params={'speaker': data['speaker'],
'parentKey': str(parent_key.urlsafe())
},
url='/tasks/add_featured_speaker_to_memcache'
)
return request
def _createSessionObject(self, request):
"""Create or update Session object, returning SessionForm/request."""
# Check if user is authorized
user = endpoints.get_current_user()
if not user:
raise endpoints.UnauthorizedException("Authorization required")
user_id = getUserId(user)
# Check if required Form fields have been filled
if not request.name:
raise endpoints.BadRequestException("Session 'name' field required")
# Retrieve the conference Key and check if it exists
websck = request.websafeConferenceKey
conf = ndb.Key(urlsafe=websck).get()
if not conf:
raise endpoints.NotFoundException("No conference found with key: %s" % websck)
# Check that user is owner of conference
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()}
sess = self._copySessionToForm(request)
del data["websafeConferenceKey"]
del data["websafeSessionKey"]
# 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 and times from strings to Date and Time objects; set month based on start_date
if data["date"]:
data["date"] = datetime.strptime(data["date"][:10], "%Y-%m-%d").date()
if data["duration"]:
data["duration"] = datetime.strptime(data["duration"][:5], "%H:%M").time()
if data["startTime"]:
data["startTime"] = datetime.strptime(data["startTime"][:5], "%H:%M").time()
# Generate Session Key from obtained Conference key
s_id = Session.allocate_ids(size=1, parent=ndb.Key(urlsafe=request.websafeConferenceKey))[0]
s_key = ndb.Key(Session, s_id, parent=ndb.Key(urlsafe=request.websafeConferenceKey))
data["key"] = s_key
# Create Session
Session(**data).put()
# Add to task queue parameters needed to determine featured speaker
taskqueue.add(
params={"speaker": data["speaker"], "websafeConferenceKey": websck}, url="/tasks/determine_featured_speaker"
)
# Return (modified) SessionForm
return sess
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')
user_id = getUserId(user)
if not request.name:
raise endpoints.BadRequestException(
"Session 'name' field required")
# get existing conference
conf = ndb.Key(urlsafe=request.websafeConferenceKey).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 create a conference's session.")
# copy ConferenceForm/ProtoRPC Message into dict
data = {
field.name: getattr(request, field.name)
for field in request.all_fields()
}
del data['websafeConferenceKey']
# 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 dates from strings to Date objects
if data['sessionDate']:
data['sessionDate'] = datetime.strptime(data['sessionDate'][:10],
"%Y-%m-%d").date()
# generate Conference Key based on conference ID and Session
# ID based on Conference key get Session key from ID
c_key = conf.key
s_id = Session.allocate_ids(size=1, parent=c_key)[0]
s_key = ndb.Key(Session, s_id, parent=c_key)
data['key'] = s_key
#data['conferenceId'] = conf.key.id()
# create Session
Session(**data).put()
taskqueue.add(params={
'speaker': data['speaker'],
'websafeConferenceKey': request.websafeConferenceKey
},
url='/tasks/set_featured_speaker')
return self._copySessionToForm(s_key.get())
def _createSessionObject(self, request):
"""Create or update Session object, returning SessionForm/request."""
# Get current user.
user = endpoints.get_current_user()
# If there isn't one, raise an authorization exception.
if not user:
raise endpoints.UnauthorizedException('Authorization required')
# Set user id using getUserId
user_id = getUserId(user)
# Make sure a name is present
if not request.name:
raise endpoints.BadRequestException("Session 'name' field required")
# Make sure websafeConferenceKey is present
if not request.websafeConferenceKey:
raise endpoints.BadRequestException("Session 'websafeConferenceKey' field required")
# Get websafeConferenceKey
conf = ndb.Key(urlsafe=request.websafeConferenceKey).get()
# Check 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()}
del data['websafeKey']
del data['websafeConferenceKey']
del data['conferenceName']
# Add default values for those missing
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
if data['date']:
data['date'] = datetime.strptime(data['date'][:10], "%Y-%m-%d").date()
if data['startTime']:
data['startTime'] = datetime.strptime(data['startTime'][:5], "%H:%M").time()
# Generate keys for Session.
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
# creation of Session & return (modified) SessionForm
Session(**data).put()
sessions = Session.query(Session.speaker == data['speaker']).count()
if sessions > 1:
taskqueue.add(params={'speaker': data['speaker']}, url='/tasks/set_featured_speaker')
# send request over to form.
return self._copySessionToForm(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')
user_id = getUserId(user)
if not request.sessionName:
raise endpoints.BadRequestException("Session 'name' field required")
# update existing conference
conf = ndb.Key(urlsafe=request.websafeConferenceKey).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.')
data = {field.name: getattr(request, field.name) for field in request.all_fields()}
wsck = data['websafeConferenceKey']
p_key = ndb.Key(Conference, request.websafeConferenceKey)
c_id = Session.allocate_ids(size=1, parent=p_key)[0]
c_key = ndb.Key(Session, c_id, parent=p_key)
data['startTime']= datetime.strptime(data['startTime'], '%H:%M:%S').time()
data['date']= datetime.strptime(data['date'], '%Y-%m-%d').date()
data['key'] = c_key
data['websafeConferenceKey'] = request.websafeConferenceKey
speaker_name = data['speaker']
#Query sessions by speaker and get all of the ones that are currently in the datastore and add them
#to the memcache
sessions_by_speaker = Session.query(ndb.AND(Session.speaker == speaker_name, Session.websafeConferenceKey == request.websafeConferenceKey)).fetch()
speaker_sessions = []
speaker_sessions = FEATURED_SPEAKER.format(speaker_name, ','.join([session.sessionName for session in sessions_by_speaker]))
print speaker_sessions
if len(sessions_by_speaker) >= 1:
#add the speaker and the sessions they are in into the memcache
self._speaker_to_memcache(speaker_sessions)
else:
print "this speaker has 0 sessions"
#add the new session data to datastore
Session(**data).put()
return request
def _createSessionObject(self, request):
"""Create Session Object, w/ createSession method returns the request ."""
#get the current user logged in
user = endpoints.get_current_user()
#if there is not a user logged in currently
if not user:
#advise auth is requried to proceed
raise endpoints.UnauthorizedException('User Authorization required')
#-----user exists--------
#get user id from user object
user_id = getUserId(user)
#if the name field has not been filled
if not request.name:
raise endpoints.BadRequestException("The session field 'name' is required")
#if the websafe conference field has not been filled
if not request.websafeConferenceKey:
raise endpoints.BadRequestException("The session field 'websafeConferenceKey' is required")
#get the conference assosiated with the provided websafeconferencekey
conf = ndb.Key(urlsafe=request.websafeConferenceKey).get()
#if the conference is not found given the provided websafeconferencekey
if not conf:
raise endpoints.NotFoundException(
"A conference could not be found with the conference key: %s" % request.websafeConferenceKey)
#if the user who is logged in is not the origional creater of the conference
if user_id != conf.organizerUserId:
raise endpoints.ForbiddenException(
"The maker of the conference is the only one that can update it.")
#get the field data from the request
data = {field.name: getattr(request, field.name) for field in request.all_fields()}
del data['websafeKey']
del data['websafeConferenceKey']
del data['conferenceName']
for df in SESSION_DEFAULTS:
if data[df] in (None, []):
data[df] = SESSION_DEFAULTS[df]
setattr(request, df, SESSION_DEFAULTS[df])
#if the session has a date format it.
if data['date']:
data['date'] = datetime.strptime(data['date'][:10], "%Y-%m-%d").date()
#if the session has a start time format it.
if data['startTime']:
data['startTime'] = datetime.strptime(data['startTime'][:5], "%H:%M").time()
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
Session(**data).put()
#get the number of speakers
#sessions = Session.query(Session.speaker == data['speaker']).count()
#if there is more than one speaker set the featured
#if sessions > 1:
taskqueue.add(params={'speaker': data['speaker'], 'websafeConferencekey': c_key}, url='/tasks/set_featured_speaker')
#return self._copySessionToForm(request)
return self._copySessionToForm(s_key.get())
def _createSessionObject(self, request):
"""Create or update a Session object, returning SessionForm/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.sessionName:
raise endpoints.BadRequestException("Session 'name' field required")
if not request.websafeConferenceKey:
raise endpoints.BadRequestException("Session 'conference key' field required")
# copy SessionForm/ProtoRPC Message into dict
data = {field.name: getattr(request, field.name) for field in request.all_fields()}
del data['websafeKey']
del data['websafeConferenceKey']
# retrieve parent conference
conf = ndb.Key(urlsafe=request.websafeConferenceKey).get()
# if current user is not the Conference creator, raise an exception
if user_id != conf.organizerUserId:
raise endpoints.ForbiddenException(
'Only the owner can create sessions on the conference.')
# convert dates from strings to Date objects
if data['date']:
try:
data['date'] = datetime.strptime(data['date'][:10], "%Y-%m-%d").date()
except ValueError as e:
raise endpoints.BadRequestException(str(e))
if data['startTime']:
try:
data['startTime'] = datetime.strptime(data['startTime'][:5], "%H:%M").time()
except ValueError as e:
raise endpoints.BadRequestException(str(e))
# Adjust session type enum field
if data['typeOfSession']:
data['typeOfSession'] = str(data['typeOfSession'])
else:
data['typeOfSession'] = 'NOT_SPECIFIED'
# use the Conference websafe key as parent key for the session
p_key = ndb.Key(urlsafe=request.websafeConferenceKey)
s_id = Session.allocate_ids(size=1, parent=p_key)[0]
s_key = ndb.Key(Session, s_id, parent=p_key)
data['key'] = s_key
# create Session, check if speaker should be featured
Session(**data).put()
taskqueue.add(params={'speaker': data['speaker'],
'conferenceKey': request.websafeConferenceKey},
url='/tasks/set_featured_speaker'
)
return BooleanMessage(data=True)
def _createSessionObject(self, request):
"""Create or update Session object, returning SessionForm/request."""
# verify if the user is authorized
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")
# verify if the conference exists
conf = ndb.Key(urlsafe=request.websafeConferenceKey).get()
if not conf:
raise endpoints.NotFoundException(
'No conference found with key: %s' % request.websafeConferenceKey)
# verify that user is the organizer
if user_id != conf.organizerUserId:
raise endpoints.ForbiddenException(
'Only the organizer can add sessions to this conference.')
# copy SessionForm/ProtoRPC Message into dict
data = {field.name: getattr(request, field.name) for field in request.all_fields()}
# convert date from string to Date object
if data['date']:
data['date'] = datetime.strptime(data['date'][:10], "%Y-%m-%d").date()
# convert time from string to Time object
if data['startTime']:
data['startTime'] = datetime.strptime(data['startTime'][:5], "%H:%M").time()
# generate Conference Key based on user ID and Conference
# ID based on Conference key get Conference key from ID
p_key = ndb.Key(Conference, conf.key.id())
c_id = Session.allocate_ids(size=1, parent=p_key)[0]
c_key = ndb.Key(Session, c_id, parent=p_key)
data['key'] = c_key
data['organizerUserId'] = user_id
del data['websafeConferenceKey']
del data['websafeKey']
# create Session, send email to organizer confirming
# creation of Session & return (modified) SessionForm
Session(**data).put()
# Broadcast a featured speaker through a memcache
sessions = Session.query(Session.speaker == data['speaker'], ancestor=p_key)
if len(list(sessions)) > 1:
cache_data = {}
cache_data['speaker'] = data['speaker']
cache_data['sessionNames'] = [session.name for session in sessions]
if not memcache.set(MEMCACHE_FEATURED_SPEAKER_KEY, cache_data):
logging.error('Memcache set failed.')
return request
def _createSessionObject(self, request):
"""Create or update Conference object, returning ConferenceForm/request."""
# load necessary data items
user = endpoints.get_current_user()
if not user:
raise endpoints.UnauthorizedException('Authorization required')
user_id = _getUserId()
if not request.name:
raise endpoints.BadRequestException(
"Session 'name' field required")
# get and check conference
conf = ndb.Key(urlsafe=request.websafeConferenceKey).get()
# check to see if that conference exists
if not conf:
raise endpoints.NotFoundException(
'No conference found with key: %s' %
request.websafeConferenceKey)
# check that user is the owner
if user_id != conf.organizerUserId:
raise endpoints.ForbiddenException(
'Only the owner can add sessions.')
# copy SessionForm/ProtoRPC Message into a dict
data = {
field.name: getattr(request, field.name)
for field in request.all_fields()
}
# convert dates from strings to Dates
if data['date']:
data['date'] = datetime.strptime(data['date'][:10],
"%Y-%m-%d").date()
# convert time from strings to Times
if data['startTime']:
data['startTime'] = datetime.strptime(data['startTime'][:5],
"%H:%M").time()
# make key based off of relationship
p_key = ndb.Key(Conference, conf.key.id())
c_id = Session.allocate_ids(size=1, parent=p_key)[0]
c_key = ndb.Key(Session, c_id, parent=p_key)
data['key'] = c_key
data['organizerUserId'] = user_id
del data['websafeConferenceKey']
del data['websafeKey']
Session(**data).put()
# check if speaker exists in other sections if the do, add to memcache
taskqueue.add(params={'speaker': data['speaker']},
url='/tasks/set_featured_speaker')
# send request over to form.
return self._copySessionToForm(request)
def _createSessionObject(self, request):
"""Create or update Session object, returning SessionForm/request."""
# get Conference object from request; bail if not found
# TODO: change this check to a try-except block
conf = ndb.Key(urlsafe=request.websafeConferenceKey).get()
if not conf:
raise endpoints.NotFoundException(
'No conference found with key: %s' % request.websafeConferenceKey)
# preload necessary data items
user = endpoints.get_current_user()
if not user:
raise endpoints.UnauthorizedException('Authorization required')
user_id = getUserId(user)
# Verify that the user_id belongs to conference organizer group
if not user_id == conf.organizerUserId:
raise endpoints.UnauthorizedException('Only organizer can create session')
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()}
# 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]
try:
data['startTime'] = datetime.strptime(data['startTime'][:10], "%H:%M").time()
except ValueError:
raise endpoints.BadRequestException("Make sure that your start time is in HH:MM format")
# generate Session key with Conference key as parent
p_key = conf.key
s_id = Session.allocate_ids(size=1, parent=p_key)[0]
s_key = ndb.Key(Session, s_id, parent=p_key)
data['key'] = s_key
self._createSessionSpeakerObject(data['speakerName'], data['speakerEmail'])
del data['speakerName']
del data['websafeConferenceKey']
del data['websafeSessionKey']
# create Session, send email to organizer confirming
# creation of Session & return (modified) SessionForm
Session(**data).put()
taskqueue.add(params={'websafeConfKey': request.websafeConferenceKey,
'speakerEmail': data['speakerEmail']},
url='/tasks/featured_speaker'
)
taskqueue.add(params={'email': user.email(),
'sessionInfo': repr(request)},
url='/tasks/send_confirmation_email'
)
return request
def _createSessionObject(self, request):
"""Create Session object for a conference, given the conference key."""
# is the user signed in?
user = endpoints.get_current_user()
if not user:
raise endpoints.UnauthorizedException('Authorization required')
user_id = getUserId(user)
# get Conference object from passed in websafeConferenceKey
conf_key = ndb.Key(urlsafe=request.websafeConferenceKey)
conference = conf_key.get()
# validate conference, user, and session name
if not conference:
raise endpoints.NotFoundException(
'Invalid conference key: %s' % request.websafeConferenceKey)
if user_id != conference.organizerUserId:
raise endpoints.BadRequestException(
'User must be the conference organizer to add a new session.')
if not request.name:
raise endpoints.BadRequestException(
'Session name is required.')
# copy SessionForm message into a dictionary and process it
data = {field.name: getattr(request, field.name)
for field in request.all_fields()}
del data['websafeConferenceKey']
del data['websafeKey']
# 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
if data['date']:
data['date'] = datetime.strptime(data['date'][:10], "%Y-%m-%d").date()
# use sessionType enum field's name string value
if data['sessionType']:
data['sessionType'] = data['sessionType'].name
# create new id and key for session with conf_key as parent
session_id = Session.allocate_ids(size=1, parent=conf_key)[0]
session_key = ndb.Key(Session, session_id, parent=conf_key)
data['key'] = session_key
# put Session in data store
Session(**data).put()
# add a new task to find feature speaker
taskqueue.add(
params={'session': str(session_key.urlsafe())},
url='/tasks/set_featuredSpeaker'
)
# return SessionForm object
return self._copySessionToForm(session_key.get())
def _createSessionObject(self, request):
"""Create or update Session object, returning ConferenceForm/request."""
# get user id
user = endpoints.get_current_user()
if not user:
raise endpoints.UnauthorizedException('Authorization required')
user_id = getUserId(user)
# check to make sure required fields are present
if not request.name:
raise endpoints.BadRequestException("Session 'name' field required")
if not request.conferenceId:
raise endpoints.BadRequestException("Session 'conferenceId' field required")
# check to make sure given conference is an actual conference
conference_key = ndb.Key(urlsafe=request.conferenceId)
if not conference_key:
raise endpoints.NotFoundException(
'No conference found with key: %s' % request.conferenceId)
# check to make sure user is owner of this conference
conference = conference_key.get()
if user_id != conference.organizerUserId:
raise endpoints.ForbiddenException(
'Only the owner can update the conference.')
# copy ConferenceForm/ProtoRPC Message into dict
data = {field.name: getattr(request, field.name) for field in request.all_fields()}
# 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]
# convert dates from strings to DateTime objects
if data['dateTime']:
data['dateTime'] = datetime.strptime(data['dateTime'][:16], "%Y-%m-%dT%H:%M")
# set seatsAvailable to be same as maxAttendees on creation
# it defaults to 0 if not provided in request
data["seatsAvailable"] = data["maxAttendees"]
# generate Session Key based on conference ID and Session
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
# create Session & return (modified) ConferenceForm
newSession = Session(**data)
newSession.put()
# if speaker given, schedule Task to check for Featured Speaker
if data['speakerUserId']:
taskqueue.add(params={'websafeConferenceKey': conference_key.urlsafe(),
'speakerUserId': data['speakerUserId']},
url='/tasks/check_featured_speaker'
)
return self._copySessionToForm(newSession)
def _createSessionObject(self, request, user=None):
"""Create Session object, returning SessionForm/request."""
user_id = getUserId(user)
# get Conference object from request; bail if not found
wck = request.websafeConferenceKey
c_key = ndb.Key(urlsafe=wck)
conf = c_key.get()
if not conf:
raise endpoints.NotFoundException(
'No conference found with key: %s' % wck)
# Check editing authorization. Creater and user match
if user_id != conf.organizerUserId:
raise endpoints.ForbiddenException(
'Only conference creator may add sessions')
if not request.name or not request.date or not request.startTime:
raise endpoints.BadRequestException(
"Session 'name', 'date', and 'startTime' fields required")
# copy SessionForm/ProtoRPC Message into dict
data = {field.name: getattr(request, field.name)
for field in request.all_fields()}
data['conferenceKey'] = wck
data.pop('websafeConferenceKey', None)
data.pop('websafeKey', None)
# convert date/time strings to Date/Time objects
if data['date']:
data['date'] = datetime.strptime(
data['date'][:10], "%Y-%m-%d").date()
if data['startTime']:
data['startTime'] = datetime.strptime(
data['startTime'][:10], "%H:%M").time()
# Check date is within conference date range (if specified)
if conf.startDate and conf.endDate:
if data['date'] < conf.startDate or data['date'] > conf.endDate:
raise endpoints.BadRequestException(
"Session date is not within conference timeframe.")
# generate Session Key based on parent key
s_id = Session.allocate_ids(size=1, parent=c_key)[0]
s_key = ndb.Key(Session, s_id, parent=c_key)
data['key'] = s_key
# create Session & return (modified) SessionForm
sess = Session(**data)
sess.put()
# Send speaker names to taskqueue for processing featured speaker
for speaker in data['speaker']:
taskqueue.add(
url='/tasks/set_featured_speaker',
params={'speaker': speaker, 'websafeConferenceKey': wck}
)
return self._copySessionToForm(sess)
def _createSessionObject(self, request):
"""Create or update _createSessionObject object, returning SessionForm/request."""
# preload necessary data items
user = endpoints.get_current_user()
if not user:
raise endpoints.UnauthorizedException('Authorization required')
#check if authorized
user_id = getUserId(user)
conf = ndb.Key(urlsafe=request.websafeConferenceKey).get()
if conf.organizerUserId != user_id:
raise endpoints.UnauthorizedException('Incorrect Authorization')
if not request.name:
raise endpoints.BadRequestException("Session 'name' field required")
#copy data into a dict
data = {field.name: getattr(request, field.name) for field in request.all_fields()}
del data['websafeConferenceKey']
del data['websafeSessionKey']
if not data['typeOfSession']:
data['typeOfSession'] = str(SessionType.NOT_SPECIFIED)
else:
data['typeOfSession']= str(data['typeOfSession'])
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['date']:
data['date'] = datetime.strptime(data['date'][:10], "%Y-%m-%d").date()
else:
data['date'] = datetime.now()
if data['startTime']:
data['startTime'] = datetime.strptime(data['startTime'], '%I:%M%p').time()
else:
data['startTime'] = datetime.strptime('12:00AM', '%I:%M%p').time()
# generate session Key/ID based on conference key
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()
taskqueue.add(params={'websafeConferenceKey': c_key.urlsafe(),
'speaker_name': data['speaker']},
url='/tasks/set_featured_speaker'
)
print s_key.get();
return self._copySessionToForm(s_key.get())
def _createSessionObject(self, request):
"""Create Session object, returning SessionForm/request."""
# preload necessary data items
user = endpoints.get_current_user()
if not user:
raise endpoints.UnauthorizedException('Authorization required')
user_id = getUserId(user)
# get the conference object user is trying to add a session to
conf = ndb.Key(urlsafe=request.websafeConferenceKey).get()
# check that conference exists
if not conf:
raise endpoints.NotFoundException(
'No conference found with key: %s' % request.websafeConferenceKey)
# check that user is the owner
if user_id != conf.organizerUserId:
raise endpoints.ForbiddenException(
'Only the owner can update the conference.')
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()}
# convert dates and times from strings to date/time objects
if data['date']:
data['date'] = datetime.strptime(data['date'][:10], "%Y-%m-%d").date()
if data['startTime']:
data['startTime'] = datetime.strptime(data['startTime'][:5], "%H:%M").time()
# create session key with ancestor relationship
conf_key = conf.key
session_id = Session.allocate_ids(size=1, parent=conf_key)[0]
session_key = ndb.Key(Session, session_id, parent=conf_key)
data['key'] = session_key
data['websafeSessionKey'] = session_key.urlsafe()
# create Session
Session(**data).put()
# if speaker is defined, check if they qualify as Featured Speaker
if data['speaker']:
taskqueue.add(params={'speaker': data['speaker'],
'websafeConferenceKey': request.websafeConferenceKey},
url='/getFeaturedSpeaker')
return request
def _createSessionObject(self, request):
""" Create Session Object
If a speaker is specified, check validity and add his key to the session
"""
user = endpoints.get_current_user()
if not user:
raise endpoints.UnauthorizedException("Authorization required")
user_id = getUserId(user)
# copy SessionForm/ProtoRPC Message into dict
data = {field.name: getattr(request, field.name) for field in request.all_fields()}
wsck = request.websafeConferenceKey
del data["websafeKey"]
conf_key = ndb.Key(urlsafe=wsck)
conf = conf_key.get()
# check that conference exists
if not conf or conf_key.kind() != "Conference":
raise endpoints.NotFoundException("No conference found with key: %s" % wsck)
# check that user is owner
if user_id != conf.organizerUserId:
raise endpoints.ForbiddenException("Only the owner can update the conference.")
# Create the Session Object from Input
# 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 dates from strings to Date and Time objects respectively
if data["date"]:
data["date"] = datetime.strptime(data["date"][:10], "%Y-%m-%d").date()
if data["startTime"]:
data["startTime"] = datetime.strptime(data["startTime"][:5], "%H:%M").time()
c_key = conf.key
s_id = Session.allocate_ids(size=1, parent=c_key)[0]
s_key = ndb.Key(Session, s_id, parent=c_key)
data["key"] = s_key
# check if speaker is provided and exists
if data["speaker"]:
speaker = self._getSpeaker(data["speaker"])
data["speaker"] = speaker.key
# abort if no speaker
if not speaker:
raise endpoints.NotFoundException("No speaker found with key: %s" % data["speaker"])
# add the task for featured speaker
taskqueue.add(params={"wsck": wsck, "speaker": speaker.fullName}, url="/tasks/featured_speaker")
del data["websafeConferenceKey"]
Session(**data).put()
return self._copySessionToForm(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')
user_id = getUserId(user)
if not request.name:
raise endpoints.BadRequestException("Session 'name' field required")
if not request.websafeConferenceKey:
raise endpoints.BadRequestException("Conference 'websafeConferenceKey' field required")
conf = ndb.Key(urlsafe=request.websafeConferenceKey).get()
if not conf:
raise endpoints.NotFoundException("No conference found for for key: %s" % websafeConferenceKey)
if user_id != conf.organizerUserId:
raise endpoints.ForbiddenException("Only the conference owner can create sessions")
# copy SessionForm/ProtoRPC Message into dict
data = {field.name: getattr(request, field.name) for field in request.all_fields()}
del data['websafeKey']
del data['websafeConferenceKey']
del data['conferenceName']
# add default values for those missing (both data model & outbound Message)
for df in SESSION_DEFAULTS:
if data[df] == 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['date']:
data['date'] = datetime.strptime(data['date'][:10], "%Y-%m-%d").date()
if data['startTime']:
data['startTime'] = datetime.strptime(data['startTime'][:5], "%H:%M").time()
# generate Session Key
# 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
# creation of Session & return SessionForm
Session(**data).put()
# add a new Memcache entry that features the speaker and session names
# if the speaker has more than one session at this conference
taskqueue.add(params={'speaker': data['speaker'],
'c_key': request.websafeConferenceKey},
url='/tasks/set_featured_speaker')
return self._copySessionToForm(request)
def createSession(self, request):
"""Create session in the conference identified by websafeConferenceKey."""
# Get Conference object from request and raise exception if not found
conf = ndb.Key(urlsafe=request.websafeConferenceKey).get()
if not conf:
raise endpoints.NotFoundException(
'No conference found with key: %s' % request.websafeConferenceKey)
if not isinstance(conf, Conference):
raise endpoints.BadRequestException('Key must refer to Conference')
# preload necessary data items
user = endpoints.get_current_user()
if not user:
raise endpoints.UnauthorizedException('Authorization required')
user_id = getUserId(user)
if user_id != conf.organizerUserId:
raise endpoints.UnauthorizedException("Only the user who created the conference can add sessions")
if not request.name:
raise endpoints.BadRequestException("Session 'name' is a required field")
if not request.speaker:
raise endpoints.BadRequestException("Session 'speaker' is a required field")
# Copying SessionForm/ProtoRPC Message into dictionary
# getattr is required to access the values
data = {field.name: getattr(request, field.name) for field in request.all_fields()}
del data['websafeConferenceKey']
del data['websafeKey']
# Parsing date strings to get Date objects
# The month is set based on start date
if data['date']:
data['date'] = datetime.strptime(data['date'][:10], "%Y-%m-%d").date()
else:
data['date'] = conf.startDate
if data['startTime']:
data['startTime'] = datetime.strptime(data['startTime'][:5], "%H:%M").time()
data['typeOfSession'] = str(data['typeOfSession'])
s_id = Session.allocate_ids(size=1, parent=conf.key)[0]
s_key = ndb.Key(Session, s_id, parent=conf.key)
data['key'] = s_key
session = Session(**data)
session.put()
taskqueue.add(params={'speaker': data['speaker'],
'wcsk': request.websafeConferenceKey},
url='/tasks/set_feature_session_announcement'
)
return self._copySessionToForm(session)
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')
user_id = getUserId(user)
if not request.name:
raise endpoints.BadRequestException("Session 'name' field required")
# update existing conference
conf = ndb.Key(urlsafe=request.websafeConferenceKey).get()
# check that conference exists
if not conf:
raise endpoints.NotFoundException(
'No conference found with key: %s' % request.websafeConferenceKey)
if conf.organizerUserId != user_id:
raise endpoints.BadRequestException("Sessions can only be created by the conference organizer.")
# copy SessionForm/ProtoRPC Message into dict
data = {field.name: getattr(request, field.name) for field in request.all_fields()}
# 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])
type_list = ["NOT_SPECIFIED", "Workshop", "Lecture", "Demo", "Seminar", "Debate", "Panel"]
# 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").date()
if data['startTime']:
data['startTime'] = datetime.strptime(data['startTime'][:10], "%H:%M").time()
if data['typeOfSession']:
if data['typeOfSession'] not in type_list:
raise endpoints.BadRequestException(type_of_session_error)
if data['speaker']:
speaker = data['speaker']
# generate conference Key based on websafeconferencekey from request, c_key = websafeConferenceKey might work?
# ID based on conference key, get session 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, send speaker info to task queue for featured speaker announcement
# creation of Session & return (modified) SessionForm
Session(**data).put()
if speaker:
taskqueue.add(params={'speaker': speaker, 'conference_key': request.websafeConferenceKey},
url='/tasks/featured_speaker'
)
sess = s_key.get()
return self._copySessionToForm(sess)
def _createSessionObject(self, request):
"""Create or update Conference object, returning SessionForm/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")
#get cinference key
wsck = request.websafeConferenceKey
# get conference object
c_key = ndb.Key(urlsafe=wsck)
conf = c_key.get()
# check that conference exists or not
if not conf:
raise endpoints.NotFoundException(
'No conference found with key: %s' % wsck)
# check that user is owner
if conf.organizerUserId != getUserId(endpoints.get_current_user()):
raise endpoints.ForbiddenException(
'You must be the organizer to create a session.')
# copy SessionForm/ProtoRPC Message into dict
data = {field.name: getattr(request, field.name) for field in request.all_fields()}
# convert date and time from strings to Date objects;
if data['date']:
data['date'] = datetime.strptime(data['date'][:10], "%Y-%m-%d").date()
if data['startTime']:
data['startTime'] = datetime.strptime(data['startTime'][:10], "%H, %M").time()
# allocate new Session ID with Conference key as parent
s_id = Session.allocate_ids(size=1, parent=c_key)[0]
# make Session key from ID
s_key = ndb.Key(Session, s_id, parent=c_key)
data['key'] = s_key
data['websafeConferenceKey'] = wsck
del data['sessionSafeKey']
# save session into database
Session(**data).put()
# This task wil send a confirmation email to the owner
taskqueue.add(params={'email': user.email(),
'conferenceInfo': repr(request)},
url='/tasks/send_confirmation_session_email'
)
speaker = data['speaker']
taskqueue.add(
url='/tasks/check_featured_speaker',
params={'speaker': speaker, 'websafeConferenceKey': wsck}
)
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')
user_id = getUserId(user)
if not request.name:
raise endpoints.BadRequestException(
"Session 'name' field required")
# copy SessionForm/ProtoRPC Message into dict
data = {
field.name: getattr(request, field.name)
for field in request.all_fields()
if field.name != "websafeConferenceKey"
}
del data['websafeKey']
# 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 dates from strings to Date objects; set month based on Date
if data['Date']:
data['Date'] = datetime.datetime.strptime(data['Date'][:10],
"%Y-%m-%d").date()
# generate key from websafeConferenceKey
p_key = ndb.Key(urlsafe=request.websafeConferenceKey)
# allocate new Session ID with Conference key as parent
c_id = Session.allocate_ids(size=1, parent=p_key)[0]
# make Session key from ID
my_key = ndb.Key(Session, c_id, parent=p_key)
data['key'] = my_key
# create Conference & return (modified) ConferenceForm
Session(**data).put()
#Check if theres more session for this speaker.
featuredSpeaker = Session.query(Session.speaker == data['speaker'])
sessions = [session.name for session in featuredSpeaker]
if sessions:
featureText = data['speaker'] + ': ' + ', '.join(sessions)
#Set in memcache
memcache.set(MEMCACHE_FEATURED_KEY, featureText)
# return sessionform
return self._copySessionToForm(my_key.get())
def _createSessionObject(self, request):
"""Create or update Session object, returning SessionForm/request."""
# Name is a required Field
if not request.name:
raise endpoints.BadRequestException(
"Conference 'name' field required")
# copy SessionForm/ProtoRPC Message into dict
data = {
field.name: getattr(request, field.name)
for field in request.all_fields()
}
logging.info('All fields are in the data dictionary')
query = Conference.query(
Conference._properties['name'] == request.conferenceName).get()
if not query:
raise endpoints.NotFoundException(
"No conference found with this name: %s", data['name'])
conference = query
logging.info('Found conference to add Session to = %s',
conference.name)
logging.info('Websafe conference key is %s', conference.key.urlsafe())
# Put websafe key to the Session, has a relationship with the Conference
data['conferenceKey'] = conference.key.urlsafe()
# conferenceName is not in the Session object it was only needed to
# find the Conference the Session belongs to so delet it and the rest
# of unused fields
del data['conferenceName']
del data['displayName']
# Insert default values for the session
for df in SESSIONDEFAULTS:
if data[df] in (None, []):
data[df] = SESSIONDEFAULTS[df]
setattr(request, df, SESSIONDEFAULTS[df])
session_id = Session.allocate_ids(size=1)[0]
session_key = ndb.Key(Session, session_id)
websafeKey = session_key.urlsafe()
logging.info('The websafe key for this session is: %s', websafeKey)
data['websafeKey'] = websafeKey
conference.sessionKeys.append(websafeKey)
# creation of Session & return (modified) SessionForm
conference.put()
Session(**data).put()
return request
def _createSessionObject(self, request):
"""Create or update Session object, returning ConferenceForm/request."""
# preload necessary data items
user = endpoints.get_current_user()
if not user:
raise endpoints.UnauthorizedException('Authorization required')
user_id = getUserId(user)
if not request.name:
raise endpoints.BadRequestException(
"Conference 'name' field required")
# copy ConferenceForm/ProtoRPC Message into dict
data = {
field.name: getattr(request, field.name)
for field in request.all_fields()
}
del data['websafeKey']
# add default values for those missing (both data model & outbound Message)
# for df in DEFAULTS:
# if data[df] in (None, []):
# data[df] = DEFAULTS[df]
# setattr(request, df, DEFAULTS[df])
# convert dates from strings to Date objects; set month based on start_date
if data['date']:
data['date'] = datetime.strptime(data['date'][:10],
"%Y-%m-%d").date()
if data['startTime']:
data['startTime'] = datetime.strptime(data['startTime'][:5],
"%H:%M").time()
if data['duration']:
data['duration'] = datetime.strptime(data['duration'][:2],
"%H").time()
# generate Profile Key based on user ID and Session
# ID based on Profile key get Session key from ID
p_key = ndb.Key(Profile, user_id)
s_id = Session.allocate_ids(size=1, parent=p_key)[0]
s_key = ndb.Key(Session, s_id, parent=p_key)
data['key'] = s_key
# create Session
Session(**data).put()
return request
def _createSessionObject(self, request):
"""Create Session object, returning SessionForm"""
# User authentication
user = endpoints.get_current_user()
if not user:
raise endpoints.UnauthorizedException('Authorization required')
user_id = getUserId(user)
# get conference object from Datastore
conf = self._getDataStoreObject(request.websafeConferenceKey)
# User Authorization
if user_id != conf.organizerUserId:
raise endpoints.ForbiddenException(
'Only the owner can add session to the conference')
# Copy SessionForm Message into dict
data = {field.name: getattr(request, field.name)
for field in request.all_fields()}
wsck = data['websafeConferenceKey']
del data['websafeKey']
del data['websafeConferenceKey']
# add default values for fields that aren't provided
for df in SESSION_DEFAULTS:
if data[df] in (None, []):
data[df] = SESSION_DEFAULTS[df]
setattr(request, df, SESSION_DEFAULTS[df])
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()
# generate session Key based on conference Key
c_key = conf.key
s_id = Session.allocate_ids(size=1, parent=c_key)[0]
s_key = ndb.Key(Session, s_id, parent=c_key)
data['key'] = s_key
Session(**data).put()
# Run queue to check featured speaker if speaker ID is provided
if data['speakerId']:
speaker = ndb.Key(Speaker, data['speakerId']).get()
if not speaker:
raise endpoints.NotFoundException(
'No speaker found with this id')
taskqueue.add(params={'wsck': wsck, 'speakerId': data['speakerId']},
url='/tasks/check_featured_speaker'
)
return self._copySessionToForm(s_key.get())
def _createSessionObject(self, request):
"""Create Session object, returning SessionForm/request."""
# check auth
user = endpoints.get_current_user()
if not user:
raise endpoints.UnauthorizedException('Authorization required')
# copy SessionForm into dict
data = {
field.name: getattr(request, field.name)
for field in request.all_fields()
}
user_id = getUserId(user)
if not request.name:
raise endpoints.BadRequestException(
"Session 'name' field required")
# add default values for those missing (both data model & outbound Message)
for df in S_DEFAULTS:
if data[df] in (None, []):
data[df] = S_DEFAULTS[df]
setattr(request, df, S_DEFAULTS[df])
# add date and time
if data['startTime']:
data['startTime'] = datetime.strptime(data['startTime'],
"%H:%M").time()
if data['date']:
data['date'] = datetime.strptime(data['date'][:10],
"%Y-%m-%d").date()
# generate session key from conference key
conf = ndb.Key(urlsafe=data['confwebsafeKey']).get()
p_key = conf.key
c_id = Session.allocate_ids(size=1, parent=p_key)[0]
c_key = ndb.Key(Session, c_id, parent=p_key)
data['key'] = c_key
if not data['speaker']:
data['speaker'] = user.nickname()
del data['confwebsafeKey']
# if speaker has at least 2 sessions, add speaker to featured speaker memcache
# The idea for defining the featured speaker and some of the session and wishlist endpoints came from
# app id: weighty-gasket-91618, author unknown
taskqueue.add(params={'speaker': data['speaker']},
url='/tasks/set_featured_speaker')
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')
user_id = getUserId(user)
if not request.name:
raise endpoints.BadRequestException(
"Session 'name' field required")
wsck = request.websafeConferenceKey
conf = ndb.Key(urlsafe=wsck).get()
if (user_id != conf.organizerUserId):
raise endpoints.BadRequestException(
"Not Organizer to create Session")
# copy 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; set month based on start_date
if data['date']:
data['date'] = datetime.strptime(data['date'][:10],
"%Y-%m-%d").date()
if data['start_time']:
data['start_time'] = datetime.strptime(data['start_time'][:10],
"%H:%M").time()
# ID based on Conference key from ID
c_key = conf.key
c_sid = Session.allocate_ids(size=1, parent=c_key)[0]
s_key = ndb.Key(Session, c_sid, parent=c_key)
data['key'] = s_key
data['conf_key'] = wsck
Session(**data).put()
taskqueue.add(params={
'user_name': data['speaker'],
'session_name': data['name']
},
url='/tasks/set_featured_speaker')
return self._copySessionToForm(s_key.get())
def _createSessionObject(self, request):
"""Create Session object, returning SessionForm/request."""
# check user, if no user, raise exception
user = endpoints.get_current_user()
if not user:
raise endpoints.UnauthorizedException('Authorization required')
user_id = getUserId(user)
c_key = validate_conf_key(request.websafeConferenceKey)
conf = c_key.get()
# check that user is owner
if user_id != conf.organizerUserId:
raise endpoints.ForbiddenException(
'Only the owner can create the session.')
if not request.name:
raise endpoints.BadRequestException("Session 'name' field required")
# copy SessionForm/ProtoRPC Message into dict
data = {field.name: getattr(request, field.name) for field in request.all_fields()}
del data['websafeSessionKey']
del data['websafeConferenceKey']
# 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 or time objects;
if data['startDateTime']:
temp = str(data['startDateTime'])
data['startDateTime'] = datetime.strptime(temp, "%Y-%m-%d %H:%M:%S")
else:
# TODO debug code for query testing
data['startDateTime'] = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
# generate Profile Key based on user ID and Session
# ID based on Profile key get Session 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, return (modified) SessionForm
Session(**data).put()
session = s_key.get()
wssk = s_key.urlsafe()
taskqueue.add(params={'sessionKey': wssk,
'speaker': session.speaker},
url='/tasks/set_speaker_announcement'
)
return self._copySessionToForm(session)
def createSessionObject(self, request):
"""Creat the session object"""
#preload necessary data
user = endpoints.get_current_user()
if not user:
raise endpoints.UnauthorizedException('Authorization required')
conf = ndb.Key(urlsafe=request.websafeConferenceKey).get()
user_id = getUserId(user)
#check the user and errors
if conf.organizerUserId != user_id:
raise endpoints.UnauthorizedException(
'Only Orgnizers can start sesssions')
if not request.name:
raise endpoints.BadRequestException(
"Session 'name' required field")
#constructing the data
data = {
field.name: getattr(request, field.name)
for field in request.all_fields()
}
print data['websafeKey']
del data['websafeConferenceKey']
del data['websafeKey']
for df in DEFAULT_SESSION:
if data[df] in (None, []):
data[df] = DEFAULT_SESSION[df]
setattr(request, df, DEFAULT_SESSION[df])
#convert dates from strings to Date object
if data['date']:
data['date'] = datetime.strptime(data['date'], "%m-%d-%Y").date()
if data['startTime']:
data['startTime'] = datetime.strptime(data['startTime'],
"%H:%M:%S").time()
data['confKey'] = request.websafeConferenceKey
p_key = ndb.Key(Profile, user_id)
s_id = Session.allocate_ids(size=1, parent=p_key)[0]
s_key = ndb.Key(Session, s_id, parent=p_key)
data['key'] = s_key
newSession = Session(**data)
data['websafeKey'] = newSession.key.urlsafe()
newSession.put()
# This is for task 4: check whether the speaker is a featured speaker or not
if data['speaker']:
self.checkFeaturedSpeaker(data)
return self._copySessionToForm(s_key.get())
def _createSessionObject(self, request):
"""Allows autheticated users to create a session for a conference"""
# get user logged in
user = endpoints.get_current_user()
if not user:
raise endpoints.UnauthorizedException('Authorization required')
user_id = getUserId(user)
# get conference of request
conf = ndb.Key(urlsafe=request.websafeConferenceKey).get()
# check validity
if not conf:
raise endpoint.NotFoundException("Non-existing conference")
# Check if user is organizer
if user_id != getattr(conf, 'organizerUserId'):
msg = 'Not organizer of conference'
raise endpoints.UnauthorizedException(msg)
if not request.sessionName:
msg = "Session 'name' field required"
raise endpoints.BadRequestException(msg)
data = {field.name: getattr(request, field.name)
for field in request.all_fields()}
# convert date from string to Date object
if data['date']:
dt = datetime.strptime(data['date'][:10], "%Y-%m-%d").date()
data['date'] = dt
# convert start time string to Time object
if data['startTime']:
st = datetime.strptime(data['startTime'][:10], "%H:%M").time()
data['startTime'] = st
conference_id = conf.key.id()
c_key = ndb.Key(Conference, conference_id)
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
del data['websafeConferenceKey']
del data['websafeKey']
# create Session, enqueue check speaker task
Session(**data).put()
taskqueue.add(params={'speaker': data['speaker'],
'wsck': c_key.urlsafe()},
url='/tasks/check_speaker')
return self._copySessionToForm(s_key.get())
def createSession(self, request):
"""Creating new sessions."""
# # first check that user is conference creator
wsck = request.websafeConferenceKey
self._verifyConfCreator(wsck)
# copy SessionForm/ProtoRPC Message into dict, omitting websafe key
data = {
field.name: getattr(request, field.name)
for field in request.all_fields()
}
del data['websafeConferenceKey']
# 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 date/time from strings to Datetime objects;
if data['date']:
data['date'] = datetime.strptime(data['date'][:10],
"%Y-%m-%d").date()
if data['startTime']:
data['startTime'] = datetime.strptime(data['startTime'][:5],
"%H:%M").time()
conf_key = ndb.Key(urlsafe=wsck)
session_id = Session.allocate_ids(size=1, parent=conf_key)[0]
session_key = ndb.Key(Session, session_id, parent=conf_key)
data['key'] = session_key
# check if session speaker has another session in this conference
speaker_sesh = Session.query(Session.speaker == request.speaker,
ancestor=conf_key).get()
if speaker_sesh:
# Yup, FEATURED SPEAKER! trigger task and end loop
taskqueue.add(url='/tasks/set_featured_speaker',
params={
'websafeKey': wsck,
'speaker': request.speaker
})
# create Session in datastore, passing in kwargs
Session(**data).put()
return request
def createSession(self, request):
"""Create 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.speakerId:
raise endpoints.BadRequestException("Session 'speakerId' field required")
c_key = ndb.Key(Conference, request.websafeConferenceKey)
s_id = Session.allocate_ids(size=1, parent=c_key)[0]
s_key = ndb.Key(Session, s_id, parent=c_key)
session = s_key.get()
if not session:
session = Session(
key = s_key,
name = request.name,
speakerId = request.speakerId,
)
if request.highlights:
session.highlights = request.highlights
if request.duration:
session.duration = request.duration
if request.typeOfSession:
session.typeOfSession = request.typeOfSession
if request.date:
session.date = datetime.strptime(request.date, "%Y-%m-%d").date()
if request.startTime:
session.startTime = datetime.strptime(request.startTime, "%H:%M:%S").time()
session.put()
taskqueue.add(params={'confKey': request.websafeConferenceKey, 'sessionKey': session.key.urlsafe(), 'speakerId': request.speakerId},
url='/tasks/set_feature_speaker'
)
return self._copySessionToForm(session)
def _sessionAdd(self, request):
"""Create a Session """
prof = self._getProfileFromUser() # get user Profile
# check if conf exists given websafeConfKey
# get conference; check that it exists
wsck = request.websafeConferenceKey
conf_k = ndb.Key(urlsafe=wsck)
conf = conf_k.get()
if not conf:
raise endpoints.NotFoundException(
'No conference found with key: %s' % wsck)
if prof.mainEmail != conf.organizerUserId:
raise endpoints.NotFoundException(
'Cannont create a sessions from this conference')
# Check for valid time
if 24 < request.startTime or 0 >= request.startTime:
raise endpoints.NotFoundException(
'Invalid time, Please use 24 hour format. e.g 17')
data = {
field.name: getattr(request, field.name)
for field in request.all_fields()
}
del data['websafeConferenceKey']
if not data['typeOfSession']:
data['typeOfSession'] = "NOT_SPECIFIED"
else:
data['typeOfSession'] = data['typeOfSession'].name
# Allocates a range of key IDs for this model class.
s_id = Session.allocate_ids(size=1, parent=conf_k)[0]
# Create a Session key the includes session and parent info
s_key = ndb.Key(Session, s_id, parent=conf_k)
data['key'] = s_key
session = Session(**data)
s = session.put()
# Added a task to check for feature speaker
taskqueue.add(url='/tasks/set_Featured_Speaker',\
params={'key': wsck, 'speaker': data['speaker']})
return self._copySessionToForm(s.get())
def _createSessionObject(self, request):
"""Create or update Session object, returning SessionForm/request."""
data = {field.name: getattr(request, field.name) for field in request.all_fields()}
if data['date']:
data['date'] = datetime.strptime(data['date'][:10], "%Y-%m-%d").date()
p_key = ndb.Key(Conference, request.websafeConferenceKey)
s_id = Session.allocate_ids(size=1, parent=p_key)[0]
s_key = ndb.Key(Session, s_id, parent=p_key)
data['key'] = s_key
del data['websafeConferenceKey']
# create session and create task for assigning featured speaker to memcache
Session(**data).put()
if data['speaker']:
taskqueue.add(url='/tasks/assign_featured_speaker', params={'speaker': data['speaker']})
return self._copySessionToForm(request)
def _createSessionObject(self, request):
""" Create a new Session object, returning SessionForm/request. """
# make sure that the user is authed
user = endpoints.get_current_user()
if not user:
raise endpoints.UnauthorizedException("Authorization required")
user_id = getUserId(user, id_type="oauth")
# get the conference model
wsck = request.websafeConferenceKey
conf = ndb.Key(urlsafe=wsck).get()
# check that conference exists
if not conf:
raise endpoints.NotFoundException(
"No conference found with key: %s" %
request.websafeConferenceKey)
# check if the user is the organizer of the conference
if user_id != conf.organizerUserId:
raise endpoints.ForbiddenException(
"Only the owner can update the conference.")
# check wether the "name" field is filled by user
if not request.name:
raise endpoints.BadRequestException(
"Session 'name' field required")
# copy SessionForm/ProtoRPC Message into dict
data = {
field.name: getattr(request, field.name)
for field in request.all_fields()
}
# 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 sessionType from enum to string
if data["typeOfSession"]:
data["typeOfSession"] = str(data["typeOfSession"])
# convert date from strings to Date objects
if data["date"]: # date
data["date"] = datetime.strptime(data["date"][:10],
"%Y-%m-%d").date()
# check if the date is during the conference period
conf_start_date = getattr(conf, "startDate")
conf_end_date = getattr(conf, "endDate")
if conf_start_date and conf_end_date:
if data["date"] < conf_start_date or data[
"date"] > conf_end_date:
raise endpoints.BadRequestException("Invallid date")
# convert time from strings to time objects
if data["startTime"]: # time
data["startTime"] = datetime.strptime(data["startTime"][:8],
"%H:%M:%S").time()
# compute the endTime using the duration field
if data["duration"] and data["startTime"]:
endTime_minute = (data["startTime"].minute + data["duration"]) % 60
endTime_hour = data["startTime"].hour \
+ (data["startTime"].minute + data["duration"]) / 60
data["endTime"] = time(endTime_hour, endTime_minute)
# delete unused fields
del [data["duration"]]
del [data["websafeConferenceKey"]]
del [data["wssk"]]
# make conference Key from the websafe conference key
c_key = ndb.Key(urlsafe=wsck)
# allocate new Session ID with the conference key as parent
s_id = Session.allocate_ids(size=1, parent=c_key)[0]
# make Session key from ID
s_key = ndb.Key(Session, s_id, parent=c_key)
data["key"] = s_key
# creates the Session object and put onto the cloud datastore
Session(**data).put()
# add task to queue to update featured speaker
taskqueue.add(params={"websafeConferenceKey": wsck},
url="/tasks/set_featured_speaker")
# return the original Session Form
return self._copySessionToForm(s_key.get())
def _createSessionObject(self, request):
"""Create a Session object, returning SessionForm/request."""
# Getting and Verifying current user
user = getUser()
# get the user_id (email)
user_id = getUserId(user)
# Check that the 'name' field if filed
checkField(request.name, 'name')
# Check that the 'parentKey' field if filed
checkField(request.parentKey, 'parentKey')
# Attempt to retrieve the Conference or raise an exception
try:
_key = ndb.Key(urlsafe=request.parentKey)
except Exception:
raise endpoints.BadRequestException(
'The parentKey given is invalid.')
# Retrieve the Conference Obj
conf = _key.get()
# Verify that the current user created the conference
if user_id != conf.organizerUserId:
raise endpoints.ForbiddenException(
'Only the conference creator can add a session to it.')
# Check speakerKey and save them
speakers = []
if request.speakerKey:
for speakerKey in request.speakerKey:
try:
speaker = ndb.Key(urlsafe=speakerKey).get()
speakers.append(speaker)
except Exception:
raise endpoints.BadRequestException(
'Check the speakerKey it is invalid.')
# Copy SessionForm/ProtoRPC Message into dict
data = ({field.name: getattr(request, field.name)
for field in request.all_fields()})
# If values not given for Session defaults, add defaults
for df in SESSION_DEFAULTS:
if data[df] in (None, []):
data[df] = SESSION_DEFAULTS[df]
setattr(request, df, SESSION_DEFAULTS[df])
# Converting the date info from strings to Date objects
# setting the object month to the start dates month
if data['date']:
data['date'] = (datetime.strptime(
data['date'][:10], "%Y-%m-%d").date())
data['month'] = data['date'].month
else:
data['month'] = conf.month
# Convert startTime from string to Time object
if data['startTime']:
data['startTime'] = (datetime.strptime(
data['startTime'][:5], "%H:%M").time())
# Convert typeOfSession to string
if data['typeOfSession']:
data['typeOfSession'] = str(data['typeOfSession'])
# Create a session id for the Session,
# create the relationship with parent key.
s_id = Session.allocate_ids(size=1, parent=_key)[0]
# Create the session key
s_key = ndb.Key(Session, s_id, parent=_key)
# Fill the session key
data['key'] = s_key
# Check that the speaker was passed
if speakers:
# Query the session for instance of speakers
s = Session.query(
ancestor=ndb.Key(urlsafe=request.parentKey))
# Setting none as featured
featured = None
# Number of session
instance_count = 0
for spkr in data['speakerKey']:
i_count = s.filter(Session.speakerKey == spkr).count()
if i_count >= instance_count:
featured = spkr
minSessions = i_count
# Advise of the featured Speaker using the taskQueue
if featured:
taskqueue.add(
params = {
'websafeConferenceKey': request.parentKey,
'websafeSpeakerKey' : featured},
url = '/tasks/set_featured_speaker',
method = 'GET')
# Store in the DataStore
Session(**data).put()
# Send an email to the conference organizer
taskqueue.add(
params = {
'email' : user.email(),
'subject' : 'You Created a New Session for %s!' % conf.name,
'body' : 'Here are the details for new Session:',
'info' : repr(request)},
url = '/tasks/send_confirmation_email')
return request
def _createSessionObject(self, request):
""" Create or update Session object, returning SessionForm/request
"""
# preload necesarry data items
user = self.get_authed_user()
user_id = getUserId(user)
conf_wsk = request.websafeConferenceKey
conf_key = ndb.Key(urlsafe=conf_wsk)
conf = conf_key.get()
if not conf:
raise endpoints.NotFoundException(
'No conference found with key {}'.format(
request.websafeConferenceKey))
if user_id != conf.organizerUserId:
raise endpoints.ForbiddenException(
'Only the owner of the conference may create a session.')
if not request.name:
raise endpoints.BadRequestException(
"Session 'name' field required")
if not request.websafeConferenceKey:
raise endpoints.BadRequestException(
"Session 'websafeConferenceKey' field required")
# copy SessionForm/ProtoRPC Message into dict
data = {
field.name: getattr(request, field.name)
for field in request.all_fields()
}
# add default values for those missing (both data model &
# outbound Message)
for sf in SESSION_DEFAULTS:
if data[sf] in (None, []):
data[sf] = SESSION_DEFAULTS[sf]
setattr(request, sf, SESSION_DEFAULTS[sf])
# convert date from string to Date object
if data['date']:
data['date'] = datetime.strptime(data['date'], "%Y-%m-%d").date()
# convert startTime from string to Time
if data['startTime']:
data['startTime'] = datetime.strptime(data['startTime'][:5],
"%H:%M").time()
data['typeOfSession'] = str(data['typeOfSession'])
if data['speakers']:
spkr_keys = [
ndb.Key(urlsafe=speaker) for speaker in data['speakers']
]
# Update session if there already is a websafeKey
if data['websafeKey']:
for speaker in spkr_keys:
self._updateSpeakerForSession(
websafeSpeakerKey=speaker.urlsafe(),
websafeSessionKey=data['websafeKey'],
add=True)
data['speakers'] = spkr_keys
# generate Conference Key based on websafeConferenceKey and
# Session ID based on Conference Key and get Session websafe key
# from ID.
sess_id = Session.allocate_ids(size=1, parent=conf_key)[0]
sess_key = ndb.Key(Session, sess_id, parent=conf_key)
data['key'] = sess_key
del data['websafeKey']
del data['websafeConferenceKey']
# create Session, send email to organizer confirming creation of
# Session and return (modified) SessionForm
session = Session(**data).put()
# Check if there is more than one session by speakers of this
# session. Speakers that are speaking at more than one session
# of the same conference are featured speakers, and should be
# added to a Memcache entry for featured speakers. (TASK 4)
if data['speakers']:
for speaker in data['speakers']:
schedule = self._getSpeakerSchedule(speaker, conf_key)
taskqueue.add(params={
'conf_wsk': conf_wsk,
'schedule': schedule
},
url='/tasks/set_featured_speakers')
taskqueue.add(params={
'email': user.email(),
'sessionInfo': repr(request)
},
url='/tasks/send_confirmation_email')
return self._copySessionToForm(session.get())
def _createSessionObject(self, request):
"""Create or update Session object, returning SessionForm/request."""
# Get current user.
user = endpoints.get_current_user()
# If there isn't one, raise an authorization exception.
if not user:
raise endpoints.UnauthorizedException('Authorization required')
# Set user id using getUserId
user_id = getUserId(user)
# Make sure a name is present
if not request.name:
raise endpoints.BadRequestException(
"Session 'name' field required")
# Make sure websafeConferenceKey is present
if not request.websafeConferenceKey:
raise endpoints.BadRequestException(
"Session 'websafeConferenceKey' field required")
# Get websafeConferenceKey
conf = ndb.Key(urlsafe=request.websafeConferenceKey).get()
# Check 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()
}
del data['websafeKey']
del data['websafeConferenceKey']
del data['conferenceName']
# Add default values for those missing
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
if data['date']:
data['date'] = datetime.strptime(data['date'][:10],
"%Y-%m-%d").date()
if data['startTime']:
data['startTime'] = datetime.strptime(data['startTime'][:5],
"%H:%M").time()
# Generate keys for Session.
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
# creation of Session & return (modified) SessionForm
Session(**data).put()
sessions = Session.query(Session.speaker == data['speaker']).count()
if sessions > 1:
taskqueue.add(params={'speaker': data['speaker']},
url='/tasks/set_featured_speaker')
# send request over to form.
return self._copySessionToForm(request)
