def default_list_parser(namespace: Namespace) -> RequestParser:
parser = namespace.parser()
parser.add_argument("limit",
type=int,
required=False,
help="number of items to include in response",
location="args")
parser.add_argument(
"offset",
type=int,
required=False,
help="number of items to offset from the start of response",
location="args")
return parser
#schema_source_model_schema = SCHEMAS_NS.schema_model('SchemaSource', {
#})
VALIDATE_NS = Namespace('validate','Validation results namespace')
wcv = fields.Wildcard(fields.Raw)
validation_input_model = VALIDATE_NS.model('ValidationInput', {
'*': wcv
})
validation_model = VALIDATE_NS.model('Validation', {
'file': fields.String(required=True, description = 'The filename of the JSON which was validated, if it was available'),
'validated': fields.Boolean(required=True, description = "Validation result"),
'schema_id': fields.String(required=False, description = 'The id of the schema used to validate'),
'schema_hash': fields.String(required=False, description = 'The SHA1 hash of the normalized JSON Schema used to validate, in hexadecimal representation'),
'errors': fields.List(fields.Nested(schema_error_model),required=False, description = 'The list of detected errors when the JSON is processed'),
})
#file_upload = reqparse.RequestParser()
file_upload = VALIDATE_NS.parser()
file_upload.add_argument('file',
location='files',
type=werkzeug.datastructures.FileStorage,
# This line can be uncommented to support multiple uploads when
# Swagger-UI fixes this case
#action='append',
required=True,
help='JSON to be validated'
)
login = namespace.model(
"User",
{
"email": fields.String(required=True),
"password": fields.String(required=True)
},
)
refresh = namespace.model("Refresh",
{"refresh_token": fields.String(required=True)})
tokens = namespace.clone("Access and Refresh Tokens", refresh,
{"access_token": fields.String(required=True)})
status_parser = namespace.parser()
status_parser.add_argument("Authorization", location="headers")
class Register(Resource):
@namespace.marshal_with(user_result)
@namespace.expect(user_payload, validate=True)
@namespace.response(201, "Success")
@namespace.response(400, "User with given email already exists")
def post(self):
"""Register and returns new user."""
payload = request.get_json()
username = payload.get("username")
email = payload.get("email")
password = payload.get("password")
from jarr.api.common import get_ui_url
from jarr.bootstrap import conf
from jarr.controllers import UserController
from jarr.lib import emails
from jarr.lib.utils import utc_now
from jarr.metrics import SERVER
auth_ns = Namespace("auth", description="Auth related operations")
model = auth_ns.model(
"Login", {
"access_token":
fields.String(description="The token that must be place "
"in the Authorization header"),
})
login_parser = auth_ns.parser()
login_parser.add_argument("login", type=str, store_missing=False)
login_parser.add_argument("password", type=str, store_missing=False)
login_init_recovery_parser = auth_ns.parser()
login_init_recovery_parser.add_argument("login",
type=str,
required=True,
store_missing=False)
login_init_recovery_parser.add_argument("email",
type=str,
required=True,
store_missing=False)
login_recovery_parser = login_init_recovery_parser.copy()
login_recovery_parser.add_argument("token",
type=str,
required=True,
from werkzeug.exceptions import UnprocessableEntity
import opml
from jarr.controllers import CategoryController, FeedController, UserController
from jarr.lib.utils import utc_now
opml_ns = Namespace('opml',
description="Allows to export and import OPML files")
model = opml_ns.model(
'OPML result', {
'created': fields.Integer(),
'failed': fields.Integer(),
'existing': fields.Integer(),
'exceptions': fields.List(fields.String())
})
parser = opml_ns.parser()
parser.add_argument('opml_file', type=FileStorage, required=True)
OK_GET_HEADERS = {
'Content-Type': 'application/xml',
'Content-Disposition': 'attachment; filename=feeds.opml'
}
@opml_ns.route('')
class OPMLResource(Resource):
@staticmethod
@opml_ns.response(200, 'OK', headers=OK_GET_HEADERS)
@jwt_required()
def get():
user_id = current_identity.id
image_serializer = api.model(
"Kind",
{
"id": fields.String(required=True),
"name": fields.String(required=True),
"image_1": fields.String(required=True, description="File Name 1"),
"image_2": fields.String(required=True, description="File Name 2"),
"image_3": fields.String(required=True, description="File Name 3"),
"image_4": fields.String(required=True, description="File Name 4"),
"image_5": fields.String(required=True, description="File Name 5"),
"image_6": fields.String(required=True, description="File Name 6"),
},
)
parser = api.parser()
parser.add_argument("range",
location="args",
help="Pagination: default=[0,19]")
parser.add_argument("sort",
location="args",
help='Sort: default=["name","ASC"]')
parser.add_argument("filter", location="args", help="Filter default=[]")
file_upload = reqparse.RequestParser()
file_upload.add_argument("image_1",
type=FileStorage,
location="files",
help="image_1")
file_upload.add_argument("image_2",
type=FileStorage,
from flask_restx import Namespace, Resource, reqparse, cors
from database import History, db
api = Namespace('calculator',
description='Computes mathematical expressions',
decorators=[cors.crossdomain(origin="*")])
calc_parser = api.parser()
calc_parser.add_argument('expression',
type=str,
required=True,
help="The mathematical expression to compute")
@api.route('/calc')
@api.expect(calc_parser)
class Calculator(Resource):
def post(self):
args = calc_parser.parse_args()
expression = args['expression']
try:
computation = eval(expression)
hist = History(expression=expression, result=computation)
db.session.add(hist)
db.session.commit()
return {"result": computation}
except:
from users_backend.models import UserModel
from users_backend.db import db
admin_namespace = Namespace('admin', description='Admin operations')
model = {
'id': fields.Integer(),
'username': fields.String(),
# DO NOT RETURN THE PASSWORD!!!
'creation': fields.DateTime(),
}
user_model = admin_namespace.model('User', model)
user_parser = admin_namespace.parser()
user_parser.add_argument('username', type=str, required=True,
help='Username')
user_parser.add_argument('password', type=str, required=True,
help='Password')
@admin_namespace.route('/users/')
class UserCreate(Resource):
@admin_namespace.expect(user_parser)
@admin_namespace.marshal_with(user_model, code=http.client.CREATED)
def post(self):
'''
Create a new user
'''
import base64
from flask import Response
from flask_jwt import current_identity, jwt_required
from flask_restx import Namespace, Resource, fields
from jarr.api.common import (EnumField, parse_meaningful_params,
set_clustering_options, set_model_n_parser)
from jarr.controllers import (FeedBuilderController, FeedController,
IconController)
from jarr.lib.enums import FeedStatus, FeedType
from jarr.lib.filter import FiltersAction, FiltersTrigger, FiltersType
feed_ns = Namespace('feed', description='Feed related operations')
url_parser = feed_ns.parser()
url_parser.add_argument('url',
type=str,
required=True,
nullable=False,
store_missing=False)
filter_model = feed_ns.model(
'Filter', {
'action': EnumField(FiltersAction),
'pattern': fields.String(),
'action on': EnumField(FiltersTrigger),
'type': EnumField(FiltersType),
})
parser = feed_ns.parser()
feed_build_model = feed_ns.model(
'FeedBuilder', {
'link':
from users_backend.db import db
from flask import abort
api_namespace = Namespace('api', description='API operations')
def authentication_header_parser(value):
username = validate_token_header(value, config.PUBLIC_KEY)
if username is None:
abort(401)
return username
# Input and output formats for Users
authentication_parser = api_namespace.parser()
authentication_parser.add_argument('Authorization', location='headers',
type=str,
help='Bearer Access Token')
login_parser = api_namespace.parser()
login_parser.add_argument('username', type=str, required=True,
help='username')
login_parser.add_argument('password', type=str, required=True,
help='password')
@api_namespace.route('/login/')
class UserLogin(Resource):
@api_namespace.doc('login')
"images_amount": fields.Integer("Number of images"),
"image_1": fields.String(required=True, description="File Name 1"),
"image_2": fields.String(required=True, description="File Name 2"),
"image_3": fields.String(required=True, description="File Name 3"),
"image_4": fields.String(required=True, description="File Name 4"),
"image_5": fields.String(required=True, description="File Name 5"),
"image_6": fields.String(required=True, description="File Name 6"),
"complete": fields.Boolean(description="Complete?"),
"created_at": fields.DateTime(description="Creation date"),
"modified_at": fields.DateTime(description="Last modification date"),
"approved_at": fields.DateTime(description="Ready for sale date"),
"prices": fields.Nested(price_fields),
}
parser = api.parser()
parser.add_argument("range", location="args", help="Pagination: default=[0,19]")
parser.add_argument("sort", location="args", help='Sort: default=["name","ASC"]')
parser.add_argument("filter", location="args", help="Filter default=[]")
@api.route("/")
@api.doc("Show all kinds.")
class KindResourceList(Resource):
@marshal_with(kind_serializer_with_relations)
@api.doc(parser=parser)
def get(self):
"""List (Product)Kinds"""
args = parser.parse_args()
range = get_range_from_args(args)
sort = get_sort_from_args(args)
from flask_restx import fields
from flask_restx import Namespace
sentiment_namespace = Namespace("sentiment")
parser = sentiment_namespace.parser()
parser.add_argument("Authorization", location="headers")
sentiment_schema = sentiment_namespace.model(
"Sentiment",
{
"id": fields.Integer(readOnly=True),
"user_id": fields.Integer(required=True),
"keyword": fields.String(required=True),
},
)
update_sentiment_schema = sentiment_namespace.model(
"Update Sentiment",
{
"id": fields.Integer(readOnly=True),
"keyword": fields.String(required=True),
},
)
#from flask_app.app.services.imageService import create_image
from flask_app.app.services.logs import complex_file_handler
from flask_app.app.database.schemas import PostSchema
from flask_app.app.services.imageService import get_picture
myNS = Namespace('my', 'Interacciones de usuarios entre sí. Follow y Chat.')
myNS.logger.addHandler(complex_file_handler)
print(myNS.logger.handlers)
myNS.models[simpleUser.name] = simpleUser
myNS.models[followModel.name] = followModel
myNS.models[profilePicture.name] = profilePicture
myNS.models[picture.name] = picture
parser = myNS.parser()
parser.add_argument('Authorization', location='headers', required=True)
@myNS.route('/foll')
class Follow(Resource):
@myNS.expect(followModel, parser)
@jwt_required()
def patch(self):
username_follower = get_jwt_identity()
body = request.get_json()
user_follower = get_user_by_id(username_follower)
user_followed = get_user_by_username(body['user']['username'])
foll = user_follows_to(user_follower, user_followed)
print(foll)
print(user_followed)
mod_list_values = api.model('ListValues',
{'values': fields.List(fields.String)})
mod_list_match = api.model('ListMatch', {
'name': fields.String,
'value': fields.String,
'matched': fields.Boolean
})
mod_list_values_paged = api.model(
'ListValuesPaged', {
'values': fields.Nested(mod_threat_value),
'pagination': fields.Nested(mod_pagination)
})
list_parser = api.parser()
list_parser.add_argument('data_type', location='args', required=False)
list_parser.add_argument('organization', location='args', required=False)
list_parser.add_argument('page',
type=int,
location='args',
default=1,
required=False)
list_parser.add_argument('page_size',
type=int,
location='args',
default=10,
required=False)
@api.route("")
from flask_restx import Namespace, Resource, fields
from pleromanet.poker import repository, service
api = Namespace('poker', description='')
game_parser = api.parser()
game_parser.add_argument('name', type=str, required=True, location='json')
game_parser.add_argument('big_blind', type=int, required=True, location='json')
game_parser.add_argument('small_blind',
type=int,
required=True,
location='json')
game_parser.add_argument('num_seats', type=int, required=True, location='json')
@api.route('/games/')
class GameList(Resource):
def get(self):
return service.get_games(), 200
@api.doc(parser=game_parser)
def post(self):
game_dict = game_parser.parse_args()
return service.create_game(game_dict), 201
@api.route('/games/id=<string:game_id>')
class Game(Resource):
def get(self, game_id):
return service.get_one_game(game_id), 200
from users_microservice.constants import DEFAULT_RESET_PWD_EMAIL, DEFAULT_RESET_PWD_LEN
from users_microservice.exceptions import (
BlockedUser,
EmailAlreadyRegistered,
PasswordDoesNotMatch,
UserDoesNotExist,
)
from users_microservice.models import BlacklistToken, User, db
from users_microservice.utils import FilterParam, generate_random_password
api = Namespace(
"Users",
description="Users operations",
)
auth_parser = api.parser()
auth_parser.add_argument('Authorization',
type=str,
location='headers',
required=True)
@api.errorhandler(UserDoesNotExist)
def handle_user_does_not_exist(_error: UserDoesNotExist):
"""Handle missing user errors."""
return {"message": "User does not exist"}, 404
@api.errorhandler(BlockedUser)
def handle_blocked_user(_error: BlockedUser):
"""Handle blocked users."""
from datetime import datetime
from flask_jwt_simple import jwt_required
from flask_restx import Resource, Namespace, reqparse
from google.cloud.firestore_v1 import CollectionReference, Query
from engine.admin import add_qa, client
from utils import KST
ns_admin_add = Namespace("admin/qa", description="질문을 추가 합니다.")
parser = ns_admin_add.parser()
parser.add_argument(
"Authorization",
type=str,
location="headers",
help="Bearer jwt token",
required=True,
)
@ns_admin_add.route("/")
class QA(Resource):
@ns_admin_add.doc("새로운 질문을 추가합니다.",
params={
"limit": "limit",
"offset": "offset"
},
parser=parser)
def get(self):
parser = reqparse.RequestParser()
'status': fields.Nested(mod_event_status),
'tags': fields.List(fields.String),
'observables': fields.List(fields.Nested(mod_observable_list)),
'case': fields.String,
'created_at': ISO8601(attribute='created_at'),
'modified_at': ISO8601(attribute='updated_at'),
'raw_log': AsDict,
'signature': fields.String
})
mod_event_rule_name_only = api.model('EventRuleNames', {
'uuid': fields.String,
'name': fields.String
})
event_rule_list_parser = api.parser()
event_rule_list_parser.add_argument('page', type=int, location='args', default=1, required=False)
event_rule_list_parser.add_argument('sort_by', type=str, location='args', default='created_at', required=False)
event_rule_list_parser.add_argument('sort_direction', type=str, location='args', default='asc', required=False)
event_rule_list_parser.add_argument('page_size', type=int, location='args', default=25, required=False)
event_rule_list_parser.add_argument('page_size', location='args', required=False, type=int, default=25)
event_rule_list_parser.add_argument('page', location='args', required=False, type=int, default=1)
event_rule_list_parser.add_argument('rules', location='args', required=False, type=str, action='split')
@api.route("")
class EventRuleList(Resource):
@api.doc(security="Bearer")
@api.marshal_with(mod_event_rule_list_paged)
@api.expect(event_rule_list_parser)
@token_required
def test_parser(self):
api = Namespace('test')
assert isinstance(api.parser(), restx.reqparse.RequestParser)
'signature_fields': fields.List(fields.String),
'observable_fields': fields.List(fields.String),
'interval': fields.Integer(default=5, required=True, min=1),
'lookbehind': fields.Integer(default=5, required=True, min=1),
'mute_period': fields.Integer(default=5, required=True, min=1),
'skip_event_rules': fields.Boolean
},
strict=True)
mod_detection_list_paged = api.model(
'DetectionListPaged', {
'detections': fields.List(fields.Nested(mod_detection_details)),
'pagination': fields.Nested(mod_pagination)
})
detection_list_parser = api.parser()
detection_list_parser.add_argument('agent',
location='args',
type=str,
required=False)
detection_list_parser.add_argument('active',
location='args',
type=xinputs.boolean,
required=False)
detection_list_parser.add_argument('page',
type=int,
location='args',
default=1,
required=False)
detection_list_parser.add_argument('page_size',
type=int,
from flask import request
from flask_restx import Namespace, Resource
from joyuriz.service.image import ImageManager
from joyuriz.service.model import ModelManager
from joyuriz.service.cnn import CNN
predict_ns = Namespace('Predict', path='/api/v1', description='predict')
swagger_parser = predict_ns.parser()
model = ModelManager(CNN, 'models/predict.pt')
@predict_ns.route('/predict')
class Predict(Resource):
""" POST로 받은 이미지를 분류하는 API """
@predict_ns.doc(responses={
200: 'OK',
204: 'Fail to find a face',
400: 'Bad Request',
500: 'Internal Server Error'
})
@predict_ns.expect(swagger_parser)
def post(self):
if "image" not in request.files:
raise ValueError
input_image = request.files["image"].read()
manager = ImageManager(input_image)
tensor_image = manager.find_face().crop_image().to_tensor().get_image()
from flask_restx import Resource, Namespace, reqparse
from werkzeug.datastructures import FileStorage
from werkzeug.utils import secure_filename
from app.utils import allowed_file, ALLOWED_EXTENSIONS
ns = Namespace('upload-file', description='Загрузка фотографии')
upload_parser = ns.parser()
upload_parser.add_argument('file',
type=FileStorage,
location='files',
required=True)
parser = reqparse.RequestParser()
parser.add_argument('file', required=True)
@ns.route("")
class UploadFile(Resource):
@ns.expect(upload_parser)
@ns.doc(responses={
200: 'OK',
400: 'Invalid Argument',
500: 'Неизвестная ошибка'
})
def post(self):
"""
Загрузка фотографии
"""
from flask_restx import Namespace, Resource, fields, reqparse
from flask import make_response, send_file
import json
api = Namespace('identification', description='Identification Type End Points')
validIdentificationCodes = [
'lei', 'birthDate', 'australianBusinessNumber', 'phoneNumber',
'benefitsCard'
]
api_params = api.parser()
# Look only in the querystring
api_params.add_argument('format',
required=False,
location='args',
help='lower case svg or png')
##### Simple Entity Type to Graphic API
@api.route('/code/<identificationcode>')
class countryFlag(Resource):
@api.expect(api_params)
def get(self, identificationcode):
args = api_params.parse_args()
fileType = args['format']
if fileType is None or fileType not in ['png', 'svg']:
fileType = 'png'
identificationCode = identificationcode
from flask_restx import Resource, Namespace, reqparse, fields
from flask_jwt_simple import jwt_required
ns_notice = Namespace("service/notice", description="Service/Notice")
parser = ns_notice.parser()
parser.add_argument(
"Authorization",
type=str,
location="headers",
help="Bearer jwt token",
required=True,
)
NOTICE = None
@ns_notice.route("/")
class Bus(Resource):
@ns_notice.doc(
"태욱아 받아라",
params={
},
)
def get(self):
return NOTICE if NOTICE else None
@ns_notice.doc(
"공지 등록.",
params={"notice": "question"},
parser=parser,
)
from werkzeug.datastructures import FileStorage
from flask import request
from flask_restx import Namespace, Resource, fields
from flask_jwt_extended import jwt_required, get_jwt_claims, get_jwt_identity
from models.software import SoftwareModel
from schemas.software import SoftwareSchema
from user_functions.record_user_log import record_user_log
from user_functions.validate_logo import allowed_file
api = Namespace('software', description='Manage antiviruses')
software_schema = SoftwareSchema()
software_schemas = SoftwareSchema(many=True)
upload_parser = api.parser()
upload_parser.add_argument('logo',
location='files',
type=FileStorage,
required=True,
help='Software Logo') # location='headers'
upload_parser.add_argument('name',
location='form',
type=str,
required=True,
help='Software Name') # location='headers'
logo_parser = api.parser()
logo_parser.add_argument('logo',
location='files',
type=FileStorage,
"last_error": fields.String(),
"type": fields.String(enum=["feed", "categ", "all-categ"]),
})
midle_panel_model = default_ns.model(
"MiddlePanel", {
"id": fields.Integer(),
"feeds_id": fields.List(fields.Integer()),
"main_article_id": fields.Integer(),
"main_feed_title": fields.String(),
"main_title": fields.String(),
"main_date": fields.DateTime(),
"main_link": fields.String(),
"liked": fields.Boolean(default=False),
"read": fields.Boolean(default=False),
})
filter_parser = default_ns.parser()
filter_parser.add_argument(
"search_str",
type=str,
store_missing=False,
help="if specify will filter list with the specified string")
filter_parser.add_argument(
"search_title",
store_missing=False,
type=inputs.boolean,
default=True,
help="if True, the search_str will be looked for in title")
filter_parser.add_argument(
"search_content",
type=inputs.boolean,
default=False,
login = auth_namespace.model(
"User",
{
"email": fields.String(required=True),
"password": fields.String(required=True)
},
)
refresh = auth_namespace.model("Refresh",
{"refresh_token": fields.String(required=True)})
tokens = auth_namespace.clone("Access and refresh_tokens", refresh,
{"access_token": fields.String(required=True)})
parser = auth_namespace.parser()
parser.add_argument("Authorization", location="headers")
class Register(Resource):
@auth_namespace.marshal_with(user)
@auth_namespace.expect(full_user, validate=True)
@auth_namespace.response(201, "Success")
@auth_namespace.response(400, "Sorry. That email already exists.")
def post(self):
post_data = request.get_json()
username = post_data.get("username")
email = post_data.get("email")
password = post_data.get("password")
user = get_user_by_email(email)
from flask import request
from flask_restx import fields, Resource, Namespace
from werkzeug import FileStorage
from libs.validate import Validate
import ipfshttpclient
import json
import os
api = Namespace('ipfs')
upload_parser = api.parser()
upload_parser.add_argument('file',
location='files',
type=FileStorage,
required=True)
conn = ipfshttpclient.connect('/dns4/ipfs.infura.io/tcp/5001/https')
v = Validate()
@api.route('/post_file')
class post_file(Resource):
def post(self):
payload = v.read_requests(request)
print(payload)
cid = conn.add_bytes(payload['buffer'])
return {'result': cid['Hash']}
def make_namespaces(api):
cloudant_client = cloudant.get_client('MODEL_CATALOG')
cos_client = cos.get_client()
bucket = 'object-storage-mnist-model'
result = cloudant_client.get_document(db='models',
doc_id='mnist',
revs=True).get_result()
for num, rev in enumerate(result['_revisions']['ids'][::-1], start=1):
try:
fname = f'model_v{num}.pkl'
ns = Namespace(f'v{num}', description=f'MNIST_v{num}')
upload_parser = ns.parser()
upload_parser.add_argument('image',
location='files',
type=FileStorage,
required=True)
cos_client.get_object(Bucket=bucket, Key=fname)
@ns.route('/info')
class Info(Resource):
FNAME = fname
BUCKET = bucket
REVISION = f'{num}-{rev}'
def get(self):
'''Model info'''
project_dir = current_app.config['PROJECT_DIR']
train_ds, test_ds = get_dataset(f'{project_dir}/data')
X_test, y_test = test_ds.data[:].float(
), test_ds.targets[:]
model_buf = io.BytesIO()
cos_client.download_fileobj(Bucket=self.BUCKET,
Key=self.FNAME,
Fileobj=model_buf)
model_buf.seek(0)
model = pickle.load(model_buf)
pipeline = make_pipeline(Scaler(), Unsqueeze(), model)
score = pipeline.score(X_test, y_test)
return {
'definition':
cloudant_client.get_document(
db='models', doc_id='mnist',
rev=self.REVISION).get_result(),
'score':
score
}
@ns.route('/predict')
@ns.expect(upload_parser)
class Predict(Resource):
FNAME = fname
BUCKET = bucket
def post(self):
'''Predict number'''
args = upload_parser.parse_args()
model_buf = io.BytesIO()
cos_client.download_fileobj(Bucket=self.BUCKET,
Key=self.FNAME,
Fileobj=model_buf)
model_buf.seek(0)
model = pickle.load(model_buf)
img_buf = io.BytesIO()
args['image'].save(img_buf)
uploaded_img = Image.open(img_buf)
pipeline = make_pipeline(Preprocess(), Scaler(),
Unsqueeze(), model)
X = [uploaded_img]
y_hat = pipeline.predict(X)
return {'result': int(y_hat[0])}
yield ns
except cos_client.exceptions.NoSuchKey:
pass
'organization': fields.String,
'name': fields.String,
'description': fields.String,
'members': fields.List(fields.String),
'permissions': fields.Nested(mod_permissions),
'created_by': fields.Nested(mod_user_list),
'created_at': ISO8601(attribute='created_at'),
'system_generated': fields.Boolean
})
mod_role_list_paged = api.model('RolesPaged', {
'roles': fields.Nested(mod_role_list),
'pagination': fields.Nested(mod_pagination)
})
role_list_parser = api.parser()
role_list_parser.add_argument('organization', location='args', required=False)
role_list_parser.add_argument(
'page', type=int, location='args', default=1, required=False)
role_list_parser.add_argument(
'page_size', type=int, location='args', default=10, required=False)
role_list_parser.add_argument(
'sort_by', type=str, location='args', default='created_at', required=False
)
role_list_parser.add_argument(
'sort_direction', type=str, location='args', default='desc', required=False
)
@api.route("")
class RoleList(Resource):
