return abort( 400, 'Não existe professor com esse ID no banco de dados.') if args: professor_selected.update(dict(**args)) db.session.commit() return {}, 204 @api.response(400, 'Não existe professor com esse ID no banco de dados.') @api.response(204, 'Success') def delete(self, unique_id): ''' Deleta um professor com o determinado ID presente no banco de dados. ''' professor_selected = Professor.query.filter_by(id=unique_id) if not professor_selected.first(): return abort( 400, 'Não existe professor com esse ID no banco de dados.') professor_selected.delete() db.session.commit() return {}, 204 api.add_resource(rota_acesso_todos_professores, '/') api.add_resource(rota_acesso_unico_professores, '/<int:unique_id>/')
@profile_orders_namespace.marshal_with(order) def get(self): """Returns all orders""" logger.info("Orders.get()") try: user_id = current_user().id orders = Orders.get_orders_of_user(user_id=user_id) return [order.to_dict() for order in orders], 200 except Exception as e: logger.exception("Orders.get(): %s", str(e)) return "Couldn't load orders", 500 @auth_required @profile_orders_namespace.expect(order) def put(self): """Updates current user order""" logger.info("Orders.put() user_id: %s", str(current_user().id)) try: content = request.get_json() Orders.update_order(content) return 'User order has been updated', 200 except Exception as e: logger.exception("Order.put(): %s", str(e)) return "Couldn't update user's order", 500 profile_orders_namespace.add_resource(OrdersNamespace, "")
lat = 0 if lon is None: lon = 0 if m is None: m = -1 if k is None: k = -1 # print(lat, lon, place_types, m, k) res = get_knearest_places(lat, lon, place_types, m, k) return res, 200 class PlaceRating(Resource): def get(self, place_id): """Returns average rating for given place id. 0 if there are no ratings.""" response_object = {} place = get_place_by_id(place_id) if not place: places_namespace.abort(404, f"Place {place_id} does not exist") rating = get_rating_by_id(place_id) return {"rating": int(rating)}, 200 places_namespace.add_resource(PlacesList, "") places_namespace.add_resource(Places, "/<int:place_id>") places_namespace.add_resource(PlacesSearches, "/<string:place_types>") places_namespace.add_resource(PlaceRating, "/rating/<int:place_id>")
"votes_voided": fields.Integer(readOnly=True), "tie_avoided": fields.Boolean(readOnly=True), "day_found": fields.Integer(readOnly=True), "day_played": fields.Integer(readOnly=True), "note": fields.String(readOnly=True), "appearance": fields.Integer(attribute="appearance.id"), }, ) class IdolList(Resource): @idol_namespace.marshal_with(idol, as_list=True) def get(self): """Returns all users.""" return get_all_idols(**request.args), 200 # class Idol(Resource): # @idol_namespace.marshal_with(idol) # @idol_namespace.response(200, "Success") # @idol_namespace.response(404, "Contestant <id> does not exist") # def get(self, contestant_id): # """Returns a single user.""" # user = get_contestant_by_id(contestant_id) # if not user: # idol_namespace.abort(404, f"Contestant {contestant_id} does not exist") # return user, 200 idol_namespace.add_resource(IdolList, "") # contestant_namespace.add_resource(Contestant, "/<int:contestant_id>")
res = empty_result(data=f"Scheduled job to renew certificates") res['job_id'] = job_id resp = make_response(json.dumps(res), 200) if total_count: resp.headers['X-Total-Count'] = total_count resp.headers['Content-Type'] = "application/json" return resp else: return empty_result( status='error', data=f"Unknown action specified: {action}"), 400 # Devices device_api.add_resource(DeviceByIdApi, '/<int:device_id>') device_api.add_resource(DeviceByHostnameApi, '/<string:hostname>') device_api.add_resource(DeviceConfigApi, '/<string:hostname>/generate_config') device_api.add_resource(DevicePreviousConfigApi, '/<string:hostname>/previous_config') device_api.add_resource(DeviceApplyConfigApi, '/<string:hostname>/apply_config') device_api.add_resource(DeviceApi, '') devices_api.add_resource(DevicesApi, '') device_init_api.add_resource(DeviceInitApi, '/<int:device_id>') device_initcheck_api.add_resource(DeviceInitCheckApi, '/<int:device_id>') device_discover_api.add_resource(DeviceDiscoverApi, '') device_syncto_api.add_resource(DeviceSyncApi, '') device_update_facts_api.add_resource(DeviceUpdateFactsApi, '') device_update_interfaces_api.add_resource(DeviceUpdateInterfacesApi, '') device_cert_api.add_resource(DeviceCertApi, '')
elif args['tags_ids'] is not None: tags_ids = args['tags_ids'] offers = filter( lambda offer: any(tag for tag in offer.tags if tag.tag_id in tags_ids), offers) return [offer.to_dict() for offer in offers], 200 # return [offer.to_dict() for offer in offers], 200 except Exception as e: logger.exception("Offers.get(): %s", str(e)) return "Couldn't load offers", 500 @auth_required @offers_current_namespace.expect(offer) def put(self): """Updates current user offer""" logger.info("Offers.put() user_id: %s", str(current_user().id)) try: content = json.loads(request.form['data']) photo = request.files.get('photo', None) photo_url = cloudinary_uploader.upload( photo)['url'] if photo else None Offer.update_offer(content, photo_url) return 'User offer has been updated', 200 except Exception as e: logger.exception("Offers.put(): %s", str(e)) return "Couldn't update user's offer", 500 offers_current_namespace.add_resource(ProfileOffers, "")
# src/api/ping.py from flask_restx import Namespace, Resource ping_namespace = Namespace("ping") class Ping(Resource): def get(self): return {"status": "success", "message": "pong!"} ping_namespace.add_resource(Ping, "")
import json import logging from flask import current_app as app from flask_restx import Namespace from flask_restx import Resource logger = logging.getLogger(__name__) health_namespace = Namespace("health") class Health(Resource): @staticmethod @health_namespace.response(200, "Health check passing") @health_namespace.response(404, "Health check failed") def get(): health = "bad" try: with open(app.config["HEALTHCHECK_FILE_PATH"], "r") as fp: health = fp.read().strip() logger.info("Health check passing") return json.dumps({"health": health}), 200 except IOError: logger.error("Health check fails", exc_info=True) return json.dumps({"health": health}), 404 health_namespace.add_resource(Health, "")
response_object = {} announcement = get_announcement_by_id(announcement_id) if not announcement: announcements_namespace.abort( 404, f"Announcement {announcement_id} does not exist") update_announcement(announcement, content) response_object["message"] = f"{announcement.id} was updated!" return response_object, 200 @announcements_namespace.response(200, "<announcement_id> was removed!") @announcements_namespace.response( 404, "Announcement <announcement_id> does not exist") def delete(self, announcement_id): """Updates a announcement.""" response_object = {} announcement = get_announcement_by_id(announcement_id) if not announcement: announcements_namespace.abort( 404, f"Announcement {announcement_id} does not exist") delete_announcement(announcement) response_object["message"] = f"{announcement.id} was removed!" return response_object, 200 announcements_namespace.add_resource(AnnouncementsList, "/") announcements_namespace.add_resource(AnnouncementsListbySponsor, "/by_sponsor/<string:sponsor_name>") announcements_namespace.add_resource(Announcements, "/<int:announcement_id>")
from flask_restx import Namespace from app.api.adapter.namespaces.rm.routes import RequirementList, RequirementItem rm_ns = Namespace(name='rm', description='Requirements Management', path='/rm') rm_ns.add_resource(RequirementList, "/requirement") rm_ns.add_resource(RequirementItem, "/requirement/<string:id>") # rm_ns.add_resource(UploadCollection, "/collection") # rm_ns.add_resource(QueryCapability, "/query_capability", defaults={'query_capability_id': ''})
class Status(Resource): @auth_namespace.marshal_with(user) @auth_namespace.response(200, "Success") @auth_namespace.response(401, "Invalid token") @auth_namespace.expect(parser) def get(self): auth_header = request.headers.get("Authorization") if auth_header: try: access_token = auth_header.split(" ")[1] resp = User.decode_token(access_token) user = get_user_by_id(resp) if not user: auth_namespace.abort(401, "Invalid token") return user, 200 except jwt.ExpiredSignatureError: auth_namespace.abort( 401, "Signature expired. Please log in again.") return "Signature expired. Please log in again." except jwt.InvalidTokenError: auth_namespace.abort(401, "Invalid token. Please log in again.") else: auth_namespace.abort(403, "Token required") auth_namespace.add_resource(Register, "/register") auth_namespace.add_resource(Login, "/login") auth_namespace.add_resource(Refresh, "/refresh") auth_namespace.add_resource(Status, "/status")
return empty_result(status='success', data=data), 201 @jwt_required def delete(self): """ Remove linknet """ json_data = request.get_json() errors = [] if 'id' not in json_data: errors.append("Required field id not found") elif not isinstance(json_data['id'], int): errors.append("Field id must be an integer") if errors: return empty_result(status='error', data=errors), 400 with sqla_session() as session: cur_linknet = session.query(Linknet).filter( Linknet.id == json_data['id']).one_or_none() if not cur_linknet: return empty_result( status='error', data="No such linknet found in database"), 404 session.delete(cur_linknet) session.commit() return empty_result( status="success", data={"deleted_linknet": cur_linknet.as_dict()}), 200 # # Links api.add_resource(LinknetsApi, '')
return abort( 400, 'Não existe professor com esse ID no banco de dados.') if args: turma_selected.update(dict(**args)) db.session.commit() return {}, 204 @api.response(400, 'Não existe turma com esse código no banco de dados.') @api.response(204, 'Success') def delete(self, codigo): ''' Deleta uma turma com o determinado codigo presente no banco de dados. ''' turma_selected = Turma.query.filter_by(codigo=codigo) if not turma_selected.first(): return abort( 400, 'Não existe turma com esse codigo no banco de dados.') turma_selected.delete() db.session.commit() return {}, 204 api.add_resource(rota_acesso_todas_turmas, '/') api.add_resource(rota_acesso_unico_turmas, '/<string:codigo>/')
time_start = datetime.strptime(json_data['start_at'], date_format) time_now = datetime.now() if time_start < time_now: return empty_result(status='error', data='start_at must be in the future') time_diff = time_start - time_now seconds = time_diff.seconds except Exception as e: logger.exception(f'Exception when scheduling job: {e}') return empty_result(status='error', data=f'Invalid date format, should be: {date_format}') scheduler = Scheduler() job_id = scheduler.add_onetime_job( 'cnaas_nms.confpush.firmware:device_upgrade', when=seconds, scheduled_by=get_jwt_identity(), kwargs=kwargs) res = empty_result(data='Scheduled job to upgrade devices') res['job_id'] = job_id return res # Firmware api.add_resource(FirmwareApi, '') api.add_resource(FirmwareImageApi, '/<string:filename>') api.add_resource(FirmwareUpgradeApi, '/upgrade')
user_record = get_user_by_id(user_id) if user_record.get_points_alert and points != event.points: try: # Req Change 3: msg = "You now have " + points + " points in the GoodDriver App." send_email(email, "Points updated in GoodDriver App", msg) except: pass response_object["message"] = f"{event.id} was updated!" return response_object, 200 @events_namespace.response(200, "<event_id> was removed!") @events_namespace.response(404, "Event <event_id> does not exist") def delete(self, event_id): """Updates a event.""" response_object = {} event = get_event_by_id(event_id) if not event: events_namespace.abort(404, f"Event {event_id} does not exist") delete_event(event) response_object["message"] = f"Event {event.id} was removed!" return response_object, 200 events_namespace.add_resource(EventsList, "/") # events_namespace.add_resource(EventsListbyUser, "/by_user/<int:user_id>") events_namespace.add_resource( EventsListbyUser, "/by_user/<int:user_id>/by_caller/<int:caller_id>") events_namespace.add_resource(Events, "/<int:event_id>")
response_object = {} quote = Quote.query.filter_by(content=content).first() if quote: response_object["message"] = "Sorry, this quote already exists." return response_object, 400 add_quote(author_name, content) response_object["message"] = f"quote was added!" return response_object, 201 # we dont use marshal with - no information class RandomQuotes(Resource): #@quotes_namespace.marshal_with(quote) def get(self): """Returns three random quotes with author info""" quotes = Quote.query.all() quotes_list = [] for q in quotes: quotes_list.append(q.to_dict()) # random choose three quotes randam_quotes = random.sample(quotes_list, k=3) return randam_quotes, 200 quotes_namespace.add_resource(Quotes, "") quotes_namespace.add_resource(RandomQuotes, "/random")
if len(shop.get(sku)) == 0: product_namespace.abort(404, f"Product (SKU{sku}) does not exist") updated_product = Product(sku, name, qty, price) shop.update(updated_product) response_object["message"] = f"Product (SKU{sku}) was updated!" return response_object, 200 @product_namespace.response(200, "All products have been deleted!") def delete(self): """deletes all products from shop""" shop.delete() response_object = {} response_object["message"] = "All products deleted!" return response_object, 200 class ProductItem(Resource): @product_namespace.marshal_with(product) @product_namespace.response(200, "Success") @product_namespace.response(404, "Product <SKU> does not exist") def get(self, sku): """Returns a single product.""" item = shop.get(sku) if not item: product_namespace.abort(404, f"Product {sku} does not exist") return item[0], 200 product_namespace.add_resource(ProductList, "") product_namespace.add_resource(ProductItem, "/<int:sku>")
"hotel_day_count as ( " "select distinct hotel_id, count(date) over(PARTITION BY hotel_id) as day_count " "from hotel_dates " "), " "available_hotels as ( " "select hotel_id " "from hotel_day_count " f"where day_count = :day_count " ") " "select distinct hotel_id " "from available_hotels left join hotels on available_hotels.hotel_id = hotels.id; " ) stmt = text(stmt) avail_hotels = db.engine.execute( stmt, checkin=checkin.isoformat(), lastnight=lastnight.isoformat(), room_types=room_types, day_count=day_count, ).fetchall() avail_hotels = [v[0] for v in avail_hotels] # Get hotels with availabilities hotel_filters.append(Hotels.id.in_(avail_hotels)) hotels = db.session.query(Hotels).filter(*hotel_filters).all() return hotels availabilities_ns.add_resource(Availabilities, "", endpoint="availabilities")
def get(self, group_name): """ Get a single group by name """ tmpgroups = groups_populate(group_name) result = {'groups': tmpgroups} return empty_result(status='success', data=result) class GroupsApiByNameOsversion(Resource): @jwt_required def get(self, group_name): """Get os version of all devices in a group""" try: group_os_versions = groups_osversion_populate(group_name) except ValueError as e: return empty_result( status='error', data="Exception while getting group {}: {}".format( group_name, str(e))), 404 except Exception as e: return empty_result( status='error', data="Exception while getting group {}: {}".format( group_name, str(e))), 500 result = {'groups': group_os_versions} return empty_result(status='success', data=result) api.add_resource(GroupsApi, '') api.add_resource(GroupsApiByName, '/<string:group_name>') api.add_resource(GroupsApiByNameOsversion, '/<string:group_name>/os_version')
return {}, 204 @api.response(400, 'Não existe turma com esse codigo no banco de dados. \n' 'Não existe frequencia com esse ID no banco de dados.') @api.response(204, 'Success') def delete(self, codigo, frequencia_id): ''' Deleta o registro de uma frequencia com determinado ID ''' if not Turma.query.filter_by(codigo=codigo).first(): return abort( 400, 'Não existe turma com esse codigo no banco de dados.') frequencia_selected = Frequencia.query.filter_by(id=frequencia_id) if not frequencia_selected.first(): return abort( 400, 'Não existe frequencia com esse ID no banco de dados.') frequencia_selected.delete() db.session.commit() return {}, 204 api.add_resource(rota_acesso_todas_frequencias, '/<string:codigo>/frequencias/') api.add_resource(rota_acesso_unico_frequencias, '/<string:codigo>/frequencias/<int:frequencia_id>/')
@api.doc( responses={ 401: 'Token inválida. \n' 'Token já expirou. \n' 'O header de autorização não está presente.' }) class rota_acesso_erros(Resource): @api.response(400, 'Não existe turma com esse código no banco de dados. \n' 'Não existe frequência com esse ID no banco de dados.') @api.response(200, 'Success', erros_field) def get(self, codigo, frequencia_id): ''' Acesso ao registro de correções feitas através da rota PUT para a presença de alunos ''' if not Turma.query.filter_by(codigo=codigo).first(): return abort( 400, 'Não existe turma com esse codigo no banco de dados.') if not Frequencia.query.filter_by(id=frequencia_id).first(): return abort( 400, 'Não existe frequencia com esse ID no banco de dados.') erros = AnotacaoErros.query.filter_by(frequencia_id=frequencia_id) return ErrosSchema(many=True).dump(erros) api.add_resource(rota_acesso_erros, '/<string:codigo>/frequencias/<int:frequencia_id>/erros/')
"""Returns user profile info""" try: args = parser.parse_args() user_id = args['user-id'] if not user_id: user_id = current_user().id logger.info("UserProfile.get() user_id: %s", str(user_id)) return User.get_user_profile_info(user_id), 200 except Exception as e: logger.exception("UserProfile.get(): %s", str(e)) return "Couldn't load user profile info", 500 @auth_required def put(self): """Updates current user profile info""" logger.info("UserProfile.put() user_id: %s", str(current_user().id)) try: user_id = current_user().id content = json.loads(request.form['data']) photo = request.files.get('photo', None) photo_url = cloudinary_uploader.upload( photo)['url'] if photo else None User.update_user_profile_info(user_id, content, photo_url) return 'User profile info has been updated', 200 except Exception as e: logger.exception("UserProfile.put(): %s", str(e)) return "Couldn't update user profile info", 500 user_profile_namespace.add_resource(UserProfile, "")
with open('registry.json', 'r') as fd: json_data = json.load(fd) if json_in['name'] not in json_data: json_data['name'] = {} json_data['name']['type'] = json_in['type'] json_data['name']['ip-address'] = json_in['ip-address'] json_data['name']['room'] = json_in['room'] with open('registry.json', 'w') as fd: fd.write(json.dumps(json_data)) register.add_resource(RegisterApi, '') app = Flask(__name__) app.config['SECRET_KEY'] = os.urandom(128) api = Api(app) api.add_namespace(register) @app.route('/dashboard') def index(): with open('registry.json', 'r') as fd: json_data = json.load(fd) return render_template("registry.html", data=json_data)
}, ) class accountsList(Resource): @accounts_namespace.marshal_with(view_account, as_list=True, envelope="data") def get(self): """Returns all accounts""" return get_all_accounts(), 200 # updated @accounts_namespace.expect(account, validate=True) def post(self): """Create new account""" post_data = request.get_json() email = post_data.get("email") password = post_data.get("password") response_object = {} account = get_account_by_email(email) if account: response_object["message"] = "Sorry. That email already exists." return response_object, 400 add_account(email, password) # new response_object["message"] = f"{email} registered!" return response_object, 201 accounts_namespace.add_resource(accountsList, "")
def setup_routes(ns: Namespace): ns.add_resource(IsConnected, "/isConnected") # Bee data ns.add_resource(Beedex, "/beedex/<int:id>") ns.add_resource(Beedex, "/beedex") ns.add_resource(BeeRecord, "/beerecord/<int:id>") ns.add_resource(BeeRecordsList, "/beerecords/<int:page>") ns.add_resource(BeeVisRecords, "/beevisrecords") ns.add_resource(BeeUserRecords, "/beerecorduser") ns.add_resource(RecordData, "/record") ns.add_resource(NoElevationData, "/noelevationrecords") # Flower data -- don't look at me like that! I didn't write the API interface spec! ns.add_resource(Flowerdex, "/addflower") # POST new flower. ns.add_resource(Flowerdex, "/flowerdex") # GET or POST flower. ns.add_resource(Flowerdex, "/flowerdex/<int:id>") # GET or DELETE flower entry ns.add_resource(Flowerdex, "/deleteflower/<int:id>") # DELETE flower. ns.add_resource(FlowerList, "/flowerlist") # Legacy support for flowerlist endpoint ns.add_resource(FlowerShapes, "/flowershapes") ns.add_resource( FlowerShapes, "/flowercolors") # Not a typo, these have the same handler... ns.add_resource(UnmatchedFlowers, "/unmatched_flowers") # Media upload ns.add_resource(UploadImage, "/uploadImage64") ns.add_resource(UploadVideo, "/uploadVideo") # Login/refresh/logout ns.add_resource(Enroll, "/enroll") ns.add_resource(Refresh, "/refresh") ns.add_resource(Unenroll, "/unenroll") # News ns.add_resource(UpdateBioCSNews, "/update_biocsnews") ns.add_resource(GetBioCSNews, "/biocsnews") ns.add_resource(UpdateNews, "/update_news") ns.add_resource(GetNews, "/news") # Admin ns.add_resource(VerifyAdmin, "/verifyAdmin")
response_object = {} # User validation before deleting was_successful, session_token = extract_token(request) response_object = {} if not was_successful: response_object["message"] = session_token return response_object, 400 # Check token validity user = get_user_by_session_token(session_token) if user is None: response_object["message"] = "Invalid token." return response_object, 400 # Create / validate Review object user_id = user.id review = get_review_by_id(review_id) if review is None: reviews_namespace.abort(404, f"Review {review_id} does not exist") elif user_id != review.user_id: reviews_namespace.abort(400, "Cannot delete other user's review") if not review: reviews_namespace.abort(404, f"Review {review_id} does not exist.") delete_review(review) response_object["message"] = f"Review {review.id} was deleted." return response_object, 200 reviews_namespace.add_resource(ReviewsList, "") reviews_namespace.add_resource(Reviews, "/<int:review_id>")
try: pmh = PluginManagerHandler() plugindata = pmh.get_plugindata() plugin_module_names = pmh.get_plugins() except Exception as e: return empty_result('error', "Error retrieving plugins {}".format(str(e))) else: return empty_result('success', { 'loaded_plugins': plugin_module_names, 'plugindata': plugindata }) @jwt_required @api.expect(plugin_model) def put(self): """ Modify plugins """ json_data = request.get_json() if 'action' in json_data: if str(json_data['action']).upper() == 'SELFTEST': pmh = PluginManagerHandler() res = pmh.pm.hook.selftest() return empty_result('success', {'result': res}) else: return empty_result('error', "Unknown action specified"), 400 else: return empty_result('error', "No action specified"), 400 api.add_resource(PluginsApi, '')
try: content = json.loads(request.form['data']) user_id = current_user().id photo = request.files.get('photo', None) photo_url = cloudinary_uploader.upload( photo)['url'] if photo else None for parameter in [ 'name', 'portions_number', 'longitude', 'latitude', 'pickup_times', 'offer_expiry' ]: if parameter not in content: return f"{parameter} missing in request", 400 offer_id = Offer.add_offer( user_id, content['name'], True, content['portions_number'], 0, content['longitude'], content['latitude'], datetime.now(), content['pickup_times'], content['offer_expiry'], content.get('description', None), photo_url) for tag_id in content.get('tags', []): OffersTags.add_offer_tag(offer_id, tag_id) return "Offer has been added", 201 except Exception as e: logger.exception("Offers.post(): %s", str(e)) return "Couldn't add offers", 500 offers_namespace.add_resource(Offers, "")
if not user: users_namespace.abort(404, f"User {user_id} does not exist") if get_user_by_email(email): response_object["message"] = "Sorry. That email already exists." return response_object, 400 update_user(user, username, email) response_object["message"] = f"{user.id} was updated!" return response_object, 200 @users_namespace.response(200, "<user_id> was removed!") @users_namespace.response(404, "User <user_id> does not exist") def delete(self, user_id): """ "Deletes a user.""" response_object = {} user = get_user_by_id(user_id) if not user: users_namespace.abort(404, f"User {user_id} does not exist") delete_user(user) response_object["message"] = f"{user.email} was removed!" return response_object, 200 users_namespace.add_resource(UsersList, "") users_namespace.add_resource(Users, "/<int:user_id>")
update_order_item(order_item, order_id, catalog_id, catalog_item_id, quantity, actual_cost, points_cost) response_object["message"] = f"{order_item.id} was updated!" return response_object, 200 @order_items_namespace.response(200, "<order_item_id> was removed!") @order_items_namespace.response(404, "Order item <order_item_id> does not exist" ) def delete(self, order_item_id): """Updates an order item.""" response_object = {} order_item = get_order_item_by_id(order_item_id) if not order_item: order_items_namespace.abort( 404, f"Order item {order_item_id} does not exist") delete_order_item(order_item) response_object["message"] = f"Order item {order_item.id} was removed!" return response_object, 200 orders_namespace.add_resource(OrdersList, "") orders_namespace.add_resource( OrdersListbyUser, "/by_user/<int:user_id>/by_caller/<int:caller_id>") # orders_namespace.add_resource(OrdersListbyUser, "/by_user") orders_namespace.add_resource(Orders, "/<int:order_id>") order_items_namespace.add_resource(OrderItemsList, "") order_items_namespace.add_resource(OrderItemsListbyOrder, "/by_order/<int:order_id>") order_items_namespace.add_resource(OrderItems, "/<int:order_item_id>")