def amenities():
"""Handle GET and POST requests to /amenities route.
Return a list of all amenities in database in the case of a GET request.
Create a new amenity record in the database in the case of a POST request.
"""
# handle GET requests:
# --------------------------------------------------------------------------
if request.method == 'GET':
list = ListStyle.list(Amenity.select(), request)
return jsonify(list)
# handle POST requests:
# --------------------------------------------------------------------------
elif request.method == 'POST':
try:
record = Amenity(name=request.form['name'])
record.save()
return jsonify(record.to_hash())
# return 409 if amenity with given name already exists
except IntegrityError:
return json_response(
add_status_=False,
status_=409,
code=10003,
msg="Name already exists"
)
def create_database():
try:
User.create_table()
except peewee.OperationalError:
pass
try:
State.create_table()
except peewee.OperationalError:
pass
try:
City.create_table()
except peewee.OperationalError:
pass
try:
Place.create_table()
except peewee.OperationalError:
pass
try:
PlaceBook.create_table()
except peewee.OperationalError:
pass
try:
Amenity.create_table()
except peewee.OperationalError:
pass
try:
PlaceAmenities.create_table()
except peewee.OperationalError:
pass
def create_amenity():
try:
new_amenity = Amenity(name=request.form['name'])
new_amenity.save()
return jsonify(new_amenity.to_dict())
except:
return jsonify({'code': 10003, 'msg': 'Name already exists'}), 409
def handle_amenity_for_place(place_id, amenity_id):
'''Add the amenity with `amenity_id` to the place with `place_id` with a
POST request. Delete the amenity with the id of `amenity_id` with a DELETE
request.
Keyword arguments:
place_id -- The id of the place.
amenity_id -- The id of the amenity.
'''
try:
Amenity.select().where(Amenity.id == amenity_id).get()
except Amenity.DoesNotExist:
return jsonify(msg="Amenity does not exist."), 404
try:
Place.select().where(Place.id == place_id).get()
except Place.DoesNotExist:
return jsonify(msg="Place does not exist."), 404
if request.method == 'POST':
'''Save the connection in the ReviewPlace table.'''
PlaceAmenities().create(place=place_id, amenity=amenity_id)
return jsonify(msg="Amenity added to place successfully."), 201
elif request.method == 'DELETE':
(PlaceAmenities
.delete()
.where((PlaceAmenities.place == place_id) &
(PlaceAmenities.amenity == amenity_id))
.execute())
Amenity.delete().where(Amenity.id == amenity_id).execute()
return jsonify(msg="Amenity deleted successfully."), 200
def create_amenity():
try:
new_amenity = Amenity(name=request.form['name'])
new_amenity.save()
return jsonify(new_amenity.to_dict())
except:
return jsonify({'code': 10003, 'msg': 'Name already exists'}), 409
def handle_amenity_for_place(place_id, amenity_id):
'''Add the amenity with `amenity_id` to the place with `place_id` with a
POST request. Delete the amenity with the id of `amenity_id` with a DELETE
request.
Keyword arguments:
place_id -- The id of the place.
amenity_id -- The id of the amenity.
'''
try:
Amenity.select().where(Amenity.id == amenity_id).get()
except Amenity.DoesNotExist:
return jsonify(msg="Amenity does not exist."), 404
try:
Place.select().where(Place.id == place_id).get()
except Place.DoesNotExist:
return jsonify(msg="Place does not exist."), 404
if request.method == 'POST':
'''Save the connection in the ReviewPlace table.'''
PlaceAmenities().create(place=place_id, amenity=amenity_id)
return jsonify(msg="Amenity added to place successfully."), 201
elif request.method == 'DELETE':
(PlaceAmenities.delete().where((PlaceAmenities.place == place_id) & (
PlaceAmenities.amenity == amenity_id)).execute())
Amenity.delete().where(Amenity.id == amenity_id).execute()
return jsonify(msg="Amenity deleted successfully."), 200
def create_amenity():
"""
Create a amenity
"""
data = request.form
try:
if 'name' not in data:
raise KeyError("'name'")
check_amenity = Amenity.select(). where(Amenity.name == data['name'])
if check_amenity:
return {'code': 10003, 'msg': 'Name already exists'}, 409
new = Amenity.create(
name=data['name']
)
res = {}
res['code'] = 201
res['msg'] = "Amenity was created successfully"
return res, 201
except KeyError as e:
res = {}
res['code'] = 40000
res['msg'] = 'missing parameters'
return res, 400
except Exception as error:
response = {}
response['code'] = 409
response['msg'] = str(error)
return response, 409
def app_create_delete_amenity(place_id, amenity_id):
try:
Place.get(Place.id == place_id)
except Place.DoesNotExist:
return jsonify({"code": 409, "msg": "place id does not exist"}), 409
try:
Amenity.get(Amenity.id == amenity_id)
except Amenity.DoesNotExist:
return jsonify({"code": 409, "msg": "amenity id does not exist"}), 409
if request.method == "POST":
if PlaceAmenities.select().where(
PlaceAmenities.place == place_id,
PlaceAmenities.amenity == amenity_id).exists():
return jsonify({
"code": 409,
"msg": "Place already has this amenity"
}), 409
PlaceAmenities.create(place=place_id, amenity=amenity_id)
return jsonify({"code": 200, "msg": "success"}), 200
elif request.method == "DELETE":
try:
query = PlaceAmenities.select().where(
PlaceAmenities.place == place_id,
PlaceAmenities.amenity == amenity_id).get()
query.delete_instance()
return jsonify({"code": 200, "msg": "success"}), 200
except:
return jsonify({"code": 404, "msg": "not found"}), 404
def get_amenity(amenity_id):
"""
Get the given amenity
Return the given amenity in the database.
---
tags:
- Amenity
parameters:
-
in: path
name: amenity_id
type: string
required: True
description: ID of the amenity
responses:
200:
description: Amenity returned successfully
schema:
id: Amenity
required:
- name
- id
- created_at
- updated_at
properties:
name:
type: string
description: Name of the amenity
default: "Swimming Pool"
id:
type: number
description: id of the amenity
default: 1
created_at:
type: datetime string
description: date and time the amenity was created in the database
default: '2016-08-11 20:30:38'
updated_at:
type: datetime string
description: date and time the amenity was updated in the database
default: '2016-08-11 20:30:38'
404:
description: Amenity was not found
500:
description: Request could not be processed
"""
try:
''' Check if amenity exists '''
query = Amenity.select().where(Amenity.id == amenity_id)
if not query.exists():
raise LookupError('amenity_id')
''' Return amenity data '''
amenity = Amenity.get(Amenity.id == amenity_id)
return amenity.to_dict(), 200
except LookupError as e:
abort(404)
except Exception as e:
abort(500)
def amenity_id(amenity_id):
if request.method == 'GET':
amenity = Amenity.get(Amenity.id == amenity_id)
return jsonify(amenity.to_hash())
elif request.method == 'DELETE':
amenity = Amenity.get(Amenity.id == amenity_id)
amenity.delete_instance()
return 'Amenity %s deleted \n' % place_id
def createAmenityViaPeewee(self):
"""
Create an amenity record using the API's database/Peewee models.
createAmenityViaPeewee returns the Peewee object for the record. This
method will not work if the database models are not written correctly.
"""
record = Amenity(name='amenity_name')
record.save()
return record
def create_amenities():
data = request.form
check_amenity = Amenity.select(). where(Amenity.name == data['name'])
if check_amenity:
return {'code': 10003, 'msg': 'Name already exists'}, 409
amenity = Amenity.create(
name = data['name']
)
return {'code': 201, 'msg': 'Amenity created successfully'}, 201
def createAmenityViaPeewee(self):
"""
Create an amenity record using the API's database/Peewee models.
createAmenityViaPeewee returns the Peewee object for the record. This
method will not work if the database models are not written correctly.
"""
record = Amenity(name= 'amenity_name')
record.save()
return record
def amenities(): if request.method == 'GET': list_amenities = Amenity.select() return json_dumps(list_amenities.to_hash()) elif request.method == 'POST': data = request.data name = data['name'] entry = Amenity.insert(name=name) entry.execute()
def create_asdfstate():
content = request.get_json()
if not all(param in content.keys() for param in ["name"]):
#ERROR
return "Failed: bad input"
try:
amenity = Amenity()
amenity.name = content["name"]
amenity.save()
except Exception as e:
return "Failed"
return "Success"
def delete_amenity(amenity_id):
"""
Delete the given amenity
Deletes the given amenity in the database.
---
tags:
- Amenity
parameters:
-
in: path
name: amenity_id
type: string
required: True
description: ID of the amenity
responses:
200:
description: Amenity deleted successfully
schema:
id: delete_200
required:
- code
- msg
properties:
code:
type: integer
description: Response code from the API
default: 200
msg:
type: string
description: Message about record deletion
default: "deleted successfully"
404:
description: Amenity was not found
500:
description: Request could not be processed
"""
try:
''' Check if amenity exists '''
query = Amenity.select().where(Amenity.id == amenity_id)
if not query.exists():
raise LookupError('amenity_id')
''' Delete the amenity '''
amenity = Amenity.delete().where(Amenity.id == amenity_id)
amenity.execute()
res = {}
res['code'] = 200
res['msg'] = "Amenity was deleted successfully"
return res, 200
except LookupError as e:
abort(404)
except Exception as e:
abort(500)
def create_amenity():
"""
Create an amenity
Creates an amenity based on post parameters.
---
tags:
- amenity
parameters:
- name: name
in: query
type: string
description: name of the amenity to create
responses:
200:
description: Success message
schema:
id: success_message
properties:
status:
type: number
description: status code
default: 200
msg:
type: string
description: Status message
default: 'Success'
400:
description: Error message
schema:
id: error_message
properties:
status:
type: number
description: status code
default: 40000
msg:
type: string
description: Status message
default: 'Missing parameters'
"""
content = request.get_json(force=True)
if not content: return error_msg(400, 400, "Error")
if not all(param in content.keys() for param in ["name"]):
#ERROR
return error_msg(400, 40000, "Missing parameters")
try:
amenity = Amenity()
amenity.name = content["name"]
amenity.save()
except Exception as e:
return error_msg(400, 400, "Error")
return error_msg(200, 200, "Success")
def delete_amenity(amenity_id):
"""
Delete amenity with id as amenity_id
"""
try:
amenity = Amenity.get(Amenity.id == amenity_id)
except Exception:
return {'code': 404, 'msg': 'Amenity not found'}, 404
amenity = Amenity.delete().where(Amenity.id == amenity_id)
amenity.execute()
res = {}
res['code'] = 201
res['msg'] = "Amenity was deleted successfully"
return res, 201
def delete_amenity(amenity_id):
try:
amenity = Amenity.get(Amenity.id == amenity_id)
amenity.delete_instance()
return jsonify({'msg': 'Deleted amenity!'})
except:
return jsonify({'code': 404, 'msg': 'not found'}), 404
def delete_amenity(amenity_id):
try:
amenity = Amenity.get(Amenity.id == amenity_id)
amenity.delete_instance()
return jsonify({'msg': 'Deleted amenity!'})
except:
return jsonify({'code': 404, 'msg': 'not found'}), 404
def place_amenity_id(place_id, amenity_id): query = Place.select().where(Place.id == place_id) if query.wrapped_count() < 1: return json_response(status_=404, msg="that place does not exist") query = Amenity.select().where(Amenity.id == amenity_id) if query.wrapped_count() < 1: return json_response(status_=404, msg="that amenity does not exist") query = PlaceAmenities.select().where(PlaceAmenities.amenity == amenity_id, PlaceAmenities.place == place_id) if query.wrapped_count() > 0: return json_response(status_=404, msg="amenity already set for given place") if request.method == "POST": insert = PlaceAmenities(place=place_id, amenity=amenity_id) insert.save() return jsonify(insert.to_dict()), 201 elif request.method == "DELETE": amenity = PlaceAmenities.get(PlaceAmenities.amenity == amenity_id, PlaceAmenities.place == place_id) amenity.delete_instance() amenity.save() return json_response(status_=200, msg="amentiy delete for given place")
def get_place_amenities(place_id):
"""
Get amenities for place
Return a list of all amenities for a place
---
tags:
- Amenity
parameters:
-
in: path
name: place_id
type: string
required: True
description: ID of the place
responses:
200:
description: List of all amenities for the place
schema:
$ref: '#/definitions/get_amenities_get_Amenities'
"""
try:
''' Check if the place exists '''
query = Place.select().where(Place.id == place_id)
if not query.exists():
raise LookupError('place_id')
''' Return amenities for the given place '''
data = Amenity.select().join(PlaceAmenities).where(PlaceAmenities.place == place_id)
return ListStyle.list(data, request), 200
except LookupError as e:
abort(404)
except Exception as e:
abort(500)
def amenity_id(amenity_id):
"""Handle GET, PUT & DELETE requests to /amenities/<amenity_id> route.
Return a hash of the appropriate record in the case of a GET request.
Delete appropriate record in case of DELETE request.
"""
# check whether resource exists:
# --------------------------------------------------------------------------
try:
record = Amenity.get(Amenity.id == amenity_id)
# return 404 not found if it does not
except Amenity.DoesNotExist:
return json_response(
add_status_=False,
status_=404,
code=404,
msg="not found"
)
# if exception does not arise:
# --------------------------------------------------------------------------
# handle GET requests
if request.method == 'GET':
return jsonify(record.to_hash())
# handle PUT requests
elif request.method == "DELETE":
record.delete_instance()
record.save()
return 'deleted booking\n'
def amenity_id(amenity_id):
"""Handle GET, PUT & DELETE requests to /amenities/<amenity_id> route.
Return a hash of the appropriate record in the case of a GET request.
Delete appropriate record in case of DELETE request.
"""
# check whether resource exists:
# --------------------------------------------------------------------------
try:
record = Amenity.get(Amenity.id == amenity_id)
# return 404 not found if it does not
except Amenity.DoesNotExist:
return json_response(add_status_=False,
status_=404,
code=404,
msg="not found")
# if exception does not arise:
# --------------------------------------------------------------------------
# handle GET requests
if request.method == 'GET':
return jsonify(record.to_hash())
# handle PUT requests
elif request.method == "DELETE":
record.delete_instance()
record.save()
return 'deleted booking\n'
def amenities_in_places(place_id):
if request.method == 'GET':
amenities_list = []
amenities = Amenity.select().join(Place).where(Place.id == place_id)
for amenity in amenities:
amenities_list.append(amenity.to_hash())
return jsonify(amenities_list)
def app_amenities_id(amenity_id):
if request.method == "GET":
try:
query = Amenity.get(Amenity.id == amenity_id)
return ListStyles.list(query, request), 200
except:
return jsonify({"code": 404, "msg": "not found"}), 404
elif request.method == "DELETE":
try:
query = Amenity.get(Amenity.id == amenity_id)
query.delete_instance()
return jsonify({"code": 200, "msg": "success"}), 200
except:
return jsonify({"code": 404, "msg": "not found"}), 404
def get_amenities():
amenities = []
query = Amenity.select()
for i in query:
amenities.append(i.to_hash())
return jsonify(amenities)
def app_amenities():
if request.method == "GET":
try:
query = Amenity.select()
if not query.exists():
return jsonify({"code": 404, "msg": "not found"}), 404
return ListStyles.list(query, request), 200
except:
return jsonify({"code": 404, "msg": "not found"}), 404
elif request.method == "POST":
try:
new = Amenity.create(name=request.form['name'])
return jsonify(new.to_dict()), 201
except:
return jsonify({"code": 10003, "msg": "Name already exists"}), 409
def subtest_createWithAllParams(self):
"""
Test proper creation of an amenity record upon POST request to the API
with all parameters provided.
"""
POST_request1 = self.createAmenityViaAPI()
self.assertEqual(POST_request1.status[:3], '200')
now = datetime.now().strftime('%d/%m/%Y %H:%M')
self.assertEqual(Amenity.get(Amenity.id == 1).name, 'amenity_name')
self.assertEqual(Amenity.get(Amenity.id == 1).created_at.strftime('%d/%m/%Y %H:%M'), now)
self.assertEqual(Amenity.get(Amenity.id == 1).updated_at.strftime('%d/%m/%Y %H:%M'), now)
# test that placebook ID for sole record in database is correct
self.assertEqual(Amenity.select().get().id, 1)
def get_amenity_by_place(id):
amenities = []
query = Amenity.select().where(Place.id == id)
for i in query:
amenities.append(i.to_hash())
return jsonify(amenities)
def get_amenity(id):
try:
amenity = Amenity.get(Amenity.id == id)
except Exception:
return {'code': 404, 'msg': 'Amenity not found'}, 404
return amenity.to_hash(), 200
def delete_amenity(id):
try:
amenity = Amenity.get(Amenity.id == id)
except Exception:
return {'code': 404, 'msg': 'Amenity not found'}, 404
amenity.delete_instance()
return {'code': 200, 'msg': 'Deleted successfully'}, 200
def app_amenities_place(place_id):
if request.method == "GET":
try:
query = Amenity.select().join(PlaceAmenities).where(
PlaceAmenities.place == place_id)
return ListStyles.list(query, request), 200
except:
return jsonify({"code": 404, "msg": "not found"}), 404
def del_amenity(amenity_id):
try:
query = Amenity.get(Amenity.id == amenity_id)
except Amenity.DoesNotExist:
return {"code":404, "msg": "not found"}, 404
out_dict = query.to_dict()
query.delete_instance()
return out_dict
def amenities_id(amenity_id): amenity = Amenity.select().where(id=amenity_id).get() if request.method == 'GET': return amenity.to_hash() elif request.method == 'DELETE': amenity.delete_instance()
def get_statdasfde_by_id(amen_id):
amens = Amenity.select().where(Amenity.id == int(amen_id))
amen = None
for u in amens:
amen = u
if amen == None:
return "Failed"
return jsonify(amen.to_hash())
def amenities_place(place_id): if request.method == "GET": try: query = Amenity.select().join(PlaceAmenities).where(PlaceAmenities.place == place_id) return ListStyle.list(query, request), 200 except: return json_response(status_=404, msg="Not found")
def get_staasedfazte_by_id(amen_id):
amens = Amenity.select().where(Amenity.id == int(amen_id))
amen = None
for u in amens:
amen = u
if amen == None:
return "Failed"
amen.delete_instance()
return "Success"
def get_amenity(amenity_id):
"""
Get a amenity with id as amenity_id
"""
try:
amenity = Amenity.get(Amenity.id == amenity_id)
except Exception:
return {'code': 404, 'msg': 'Amenity not found'}, 404
return amenity.to_dict(), 200
def create_amenity():
post_data = request.values
if 'name' not in post_data:
return {"code":404, "msg": "not found"}, 404
new_amenity, created = Amenity.get_or_create(name = post_data['name'])
if not created:
out = {'code': 10003, 'msg': 'Name already exists'}
return out, 409
return new_amenity.to_dict()
def handle_amenity_id(amenity_id):
'''Returns a JSON object of the amenity with the id passed as parameter
with a GET request method. Removes an amenity with DELETE request method.
Keyword arguments:
amenity_id: The id of the amenity.
'''
try:
amenity = Amenity.select().where(Amenity.id == amenity_id).get()
except Amenity.DoesNotExist:
raise Exception("There is no amenity with this id.")
if request.method == 'GET':
return jsonify(amenity.to_dict()), 200
elif request.method == 'DELETE':
amenity = Amenity.delete().where(Amenity.id == amenity_id)
amenity.execute()
return jsonify(msg="Amenity deleted successfully."), 200
def handle_amenity_id(amenity_id):
'''Returns a JSON object of the amenity with the id passed as parameter
with a GET request method. Removes an amenity with DELETE request method.
Keyword arguments:
amenity_id: The id of the amenity.
'''
try:
amenity = Amenity.select().where(Amenity.id == amenity_id).get()
except Amenity.DoesNotExist:
raise Exception("There is no amenity with this id.")
if request.method == 'GET':
return jsonify(amenity.to_dict()), 200
elif request.method == 'DELETE':
amenity = Amenity.delete().where(Amenity.id == amenity_id)
amenity.execute()
return jsonify(msg="Amenity deleted successfully."), 200
def amenities_id(amenity_id): if request.method == 'GET': try: amenity = Amenity.select().where(Amenity.id == amenity_id) except Amenity.DoesNotExist: return json_response(status_=404, msg="Not found") return jsonify(amenity.to_dict()), 200 elif request.method == 'DELETE': try: amenity = Amenity.get(Amenity.id == amenity_id) except Amenity.DoesNotExist: return json_response(status_=404, msg="Not found") amenity.delete_instance() amenity.save() return json_response(status_=200, msg="Amenity deleted")
def handle_amenity():
'''Returns all amenities as JSON objects in an array with a GET request.
Adds an amenity with a POST request.
'''
if request.method == 'GET':
list = ListStyle().list(Amenity.select(), request)
return jsonify(list), 200
elif request.method == 'POST':
try:
Amenity.select().where(Amenity.name == request.form['name']).get()
return jsonify(code=10003, msg="Name already exists"), 409
except Amenity.DoesNotExist:
'''Check that all the required parameters are made in request.'''
required = set(["name"]) <= set(request.values.keys())
if required is False:
return jsonify(msg="Missing parameter."), 400
amenity = Amenity.create(name=request.form['name'])
return jsonify(amenity.to_dict()), 200
def subtest_createWithAllParams(self):
"""
Test proper creation of an amenity record upon POST request to the API
with all parameters provided.
"""
POST_request1 = self.createAmenityViaAPI()
self.assertEqual(POST_request1.status[:3], '200')
now = datetime.now().strftime('%d/%m/%Y %H:%M')
self.assertEqual(Amenity.get(Amenity.id == 1).name, 'amenity_name')
self.assertEqual(
Amenity.get(Amenity.id == 1).created_at.strftime('%d/%m/%Y %H:%M'),
now)
self.assertEqual(
Amenity.get(Amenity.id == 1).updated_at.strftime('%d/%m/%Y %H:%M'),
now)
# test that placebook ID for sole record in database is correct
self.assertEqual(Amenity.select().get().id, 1)
def place_amenities(place_id):
# need to test and correct this request handler
query = (Amenity.select().join(
PlaceAmenities, on=(Amenity.id == PlaceAmenities.amenity)).join(
Place, on=(Place.id == PlaceAmenities.place)).where(
Place.id == place_id).get())
for record in query:
hash = record.to_hash()
list.append(hash)
return jsonify(list)
def handle_amenity():
'''Returns all amenities as JSON objects in an array with a GET request.
Adds an amenity with a POST request.
'''
if request.method == 'GET':
list = ListStyle().list(Amenity.select(), request)
return jsonify(list), 200
elif request.method == 'POST':
try:
Amenity.select().where(Amenity.name == request.form['name']).get()
return jsonify(code=10003, msg="Name already exists"), 409
except Amenity.DoesNotExist:
'''Check that all the required parameters are made in request.'''
required = set(["name"]) <= set(request.values.keys())
if required is False:
return jsonify(msg="Missing parameter."), 400
amenity = Amenity.create(name=request.form['name'])
return jsonify(amenity.to_dict()), 200
def list_select_amenities(place_id):
try:
Place.get(Place.id == place_id)
except Place.DoesNotExist:
return jsonify({'code': 404, 'msg': ' place not found'}), 404
list = ListStyle.list(
Amenity.select().join(PlaceAmenities).where(
Amenity.id == PlaceAmenities.amenity).where(
PlaceAmenities.place == place_id), request)
return jsonify(list)
def list_select_amenities(place_id):
try:
Place.get(Place.id == place_id)
except Place.DoesNotExist:
return jsonify({'code': 404, 'msg': ' place not found'}), 404
list = ListStyle.list(Amenity.select()
.join(PlaceAmenities)
.where(Amenity.id == PlaceAmenities.amenity)
.where(PlaceAmenities.place == place_id), request)
return jsonify(list)
def amenities():
"""Handle GET and POST requests to /amenities route.
Return a list of all amenities in database in the case of a GET request.
Create a new amenity record in the database in the case of a POST request.
"""
# handle GET requests:
# --------------------------------------------------------------------------
if request.method == 'GET':
list = []
for record in Amenity.select():
hash = record.to_hash()
list.append(hash)
return jsonify(list)
# handle POST requests:
# --------------------------------------------------------------------------
elif request.method == 'POST':
try:
record = Amenity(name=request.form['name'])
record.save()
return jsonify(record.to_hash())
# return 409 if amenity with given name already exists
except IntegrityError:
return json_response(add_status_=False,
status_=409,
code=10003,
msg="Name already exists")
def amenities():
if request.method == 'GET':
amenities_list = []
amenities = Amenity.select()
for amenity in amenities:
amenities_list.append(amenity.to_hash())
return jsonify(amenities_list)
elif request.method == 'POST':
amenities = Amenity.select()
for amenity in amenities:
if amenity.name == request.form['name']:
message = {
'code': 10003,
'msg': 'Amenity already exists',
}
res = jsonify(message)
res.status_code = 409
return res
else:
new_amenity = Amenity.create(name=request.form['name'])
return jsonify(new_amenity.to_hash())
def update(place_id, amenity_id):
# Checking if place exist
try:
Place.get(Place.id == place_id)
except Place.DoesNotExist:
return jsonify({'code': 404, 'msg': 'Place not found'}), 404
# Checking is Amenity exist
try:
Amenity.get(Amenity.id == amenity_id)
except Amenity.DoesNotExist:
return jsonify({'code': 404, 'msg': 'Amenity not found'}), 404
if request.method == "POST":
new_place_amenity = PlaceAmenities(place=place_id, amenity=amenity_id)
new_place_amenity.save()
return jsonify(new_place_amenity.amenity.to_dict())
elif request.method == "DELETE":
get_place_a = PlaceAmenities.get(
PlaceAmenities.place == place_id
and PlaceAmenities.amenity == amenity_id)
get_place_a.delete_instance
return "amenity deleted"
def handle_place_id_amenity(place_id):
'''Returns all amenities of the place_id as JSON objects in an array with a
GET request.
Keyword arguments:
place_id: The id of the amenity.
'''
try:
PlaceAmenities.select().where(PlaceAmenities.place == place_id).get()
except PlaceAmenities.DoesNotExist:
return jsonify(msg="Amenity does not exist."), 404
if request.method == 'GET':
'''Use a join statement to get the instances in the amenity table.'''
list = ListStyle().list((Amenity.select().join(
PlaceAmenities, on=PlaceAmenities.amenity).where(
PlaceAmenities.place == place_id)), request)
return jsonify(list), 200
def amenities(): if request.method == 'GET': amenities = Amenity.select() return ListStyle.list(amenities, request), 200 elif request.method == 'POST': try: if "name" not in request.form: return json_response(status_=400, msg="missing parameters", code=40000) test = Amenity.select().where(Amenity.name == request.form["name"]) if test.wrapped_count() > 0: return json_response(status_=409, code=10002, msg="place already exists with this name") amenity = Amenity(name=request.form["name"]) amenity.save() return jsonify(amenity.to_dict()), 201 except IntegrityError: return json_response(status_=409, msg="Name already exists", code=10003)
def find_amenity(amenity_id):
try:
list = Amenity.get(Amenity.id == amenity_id)
return jsonify(list.to_dict())
except:
return jsonify({'code': 404, 'msg': 'not found'}), 404
def list_amenities():
try:
list = ListStyle.list(Amenity.select(), request)
return jsonify(list)
except:
return jsonify({'code': 404, 'msg': 'not found'}), 404
def get_amenities():
"""
Get all amenities
"""
data = Amenity.select()
return ListStyle.list(data, request), 200