def make_reservation(place_id): try: Place.get(Place.id == place_id) except Place.DoesNotExist: return make_response(jsonify({'code': '10001', 'msg': 'Place not found'}), 404) if request.method == "POST": year = int(request.form["year"]) month = int(request.form["month"]) day = int(request.form["day"]) try: # getting the place get_booking = PlaceBook.get(PlaceBook.place == place_id) # Creating a datetime with the post parameters date_object = datetime(year, month, day).strftime("%d/%m/%Y") # getting the date from start and formatting its date = get_booking.to_dict()['date_start'].strftime("%d/%m/%Y") # Getting the duration of the booking duration = get_booking.to_dict()['number_nights'] # Getting the exact day of checkout total_days = (get_booking.to_dict()['date_start'] + timedelta(duration)).strftime("%d/%m/%Y") if date_object >= date and date_object <= total_days: return jsonify({'Available': False}) else: return jsonify({'Available': True}) except: return make_response(jsonify({'code': '10001', 'msg': 'Wrong date format'}), 400)
def modify_place(place_id): id = place_id if request.method == 'GET': try: get_place = Place.get(Place.id == id).to_dict() return jsonify(get_place) except: return make_response(jsonify({'code': '10001', 'msg': 'Place not found'}), 404) elif request.method == 'PUT': place = Place.select().where(Place.id == place_id).get() params = request.values for key in params: if key == 'owner' or key == 'city': return jsonify(msg="You may not update the %s." % key), 409 if key == 'updated_at' or key == 'created_at': continue else: setattr(place, key, params.get(key)) place.save() return jsonify(msg="Place information updated successfully."), 200 elif request.method == 'DELETE': try: get_place = Place.get(Place.id == id) get_place.delete_instance() return "Place with id = %d was deleted\n" % (int(id)) except: return make_response(jsonify({'code': '10001', 'msg': 'Place not found'}), 404)
def find_book(place_id): # Checking if the place exist try: Place.get(Place.id == place_id) except Place.DoesNotExist: return jsonify({'code': 404, 'msg': 'Place not found'}), 404 if request.method == "GET": try: # Selecting the place booked list = ListStyle.list(PlaceBook.select() .where(PlaceBook.place == place_id), request) return jsonify(list) except: return jsonify({'code': 404, 'msg': 'Book not found'}), 404 if request.method == "POST": # cheking if there is a place try: Place.get(Place.id == place_id) except Place.DoesNotExist: return jsonify({'code': 404, 'Place not found': 'hello'}), 404 try: # getting the place get_booking = PlaceBook.get(PlaceBook.place == place_id) # getting the date from start and formatting its date = get_booking.to_dict()['date_start'] # .strftime("%d/%m/%Y") # Getting the duration of the booking duration = get_booking.to_dict()['number_nights'] # Getting the exact day of checkout total_days = (get_booking.to_dict()['date_start'] + timedelta(duration)) # .strftime("%d/%m/%Y") # Create a new booking from POST data for a selected place except: date = datetime(2000, 01, 01) total_days = datetime(2000, 01, 01) # try: get_user = request.form['user_id'] get_date = request.form['date_start'] get_nights = int(request.form['number_nights']) # formatting the date from unicode to datetime to_date = datetime.strptime(get_date, '%Y-%m-%d %H:%M:%S') # Checking if the place is Available in the desired dates if to_date >= date and to_date <= total_days: return make_response( jsonify({'code': '110000', 'msg': "Place unavailable at this date"}), 410) # Booking the place since it is Available new_book = PlaceBook(place=place_id, user=get_user, date_start=get_date, number_nights=get_nights) new_book.save() return jsonify(new_book.to_dict())
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 place_id(place_id): """Handle GET, PUT, and DELETE requests to /places/<place_id> route. Return a hash of the appropriate record in the case of a GET request. Update appropriate hash in database in case of PUT request. Delete appropriate record in case of DELETE request. """ # check whether resource exists: # -------------------------------------------------------------------------- try: record = Place.get(Place.id == place_id) # return 404 not found if it does not except Place.DoesNotExist: return json_response( add_status_=False, status_=404, code=404, msg="not found" ) # if exception does not arise: if request.method == 'GET': return jsonify(record.to_hash()) # if exception does not arise: # -------------------------------------------------------------------------- # handle GET requests elif request.method == 'PUT': record = Place.get(Place.id == place_id) # code below can be optimized in future using list comprehensions for key in request.values.keys(): if key == "name": record.name = request.values[key] elif key == "description": record.description = request.values[key] elif key == "number_rooms": record.number_rooms = request.values[key] elif key == "number_bathrooms": record.number_bathrooms = request.values[key] elif key == "max_guest": record.max_guest = request.values[key] elif key == "price_by_night": record.price_by_night = request.values[key] elif key == "latitude": record.latitude = request.values[key] elif key == "longitude": record.longitude = request.values[key] record.save() return jsonify(record.to_hash()) # handle DELETE requests elif request.method == "DELETE": record.delete_instance() record.save() return 'deleted city\n'
def place_id(place_id): """Handle GET, PUT, and DELETE requests to /places/<place_id> route. Return a hash of the appropriate record in the case of a GET request. Update appropriate hash in database in case of PUT request. Delete appropriate record in case of DELETE request. """ # check whether resource exists: # -------------------------------------------------------------------------- try: record = Place.get(Place.id == place_id) # return 404 not found if it does not except Place.DoesNotExist: return json_response(add_status_=False, status_=404, code=404, msg="not found") # if exception does not arise: if request.method == 'GET': return jsonify(record.to_hash()) # if exception does not arise: # -------------------------------------------------------------------------- # handle GET requests elif request.method == 'PUT': record = Place.get(Place.id == place_id) # code below can be optimized in future using list comprehensions for key in request.values.keys(): if key == "name": record.name = request.values[key] elif key == "description": record.description = request.values[key] elif key == "number_rooms": record.number_rooms = request.values[key] elif key == "number_bathrooms": record.number_bathrooms = request.values[key] elif key == "max_guest": record.max_guest = request.values[key] elif key == "price_by_night": record.price_by_night = request.values[key] elif key == "latitude": record.latitude = request.values[key] elif key == "longitude": record.longitude = request.values[key] record.save() return jsonify(record.to_hash()) # handle DELETE requests elif request.method == "DELETE": record.delete_instance() record.save() return 'deleted city\n'
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 test_update(self): """ test_update tests update of place records upon PUT requests to API """ self.createPlaceViaPeewee() PUT_request1 = self.app.put('/places/1', data=dict( name="foo-name2", description="foo description 2", number_rooms=2, number_bathrooms=2, max_guest=2, price_by_night=2, latitude=30.0, longitude=32.0 )) self.assertEqual(PUT_request1.status[:3], '200') self.assertEqual(Place.get(Place.id == 1).name, 'foo-name2') self.assertEqual(Place.get(Place.id == 1).description, 'foo description 2') self.assertEqual(Place.get(Place.id == 1).number_rooms, 2) self.assertEqual(Place.get(Place.id == 1).number_bathrooms, 2) self.assertEqual(Place.get(Place.id == 1).max_guest, 2) self.assertEqual(Place.get(Place.id == 1).price_by_night, 2) self.assertEqual(Place.get(Place.id == 1).latitude, 30.0) self.assertEqual(Place.get(Place.id == 1).longitude, 32.0) # test response of PUT request for place by place id which does not exist PUT_request2 = self.app.put('/places/1000') self.assertEqual(PUT_request2.status[:3], '404')
def test_update(self): """ test_update tests update of place records upon PUT requests to API """ self.createPlaceViaPeewee() PUT_request1 = self.app.put('/places/1', data=dict(name="foo-name2", description="foo description 2", number_rooms=2, number_bathrooms=2, max_guest=2, price_by_night=2, latitude=30.0, longitude=32.0)) self.assertEqual(PUT_request1.status[:3], '200') self.assertEqual(Place.get(Place.id == 1).name, 'foo-name2') self.assertEqual( Place.get(Place.id == 1).description, 'foo description 2') self.assertEqual(Place.get(Place.id == 1).number_rooms, 2) self.assertEqual(Place.get(Place.id == 1).number_bathrooms, 2) self.assertEqual(Place.get(Place.id == 1).max_guest, 2) self.assertEqual(Place.get(Place.id == 1).price_by_night, 2) self.assertEqual(Place.get(Place.id == 1).latitude, 30.0) self.assertEqual(Place.get(Place.id == 1).longitude, 32.0) # test response of PUT request for place by place id which does not exist PUT_request2 = self.app.put('/places/1000') self.assertEqual(PUT_request2.status[:3], '404')
def place(place_id): if request.method == 'GET': try: new_place = Place.get(Place.id == place_id) return new_place.to_hash() except: return {'code':404, "msg":"not found"}, 404 else: try: query = Place.get(Place.id == place_id) except: return {'code':404, "msg":"user does not exist"}, 404 out_dict = query.to_hash() query.delete_instance() return out_dict
def put_place(place_id): post_data = request.values try: place = Place.get(Place.id == place_id) except Place.DoesNotExist: return {"code":404, "msg":"not found"}, 404 if 'name' in post_data: place.name = post_data['name'] if 'description' in post_data: place.description = post_data['description'] if 'number_rooms' in post_data: place.number_rooms = int(post_data['number_rooms']) if 'number_bathrooms' in post_data: place.number_bathrooms = int(post_data['number_bathrooms']) if 'max_guest' in post_data: place.max_guest = int(post_data['max_guest']) if 'price_by_night' in post_data: place.price_by_night = int(post_data['price_by_night']) if 'latitude' in post_data: place.latitude = float(post_data['latitude']) if 'longitude' in post_data: place.longitude = float(post_data['longitude']) place.save() return place.to_dict()
def get_place(id): try: place = Place.get(Place.id == id) except Exception: return {'code': 404, 'msg': 'Place not found'}, 404 return place.to_hash(), 200
def put_place(place_id): post_data = request.values try: place = Place.get(Place.id == place_id) except: return {"code":404, "msg":"not found"}, 404 try: for key in post_data: if key == 'name': place.name = post_data[key] if key == 'description': place.description = post_data[key] if key == 'number_rooms': place.number_rooms = int(post_data[key]) if key == 'number_bathrooms': place.number_bathrooms = int(post_data[key]) if key == 'max_guest': place.max_guest = int(post_data[key]) if key == 'price_by_night': place.price_by_night = int(post_data[key]) if key == 'latitude': place.latitude = float(post_data[key]) if key == 'longitude': place.longitude = float(post_data[key]) place.save() return place.to_hash() except: return {"code":404, "msg":"not found"}, 404
def delete_place(id): try: place = Place.get(Place.id == id) except Exception: return {'code': 404, 'msg': 'Place not found'}, 404 place.delete_instance() return {'code': 200, 'msg': 'Deleted successfully'}, 200
def delete_single_place(place_id): try: query = Place.get(Place.id == place_id) except Place.DoesNotExist: return {'code':404, "msg":"place does not exist"}, 404 out_dict = query.to_dict() query.delete_instance() return out_dict
def place_reviews(place_id): """Handle GET and POST requests to /places/<place_id>/reviews route. Return a list of all reviews for given place in the database in the case of a GET request. Create a new place review in the database in the case of a POST request. """ # check whether place resource exists: # -------------------------------------------------------------------------- try: record = Place.get(Place.id == place_id) # return 404 not found if it does not except Place.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': list = [] for record in ReviewPlace.select().where(ReviewPlace.place == place_id): hash = record.review.to_hash() list.append(hash) return jsonify(list) # handle POST requests: # -------------------------------------------------------------------------- elif request.method == 'POST': if "stars" in request.form.keys(): record = Review( message=request.form["message"], user=request.form["user_id"], stars=request.form["stars"] ) else: record = Review( message=request.form["message"], user=request.form["user_id"] ) record.save() p_review = ReviewPlace( place=place_id, review=record.id ) p_review.save() return jsonify(record.to_hash())
def get_place(place_id): """ Get a place with id as place_id """ try: place = Place.get(Place.id == place_id) except Exception: return {'code': 404, 'msg': 'Place not found'}, 404 return place.to_dict(), 200
def find_booking(place_id, book_id): # Checking if the place exist try: Place.get(Place.id == place_id) except Place.DoesNotExist: return jsonify({'code': 404, 'msg': 'Place not found'}), 404 # Checking if the booking exist try: PlaceBook.get(PlaceBook.id == book_id) except PlaceBook.DoesNotExist: return jsonify({'code': 404, 'msg': 'Booking not found'}), 404 # Find a booking try: booking = PlaceBook.get(PlaceBook.id == book_id and PlaceBook.place == place_id) return jsonify(booking.to_dict()) except: return jsonify({'code': 404, 'msg': 'not found'}), 404
def delete_booking(place_id, book_id): # Checking if the place exist try: Place.get(Place.id == place_id) except Place.DoesNotExist: return jsonify({'code': 404, 'msg': 'Place not found'}), 404 # Checking if the booking exist try: PlaceBook.get(PlaceBook.id == book_id) except PlaceBook.DoesNotExist: return jsonify({'code': 404, 'msg': 'Booking not found'}), 404 # Delete a booking try: booking = PlaceBook.get(PlaceBook.id == book_id and PlaceBook.place == place_id) booking.delete_instance() return jsonify({'msg': 'Booked place was deleted'}), 200 except: return jsonify({'code': 404, 'msg': 'not found'}), 404
def list_put_delete(): place = Place.get().where(Place.id == place_id) if method == 'GET': return jsonify(place.to_hash()) elif method == 'PUT': place_info = request.values for key in place_info: '''Sustained by MySQL''' if key == 'updated_at' or key == 'created_at' or key == 'id': continue if key == 'owner_id': place.owner_id = place_info.get(key) if key == 'city_id': place.city_id = place_info.get(key) if key == 'name': place.name = place_info.get(key) if key == 'description': place.description = place_info.get(key) if key == 'number_rooms': place.number_rooms = place_info.get(key) if key == 'number_bathrooms': place.number_bathrooms = place_info.get(key) if key == 'max_guest': place.max_guest = place_info.get(key) if key == 'price_by_night': place.price_by_night = place_info.get(key) if key == 'latitude': place.latitude = place_info.get(key) if key == 'longitude': place.longitude = place_info.get(key) user.save() return jsonify(place.to_hash()) elif method == 'DELETE': place_info = Place.get().where(Place.id == place_id) place_info.delete_instance() place_info.save() return jsonify(msg='Place deleted')
def review_place_id(place_id, review_id): """Handle GET and DELETE requests to /places/<place_id>/reviews/<review_id>. Return a hash representing place review in the case of a GET request. Delete appropriate records for place review in case of DELETE request. """ # check whether place resource exists: # -------------------------------------------------------------------------- try: record = Place.get(Place.id == place_id) # return 404 not found if it does not except Place.DoesNotExist: return json_response( add_status_=False, status_=404, code=404, msg="not found" ) # if exception does not arise: # check whether review resource exists: # -------------------------------------------------------------------------- try: record = Review.get(Review.id == review_id) # return 404 not found if it does not except Review.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 DELETE requests elif request.method == "DELETE": pr_record = ReviewPlace.get(ReviewPlace.review == review_id) pr_record.delete_instance() pr_record.save() record.delete_instance() record.save() return 'deleted review record\ndeleted review place record\n'
def delete_place(place_id): """ Delete place with id as place_id """ try: place = Place.get(Place.id == place_id) except Exception: return {'code': 404, 'msg': 'Place not found'}, 404 delete_place = Place.delete().where(Place.id == place_id) delete_place.execute() response = {} response['code'] = 200 response['msg'] = "Place was deleted successfully" return response, 200
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 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 app_places_id(place_id): if request.method == "GET": try: query = Place.get(Place.id == place_id) return jsonify(query.to_dict()), 200 except: return jsonify({"code": 404, "msg": "not found"}), 404 elif request.method == "PUT": try: query = Place.get(Place.id == place_id) [setattr(query, key, value) for (key, value) in request.form.items() if key != "updated_at" and key != "created_at"] query.save() return jsonify(query.to_dict()), 200 except: return jsonify({"code": 404, "msg": "not found"}), 404 elif request.method == "DELETE": try: query = Place.get(Place.id == place_id) query.delete_instance() return jsonify({"code": 200, "msg": "success"}), 200 except: return jsonify({"code": 404, "msg": "not found"}), 404
def test_createByCity(self): """ test_createByCity tests proper creation of a place record by city upon POST request to API """ POST_request = self.app.post('/states/1/cities/1/places', data=dict(owner_id=1, name="foo", description="foo description", number_rooms=1, number_bathrooms=1, max_guest=1, price_by_night=1, latitude=20.0, longitude=22.0)) self.assertEqual(Place.get(Place.id == 1).city.id, 1)
def test_createByCity(self): """ test_createByCity tests proper creation of a place record by city upon POST request to API """ POST_request = self.app.post('/states/1/cities/1/places', data=dict( owner_id=1, name="foo", description="foo description", number_rooms=1, number_bathrooms=1, max_guest=1, price_by_night=1, latitude=20.0, longitude=22.0 )) self.assertEqual(Place.get(Place.id == 1).city.id, 1)
def update_place(id): data = request.form try: place = Place.get(Place.id == id) except Exception: return {'code': 404, 'msg': 'Place not found'}, 404 for i in data: if i == 'owner' or i == 'city': switch = { 'owner': 'owner_id', 'city' : 'city_id' }.get(i) i = switch setattr(place, i, data[i]) place.save() return {'code': 200, 'msg': 'Updated successfully'}, 200
def post_review_by_place(place_id): post_data = request.values if 'message' not in post_data or 'user_id' not in post_data: return {"code": 400, "msg":"bad request, incomplete parameters"}, 400 try: place_get = Place.get(Place.id == place_id) except Place.DoesNotExist: return {'code': 10004, 'msg': 'Place does not exist'}, 404 review_dictionary = review_dict( post_data['message'], post_data['user_id'], post_data.get('stars'), ) new_review, created = Review.create_or_get(**review_dictionary) if not created: return {'code': 404, 'msg': 'User does not exist'}, 404 new_review_place = ReviewPlace.create(place=place_id, review=new_review) return new_review.to_dict()
def list_place_by_state(): place_info = Place.get().where(Place.state == state_id).where( Place.city == city_id) if method == 'GET': jsonify(place_info.to_hash()) elif method == 'POST': place_info = Place.create( owner_id=request.form['owner_id'], city_id=request.form['city_id'], name=request.form['name'], description=request.form['description'], number_rooms=request.form['number_rooms'], number_bathrooms=request.form['number_bathrooms'], max_guest=request.form['max_guest'], price_by_night=request.form['price_by_night'], latitude=request.form['latitude'], longitude=request.form['longitude']) return jsonify(place_info.to_hash())
def update_place(place_id): """ Update the place details of place with id as place_id """ data = request.form try: place = Place.get(Place.id == place_id) for key in data: if key == 'owner': raise Exception('Owner cannot be changed') elif key == 'city': raise Exception('City cannot be changed') elif key == 'name': place.name = data[key] elif key == 'description': place.description = data[key] elif key == 'number_rooms': place.number_rooms = data[key] elif key == 'number_bathrooms': place.number_bathrooms = data[key] elif key == 'max_guest': place.max_guest = data[key] elif key == 'price_by_night': place.price_by_night = data[key] elif key == 'latitude': place.latitude = data[key] elif key == 'longitude': place.longitude = data[key] place.save() res = {} res['code'] = 200 res['msg'] = "Place was updated successfully" return res, 200 except Exception as error: res = {} res['code'] = 403 res['msg'] = str(error) return res, 403
def get_place(place_id): """ Get the given place Returns the given place in the database. --- tags: - Place parameters: - in: path name: place_id type: integer required: True description: ID of the place responses: 200: description: Place returned successfully schema: id: Place required: - owner_id - city_id - name - id - created_at - updated_at properties: owner_id: type: integer description: user id of the owner default: 1 city_id: type: integer description: id of the city default: 1 name: type: string description: name of the place default: 'Amazing view near San Francisco' description: type: string description: description of the place default: "The place is located on the ocean's edge... literally." number_rooms: type: integer description: number of rooms default: 3 number_bathrooms: type: integer description: number of bathrooms default: 2 max_guest: type: integer description: the max number of guests default: 6 price_by_night: type: integer description: the price per night of the location default: 200 latitude: type: float description: the latitude of the place location default: 37.642357 longitude: type: float description: the longitude of the place location default: -122.493439 id: type: integer description: id of the place default: 1 created_at: type: datetime string description: date and time the booking was created in the database default: '2016-08-11 20:30:38' updated_at: type: datetime string description: date and time the booking was updated in the database default: '2016-08-11 20:30:38' 404: description: Place, owner or city was not found 500: description: Request could not be processed """ try: ''' Check if place_id exists ''' query = Place.select().where(Place.id == place_id) if not query.exists(): raise LookupError('place_id') ''' Return place data ''' place = Place.get(Place.id == place_id) return place.to_dict(), 200 except LookupError as e: abort(404) except Exception as e: abort(500)
def update_place(place_id): """ Update a place Update a place in the database --- tags: - Place parameters: - name: place_id in: path type: integer required: True description: ID of the place - name: name in: form type: string description: name of the place - name: description in: form type: string description: description of the place - name: number_rooms in: form type: integer description: number of rooms - name: number_bathrooms in: form type: integer description: number of bathrooms - name: max_guest in: form type: integer description: the max number of guests - name: price_by_night in: form type: integer description: the price per night of the location - name: latitude in: form type: float description: the latitude of the place location - name: longitude in: form type: float description: the longitude of the place location responses: 200: description: Place was updated schema: $ref: '#/definitions/update_booking_put_put_success' 400: description: Issue with booking update request 404: description: Place was not found 410: description: Place is unavailable for the requested booking 500: description: The request was not able to be processed """ try: data = {} for key in request.form.keys(): for value in request.form.getlist(key): data[key] = value ''' Check if place_id exists ''' query = Place.select().where(Place.id == place_id) if not query.exists(): raise LookupError('place_id') ''' Check that no request to change protected values ''' if 'owner_id' in data: raise ValueError('Owner cannot be changed') if 'city_id' in data: raise ValueError('City cannot be changed') ''' Check for valid data types ''' if 'name' in data and not type_test(data['name'], 'string'): raise TypeError('name is not a string') if 'description' in data and not type_test(data['description'], 'string'): raise TypeError('description is not a string') if 'number_rooms' in data and not type_test(data['number_rooms'], int): raise TypeError('number_rooms is not an integer') if 'number_bathrooms' in data and not type_test(data['number_bathrooms'], int): raise TypeError('number_bathrooms is not an integer') if 'max_guest' in data and not type_test(data['max_guest'], int): raise TypeError('max_guest is not an integer') if 'price_by_night' in data and not type_test(data['price_by_night'], int): raise TypeError('price_by_night is not an integer') if 'latitude' in data and not type_test(data['latitude'], float): raise TypeError('latitude is not a float') if 'longitude' in data and not type_test(data['longitude'], float): raise TypeError('longitude is not a float') place = Place.get(Place.id == place_id) for key in data: if key == 'name': place.name = data[key] elif key == 'description': place.description = data[key] elif key == 'number_rooms': place.number_rooms = data[key] elif key == 'number_bathrooms': place.number_bathrooms = data[key] elif key == 'max_guest': place.max_guest = data[key] elif key == 'price_by_night': place.price_by_night = data[key] elif key == 'latitude': place.latitude = data[key] elif key == 'longitude': place.longitude = data[key] place.save() res = {} res['code'] = 200 res['msg'] = "Place was updated successfully" return res, 200 except ValueError as e: res = {} res['code'] = 403 res['msg'] = e.message return res, 403 except LookupError as e: abort(404) except TypeError as e: res = {} res['code'] = 400 res['msg'] = e.message return res, 400 except Exception as error: abort(500)
def get_single_place(place_id): try: new_place = Place.get(Place.id == place_id) except Place.DoesNotExist: return {'code':404, "msg":"not found"}, 404 return new_place.to_dict()
def place_id(place_id): if request.method == "GET": try: place = Place.get(Place.id == place_id) return jsonify(place.to_dict()), 200 except Place.DoesNotExist: return json_response(status_=404, code=404, msg="Not found") elif request.method == "PUT": try: place = Place.get(Place.id == place_id) except Place.DoesNotExist: return json_response(status_=404, code=404, msg="Not found") for key in request.form: if key == "name": place.name = request.form[key] elif key == "description": place.description = request.form[key] elif key == "number_rooms": place.number_rooms = request.form[key] elif key == "number_bathrooms": place.number_bathrooms = request.form[key] elif key == "max_guest": place.max_guest = request.form[key] elif key == "price_by_night": place.price_by_night = request.form[key] elif key == "latitude": place.latitude = request.form[key] elif key == "longitude": place.longitude = request.form[key] elif key == "owner_id": return json_response(status_=400, msg="Cant update owner id") elif key == "city": return json_response(status_=400, msg="Cant update city id") place.save() return jsonify(place.to_dict()), 200 elif request.method == "DELETE": try: place = Place.get(Place.id == place_id) except Place.DoesNotExist: return json_response(code=404, status_=404, msg="Not found") place.delete_instance() place.save() return json_response(status_=200, msg="Place deleted")
def place_id(place_id): if request.method == 'GET': place = Place.get(Place.id == place_id) return jsonify(place.to_hash()) if request.method == 'PUT': try: update_place = Place.update(name=request.form['name']).where( Place.id == place_id) update_place.execute() except: pass try: update_place = Place.update( description=request.form['description']).where( Place.id == place_id) update_place.execute() except: pass try: update_place = Place.update( number_rooms=request.form['number_rooms']).where( Place.id == place_id) update_place.execute() except: pass try: update_place = Place.update( number_bathrooms=request.form['number_bathrooms']).where( Place.id == place_id) update_place.execute() except: pass try: update_place = Place.update( max_guest=request.form['max_guest']).where( Place.id == place_id) update_place.execute() except: pass try: update_place = Place.update( price_by_night=request.form['price_by_night']).where( Place.id == place_id) update_place.execute() except: pass try: update_place = Place.update( latitude=request.form['latitude']).where(Place.id == place_id) update_place.execute() except: pass try: update_place = Place.update( longitude=request.form['longitude']).where( Place.id == place_id) update_place.execute() except: pass updated_place = Place.get(Place.id == place_id) return jsonify(updated_place.to_hash()) elif request.method == 'DELETE': place = Place.get(Place.id == place_id) place.delete_instance() return 'Place %s deleted \n' % place_id