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 _createSpeakerObject(self, request): """Create Speaker Object, returning SessionForm/request.""" data = {field.name: getattr(request, field.name) for field in request.all_fields()} del data['speakerId'] key = Speaker(**data).put() return self._copySpeakerToForm(key.get())
def _createSpeakerObject(self, request): """Create Speaker object, returning SpeakerForm.""" # check for auth'ed and valid user user = endpoints.get_current_user() if not user: raise endpoints.UnauthorizedException('Authorization required') user_id = getUserId(user) # Speaker name must be filled if not request.name: raise endpoints.BadRequestException("Field 'name' required") # copy SpeakerForm/ProtoRPC Message into dict data = { field.name: getattr(request, field.name) for field in request.all_fields() } # allocate new Speaker ID s_id = Speaker.allocate_ids(size=1)[0] # make Speaker key from ID s_key = ndb.Key(Speaker, s_id) data['key'] = s_key # create Speaker & return SpeakerForm speaker = Speaker(**data) speaker.put() return self._copySpeakerToForm(speaker)
def _createSpeakerObject(self, request): """Create Speaker object, returning SpeakerForm/request.""" # preload necessary data items user = endpoints.get_current_user() # make sure user is authenticated if not user: raise endpoints.UnauthorizedException('Authorization required') user_id = getUserId(user) # make sure session name is entered if not request.name: raise endpoints.BadRequestException( "Session name field required") # copy SessionForm/ProtoRPC Message into dict data = {field.name: getattr(request, field.name) for field in request.all_fields()} # generate Speaker Key based on Profile key and # profile ID p_key = ndb.Key(Profile, user_id) s_id = Speaker.allocate_ids(size=1, parent=p_key)[0] s_key = ndb.Key(Speaker, s_id, parent=p_key) data['key'] = s_key # save form data to datastore Speaker(**data).put() # create Speaker & return (modified) SpeakerForm return request
def _createSpeakerObject(self, request): """Create or update Speaker object, returning SpeakerForm.""" if not request.name: raise endpoints.BadRequestException( "Speaker 'name' field required") q = Speaker.query() q = q.filter(Speaker.name == request.name) if q.count() != 0: raise endpoints.BadRequestException("Speaker already excists") # copy SpeakerForm/ProtoRPC Message into dict data = { field.name: getattr(request, field.name) for field in request.all_fields() } # Create session id from parent COnference Key and # a Session key from that id s_id = Speaker.allocate_ids(size=1)[0] s_key = ndb.Key(Speaker, s_id) data['key'] = s_key del data['websafeKey'] # Save session and return a SessionForm to the user Speaker(**data).put() return self._copySpeakerToForm(s_key.get())
def createSpeaker(self, request): """Create Speaker object, returning SpeakerForm/request.""" # preload necessary data items user = endpoints.get_current_user() if not user: raise endpoints.UnauthorizedException('Authorization required') if not request.name: raise endpoints.BadRequestException("Speaker 'name' field required") if not request.mainEmail: raise endpoints.BadRequestException("Speaker 'mainEmail' field required") sp_key = ndb.Key(Speaker, request.mainEmail) speaker = sp_key.get() if not speaker: speaker = Speaker( key = sp_key, name = request.name, mainEmail = request.mainEmail, ) if request.title: speaker.title = request.title if request.bio: speaker.bio = request.bio speaker.put() return request
def _createSpeakerObject(self, request): """Create a speaker, returning SpeakerForm/request.""" # Preload necessary data items user = endpoints.get_current_user() if not user: raise endpoints.UnauthorizedException('Authorization required') user_id = user.email() if not request.name: raise endpoints.BadRequestException( "Speaker 'name' field required") # Copy SpeakerForm/ProtoRPC Message into dict data = { field.name: getattr(request, field.name) for field in request.all_fields() } del data['websafeKey'] # Add default values for those missing (both data model and # outbound Message) for df in SPEAKER_DEFAULTS: if data[df] in (None, []): data[df] = SPEAKER_DEFAULTS[df] # Create Speaker and return SpeakerForm speaker = Speaker(**data) speaker.put() return self._copySpeakerToForm(speaker)
def _createSpeakerObject(self, request): """Create or update Speaker object, returning Speaker/request.""" # preload necessary data items user = endpoints.get_current_user() if not user: raise endpoints.UnauthorizedException('Authorization required') if not request.name: raise endpoints.BadRequestException( "Speaker 'name' field required") # copy Speaker/ProtoRPC Message into dict data = {field.name: getattr(request, field.name) \ for field in request.all_fields()} del data['websafeKey'] # add defaults for missing values (both data model & outbound Message) for df in DEFAULTS_SPEAKER: if data.get(df, None) is None: data[df] = DEFAULTS_SPEAKER[df] setattr(request, df, DEFAULTS_SPEAKER[df]) # create Speaker and return updated SpeakerForm with websafeKey request.websafeKey = Speaker(**data).put().urlsafe() return request
def _createSpeakerObject(self, request): """Create Speaker object, returning SpeakerForm/request.""" # preload necessary data items user = endpoints.get_current_user() if not user: raise endpoints.UnauthorizedException('Authorization required') user_id = getUserId(user) if not request.name: raise endpoints.BadRequestException( "Speaker 'name' field required") # copy SpeakerForm/ProtoRPC Message into dict data = {field.name: getattr(request, field.name) \ for field in request.all_fields()} del data['websafeKey'] speaker_id = Speaker.allocate_ids(size=1)[0] speaker_key = ndb.Key(Speaker, speaker_id) data['key'] = speaker_key # create Speaker speaker = Speaker(**data) speaker.put() # return the modified SpeakerForm return self._copySpeakerToForm(speaker)
def _createSpeakerObject(self, request): """Create a Speaker object.""" # preload necessary data items user = endpoints.get_current_user() if not user: raise endpoints.UnauthorizedException('Authorization required') user_id = getUserId(user) if not request.firstName: raise endpoints.BadRequestException( "Speaker 'firstName' field required") if not request.lastName: raise endpoints.BadRequestException( "Speaker 'lastName' field required") # copy SpeakerForm Message into dict data = {field.name: getattr(request, field.name) for field in request.all_fields()} # generate Profile Key based on user ID and Speaker # ID based on Profile key get Speaker key from ID p_key = ndb.Key(Profile, user_id) speaker_id = Speaker.allocate_ids(size=1, parent=p_key)[0] speaker_key = ndb.Key(Speaker, speaker_id, parent=p_key) data['key'] = speaker_key del data['speakerWebSafeKey'] # creation Speaker entity Speaker(**data).put() return request
def _createSpeakerObject(self, request): """Create or update Speaker object, returning SpeakerForm/request.""" # preload necessary data items user = endpoints.get_current_user() if not user: raise endpoints.UnauthorizedException('Authorization required') if not request.displayName: raise endpoints.BadRequestException("Speaker 'displayName' field required") # copy ConferenceForm/ProtoRPC Message into dict data = {field.name: getattr(request, field.name) for field in request.all_fields()} # this is automatically generated for display but should # be ignored if it is input. del data['websafeKey'] # Now create the speaker key. # NOTE: allocate_ids returns a list, so take the first element. speaker_id = Speaker.allocate_ids(size=1)[0] speaker_key = ndb.Key(Speaker, speaker_id) data['key'] = speaker_key # create Speaker, send email to creator confirming # creation of Speaker & return (modified) SpeakerForm Speaker(**data).put() taskqueue.add(params={'email': user.email(), 'speakerInfo': repr(request)}, url='/tasks/send_speaker_confirmation_email' ) return request
def _createSpeakerObject(self, request): """Create 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 create_speaker(self, request): """Create a new speaker.""" user = endpoints.get_current_user() if not user: raise endpoints.UnauthorizedException("Authorization required.") speaker = Speaker(name=request.name) speaker.put() return speaker.to_message()
def _createSpeakerObject(self, request): speaker_id = request.mainEmail sp_key = ndb.Key(Speaker, speaker_id) speaker = Speaker( key=sp_key, name=request.name, mainEmail=request.mainEmail, phone=request.phone, ) speaker.put() return request
def _createSpeakerObject(self, name): """Create or update Speaker object,\ returning SpeakerForm/request.""" sp_key = ndb.Key(Speaker, name) speaker = sp_key.get() if not speaker: speaker = Speaker( key=sp_key, name=name, details='', ) speaker.put() return speaker
def createSpeaker(self, request): """Create new speaker""" # check for required fields if not request.name: raise endpoints.BadRequestException( "Speaker 'name' field required") # create speaker speaker = Speaker( name=request.name.title( ), #store in fixed title case for case-independent string request later bio=request.bio) speaker.put() # return SpeakerForm return self._copySpeakerToForm(speaker)
def _getSpeaker(self, email): # Create a new key of kind Speaker from the id. s_key = ndb.Key(Speaker, email) # Get the entity from datastore by using get() on the key speaker = s_key.get() # If speaker doesn't exist, we create a new one if not speaker: speaker = Speaker( key=s_key, email=email, # e-mail is enough, no name to store ) # Save the speaker to datastore speaker.put() return speaker # return Speaker
def add_speakers(payload): body = request.get_json() new_name = body.get("event", None) new_expertise = body.get("event_date", None) if body is None: abort(400) try: speaker = Speaker(name=new_name, expertise=new_expertise) speaker.insert() return jsonify({"success": True, "created": speaker}) except Exception: abort(422)
def _createSpeakerObject(self, request): """ Creates a Speaker entity in datastore based on the information provided by client. Sends a confirmation email after adding the new Speaker """ # preload necessary data items user = endpoints.get_current_user() if not user: raise endpoints.UnauthorizedException('Authorization required') user_id = getUserId(user) if not request.name: raise endpoints.BadRequestException("Speaker 'name' \ field required") data = { field.name: getattr(request, field.name) for field in request.all_fields() } del data['websafeSpeakerKey'] # create Speaker & return (modified) SpeakerForm speaker_key = Speaker(**data).put() taskqueue.add(params={ 'email': user.email(), 'speakerInfo': repr(request) }, url='/tasks/send_speaker_confirmation_email') # Return data as SpeakerForm speakerform = SpeakerForm() for field in speakerform.all_fields(): if data.has_key(field.name): setattr(speakerform, field.name, data[field.name]) # Checks if the field is websafeSpeakerKey, then converts it into # urlsafe key elif field.name == "websafeSpeakerKey": setattr(speakerform, field.name, speaker_key.urlsafe()) speakerform.check_initialized() return speakerform
def _createSpeakerObject(self, request): """Create speaker object""" user = endpoints.get_current_user() if not user: raise endpoints.UnauthorizedException('Authorization required') user_id = getUserId(user) if not request.name: raise endpoints.BadRequestException( "Speaker 'name' field required") # copy SpeakerForm/ProtoRPC Message into dict data = { field.name: getattr(request, field.name) for field in request.all_fields() } s_key = Speaker(**data).put() return request
def _createSpeakerObject(self, request): """ Create or update Speaker object, returning SpeakerForm """ if not request.name: raise endpoints.BadRequestException( "Session 'name' field required") # copy SpeakerForm/ProtoRPC Message into dict data = { field.name: getattr(request, field.name) for field in request.all_fields() } del data['websafeKey'] s_id = Speaker.allocate_ids(size=1)[0] s_key = ndb.Key(Speaker, s_id) data['key'] = s_key spkr_key = Speaker(**data).put() return self._copySpeakerToForm(spkr_key.get())
def __init__(self, target_size, vocab_size, bias, test_data, seed, episodes=1000): self.data = test_data self.vocab_size = vocab_size self.target_size = target_size self.speaker_bias = 1.0 - bias self.listener_bias = bias self.speaker = Speaker(512, self.target_size, self.vocab_size, self.speaker_bias, seed) self.listener = Listener(512, self.vocab_size, self.target_size, self.listener_bias, seed) self.episode_rewards = [] self.accuracy_history = deque(maxlen=100) self.symbols_used = {} self.synonym_array = np.zeros((target_size, vocab_size)) self.accuracy_record = [] self.episodes = 1000
def addSpeaker(self, request): """Add speaker""" # verify user is authed user = endpoints.get_current_user() if not user: raise endpoints.UnauthorizedException('Authorization required') # generate unique id for speaker s_id = Speaker.allocate_ids(size=1)[0] s_key = ndb.Key(Speaker, s_id) # save into datastore speaker = Speaker(key=s_key, displayName=request.displayName) speaker_key = speaker.put() # get speaker urlsafe string s_uss = speaker_key.urlsafe() if not s_uss: raise endpoints.NotFoundException( 'Unable to get speakerKey from Datastore') return SpeakerForm(speakerKey=s_uss)
def _doSpeaker(self, request): """Get, create or update speaker""" sp_key = ndb.Key(Speaker, request.displayName) speaker = sp_key.get() # if speaker exists, process user-modifyable fields if speaker: for field in ('displayName', 'bio'): if hasattr(request, field): val = getattr(request, field) if val: setattr(speaker, field, str(val)) # if speaker doesn't exist, create new speaker object else: speaker = Speaker(key=sp_key, displayName=request.displayName, mainEmail=request.mainEmail, bio=request.bio, sessionKeys=[]) # put the modified speaker to datastore speaker.put() # return SpeakerForm return self._copySpeakerToForm(speaker)
def _createSpeakerObject(self, request): """Create or update a Speaker object""" user = endpoints.get_current_user() if not user: raise endpoints.UnauthorizedException('Authorization required') user_id = getUserId(user) if not request.name: raise endpoints.BadRequestException( "Speaker 'name' field required") data = { field.name: getattr(request, field.name) for field in request.all_fields() } s_id = Speaker.allocate_ids(size=1)[0] s_key = ndb.Key(Speaker, s_id) data['key'] = s_key Speaker(**data).put() return request
def _getKeyForSpeaker(self, request): """ This function gets the key for an existing speaker that has been requested. """ if not request.name: raise endpoints.BadRequestException("Speaker 'name' field \ required") # creates new key for Speaker spkr_key = Speaker().key # for all noted speakers, make a query notedSpeakersQuery = Speaker.query() # lists noted speakers notedSpeakers = [] for ns in notedSpeakersQuery: notedSpeakers.append(ns.name) # When no speaker is found with a name, a NotFoundException is raised. if request.name not in notedSpeakers: raise endpoints.NotFoundException( 'No speaker found with name: %s' % request.name) # Otherwise, have its key returned. else: spkr_key = Speaker.query(Speaker.name == request.name).get().key return spkr_key
def _createSpeakerObject(self, request): """Create or update Speaker object, returning SpeakerForm/request.""" # preload necessary data items user = endpoints.get_current_user() #check if logged in if not user: raise endpoints.UnauthorizedException('Authorization required') #check if the user specified a name if not request.name: raise endpoints.BadRequestException( "Speaker 'name' field required") data = { field.name: getattr(request, field.name) for field in request.all_fields() } #delete, doesn't exist in model del data['websafeKey'] Speaker(**data).put() return request
def createSpeaker(self, request): """Create a new spaeker form with provided speaker name and organization""" # make sure user is logged in. user = endpoints.get_current_user() if not user: raise endpoints.UnauthorizedException('Authorization required') # copy request data into a dictionary. data = { field.name: getattr(request, field.name) for field in request.all_fields() } # get a key for the speaker. speaker_id = Speaker.allocate_ids(size=1)[0] speaker_key = ndb.Key(Speaker, speaker_id) data['key'] = speaker_key new_speaker = Speaker(**data) new_speaker.put() return self._copySpeakerToForm(new_speaker)
def _createSpeakerObject(self, request): speaker = Speaker(name=request.name, mainEmail=request.mainEmail) speaker.put() speaker.websafeKey = speaker.key.urlsafe() speaker.put() return self._copySpeakerToForm(speaker)
("Your silence will not protect you", "1990-01-02 01:01:01"), ], }, ] # Delete database file if it exists currently if os.path.exists('speakers.db'): os.remove('speakers.db') if os.path.exists('truths.db'): os.remove('truths.db') # Create the database db.create_all() # Iterate over the TRUTHS structure and populate the database for speaker in SPEAKERS: s = Speaker(name=speaker.get("name"), ) # Add the truths for each person for truth in speaker.get("truths"): content, timestamp = truth s.truths.append( Truth( content=content, timestamp=datetime.strptime(timestamp, "%Y-%m-%d %H:%M:%S"), )) db.session.add(s) db.session.commit()