def route_two_people(): try: schema = PersonSchema() person1 = request.args.get("person1") validated_person1 = schema.load(person1) person2 = request.args.get("person2") person1_details = MONGO.db.people.find_one({"name": validated_person1}) validated_person2 = schema.load(person2) person2_details = MONGO.db.people.find_one({"name": validated_person2}) person1_response = { "username": person1_details["name"], "age": person1_details["age"], "address": person1_details["address"], "phone": person1_details["phone"], } person2_response = { "username": person2_details["name"], "age": person2_details["age"], "address": person2_details["address"], "phone": person2_details["phone"], } common_friends = find_common_friends(person1_details, person2_details) response = { "person1": person1_response, "person2": person2_response, "common_friends": common_friends, } return jsonify(response) except: error_response = { "status": "Error", "message": "An error ocurred while processing this request", } return jsonify(error_response["message"])
def post(self): json_data = request.get_json() if not json_data: api.abort(404, 'No input data provided') schema = PersonSchema() try: new_person = schema.load(json_data, session=db.session) except ValidationError as err: api.abort(400, str(err)) raise first_name, last_name = new_person.fname, new_person.lname existing_person = Person.query \ .filter(Person.fname == first_name) \ .filter(Person.lname == last_name) \ .one_or_none() if existing_person: api.abort( 409, 'Person {} {} already exists in the database'.format( first_name, last_name)) db.session.add(new_person) db.session.commit() return schema.dump(new_person), 201
def put(self, person_id): """ Defines a unique URL to update an existing order :param person_id: :return: person object """ json_data = request.get_json() if not json_data: api.abort(404, 'No input data provided') schema = PersonSchema() try: new_person = schema.load(json_data, session=db.session) except ValidationError as err: api.abort(400, str(err)) raise existing_person = Person.query \ .filter(Person.person_id == person_id) \ .one_or_none() if not existing_person: self.id_not_found(person_id) new_person.person_id = existing_person.person_id db.session.merge(new_person) db.session.commit() return schema.dump(existing_person), 201
def create(person): """ This function creates a new person in the users structure based on the passed in person data :param person: person to create in users structure :return: 201 on success, 406 on person exists """ lname = person.get("lname", None) fname = person.get("fname", None) age = person.get("age", None) job = person.get("job", None) existing_person = Person.query.filter(Person.fname == fname, Person.lname == lname, Person.age == age, Person.job == job).one_or_none() if not existing_person: schema = PersonSchema() new_person = schema.load(person, session=db.session).data db.session.add(new_person) db.session.commit() return schema.dump(new_person).data, 201 else: abort( 406, "Person {lname} {fname} exists already".format(lname=lname, fname=fname))
def create(person): """ Function responding to requests for creating a new person :param person: person to create in people's structure :return: 201 on success, 406 if person already exists """ lname = person.get("lname", None) fname = person.get("fname", None) existing_person = (Person.query.filter(Person.fname == fname).filter( Person.lname == lname).one_or_none()) if existing_person is None: # Create a person instance using schema and passed in person schema = PersonSchema() new_person = schema.load(person, session=db.session).data # Add person to the session and commit to database db.session.add(new_person) db.session.commit() # Serialize and return newly created person in response data = schema.dump(new_person).data return data, 201 else: abort( 409, "Person {fname} {lname} exists already".format(fname=fname, lname=lname), )
def update(person_id, person): """ This function updates an existing person in the people structure :param person_id: Id of the person to update in the people structure :param person: person to update :return: updated person structure """ # Get the person requested from the db into session update_person = Person.query.filter( Person.person_id == person_id).one_or_none() # Did we find an existing person? if update_person is not None: # turn the passed in person into a db object schema = PersonSchema() update = schema.load(person, session=db.session).data # Set the id to the person we want to update update.person_id = update_person.person_id # merge the new object into the old and commit it to the db db.session.merge(update) db.session.commit() # return updated person in the response data = schema.dump(update_person).data return data, 200 # Otherwise, nope, didn't find that person else: abort(404, f"Person not found for Id: {person_id}")
def route_person(person_name): """ Return details of a single person """ try: schema = PersonSchema() validated_person_name = schema.load(person_name) user_detail = {} person_details = MONGO.db.people.find_one( {"name": validated_person_name}) user_detail.update({"username": person_details["name"]}) user_detail.update({"age": person_details["age"]}) favFood = person_details["favouriteFood"] favFruit = [] favVeggie = [] for each_fooditem in favFood: if each_fooditem in fruits: favFruit.append(each_fooditem) elif each_fooditem in vegetables: favVeggie.append(each_fooditem) user_detail.update({"fruits": favFruit}) user_detail.update({"vegetables": favVeggie}) return jsonify(user_detail) except: error_response = { "status": "Error", "message": "An error ocurred while processing this request", } return jsonify(error_response["message"])
def create(person): """ This function creates a new person in the people structure based on the passed in person data :param person: person to create in people structure :return: 201 on success, 406 on person exists """ lname = person.get("lname", None) fname = person.get("fname", None) # Does the person already exist? existing_person = ( Person.query.filter(Person.fname == fname) .filter(Person.lname == lname) .one_or_none() ) # Can we insert this person if existing_person is None: # Create a person instance using the schema and the passed in person schema = PersonSchema() new_person = schema.load(person, session=db.session) # Add the person to the database db.session.add(new_person) db.session.commit() # Serialize and return the newly created person in the response return schema.dump(new_person), 201
def update(person_id, person): """ This function updates an existing person in the persons database :param person_id: ID of person to update in the persons database :param person: person data to update :return: updated person structure """ # Get the person from the db update_person = Person.query.filter( Person.id == person_id ).one_or_none() # Abort if we can't find the person if update_person is None: abort( 404, f"Person not found for Id: {person_id}", ) # turn the passed in person into a db object person_schema = PersonSchema() updater = person_schema.load(person, session=db.session) # Set the id to the person we want to update updater.id = update_person.id # merge the new object into the old and commit it to the db db.session.merge(updater) db.session.commit() # return updated person in the response data = person_schema.dump(update_person) return data, 200
def update(person_id, person): # fname = person.get("fname", None) # if lname in PEOPLE and lname is not None: # PEOPLE[lname]["fname"] = person.get("fname", None) # PEOPLE[lname]["timestamp"] = get_timestamp() # return make_response( # "Successfully updated person {lname}".format(lname=lname) # ) # else: # abort( # 404, "Person with {lname} does not exist".format(lname=lname) # ) fname = person.get("fname", None) lname = person.get("lname", None) # updated_person = Person.query.filter(Person.person_id == person_id).update( # {Person.fname: fname, Person.lname: lname} # ) schema = PersonSchema() update = schema.load(person) update.person_id = person_id db.session.merge(update) db.session.commit() return schema.dump(update)
def update(person_id, person): """ Function for updating existing person in people's structure :param person_id: Id of the person to update in people structure :param person: person to update :return: updated person structure """ update_person = Person.query.filter( Person.person_id == person_id).one_or_none() # If person exists if update_person is not None: # create person from data passed schema = PersonSchema() update = schema.load(person, session=db.session).data # Set the id to the new person update.id = update_person.person_id # merge the new object in old and commit it to db db.session.merge(update) db.session.commit() # return updated person data = schema.dump(update_person).data return data, 200 # Person does not exist else: abort( 404, "Person not found for Id: {person_id}".format(person_id=person_id), )
def create(person): """ This function creates a new person in the people structure based on the passed-in person data :param person: person to create in people structure :return: 201 on success, 406 on person exists """ lname = person.get("lname") fname = person.get("fname") # Does the person exist already? existing_person = Person.query.filter(Person.fname == fname).filter( Person.lname == lname).one_or_none() if existing_person is None: # Create a person instance using the schema and the passed in person schema = PersonSchema() new_person = schema.load(person, session=db.session) # Add the person to the database db.session.add(new_person) db.session.commit() # Serialize and return the newly created person in the response data = schema.dump(new_person) return data, 201 else: abort( 409, 'Person {fname} {lname} exists already'.format(fname=fname, lname=lname))
def update(person_id, person): """ This function updates an existing person in the people structure Throws an error if a person with the name we want to update to already exists in the database. :param person_id: Id of the person to update in the people structure :param person: person to update :return: updated person structure """ # Get the person requested from the db into session update_person = Person.query.filter( Person.person_id == person_id ).one_or_none() # Try to find an existing person with the same name as the update fname = person.get("fname") lname = person.get("lname") existing_person = ( Person.query.filter(Person.fname == fname) .filter(Person.lname == lname) .one_or_none() ) # Are we trying to find a person that does not exist? if update_person is None: abort( 404, "Person not found for Id: {person_id}".format(person_id=person_id), ) # Would our update create a duplicate of another person already existing? elif ( existing_person is not None and existing_person.person_id != person_id ): abort( 409, "Person {fname} {lname} exists already".format( fname=fname, lname=lname ), ) # Otherwise go ahead and update! else: # turn the passed in person into a db object schema = PersonSchema() update = schema.load(person, session=db.session) # Set the id to the person we want to update update.person_id = update_person.person_id # merge the new object into the old and commit it to the db db.session.merge(update) db.session.commit() # return updated person in the response data = schema.dump(update_person) return data, 200
def create(person): """ This function creates a new person in the people structure based on the passed in person data :param person: person to create in people structure :return: 201 on success, 406 on person exists """ lname = person.get('lname') fname = person.get('fname') existing_person = Person.query \ .filter(Person.fname == fname) \ .filter(Person.lname == lname) \ .one_or_none() if existing_person is None: schema = PersonSchema() new_person = schema.load(person, session=db.session).data db.session.add(new_person) db.session.commit() return schema.dump(new_person).data, 201 else: abort(409, f'Person {fname} {lname} exists already')
def update(person_id, person): """ This function updates an existing person in the people structure :param person_id: Id of the person to update in the people structure :param person: person to update :return: updated person structure """ update_person = Person.query \ .filter(Person.person_id == person_id) \ .one_or_none() if update_person is not None: schema = PersonSchema() update = schema.load(person, session=db.session).data update.id = update_person.id db.session.merge(update) db.session.commit() data = schema.dump(update_person).data return data, 200 else: abort( 404, 'Person not found for Id: {person_id}'.format(person_id=person_id))
def update(person_id, person): """ Updates person with person_id with passed in person """ # Get the person requested for update from the db into session update_person = Person.query.filter( Person.person_id == person_id).one_or_none() # Exit if person to update is not present in db if update_person is None: abort(404, f"Person with id: {person_id} not found") # Try to find after updating existing record, would we get a person that # already exists in the db fname = person.get("fname") lname = person.get("lname") existing_person = (Person.query.filter(Person.fname == fname).filter( Person.lname == lname).one_or_none()) if existing_person is not None and existing_person.person_id != person_id: abort(409, f"Person with {fname} {lname} already exists") # Go ahead and update person # Turn passed-in person into a db object schema = PersonSchema() update = schema.load(person, session=db.session) update.person_id = update_person.person_id # Use .merge() to update record db.session.merge(update) db.session.commit() data = schema.dump(update_person) return data, 200
def create(person): """ This function creates a new person in the people structure based on the passed in person data :param person: person to create in people structure :return: 201 on success, 406 on person exists """ fname = person.get("fname") lname = person.get("lname") existing_person = (Person.query.filter(Person.fname == fname).filter( Person.lname == lname).one_or_none()) # Can we insert this person? if existing_person is None: # Create a person instance using the schema and the passed in person schema = PersonSchema() new_person = schema.load(person, session=db.session).data # Add the person to the database db.session.add(new_person) db.session.commit() # Serialize and return the newly created person in the response data = schema.dump(new_person).data return data, 201 # Otherwise, nope, person exists already else: abort(409, f"Person {fname} {lname} exists already")
def create(person): """ This function creates a new person in the persons database based on the passed in person data :param person: person to create in persons structure :return: 201 on success, 409 on person already exists """ first_name = person.get('first_name') last_name = person.get('last_name') email = person.get('email') age = person.get('age') try: # Check if person exists already existing_person = Person.query \ .filter(Person.first_name == first_name) \ .filter(Person.last_name == last_name) \ .filter(Person.email == email) \ .filter(Person.age == age) \ .one_or_none() if existing_person is None: person_schema = PersonSchema() new_person = person_schema.load(person, session=db.session) db.session.add(new_person) db.session.commit() data = person_schema.dump(new_person) return data, 201 abort(409, f"Person with name {first_name} {last_name} already exists") except sqlalchemy.exc.SQLAlchemyError as e: logging.error(f'SQLAlchemyError: {e}')
def create(person): fname = person.get("fname") lname = person.get("lname") existing_person = ( Person.query.filter(Person.fname == fname) .filter(Person.lname == lname) .one_or_none() ) if existing_person is None: # Create a person instance using the schema and the passed in person schema = PersonSchema() new_person = schema.load(person, session=db.session) # Add the person to the database db.session.add(new_person) db.session.commit() # Serialize and return the newly created person in the response data = schema.dump(new_person) return data, 201 # Otherwise, person exists already else: abort( 409, "Person {fname} {lname} exists already".format( fname=fname, lname=lname ), )
def create(person): """ This function creates a new person in the people list based on the passed in person data :param person: person to create in the people list :return: 201 on success, 406 on person exist """ lname = person.get("lname", None) fname = person.get("fname", None) # Existing person existing_person = Person.query.filter(Person.fname==fname).filter(Person.lname==lname).one_or_none() # does the person exist already if existing_person is None: # Create the person instance using the schema and the person data that is passed in person_schema = PersonSchema() new_person = person_schema.load(person, session=db.session) # Add the person to the database db.session.add(new_person) db.session.commit() # Serialize and return the newly created person as response data = person_schema.dump(new_person) return data, 201 else: abort( 406, f"Person {fname} {lname} already exists" )
def create(person): fname = person.get("fname", None) lname = person.get("lname", None) schema = PersonSchema() new_person = schema.load(person) db.session.add(new_person) db.session.commit() return schema.dump(new_person)
def update(person_id, person): """ This function updates an existing person in the people structure :param person_id: Id of the person to update in the people structure :param person: person to update :return: updated person structure """ # Get the person requested from the db into session person_to_update = Person.query.filter( Person.person_id == person_id).one_or_none() # Did we find a person? if person_to_update is not None: # turn the passed in person into a db object schema = PersonSchema() person_new_data = schema.load(person, session=db.session).data print('============update============') print(person_new_data) #print(person_new_data.id) print(person_new_data.person_id) print(person_new_data.fname) print(person_new_data.lname) print('============person_new_data============') print('============person_to_update============') print(person_to_update) print(person_to_update.person_id) print(person_to_update.fname) print(person_to_update.lname) print('============person_to_update============') # Set the id to the person we want to update #person_new_data.id = person_to_update.person_id # this only works using the web form (home.html) and not when calling the API directly via curl/postman person_new_data.person_id = person_to_update.person_id # this works in bith: using the web form (home.html), and not when calling the API directly via curl/postman # merge the new object into the old and commit it to the db db.session.merge(person_new_data) db.session.commit() # return updated person in the response data = schema.dump(person_to_update).data return data, 200 # Otherwise, nope, didn't find that person else: abort( 404, "Person not found for Id: {person_id}".format(person_id=person_id), )
def update(person_id, person): """ This function updates an existing person in the people list :param person_id: id of the person to update in the people list :param person: person to update :return: updated person structure """ # Get the person requested update_person = Person.query.filter(Person.person_id==person_id).one_or_none() # Try to find an existing person with the same name as update lname = person.get("lname", None) fname = person.get("fname", None) existing_person = Person.query.filter(Person.fname == fname).filter(Person.lname == lname).one_or_none() # Are we trying to update a person that does not exist? if update_person is None: abort( 404, "Person with person id {person_id} not found".format(person_id=person_id) ) # Will our update create a duplicate person? elif existing_person is not None and existing_person.person_id != person_id: abort( 406, "Person {fname} {lname} already exists".format(fname=fname, lname=lname) ) # Otherwise go ahead and update else: # Convert the passed in person into a db object person_schema = PersonSchema() update = person_schema.load(person, session=db.session) # set the id to the person we want to update update.person_id = update_person.person_id # merge the new object into the old and commit it db.session.merge(update) db.session.commit() # retrun the updated person in response data = person_schema.dump(update_person) return data, 200
def update(person_id, person): # Get the person requested from the db into session update_person = Person.query.filter( Person.person_id == person_id ).one_or_none() # Try to find an existing person with the same name as the update fname = person.get("fname") lname = person.get("lname") existing_person = ( Person.query.filter(Person.fname == fname) .filter(Person.lname == lname) .one_or_none() ) if update_person is None: abort( 404, "Person not found for Id: {person_id}".format(person_id=person_id), ) elif ( existing_person is not None and existing_person.person_id != person_id ): abort( 409, "Person {fname} {lname} exists already".format( fname=fname, lname=lname ), ) else: schema = PersonSchema() update = schema.load(person, session=db.session) update.person_id = update_person.person_id db.session.merge(update) db.session.commit() data = schema.dump(update_person) return data, 200
def update(person_id, person): """ This function updates an existing person in the people structure :param person_id: ID of person to update in the people structure :param person: person to update :return: updated person structure """ # Get the person requested from the db into session update_person = Person.query.filter( Person.person_id == person_id).one_or_none() # try to find an existing person with the same name as the update fname = person.get("fname") lname = person.get("lname") existing_person = (Person.query.filter(Person.fname == fname).filter( Person.lname == lname).one_or_none()) # are we trying to find a person that does not exist? if update_person is None: abort(404, f"Person for ID {person_id} not found.") # would our update create a duplicate of another person already existing? elif (existing_person is not None and existing_person.person_id != person_id): abort(409, f"Person {fname} {lname} already exists.") # no? then update else: # turn the person into a db object schema = PersonSchema() update = schema.load(person, session=db.session) # set the ID of the person we want to update update.person_id = update_person.person_id # merge the new object into the old and commit it to the db db.session.merge(update) db.session.commit() # return the updated person in the response data = schema.dump(update_person) return data, 200
def create(person): """ This function creates a new person in the people structure based on the passed in person data :param person: person to create in people structure :return: 201 on success, 406 on person exists """ Survived = person.get("Survived") Pclass = person.get("Pclass") Name = person.get("Name") Sex = person.get("Sex") Age = person.get("Age") SiblingsSpousesAboard = person.get("SiblingsSpousesAboard") ParentsChildrenAboard = person.get("ParentsChildrenAboard") Fare = person.get("Fare") existing_person = (Person.query.filter(Person.Survived == Survived).filter( Person.Name == Name).one_or_none()) # Can we insert this person? if existing_person is None: # Create a person instance using the schema and the passed in person schema = PersonSchema() new_person = schema.load(person, session=db.session).data # Add the person to the database db.session.add(new_person) db.session.commit() # Serialize and return the newly created person in the response data = schema.dump(new_person).data return data, 201 # Otherwise, nope, person exists already else: abort( 409, "Person {Name} {Survived} exists already".format( Name=Name, Survived=Survived), )
def create(person): """ Creates a person in the people structure based on passed in person data """ fname = person.get("fname") lname = person.get("lname") existing_person = (Person.query.filter(Person.fname == fname).filter( Person.lname == lname).one_or_none()) if existing_person is None: # Create a person instance using schema and passed-in person schema = PersonSchema() new_person = schema.load(person, session=db.session) # Add person to db db.session.add(new_person) db.session.commit() else: abort(409, f"Person with {fname} {lname} already exists")
def create(person): """ This function creates a new person in the people structure based on the passed in person data :param person: person to create in people structure :return: 201 on success, 406 on person exists """ fio = person.get("fio") birthday = person.get("birthday") office = person.get("office") #______________#______________ existing_person = ( Person.query.filter( Person.fio == fio).filter(Person.birthday == birthday).filter( Person.office == office) #______________#______________ .one_or_none()) # Can we insert this person? if existing_person is None: # Create a person instance using the schema and the passed in person schema = PersonSchema() new_person = schema.load(person, session=db.session).data # Add the person to the database db.session.add(new_person) db.session.commit() # Serialize and return the newly created person in the response data = schema.dump(new_person).data return data, 201 # Otherwise, nope, person exists already else: abort( 409, "Person {fio} {birthday} {office} exists already".format( fio=fio, birthday=birthday, office=office), )
def update(person_id, person): ''' This function updates an existing person in the people structure Parameters ---------- person_id: int Id of the person to update in the people structure person: Person Person to update Returns ------- Person Updated person structure ''' # Get the person requested from the db into session update_person = Person.query.filter( Person.person_id == person_id).one_or_none() # Did we find an existing person? if update_person is not None: # Turn the passed in person into a db object schema = PersonSchema() update = schema.load(person, session=db.session).data # Set the id to the person we want to update update.person_id = update_person.person_id # Merge the new object into the old and commit it to the db db.session.merge(update) db.session.commit() # Return the updated person in the response data = schema.dump(update_person) return data, 200 # Otherwise, nope, that's an error else: abort(404, f'Person with Id {person_id} not found')
def create(person): """ This function creates a new person in the people structure based on the passed in person data :param person: person to create in people structure :return: 201 on success, 406 on person exists """ fname = person.get("fname") lname = person.get("lname") existing_person = (Person.query.filter(Person.fname == fname).filter( Person.lname == lname).one_or_none()) # Can we insert this person? if existing_person is None: print(f"create Rx = {person}") # Create a person instance using the schema and the passed in person schema = PersonSchema() new_person = schema.load(person) # Add the person to the database new_person_model = Person(**new_person) db.session.add(new_person_model) db.session.commit() # get new info from DB ( timestam and id ) to return db.session.refresh(new_person_model) # Serialize and return the newly created person in the response data = schema.dump(new_person_model) return data, 201 # Otherwise, nope, person exists already else: abort( 409, "Person {fname} {lname} exists already".format(fname=fname, lname=lname), )