def register_schema(api: Namespace) -> Namespace:
all_models = [
getattr(schema, attr) for attr in dir(schema)
if isinstance(getattr(schema, attr), Model)
]
# TODO: only a subset of all models should be registered.
for model in all_models:
api.add_model(model.name, model)
return api
from flask_restplus import Namespace, Resource
from service import BuildingRoomSvc
from service import BuildingSvc
from view.decorator import modal_body_with
from .model import BuildingModel
from .model import BuildingRoomModel
api = Namespace('building')
api.add_model('Building', BuildingModel)
api.add_model('BuildingRoom', BuildingRoomModel)
parser = api.parser()
parser.add_argument('room_id')
parser.add_argument('building_type_id')
parser.add_argument('production_type_id')
parser.add_argument('worker', action='append')
@api.route('')
class BuildingList(Resource):
@api.doc('list all')
@api.marshal_list_with(BuildingModel)
def get(self):
return BuildingSvc.read_all()
@api.route('/<int:id>')
@api.param('id', 'The building identifier')
@api.response(404, 'Building not found')
class Building(Resource):
from flask_restplus import Resource
from flask_restplus import Namespace
from flask_restplus import abort
from flask import request
from utils.errors import BadRequest
from api.schema import URL_schema
from api.schema import Original_schema
from api.schema import Short_schema
from api.service import UrlDAO
ns = Namespace('', description='Simple URL shorted MS')
ns.add_model('URL', URL_schema)
ns.add_model('Short', Short_schema)
ns.add_model('Original', Original_schema)
DAO = UrlDAO()
@ns.route("/shorten")
class Short(Resource):
@ns.doc(body=Original_schema)
@ns.expect(Original_schema)
@ns.marshal_with(URL_schema, skip_none=True, code=200)
def put(self, **kwargs):
url = DAO.put(ns.payload, request.host_url)
if url == None:
return abort(400, BadRequest)
return url
# limitations under the License.
#
from flask_restplus import Namespace, Resource
from powderbooking.models import model_weather
from sqlalchemy import MetaData
from database import db
from database.query import Query
from utils.convert_models import convert_sqlalchemy_to_restplus_model
api = Namespace('weather', description='Weather reports of a overview')
weather = convert_sqlalchemy_to_restplus_model(table=model_weather(
metadata=MetaData()))
api.add_model(name=weather.name, definition=weather)
@api.route('/<int:resort_id>')
@api.param('resort_id', 'The overview identifier')
@api.response(404, 'No weather report for given overview identifier found')
class Weather(Resource):
@api.doc('get_weather_report')
@api.marshal_with(weather)
def get(self, resort_id: int):
"""Get the latest weather report for the given overview identifier"""
result = db.execute_query(Query.select_weather_recent,
resort_id=resort_id)
if result.rowcount == 1:
return result.fetchone()
@author: Jonas
"""
from flask_restplus import Resource, Namespace, Model, fields
from flask.globals import request
from son_editor.util.requestutil import get_json
from son_editor.impl import platformsimpl, platform_connector
from son_editor.util.constants import WORKSPACES, PLATFORMS, SERVICES
from son_editor.util.requestutil import prepare_response
namespace = Namespace(WORKSPACES + '/<int:ws_id>/' + PLATFORMS, description="Platform Resources")
serv_id = Model("Service ID", {
'id': fields.Integer(required=True, description='The son-editor id of the service being published')
})
namespace.add_model(serv_id.name, serv_id)
@namespace.route("/")
@namespace.response(200, "OK")
class Platforms(Resource):
"""Platforms"""
def get(self, ws_id):
"""List platforms
Lists all service platforms in the given workspace"""
return prepare_response(platformsimpl.get_platforms(ws_id))
@namespace.doc("")
def post(self, ws_id):
})
payload = model_ns.model(
'uPayload', {
'payload':
fields.Nested(
model_output,
as_list=True,
required=True,
description="Array of model predictions for each input."),
'total':
fields.Integer(required=False,
description="Total number of predictions.")
})
model_ns.add_model('model_input', model_input)
@probe_ns.route('/liveness')
class Liveness(Resource):
# noinspection PyMethodMayBeStatic
def get(self):
"""Heartbeat."""
return {'Status': "Running OK."}, HTTPStatus.OK
@probe_ns.route('/readiness')
class Readiness(Resource):
# noinspection PyMethodMayBeStatic
serv_id = Model("Service ID", {
'id': fields.Integer(required=True, description='The son-editor id of the service being published')
})
serv_response = serv.inherit("ServiceResponse", serv, {
"descriptor": fields.Nested(model=serv, description="The Complete Service Descriptor"),
"id": fields.Integer(description='The Project ID'),
"project_id": fields.Integer(description='The parent workspace id'),
})
message_response = proj_namespace.model("Message", {
'message': fields.String(required=True, description="The result message")
})
proj_namespace.add_model(serv_update.name, serv_update)
proj_namespace.add_model(serv.name, serv)
proj_namespace.add_model(serv_response.name, serv_response)
@proj_namespace.route('/')
@cata_namespace.route('/')
@plat_namespace.route('/')
@proj_namespace.param('ws_id', 'The Workspace identifier')
@cata_namespace.param('ws_id', 'The Workspace identifier')
@plat_namespace.param('ws_id', 'The Workspace identifier')
@proj_namespace.param('parent_id', 'The Project identifier')
@cata_namespace.param('parent_id', 'The Catalogue identifier')
@plat_namespace.param('parent_id', 'The Platform identifier')
@proj_namespace.response(200, "OK")
class Services(Resource):
})
fields11 = api.model(
'MyModel', {
'name': fields.String(description='The name', required=True),
'type': fields.String(description='The object type', enum=['A', 'B']),
'age': fields.Integer(min=0),
})
name = 'job'
__type__ = String
items = {
name: fields.String,
}
job = api.model(name, items)
api.add_model('123', fields11)
test_parser = api.parser()
test_parser.add_argument('data',
type=dict,
location='json',
help='使用json方式传递 与以下参数方式'
' 相等 {"ge_id": 0, "eq_id": 0 }')
@api.expect(test_parser)
@api.route('/dict', doc={"description": "请求发送字典model样例"})
class DictView(Resource):
@api.expect(job)
# @api.expect(resource_fields)
# @api.doc(model=fields)
from flask_restplus import Namespace
from models.swagger import new_user_swgger
AuthenticationApi = Namespace('Authentication',
'All related with authentication')
UserApi = Namespace('User', 'User management')
UserApi.add_model('new_user', new_user_swgger)
from flask_restplus import Namespace
from flask_restplus import abort
from flask import request
from api.schema import response_schema
from api.schema import request_schema
from api.schema import query_schema
from api.service import search
from metrics.prometheus import SEARCH_COUNTER
from metrics.prometheus import FLASK_REQUEST_LATENCY
ns = Namespace('', description='Simple word search engine')
ns.add_model('Word', response_schema)
ns.add_model('Query', query_schema)
ns.add_model('Search', request_schema)
@ns.route("/search")
class Search(Resource):
@ns.doc(body=request_schema)
@ns.expect(request_schema)
@ns.marshal_with(response_schema, skip_none=True, code=200)
@FLASK_REQUEST_LATENCY.time()
def put(self, **kwargs):
res = search(ns.payload)
if res == None:
from son_editor.impl import platformsimpl, platform_connector
from son_editor.util.constants import WORKSPACES, PLATFORMS, SERVICES
from son_editor.util.requestutil import prepare_response
namespace = Namespace(WORKSPACES + '/<int:ws_id>/' + PLATFORMS,
description="Platform Resources")
serv_id = Model(
"Service ID", {
'id':
fields.Integer(
required=True,
description='The son-editor id of the service being published')
})
namespace.add_model(serv_id.name, serv_id)
@namespace.route("/")
@namespace.response(200, "OK")
class Platforms(Resource):
"""Platforms"""
def get(self, ws_id):
"""List platforms
Lists all service platforms in the given workspace"""
return prepare_response(platformsimpl.get_platforms(ws_id))
@namespace.doc("")
def post(self, ws_id):
"""Create a new service platform
from flask_restplus import Namespace, Resource
from db import ShapeMultiPolygonDao
from .model import ShapePointModel as ShapePointModel, ShapeRingModel as ShapeRingModel, \
ShapePolygonModel as ShapePolygonModel, ShapeMultiPolygonModel as ShapeMultiPolygonModel
api = Namespace('shape')
api.add_model('ShapePoint', ShapePointModel)
api.add_model('ShapeRing', ShapeRingModel)
api.add_model('ShapePolygon', ShapePolygonModel)
api.add_model('ShapeMultiPolygon', ShapeMultiPolygonModel)
@api.route('')
class ShapeList(Resource):
@api.doc('list all')
@api.marshal_list_with(ShapeMultiPolygonModel)
def get(self):
return ShapeMultiPolygonDao.read_all()
# See the License for the specific language governing permissions and
# limitations under the License.
#
from flask_restplus import Namespace, Resource
from powderbooking.models import model_resort
from sqlalchemy import MetaData
from database import db
from utils.convert_models import convert_sqlalchemy_to_restplus_model
api = Namespace('resort', description='Details of the resorts')
resort = convert_sqlalchemy_to_restplus_model(table=model_resort(
metadata=MetaData()))
api.add_model(name=resort.name, definition=resort)
@api.route('/<int:id>')
@api.param('id', 'The overview identifier')
@api.response(404, 'Resort not found')
class Resort(Resource):
@api.doc('get_resort')
@api.marshal_with(resort)
def get(self, id: int):
"""Get overview details given its identifier"""
result = db.execute(
db.get_table('resort').select().where(
db.get_table_column('resort', 'id') == id))
if result.rowcount == 1:
__all__ = ['user_ns']
from flask_restplus import Namespace
from documentation.models import (login_model, registration_model, auth_model,
message_model, gallery_item, metadata,
friend_model, upload_img, user_model,
comment_model, message_post, post_response,
pending_frame_model, pending_model_update,
add_role)
user_ns = Namespace('user',
path='/users/<string:username>',
description='User level operations')
for model in [
login_model, registration_model, auth_model, metadata, message_model,
friend_model, upload_img, user_model, gallery_item, comment_model,
message_post, post_response, pending_frame_model, pending_model_update,
add_role
]:
user_ns.add_model(model.name, model)
from sqlalchemy import MetaData
from utils.convert_models import filter_restplus_columns, convert_sqlalchemy_to_restplus_model
from database import db
from database.query import Query
from apis.resort import resort
api = Namespace('overview', description='Overview of all resorts with aggregate forecast data')
filtered_resort = filter_restplus_columns(model=resort, mask=['id', 'lat', 'lng', 'village'])
forecast_week = convert_sqlalchemy_to_restplus_model(table=model_forecast_week(metadata=MetaData()))
filtered_forecast_week = filter_restplus_columns(model=forecast_week, mask=['rain_week_mm', 'snow_week_mm'])
overview = Model('overview', {**filtered_resort, **filtered_forecast_week}) # pythonic way to union two dicts
api.add_model(name=overview.name, definition=overview)
max_overview = Model('max_overview', {
'max': fields.Float(description='The maximum amount of snow or rain forecast of today', required=True)
})
api.add_model(name=max_overview.name, definition=max_overview)
@api.route('/')
class OverviewList(Resource):
@api.doc('list_overview')
@api.marshal_list_with(overview)
def get(self):
"""List all resorts with aggregate forecast data of today"""
return db.execute_query(Query.select_overview).fetchall()
uid = Model("VNF_UID", {
'id': fields.String(required=True, description='The VNF UID')
})
funct_response = funct.inherit("FunctionResponse", funct, {
"descriptor": fields.Nested(model=funct, description="The Complete VNF Descriptor"),
"id": fields.Integer(description='The Project ID'),
"project_id": fields.Integer(description='The parent project id'),
})
message_response = namespace.model("Message", {
'message': fields.String(required=True, description="The result message")
})
namespace.add_model(funct.name, funct)
namespace.add_model(funct_response.name, funct_response)
@namespace.route('/')
@namespace.param('ws_id', 'The Workspace identifier')
@namespace.param('project_id', 'The Project identifier')
class Functions(Resource):
"""Resource methods for all function descriptors of this directory"""
@namespace.response(200, "OK", [funct_response])
def get(self, ws_id, project_id):
"""List all functions
Lists all available functions in the given project or catalogue."""
functions = functionsimpl.get_functions(ws_id, project_id)
from flask_restplus import Namespace, Resource
from db import ResourceDao
from .model import ResourceModel
api = Namespace('resource')
api.add_model('Resource', ResourceModel)
@api.route('')
class ResourceList(Resource):
@api.doc('list all')
@api.marshal_list_with(ResourceModel)
def get(self):
return ResourceDao.read_all()
@api.route('/<int:id>')
@api.param('id', 'The resource identifier')
@api.response(404, 'Resource not found')
class Resource(Resource):
@api.doc('get by given id')
@api.marshal_with(ResourceModel)
def get(self, id):
obj = ResourceDao.read(id)
if obj is not None:
return obj
else:
api.abort(404, 'Resource {} does not exist'.format(id))
funct_response = funct.inherit(
"FunctionResponse", funct, {
"descriptor":
fields.Nested(model=funct, description="The Complete VNF Descriptor"),
"id":
fields.Integer(description='The Project ID'),
"project_id":
fields.Integer(description='The parent project id'),
})
message_response = proj_namespace.model("Message", {
'message':
fields.String(required=True, description="The result message")
})
proj_namespace.add_model(funct.name, funct)
proj_namespace.add_model(funct_response.name, funct_response)
@proj_namespace.route('/')
@cata_namespace.route('/')
@plat_namespace.route('/')
@proj_namespace.param('ws_id', 'The Workspace identifier')
@cata_namespace.param('ws_id', 'The Workspace identifier')
@plat_namespace.param('ws_id', 'The Workspace identifier')
@proj_namespace.param('parent_id', 'The Project identifier')
@cata_namespace.param('parent_id', 'The Catalogue identifier')
@plat_namespace.param('parent_id', 'The Platform identifier')
class Functions(Resource):
"""Resource methods for all function descriptors of this directory"""
@proj_namespace.response(200, "OK", [funct_response])
__all__ = ['base_ns']
from flask_restplus import Namespace
from documentation.models import (login_model, registration_model, auth_model, message_model, gallery_item, metadata,
friend_model, upload_img, user_model)
base_ns = Namespace('base', path='/', description='Base level operations')
for model in [login_model, registration_model, auth_model, metadata, message_model,
friend_model, upload_img, user_model, gallery_item]:
base_ns.add_model(model.name, model)
from flask_restplus import Namespace, Resource
from service import ProductionSvc
from view.decorator import modal_body_with
from .model import ProductionModel
api = Namespace('production')
api.add_model('Production', ProductionModel)
parser = api.parser()
parser.add_argument('type')
parser.add_argument('worker', action='append')
parser.add_argument('tool', action='append')
parser.add_argument('resource', action='append')
@api.route('')
class ProductionList(Resource):
@api.doc('list all')
@api.marshal_list_with(ProductionModel)
def get(self):
return ProductionSvc.read_all()
@api.doc('create')
@modal_body_with(ProductionModel)
def post(self):
args = parser.parse_args()
type = args.get('type')
workers = args.get('worker') if args.get('worker') is not None else []
tools = args.get('tool') if args.get('tool') is not None else []
resources = args.get('resource') if args.get(
uid = Model("VNF_UID", {
'id': fields.String(required=True, description='The VNF UID')
})
funct_response = funct.inherit("FunctionResponse", funct, {
"descriptor": fields.Nested(model=funct, description="The Complete VNF Descriptor"),
"id": fields.Integer(description='The Project ID'),
"project_id": fields.Integer(description='The parent project id'),
})
message_response = proj_namespace.model("Message", {
'message': fields.String(required=True, description="The result message")
})
proj_namespace.add_model(funct.name, funct)
proj_namespace.add_model(funct_response.name, funct_response)
@proj_namespace.route('/')
@cata_namespace.route('/')
@plat_namespace.route('/')
@proj_namespace.param('ws_id', 'The Workspace identifier')
@cata_namespace.param('ws_id', 'The Workspace identifier')
@plat_namespace.param('ws_id', 'The Workspace identifier')
@proj_namespace.param('parent_id', 'The Project identifier')
@cata_namespace.param('parent_id', 'The Catalogue identifier')
@plat_namespace.param('parent_id', 'The Platform identifier')
class Functions(Resource):
"""Resource methods for all function descriptors of this directory"""
from documentation.models import message_model
from flask_restplus import Namespace
functions_ns = Namespace('function',
path='/function',
description='Function operations')
for model in [message_model]:
functions_ns.add_model(model.name, model)
"ServiceResponse", serv, {
"descriptor":
fields.Nested(model=serv,
description="The Complete Service Descriptor"),
"id":
fields.Integer(description='The Project ID'),
"project_id":
fields.Integer(description='The parent workspace id'),
})
message_response = namespace.model("Message", {
'message':
fields.String(required=True, description="The result message")
})
namespace.add_model(serv_update.name, serv_update)
namespace.add_model(serv.name, serv)
namespace.add_model(serv_response.name, serv_response)
@namespace.route('/')
@namespace.param('ws_id', 'The Workspace identifier')
@namespace.param('project_id', 'The Project identifier')
@namespace.response(200, "OK")
class Services(Resource):
"""
Api Methods for all services in this resource
"""
@namespace.doc("Gets a list of services")
@namespace.response(200, "OK", [serv_response])
def get(self, ws_id, project_id):
# limitations under the License.
#
from flask_restplus import Namespace, Resource
from powderbooking.models import model_forecast
from sqlalchemy import MetaData
from database import db
from database.query import Query
from utils.convert_models import convert_sqlalchemy_to_restplus_model
api = Namespace('forecast', description='Weather reports of a overview')
forecast = convert_sqlalchemy_to_restplus_model(table=model_forecast(
metadata=MetaData()))
api.add_model(name=forecast.name, definition=forecast)
@api.route('/current/<int:resort_id>')
@api.param('resort_id', 'The overview identifier')
@api.response(404,
'No current forecast report for given overview identifier found')
class ForecastCurrent(Resource):
@api.doc('get_current_forecast_report')
@api.marshal_list_with(fields=forecast)
def get(self, resort_id: int):
"""Get the current forecast report from today for the given overview identifier"""
result = db.execute_query(Query.select_forecast_current,
resort_id=resort_id)
if result.rowcount > 0:
