def read_all():
people = Person.query.order_by(Person.lname).all()
person_schema = PersonSchema(many=True)
data = person_schema.dump(people)
return data
def read_one(person_id):
"""
This function responds to a request for /api/people/{person_id}
with one matching person from people
:param person_id: Id of person to find
:return: person matching id
"""
# Get the person requested
person = db.session.query(Person).filter(
Person.id == person_id).one_or_none()
# Did we find a person?
if person is not None:
# Serialize the data for the response
person_schema = PersonSchema()
data = person_schema.dump(person)
return data
# Otherwise, nope, didn't find that person
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
"""
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 read_one(person_id):
"""
This function responds to a request for /api/people/{lname}
with one matching person from people
:param lname: last name of person to find
:return: person matching last name
"""
"""
This function responds to a request for /api/people/{person_id}
with one matching person from people
:param person_id: ID of person to find
:return: person matching ID
"""
# Get the person requested
person = Person.query \
.filter(Person.person_id == person_id) \
.one_or_none()
# Did we find a person?
if person is not None:
# Serialize the data for the response
person_schema = PersonSchema()
return person_schema.dump(person)
# 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):
# 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 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 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 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 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 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 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 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 read_all():
# return a list of Person Python objects as the variable people.
people = Person.query.order_by(Person.lname).all()
# if exists many Python objects that need to be serialized at the same time, you need set "many=True"
person_schema = PersonSchema(many=True)
# Serialize an object to native Python data types according to this Schema's fields.
return person_schema.dump(people).data
def read_one(person_id):
"""
This function responds to a request for /api/people/{person_id}
with one matching person from people.
This is where the outer join comes in handy. It’s a kind of boolean or operation.
It returns person data even if there is no associated note data to combine with.
This is the behavior you want for read_one(person_id) to handle the case of a newly
created Person object that has no notes yet.
:param person_id: Id of person to find
:return: person matching id
"""
# Build the initial query
person = (
Person.query.filter(Person.person_id == person_id)
.outerjoin(Note) # 外连接
.one_or_none()
)
# Did we find a person?
if person is not None:
# Serialize the data for the response
person_schema = PersonSchema()
data = person_schema.dump(person).data
return data
# Otherwise, nope, didn't find that person
else:
abort(404, f"Person not found for Id: {person_id}")
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):
"""
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 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')
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 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 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 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 read_one(person_id):
"""
This function responds to a request for /api/people/{person_id}
with one matching person from people
:param person_id: ID of person to find
:return: person matching ID
"""
# Get the person requested
person = Person.query.filter(
Person.person_id == person_id).outerjoin(Note).one_or_none()
if person is not None:
# Serialize the data for the response
person_schema = PersonSchema()
data = person_schema.dump(person)
return data
# otherwise, nope, not found
else:
abort(
404,
"Person not found for Id: {person_id}".format(person_id=person_id))
return person
def read_all():
"""
This function responds to a request for /api/people
with the complete lists of people
:return: sorted list of people
"""
# Create the list of people from our data
# return [PEOPLE[key] for key in sorted(PEOPLE.keys())]
# conn = sqlite3.connect('people.db')
# cur = conn.cursor()
# cur.execute('select * from person')
# peoples = cur.fetchall()
# print(peoples)
# Create the list of people from our data
people = Person.query.order_by(Person.lname).all()
if people is not None:
# Serialize the data for the response
person_schema = PersonSchema(many=True)
return person_schema.dump(people)
else:
abort(404, 'No People 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
"""
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 read_one(office):
"""
This function responds to a request for /api/people/{office}
with one matching person from people
:param office: office of person to find
:return: person matching id
"""
# Get the person requested
person = Person.query.filter(
Person.office == office).all() #################################
# Did we find a person?
if person is not None:
# Serialize the data for the response
person_schema = PersonSchema()
data = person_schema.dump(person).data
return data
# Otherwise, nope, didn't find that person
else:
abort(
404,
"Person not found for Id: {office}".format(office=office),
)
def read_one(person_id):
"""
This function responds to a request for /api/people/{person_id}
with one matching person from people
:param person_id: Id of person to find
:return: person matching id
"""
# Build the initial query
person = (
Person.query.filter(Person.person_id == person_id)
.outerjoin(Note)
.one_or_none()
)
# Did we find a person?
if person is not None:
# Serialize the data for the response
person_schema = PersonSchema()
data = person_schema.dump(person).data
return data
# Otherwise, nope, didn't find that person
else:
abort(404, f"Person not found for Id: {person_id}")
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:
update_person.lname = person.get("lname")
update_person.fname = person.get("fname")
# commit it to the db
db.session.commit()
# return updated person in the response
schema = PersonSchema()
data = schema.dump(update_person)
return data, 200
# Otherwise, nope, didn't find that person
else:
abort(404, f"Person not found for Id: {person_id}")
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 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"
)
