def create_restful_namespace(self, name: str,
description: str) -> Namespace:
current_app.logger.debug(f"Creating the {name} Namespace")
# create and set up namespace
ns = Namespace(name, description=description)
response_env = ns.model(response_envelope.get("name"),
response_envelope.get("fields"))
meta_env = ns.model(meta_envelope.get("name"),
meta_envelope.get("fields"))
links_env = ns.model(links_envelope.get("name"),
links_envelope.get("fields"))
get_entity_model = ns.clone(f"get_entity_model", response_envelope,
{"data": fields.Raw})
get_entity_list_model = ns.clone(
f"get_entity_list_model",
response_envelope,
{
"data": fields.List(fields.Raw),
"_meta": fields.Nested(meta_env),
"_links": fields.Nested(links_env),
},
)
self._ns = ns
return ns
def test_clone_with_multiple_parents(self):
api = Namespace("test")
grand_parent = api.model("GrandParent", {})
parent = api.model("Parent", {})
api.clone("Child", grand_parent, parent, {})
assert "Child" in api.models
assert "Parent" in api.models
assert "GrandParent" in api.models
def test_inherit_from_multiple_parents(self):
api = Namespace("test")
grand_parent = api.model("GrandParent", {})
parent = api.model("Parent", {})
api.inherit("Child", grand_parent, parent, {})
assert "GrandParent" in api.models
assert "Parent" in api.models
assert "Child" in api.models
def test_clone_with_multiple_parents(self):
api = Namespace('test')
grand_parent = api.model('GrandParent', {})
parent = api.model('Parent', {})
api.clone('Child', grand_parent, parent, {})
assert 'Child' in api.models
assert 'Parent' in api.models
assert 'GrandParent' in api.models
def test_inherit_from_multiple_parents(self):
api = Namespace('test')
grand_parent = api.model('GrandParent', {})
parent = api.model('Parent', {})
api.inherit('Child', grand_parent, parent, {})
assert 'GrandParent' in api.models
assert 'Parent' in api.models
assert 'Child' in api.models
def test_clone(self):
api = Namespace("test")
parent = api.model("Parent", {})
api.clone("Child", parent, {})
assert "Child" in api.models
assert "Parent" in api.models
def test_clone(self):
api = Namespace('test')
parent = api.model('Parent', {})
api.clone('Child', parent, {})
assert 'Child' in api.models
assert 'Parent' in api.models
def set_resp(namespace: Namespace, model: Model = None):
data = fields.Nested(model)
return namespace.model(
model.name + "-response", {
'status': fields.Integer(description='status'),
'message': fields.String(description='message'),
'data': data if data else fields.Raw
})
def init_models(self, namespace: flask_restx.Namespace):
"""
Create flask-restx models that can be used to marshall results (and document service).
:param namespace: Flask-RestX API or namespace.
"""
self.json_post_model = namespace.model(
f"{self.table_or_collection.__name__}_PostRequestModel",
post_request_fields(self.table_or_collection, namespace),
)
self.json_put_model = namespace.model(
f"{self.table_or_collection.__name__}_PutRequestModel",
put_request_fields(self.table_or_collection, namespace),
)
self.get_response_model = namespace.model(
f"{self.table_or_collection.__name__}_GetResponseModel",
get_response_fields(self.table_or_collection, namespace),
)
self.get_history_response_model = namespace.model(
f"{self.table_or_collection.__name__}_GetHistoryResponseModel",
get_history_response_fields(self.table_or_collection, namespace),
)
if self.audit:
self.get_audit_response_model = namespace.model(
f"{self.table_or_collection.__name__}_GetAuditResponseModel",
get_audit_response_fields(self.table_or_collection,
self.history, namespace),
)
self.get_model_description_response_model = namespace.model(
f"{self.table_or_collection.__name__}_GetDescriptionResponseModel",
get_description_response_fields(self.table_or_collection),
)
def test_inherit(self):
authorizations = {
'apikey': {
'type': 'apiKey',
'in': 'header',
'name': 'X-API-KEY'
}
}
api = Namespace('test', authorizations=authorizations)
parent = api.model('Parent', {})
api.inherit('Child', parent, {})
assert 'Parent' in api.models
assert 'Child' in api.models
assert api.authorizations == authorizations
def test_inherit(self):
authorizations = {
"apikey": {
"type": "apiKey",
"in": "header",
"name": "X-API-KEY"
}
}
api = Namespace("test", authorizations=authorizations)
parent = api.model("Parent", {})
api.inherit("Child", parent, {})
assert "Parent" in api.models
assert "Child" in api.models
assert api.authorizations == authorizations
from werkzeug.security import safe_str_cmp
from flask_jwt_extended import create_refresh_token, create_access_token
from flask_restx import Resource, Namespace, fields
from src.models.user import UserModel
ns = Namespace("users", description="Users resource.")
user_schema = ns.model(
"User",
dict(id=fields.Integer(readonly=True, description="User unique id."),
username=fields.String(required=True, description="User name."),
password=fields.String(required=True, description="User password.")))
@ns.route("/")
class Users(Resource):
@ns.doc("list_users")
@ns.marshal_list_with(user_schema, skip_none=True)
def get(self):
return [user.as_dict() for user in UserModel.get_all()]
@ns.doc("create_user")
@ns.expect(user_schema)
@ns.marshal_with(user_schema, skip_none=True)
def post(self):
user = UserModel(username=ns.payload.get('username'),
password=ns.payload.get('password'))
user.save()
return user.as_dict(), 201
from flask import Blueprint, request, jsonify
from http import HTTPStatus
from sqlalchemy import exc, or_
from project.extensions import bcrypt
from project.modules.utils import authenticate
from project.modules.users.models import Users
from flask_restx import Resource, Namespace, fields
from project.modules.utils import authenticate_restful
api = Namespace("Authentication",
description="Authentication related operations")
login_model = api.model(
'Login', {
"email": fields.String(required=True,
description="User email for login"),
"password": fields.String(required=True,
description="Password for login")
})
@api.route('/login')
class Login(Resource):
@api.expect(login_model, validate=True)
def post(self):
post_data = api.payload
response_object = {'status': 'fail', 'message': 'Invalid payload'}
if not post_data:
return response_object, HTTPStatus.BAD_REQUEST
email = post_data.get('email')
from freshermeat.models import User
user_ns = Namespace("user", description="User related operations.")
# Argument Parsing
parser = reqparse.RequestParser()
parser.add_argument("user_id", type=str, help="The id of the user.")
parser.add_argument("login", type=str, help="The login of the user.")
parser.add_argument("page", type=int, default=1, location="args")
parser.add_argument("per_page", type=int, location="args")
# Response marshalling
user = user_ns.model(
"User",
{
"user_id": fields.String(description="The id of the user.", ),
"login": fields.String(description="The login of the user."),
},
)
user_list_fields = user_ns.model(
"UsersList",
{
"metadata":
fields.Raw(
description=
"Metada (number of page, current page, total number of items)."),
"data":
fields.List(fields.Nested(user), description="List of items."),
},
)
from flask_restx import Namespace, Resource, fields
api = Namespace('test', description='TEST related operations')
testserver = api.model(
"TEST Server",
{
"id": fields.String(required=True, description="Server ID"),
"name": fields.String(required=True, description="Server Name"),
"address": fields.String(required=True, description="Server Address")
},
)
SERVERS = [
{
"id": "test01",
"name": "test01.net.windwave.tc",
"address": "10.255.5.10"
},
]
@api.route("/")
class TESTServerList(Resource):
@api.doc("list_servers")
@api.marshal_list_with(testserver)
def get(self):
return SERVERS
from flask_jwt_extended import create_access_token, create_refresh_token, jwt_refresh_token_required
from marshmallow import ValidationError
from models.user_model import User, UserSchema
from models.user_roles_model import UserRole, UserRoleSchema
from user_functions.user_role_manager import UserPrivilege
api = Namespace('login', description='Log in')
user_schema = UserSchema()
users_schema = UserSchema(many=True)
user_role_schema = UserRoleSchema()
my_user_model = api.model('Login', {
'id_no': fields.Integer(required=True, description='ID Number'),
'password': fields.String(required=True, description='Password')
})
@api.route('')
class Login(Resource):
@api.doc('login_user')
@api.expect(my_user_model)
def post(self):
'''Log in user'''
data = api.payload
if not data:
abort(400, 'No input data detected')
id_no = data['id_no']
from flask_restx import Resource, Namespace, fields
from flask import request
import json
from application.service.CarService import CarService # noqa
from core.domain.dto.CarInsertRequestDTO import CarInsertRequestDTO
from core.domain.dto.CarUpdateRequestDTO import CarUpdateRequestDTO
from core.domain.dto.CarInsertResponseDTO import CarInsertResponseDTO
from os import environ
api = Namespace('Car Dealer', description='Car Dealer Services')
# definição de modelo que será validado ao receber post
modelInsert = api.model(
'CarModelInsert', {
'name': fields.String,
'type': fields.String,
'year': fields.Integer,
'isNew': fields.Boolean
})
# definição de modelo que será validado ao receber put
modelUpdate = api.model(
'CarModelUpdate', {
'name': fields.String,
'type': fields.String,
'year': fields.Integer,
'isNew': fields.Boolean
})
hostName = environ.get('SERVER_HOST', 'localhost')
from utils import list_keys
from .handling import generate_yara_rule
from handlers import git_handler
from database.operations import update_rule, get_rule, get_rules
from handlers.config_handler import CONFIG
from handlers.log_handler import create_logger
api = Namespace('core', description='Core API')
log = create_logger(__name__)
yara_metadata_model = api.model("YARA-Metadata", {
"identifier": fields.String(required=True, pattern=r"([a-zA-Z]([a-z0-9])+)"),
"value": fields.String(required=True, pattern=r'.*'),
"value_type": fields.String(required=True, pattern=r'str|int|bool'),
})
yara_string_model = api.model("YARA-String", {
"identifier": fields.String(required=True, pattern=r"([a-zA-Z]([a-z0-9])+)"),
"value": fields.String(required=True, pattern=r'.*'),
"value_type": fields.String(required=True, pattern=r'str|int|bool'),
"string_type": fields.String(required=True, pattern=r'text|hex|regex'),
"modifiers": fields.List(
fields.String(
required=True,
pattern=r"nocase|wide|ascii|xor|base64(wide)?(?'base64_alphabet'.*)?|fullword|private")
),
"modifier_str": fields.String(
required=True,
from flask import request
from flask_restx import Resource, Namespace
from .core import get_resource_modelsdshknn
from ....iomodels import input_def_modelsdshneig, output_def_modelsdshneig
ns_modelsdsh = Namespace(
'others',
description='Fetch/Compute other useful infos for models-dashboard')
input_def = ns_modelsdsh.model(*input_def_modelsdshneig)
output_def = ns_modelsdsh.model(*output_def_modelsdshneig)
@ns_modelsdsh.route("/modelsdsh/neighbors")
class KnnlamdshOthers(Resource):
'''This is a test'''
@ns_modelsdsh.expect(input_def, validate=True)
@ns_modelsdsh.marshal_with(output_def)
def post(self):
'''Fetch/Compute knn vector for a specific resource for models-dashboard'''
return get_resource_modelsdshknn(request.json)
@ns_modelsdsh.errorhandler
def default_error_handler(error):
'''Default error handler'''
return {'message': str(error)}, getattr(error, 'code', 500)
from storages import Storage
from utils.scan import get_scan_by_uuid
from utils.scan import validate_schedule
from .authorizers import token_required
from .parsers import Parser
api = Namespace("scan")
RRULE_WEEKDAY_LIST = ["MO", "TU", "WE", "TH", "FR", "SA", "SU"]
ScanResultGetResponseSchema = api.model(
"Scan Result Get Response",
{
"host": fields.String(required=True),
"port": fields.String(required=True),
"name": fields.String(required=True),
"description": fields.String(required=True),
"severity": fields.String(required=True),
},
)
ScanGetResponseSchema = api.model(
"Scan Get Response",
{
"uuid":
fields.String(required=True, attribute=lambda scan: scan["uuid"].hex),
"name":
fields.String(required=True),
"description":
fields.String(required=True),
"target":
from project.api.users.crud import (
get_all_users,
get_user_by_email,
add_user,
get_user_by_id,
update_user,
delete_user,
)
users_namespace = Namespace("users")
user = users_namespace.model(
"User",
{
"id": fields.Integer(readOnly=True),
"username": fields.String(required=True),
"email": fields.String(required=True),
"created_date": fields.DateTime,
},
)
class UsersList(Resource):
@users_namespace.marshal_with(user, as_list=True)
def get(self):
"""Returns all users."""
return get_all_users(), 200
@users_namespace.expect(user, validate=True)
@users_namespace.response(201, "<user_email> was added!")
@users_namespace.response(400, "Sorry. That email already exists.")
mood_mappings = {'Indifferent': {'Western', 'War', 'Biography', 'Family'},
'Sad and Rejected': {'Musical', 'Comedy', 'Romance'},
'Flirty': {'Musical', 'Drama', 'Fantasy', 'Romance'},
'Energetic and Excited': {'Thriller', 'Musical', 'Crime', 'Drama',
'Fantasy', 'Adventure', 'Sci-Fi', 'Action', 'Comedy'
},
'Stressed': {'Animation'},
'Weird': {'Film-Noir', 'Crime', 'Drama', 'Horror', 'Mystery'}
}
api = Namespace('Movies', 'Search for Movies and get Movie details', '/movies')
film_summary = api.model('Film Summary',
{'movieID': fields.Integer,
'title': fields.String,
'year': fields.Integer,
'rating': fields.String(description = 'Average rating out of 5')
}
)
search_results = api.model('Search Results',
{'data': fields.List(fields.Nested(film_summary)),
'count': fields.Integer(description = 'The total number of search results')
}
)
parser = reqparse.RequestParser()
parser.add_argument('page_size', 10, type = int)
parser.add_argument('page_index', required = True, type = int)
parser.add_argument('name', '')
parser.add_argument('description', '')
""" Movies Endpoint """
from flask import request
from flask_restx import Namespace, Resource, fields
from service.movies import Movies
NS = Namespace('movies', description='Operations related to movies')
MOVIE = NS.model(
'Movie', {
'title':
fields.String(required=True,
description='Movie title',
example='Django Unchained'),
'genre':
fields.String(
required=True, description='Movie type', example='Drama/Action')
})
@NS.route("")
class MoviesCollection(Resource):
""" Movies Collection methods """
def get(self):
""" Returns list of movies """
return Movies().get_all()
@NS.expect(MOVIE)
def post(self):
""" Creates a movie """
return Movies().create_one(request.get_json())
from flask_restx import Namespace, Resource, fields, reqparse, inputs
api = Namespace('apis', description='Google Cloud Platform APIs')
apimodel = api.model(
'Api', {
'api':
fields.String(required=True, description='API service name'),
'title':
fields.String(required=True, description='API title'),
'description':
fields.String(description='API description'),
'preApproved':
fields.Boolean(required=True,
description='Is API pre-approved for use'),
})
apis = []
class Apis:
def get_namespace(config):
for _name, _api in config['approvedApis']['approved'].items():
apis.append({
'api': _name,
'title': _api['title'],
'description': _api['description'],
'preApproved': True,
})
for _name, _api in config['approvedApis']['holdForApproval'].items():
apis.append({
'api': _name,
from flask import request
from flask_restx import Resource, Namespace
from .core import get_knn_resourcesmetadata
from ....iomodels import input_def_knn_res, output_def
ns_lamdsh = Namespace('others',
description='Fetch/Compute doc2vec vector')
input_def = ns_lamdsh.model(*input_def_knn_res)
output_def = ns_lamdsh.model(*output_def)
@ns_lamdsh.route("/lamdsh/knnlamdsh", doc=False)
class KnnlamdshOthers(Resource):
'''This is a test'''
@ns_lamdsh.expect(input_def, validate=True)
@ns_lamdsh.marshal_with(output_def)
def post(self):
'''Fetch/Compute knn doc2vec vector for a specific resource for lam-dashboard'''
tmp = get_knn_resourcesmetadata(**request.json)
# print(tmp)
return {'output': tmp}
@ns_lamdsh.errorhandler
def default_error_handler(error):
'''Default error handler'''
return {'message': str(error)}, getattr(error, 'code', 500)
import platform
from flask import request
from flask_restx import fields, Namespace, Resource
respond_namespace = Namespace(
'respond',
description='Provides operations that generate a simple response.')
copy_cat_model = respond_namespace.model(
'Respond', {'response': fields.String(description='The string provided.')})
@respond_namespace.route('<string>')
class Copycat(Resource):
@respond_namespace.marshal_with(copy_cat_model)
def get(self, string: str):
return {
'response': string,
}
platform_model = respond_namespace.model('Host', {
'hostname_or_ip': fields.String(
description='The computer’s network name (may not be fully qualified!) or its ip address.' \
'An empty string is returned if the value cannot be determined.'
),
'system': fields.String(
description='Returns the system/OS name, such as "Linux", "Darwin", ' \
'"Java", "Windows". An empty string is returned if the' \
'value cannot be determined.'
from flask_restx import Namespace, Resource, fields
from datetime import datetime
from src.api.users.models import User
from src.api.users.crud import ( # isort:skip
get_all_users, get_user_by_email, add_user, get_user_by_id, update_user,
delete_user, get_all_deliveries, get_delivery_by_id, add_delivery,
update_delivery_status, delete_delivery,
)
users_namespace = Namespace("users")
user = users_namespace.model(
"User",
{
"id": fields.Integer(readOnly=True),
"username": fields.String(required=True),
"email": fields.String(required=True),
"created_date": fields.DateTime,
},
)
user_post = users_namespace.inherit("User post", user,
{"password": fields.String(required=True)})
class UsersList(Resource):
@users_namespace.marshal_with(user, as_list=True)
def get(self):
"""Returns all users."""
return get_all_users(), 200
model_recipe = api.model(
'recipe', {
'nextId':
fields.Integer(required=True, description='The next identifier;'),
'payload':
fields.List(
fields.Nested(
api.model(
'recipe_payload', {
'recipe_id':
fields.Integer(required=True,
description='Recipe idenifier'),
'name':
fields.String(required=True,
description='Recipe name'),
'tags':
fields.List(
fields.Nested(
api.model(
'tag list', {
'tag_name':
fields.String(required=True,
description='tag name'),
'tag_group':
fields.String(required=True,
description='tag group'),
}))),
'duration':
fields.Float
})))
})
from flask_restx import Namespace, Resource, fields
api = Namespace("cats", description="Cats related operations")
cat = api.model(
"Cat",
{
"id": fields.String(required=True, description="The cat identifier"),
"name": fields.String(required=True, description="The cat name"),
},
)
CATS = [
{"id": "felix", "name": "Felix"},
]
@api.route("/")
class CatList(Resource):
@api.doc("list_cats")
@api.marshal_list_with(cat)
def get(self):
"""List all cats"""
return CATS
@api.route("/<id>")
@api.param("id", "The cat identifier")
@api.response(404, "Cat not found")
class Cat(Resource):
@api.doc("get_cat")
from flask_restx import Namespace, Resource, fields
api = Namespace('teams', description='Project teams')
team = api.model(
'Team', {
'id': fields.String(required=True, description='Team id'),
'title': fields.String(required=True, description='Team title'),
'description': fields.String(description='Team description'),
})
teams = []
class Teams:
def get_namespace(config):
for _id, _team in config['config']['projectGroups'].items():
teams.append({
'id': _id,
'title': _team['title'],
'description': _team['description'],
})
return api
@api.route('/')
class TeamsList(Resource):
@api.doc('list_teams')
@api.marshal_list_with(team)
