class OrderCollectionResource(Resource): decorators = [auth.login_required] @marshal_with(order_list_fields) def get(self, enter_id=None, monitor_id=None): parser = reqparse.RequestParser() parser.add_argument('currentPage', type=int, default=1) parser.add_argument('pageSize', type=int, default=20) parser.add_argument('enterId', default=enter_id) parser.add_argument('monitorId', default=monitor_id) parser.add_argument('state', type=str, default='') args = parser.parse_args() current_page = args.pop('currentPage') page_size = args.pop('pageSize') if args['enterId']: query = Enter.query.get_or_abort(args.pop('enterId')).orders elif args['monitorId']: query = Monitor.query.get_or_abort(args.pop('monitorId')).orders else: query = Order.query.filter_by_user() return query.filter_by_state(args.pop('state')) \ .filter_by_args(args) \ .paginate(current_page, page_size, False) api.add_resource(OrderResource, '/orders/<int:order_id>', '/processes/<int:process_id>/order') api.add_resource(OrderCollectionResource, '/orders', '/enters/<int:enter_id>/orders', '/monitors/<int:monitor_id>/orders')
Date: 2018/6/2 """ from flask_restful import Resource from app.api import api from app.models.admin.config import FConfig, config_parse from lib.principal.auth import admin_authority, auth_token from flask_login import login_required from lib.code import Msg from datetime import datetime from flask import g class CrudConfig(Resource): @auth_token @admin_authority def post(self): arg = config_parse.parse_args() config = FConfig.query_one(server_name=arg['server_name']) if config: arg['update_time'] = datetime.now() config.update(**arg) arg['update_time'] = str(config.update_time) arg['create_time'] = str(config.create_time) return Msg.success('ok', config=arg) else: FConfig.create(**arg) return Msg.success('ok', config=arg) api.add_resource(CrudConfig, '/config', endpoint='config')
teams.append(team) return {'success': teams} class AllPlayers(Resource): """AllPlayers Class is the Resource for fetching all players in the elastic search index :extends Resource :returns: a JSON response """ @api_response def get(self): query = {"query": {"match_all": {}}} resp = requests.post(elasticsearch_url + 'nba_players/_search', json=query) data = resp.json() teams = [] for hit in data['hits']['hits']: team = hit['_source'] team['id'] = hit['_id'] teams.append(team) return {'success': teams} # Add resource endpoints here ================================================= api.add_resource(Player, '/player/search') api.add_resource(AllPlayers, '/players')
topic.followers_count += 1 print topic.followers_count db.session.commit() except: db.session.rollback() return abort(500, message='operation failed') return topic def delete(self, name): topic = None if not current_user.is_authenticated: return abort(401, message='permission denied') for topic in current_user.following_topics: if topic.name == name: break else: return abort(400, message='topic not found') try: current_user.following_topics.remove(topic) if topic.followers_count > 0: topic.followers_count -= 1 db.session.commit() except: db.session.rollback() return abort(500, message='operation failed') api.add_resource(UserTopics, '/api/user/topics/<string:name>', endpoint='api.user_topics')
} class CtlUser(Resource): @marshal_with(user_fields) def get(self, uid=None): arg = user_get_parser.parse_args() id = arg.get('uid') user = User.get_by_id(id) return user @marshal_with(user_fields) def post(self): arg = user_parser.parse_args() user = User.create(**arg) use_folder = user.use_folder os.mkdir(os.path.join(UPLOAD_PATH, use_folder)) return user class UpdateUser(Resource): @marshal_with(user_fields) def post(self): arg = user_parser.parse_args() user = User.update(**arg) return user api.add_resource(HelloWorld, '/hello', endpoint='hello') api.add_resource(CtlUser, '/user', endpoint='user')
from app.api import api from app.main.resources import UserListResource from app.climbing.resources import (RouteResource, RouteListResource, SessionResource) api.add_resource(UserListResource, '/users') api.add_resource(RouteListResource, '/routes') api.add_resource(RouteResource, '/route/<int:route_id>') api.add_resource(SessionResource, '/session', '/session/<int:session_id>')
application.logger.error("UnicodeError: " + str(e)) return "Bad Request", 400 except TypeError as e: application.logger.error("TypeError: " + str(e)) return "Bad Request", 400 except KeyError as e: application.logger.error("KeyError: " + str(e)) return "Bad Request", 400 except Exception as e: application.logger.error("Unknow Exception: " + str(e)) return "Bad Request", 400 return save_events(events) api.add_resource(ReadEventsFromArgument, "/api/events") @application.route("/events", methods=["POST"]) @auth.login_required def save_events_from_file(): """ Api method to receive the events from all the devices :return: HTML answer """ try: f = request.files["uploaded_file"] # Uncompress Gzip file u = gzip.open(f, "rb")
class LicenseFactorCollectionResource(Resource): decorators = [auth.login_required] @marshal_with(license_factor_list_fields) def get(self, license_id=None): parser = reqparse.RequestParser() parser.add_argument('currentPage', type=int, default=1) parser.add_argument('pageSize', type=int, default=20) parser.add_argument('licenseId', default=license_id) args = parser.parse_args() current_page = args.pop('currentPage') page_size = args.pop('pageSize') if args['licenseId']: query = License.query.get_or_abort( args.pop('licenseId')).licenseFactors else: query = LicenseFactor.query return query.filter_by_args(args) \ .paginate(current_page, page_size, False) api.add_resource(LicenseResource, '/licenses/<int:license_id>', '/licenseFactors/<int:factor_id>/license') api.add_resource(LicenseCollectionResource, '/licenses', '/enters/<int:enter_id>/licenses') api.add_resource(LicenseFactorResource, '/licenseFactors/<int:factor_id>') api.add_resource(LicenseFactorCollectionResource, '/licenseFactors', '/licenses/<int:license_id>/licenseFactors')
@auth_token def post(self): arg = self.parse.parse_args() folder = DiskFolder.get_by_id(arg['id']) if folder: print(arg) folder.update(**arg) return Msg.success('ok') else: return Msg.failed_dict(1002) class DeleteFolder(Resource): parse = reqparse.RequestParser() parse.add_argument('id', type=int, required=True) @auth_token def post(self): arg = self.parse.parse_args() folder = DiskFolder.get_by_id(**arg) if folder: folder.delete() return Msg.success('ok') else: return Msg.failed_dict(1002) api.add_resource(CreateFolder, '/folder/add', endpoint='c_folder') api.add_resource(UpdateFolder, '/folder/update', endpoint='u_folder') api.add_resource(DeleteFolder, '/folder/delete', endpoint='d_folder')
user_fields = { 'username': fields.String, 'email': fields.String, } class UserResource(Resource): # @marshal_with(user_fields) def get(self, username=None): user = User.query.filter_by(username=username).first() if user is None: raise NotFoundError( message="not found username like '{0}'".format(username)) return user.to_dict() class UserCollectionResource(Resource): def get(self): users = [item.to_dict() for item in User.query.all()] return {'data': users} @marshal_with(user_fields) def post(self): user = User.create(**user_parser.parse_args()) return user, 201 api.add_resource(UserResource, '/users/<username>') api.add_resource(UserCollectionResource, '/users')
parser.add_argument('pageSize', type=int, default=20) parser.add_argument('enterId', default=enter_id) parser.add_argument('dischargeId', default=discharge_id) parser.add_argument('enterName', default=None) parser.add_argument('areaCode', default=None) parser.add_argument('monitorType', default=None) parser.add_argument('state', type=str, default='') args = parser.parse_args() current_page = args.pop('currentPage') page_size = args.pop('pageSize') if args['enterId']: query = Enter.query.get_or_abort(args.pop('enterId')).monitors elif args['dischargeId']: query = Discharge.query.get_or_abort( args.pop('dischargeId')).monitors else: query = Monitor.query.filter_by_user() return query.filter_by_state(args.pop('state')) \ .filter_by_args(args) \ .paginate(current_page, page_size, False) api.add_resource(MonitorResource, '/monitors/<int:monitor_id>', '/orders/<int:order_id>/monitor', '/reports/<int:report_id>/monitor', '/dischargeReports/<int:discharge_report_id>/monitor', '/factorReports/<int:factor_report_id>/monitor') api.add_resource(MonitorCollectionResource, '/monitors', '/enters/<int:enter_id>/monitors', '/discharges/<int:discharge_id>/monitors')
return DischargeReport.query.get_or_abort(discharge_report_id).discharge elif factor_report_id: return FactorReport.query.get_or_abort(factor_report_id).discharge class DischargeCollectionResource(Resource): decorators = [auth.login_required] @marshal_with(discharge_list_fields) def get(self, enter_id=None): parser = reqparse.RequestParser() parser.add_argument('currentPage', type=int, default=1) parser.add_argument('pageSize', type=int, default=20) parser.add_argument('enterId', default=enter_id) parser.add_argument('dischargeType', default=None) args = parser.parse_args() current_page = args.pop('currentPage') page_size = args.pop('pageSize') if args['enterId']: query = Enter.query.get_or_abort(args.pop('enterId')).discharges else: query = Discharge.query.filter_by_user() return query.filter_by_args(args) \ .paginate(current_page, page_size, False) api.add_resource(DischargeResource, '/discharges/<int:discharge_id>', '/monitors/<int:monitor_id>/discharge', '/reports/<int:report_id>/discharge', '/dischargeReports/<int:discharge_report_id>/discharge', '/factorReports/<int:factor_report_id>/discharge') api.add_resource(DischargeCollectionResource, '/discharges', '/enters/<int:enter_id>/discharges')
from app.api import api from app.api.api_classes import * """ Applications """ api.add_resource(Applications, '/applications') api.add_resource(ApplicationSingle, '/applications/<application_id>') api.add_resource(ApplicationSingleCargos, '/applications/<application_id>/cargos') api.add_resource(ApplicationSingleDrivers, '/applications/<application_id>/drivers') api.add_resource(ApplicationSingleCars, '/applications/<application_id>/cars') api.add_resource(ApplicationSingleDriverSingle, '/applications/<application_id>/drivers/<driver_id>') api.add_resource(ApplicationSingleCarSingle, '/applications/<application_id>/cars/<car_id>') """ Drivers """ api.add_resource(Drivers, '/drivers') api.add_resource(DriverSingle, '/drivers/<driver_id>') api.add_resource(DriversService, '/drivers/<driver_id>/service') api.add_resource(DriversApplications, '/drivers/<driver_id>/applications') """ Cars """ api.add_resource(Cars, '/cars') api.add_resource(CarSingle, '/cars/<car_id>') api.add_resource(CarsService, '/cars/<car_id>/service') api.add_resource(CarsApplications, '/cars/<car_id>/applications') """ Clients """ api.add_resource(Clients, '/clients') api.add_resource(ClientSingle, '/clients/<client_id>')
@auth_token def post(self): arg = self.parse.parse_args() file = DiskFile.query_one(id=arg['id'], user_id=g.user.id) if file: file.update(**arg) return Msg.success('ok') else: return Msg.failed_dict(1002) # 此处删除为逻辑删除 class DeleteFile(Resource): parse = reqparse.RequestParser() parse.add_argument('id', type=int, required=True) @auth_token def post(self): arg = self.parse.parse_args() file = DiskFile.query_one(id=arg['id'], user_id=g.user.id) if file: file.update(id=arg['id'], is_trash=1) return Msg.success('ok') else: return Msg.failed_dict(1002) api.add_resource(CreateFile, '/file/add', endpoint='c_file') api.add_resource(UpdateFile, '/file/update', endpoint='u_file') api.add_resource(DeleteFile, '/file/delete', endpoint='d_file')
class BackupFiles(Resource): folder_parse = reqparse.RequestParser() # folder_parse.add_argument('event', required=True, type=str) folder_parse.add_argument('file_data', required=True, type=FileStorage, location='files') folder_parse.add_argument('show_name', required=True, type=int) folder_parse.add_argument('file_name', required=True, type=int) folder_parse.add_argument('file_size', required=True, type=str) folder_parse.add_argument('user_id', required=True, type=str) folder_parse.add_argument('is_share', required=True, type=str) @admin_authority @auth_token def post(self): arg = self.folder_parse.parse_args() ad_config = FConfig.query_one(server_name=SERVER_NAME) backup_base_path = ad_config.backup_base_path path = os.path.join(backup_base_path, arg['file_name']) file = arg['file_data'] file.save(path) arg['path'] = path arg.pop('file_data') Backup.create(**arg) return Msg.success('ok', filename=arg['file_name']) api.add_resource(BackupFiles, '/backup', endpoint='backup')
db.session.flush() if files: for file in files: file_args = save_file(file) file_args['fileModelId'] = report.reportId file_args['fileModel'] = app.app.config[ 'FACTOR_REPORT_FILE_MODEL'] file_args['fileType'] = app.app.config[ 'FACTOR_REPORT_FILE_TYPE'] attachment = Attachment(**file_args) db.session.add(attachment) db.session.commit() return {'success': True, 'message': '提交成功'} api.add_resource(ReportResource, '/reports/<int:report_id>') api.add_resource(ReportCollectionResource, '/reports', '/enters/<int:enter_id>/reports', '/discharges/<int:discharge_id>/reports', '/monitors/<int:monitor_id>/reports') api.add_resource(LongStopReportResource, '/longStopReports/<int:report_id>') api.add_resource(LongStopReportCollectionResource, '/longStopReports', '/enters/<int:enter_id>/longStopReports') api.add_resource(DischargeReportResource, '/dischargeReports/<int:report_id>') api.add_resource(DischargeReportCollectionResource, '/dischargeReports', '/enters/<int:enter_id>/dischargeReports', '/discharges/<int:discharge_id>/dischargeReports', '/monitors/<int:monitor_id>/dischargeReports') api.add_resource(FactorReportResource, '/factorReports/<int:report_id>') api.add_resource(FactorReportCollectionResource, '/factorReports', '/enters/<int:enter_id>/factorReports',
from flask_restful import reqparse, Resource from app.api import api from workers.worker1 import printNumbers from random import randint parser = reqparse.RequestParser() parser.add_argument('url') class UrlsResource(Resource): def post(self): args = parser.parse_args() #add celery job here printNumbers.delay() #for now make dummy response with post url parameters response = { 'job_id' : randint(0,1000), 'status' : "queued", 'description' : 'Your crawling reuest for url ' + args.url + 'is accpeted', } return response,200 api.add_resource(UrlsResource, '/urls')
from app.api import (AllUsers, AllRequests, Manage, ManageRequests, UserLogin, UserRegistration, api, app, AdminApproval, AdminDisapprove, AdminResolve) from flask_jwt_extended import JWTManager app.config['JWT_SECRET_KEY'] = 'jwt-secret-string' jwt = JWTManager(app) api.add_resource(UserRegistration, '/auth/signup') # user registration api.add_resource(UserLogin, '/auth/login') # user login api.add_resource(ManageRequests, '/users/requests') # creating a request api.add_resource(AllRequests, '/requests') # view all requests # put and get for a single record api.add_resource(Manage, '/users/requests/<int:id>') # approve a request api.add_resource(AdminApproval, '/requests/<int:id>/approve') # disapprove a request api.add_resource(AdminDisapprove, '/requests/<int:id>/disapprove') # resolve approved requests api.add_resource(AdminResolve, '/requests/<int:id>/resolve') api.add_resource(AllUsers, '/users') if __name__ == '__main__': app.run(debug=True)
return abort(403, message='points are not enough') current_user.points -= pt s.ratings_count += 1 s.rating = (rating_sum + rating) / s.ratings_count log = PointLog('SNIPPET_RATING', pt, user, s) voter = Voter(user, s) voter.value = rating db.session.add(voter) db.session.add(log) db.session.add(s) else: s.rating = (rating_sum - voter.value + rating) / s.ratings_count voter.value = rating db.session.add(voter) try: db.session.commit() except: db.session.rollback() return abort(500, message='operation failed') result = marshal(voter, voter_fields) result['snippet'] = marshal(s, snippet_fields) return result api.add_resource(Snippets, '/api/repos/<string:username>/<string:repo>/snippets', endpoint='api.snippets') api.add_resource(SnippetVoters, '/api/snippets/<string:id>/voters/<string:username>', endpoint='api.snippet_voters')
from app.api import api from app.api.resources.ping import Ping from app.api.resources.login import Login from app.api.resources.user import User, UserList from app.api.resources.post import Post, PostList from app.api.resources.comment import Comment, CommentList from app.api.resources.info import Info api.add_resource(Ping, "/ping/") api.add_resource(Login, "/login/") # api.add_resource(UserList, "/users") api.add_resource(User, "/users/<user_id>/") api.add_resource(PostList, "/posts/") api.add_resource(Post, "/posts/<post_id>/") api.add_resource(CommentList, "/comments/") api.add_resource(Comment, "/comments/<comment_id>/") api.add_resource(Info, "/info/")
""" CREATE: 2018/5/16 AUTHOR: HEHAHUTU """ from flask_restful import Resource from app.api import api from flask_login import login_required from lib.code import Msg class TaskOperation(Resource): @login_required def get(self): return Msg.success('success') api.add_resource(TaskOperation, '/task', endpoint='task')
@marshal_with(factor_list_fields) def get(self, enter_id=None, discharge_id=None, monitor_id=None): parser = reqparse.RequestParser() parser.add_argument('currentPage', type=int, default=1) parser.add_argument('pageSize', type=int, default=20) parser.add_argument('factorCode', default=None) parser.add_argument('enterId', default=enter_id) parser.add_argument('dischargeId', default=discharge_id) parser.add_argument('monitorId', default=monitor_id) args = parser.parse_args() current_page = args.pop('currentPage') page_size = args.pop('pageSize') if args['enterId']: query = Enter.query.get_or_abort(args.pop('enterId')).factors elif args['dischargeId']: query = Discharge.query.get_or_abort( args.pop('dischargeId')).factors elif args['monitorId']: query = Monitor.query.get_or_abort(args.pop('monitorId')).factors else: query = Factor.query return query.filter_by_args(args) \ .paginate(current_page, page_size, False) api.add_resource(FactorResource, '/factors/<int:factor_id>') api.add_resource(FactorCollectionResource, '/factors', '/enters/<int:enter_id>/factors', '/discharges/<int:discharge_id>/factors', '/monitors/<int:monitor_id>/factors')
factor_report_id=None, process_id=None): parser = reqparse.RequestParser() parser.add_argument('currentPage', type=int, default=1) parser.add_argument('pageSize', type=int, default=20) parser.add_argument('dischargeReportId', default=discharge_report_id) parser.add_argument('factorReportId', default=factor_report_id) parser.add_argument('processId', default=process_id) args = parser.parse_args() current_page = args.pop('currentPage') page_size = args.pop('pageSize') if args['dischargeReportId']: query = DischargeReport.query.get_or_abort( args.pop('dischargeReportId')).attachments elif args['factorReportId']: query = FactorReport.query.get_or_abort( args.pop('factorReportId')).attachments elif args['processId']: query = Process.query.get_or_abort( args.pop('processId')).attachments else: query = Attachment.query return query.paginate(current_page, page_size, False) api.add_resource(AttachmentResource, '/attachments/<int:attachment_id>') api.add_resource(AttachmentCollectionResource, '/attachments', '/dischargeReports/<int:discharge_report_id>/attachments', '/factorReports/<int:factor_report_id>/attachments', '/processes/<int:process_id>/attachments')
from flask_restful import Resource from app.api import api from app.api.helpers import cityAddress # @app.route('/city/<cityname>') # def get_city(cityname): # return 'User %s' % cityname class city(Resource): def get(self, cityname): return cityAddress.get_address(cityname) api.add_resource(city, '/city/<string:cityname>')
page = request.args.get('page', 1, type=int) per_page = min(request.args.get('per_page', 10, type=int), 100) data = Task.to_collection_dict(Task.query, page, per_page) return data class ApiTaskToggleDone(Resource): """ Defines resource class for task done """ def put(self, task_id): """ Implement PUT method """ task = Task.query.get(task_id) if not task: return error_response(404, "There is no task with this id") if task.done: done_task = DoneTask.query.filter_by(task_id=task_id).first() db.session.delete(done_task) else: done_task = DoneTask(task_done=task) db.session.add(done_task) db.session.commit() return jsonify(task.to_dict()) api.add_resource(ApiTask, '/api/tasks') api.add_resource(ApiTaskId, '/api/tasks/<int:task_id>') api.add_resource(ApiTaskToggleDone, '/api/tasks/<int:task_id>/toggle_done')
from flask_restful import Resource from app.api import api from flask_restful_swagger import swagger class CustomersResource(Resource): "My CUSTOMER API" @swagger.operation( notes='get a customer list', nickname='get', # Parameters can be automatically extracted from URLs (e.g. <string:id>) # but you could also override them here, or add other parameters. parameters=[ { "name": "customer_id", "description": "The ID of customer", "required": True, "allowMultiple": False, "dataType": 'string', } ]) def get(self): customers = { '1' : "customer 1", '2' : "customer 2", '3' : "customer 3", } return customers,200 api.add_resource(CustomersResource, '/customers')
class LoginUser(Resource): def post(self): arg = login_parse.parse_args() user = User.query.filter_by(username=arg.get('username')).first() if user: if user.check_password(arg.get('password')): next = request.args.get('next') # next_is_valid should check if the user has valid # identity_changed.send(current_app._get_current_object(), identity=Identity(user.id)) # permission to access the `next` url if not next_is_valid(next): return {'message': 'next url valid failed'}, 400 return Msg.success('登录成功', assess_key=user.generate_auth_token()) else: return Msg.login_password_error('用户名和密码不匹配') else: return Msg.login_username_error('用户名不存在') class LogoutUser(Resource): def post(self): return Msg.success('logout success') api.add_resource(LoginUser, '/login', endpoint='login') api.add_resource(LogoutUser, '/logout', endpoint='logout')
"1,1452*,785*,452*,15*,23*,1*", "50": "1,%s,0*,%s" % (g.user.rainEnterCount, g.user.rainDischargeCount), "40": "1,%s,%s,257*,%s,%s,%s,%s,%s,0*" % (g.user.totalEnterCount, g.user.importantEnterCount, g.user.waterEnterCount, g.user.airEnterCount, g.user.waterAirEnterCount, g.user.waterDischargeCount, g.user.airDischargeCount), "30": "1, 16*, 93.75*, 92.75*, 100*", "20": "1,41*, 28*, 30*", "31": "1, 10*, 100*, 100*, 88.89*", "10": "1,南昌市*,2019年08月10日 09时*,67*,良*,PM2.5 SO2*,80*,72*,12*,22*,20*,0.32*", "21": "1, 91.4*, 96.19*, 202*" } } api.add_resource(AdminUserResource, '/admin/users/<int:id>', '/admin/users/<string:user_name>') api.add_resource(AdminUserCollectionResource, '/admin/users') api.add_resource(AdminTokenResource, '/admin/token') api.add_resource(EnterTokenResource, '/enter/token') api.add_resource(IndexResource, '/index')
teams.append(team) return {'success': teams} class AllGames(Resource): """AllGames Class is the Resource for fetching all of the game data limited to 100 response hits from an elasticsearch instance :extends Resource :returns: a JSON response """ @api_response def get(self): query = {"query": {"match_all": {}}, "size": 100} resp = requests.post(elasticsearch_url + 'nba_games/_search', json=query) data = resp.json() teams = [] for hit in data['hits']['hits']: team = hit['_source'] team['id'] = hit['_id'] teams.append(team) return {'success': teams} # Add resource endpoints here ================================================= api.add_resource(Game, '/game/search') api.add_resource(AllGames, '/games')
parser = reqparse.RequestParser() parser.add_argument('roles') args = parser.parse_args() user = User.get(User.id == id) user_roles = [role.name for role in list(user.roles.select())] roles = args['roles'].strip(",").replace(" ", "").split(",") for role in roles: if role not in user_roles: user_datastore.add_role_to_user(user, role) for role in user_roles: if role not in roles: user_datastore.remove_role_from_user(user, role) return user @roles_required("admin") def delete(self, id): user = User.get(User.id == id) user_datastore.delete_user(user) return "Deleted" api.add_resource(UserList, '/users/') api.add_resource(UserDetail, '/user/<int:id>')
from app.api import api from .resources.signin import Signin from .resources.login import Login from .resources.deliveries import Deliveries from .resources.test import Test api.add_resource(Signin,'/signin',endpoint='signin') api.add_resource(Login,'/login',endpoint='login') api.add_resource(Deliveries,'/deliveries',endpoint='deliveries') api.add_resource(Test,'/')
from flask_restful import Resource from app.api import api from flask_restful_swagger import swagger class UsersResource(Resource): "My USER API" @swagger.operation( notes='get a user list', nickname='get', # Parameters can be automatically extracted from URLs (e.g. <string:id>) # but you could also override them here, or add other parameters. parameters=[ { "name": "user_id", "description": "The ID of user", "required": True, "allowMultiple": False, "dataType": 'string', } ]) def get(self): users = { '1' : "User 1", '2' : "User 2", '3' : "User 3", } return users,200 api.add_resource(UsersResource, '/users')