class RoleDto:
api = Namespace('role', description='roles')
role = api.model(
'role',
{
'id':
fields.Integer(required=True, description='Mã vai trò'),
'name':
fields.String(required=True, description='Tên vai trò'),
'description':
fields.String(required=True, description='Mô tả vai trò'),
# 'created_at': fields.String(required=True, description='Ngày tạo vai trò'),
})
role_create = api.model(
'role_create',
{
'name':
fields.String(required=True, description='Tên vai trò'),
'description':
fields.String(required=True, description='Mô tả vai trò'),
# 'created_at': fields.String(required=True, description='Ngày tạo vai trò'),
})
set_role = api.model('role_update', {
'role_id':
fields.Arbitrary(required=True, description='Mã vai trò'),
})
class PermissionDto:
api = Namespace('permission', description='permissions')
permission = api.model(
'permission',
{
'id':
fields.Integer(required=True, description='Mã quyền truy cập'),
'name':
fields.String(required=True, description='Tên quyền truy cập'),
'description':
fields.String(required=True, description='Mô tả quyền truy cập'),
# 'created_at': fields.String(required=True, description='Ngày tạo vai trò'),
})
permission_create = api.model(
'permission',
{
'name':
fields.String(required=True, description='Tên quyền truy cập'),
'description':
fields.String(required=True, description='Mô tả quyền truy cập'),
# 'created_at': fields.String(required=True, description='Ngày tạo vai trò'),
})
set_permission = api.model(
'permission', {
'permission_id':
fields.Arbitrary(required=True, description='Mã quyền truy cập'),
})
def field_of(value):
if isinstance(value, str):
return fields.String(example=value)
if isinstance(value, unicode):
return fields.String(example=value.encode('utf-8'))
if isinstance(value, int):
return fields.Integer(example=value)
if isinstance(value, float):
return fields.Arbitrary(example=value)
if isinstance(value, bool):
return fields.Boolean(example=value)
if isinstance(value, list):
return fields.List(field_of(value[0]))
return fields.Nested(
Mod({key: field_of(val)
for (key, val) in value.items()}))
def test_with_default(self):
field = fields.Arbitrary(default=0.5)
assert field.__schema__ == {'type': 'number', 'default': 0.5}
def test_defaults(self):
field = fields.Arbitrary()
assert not field.required
assert field.__schema__ == {'type': 'number'}
from flask import request
from flask_restplus.resource import Resource
from flask_restplus import fields
from bapi.api.core import api
from bapi.core.storage import storage
from beancount.core.number import D
from beancount.core import amount, data
ns = api.namespace('transaction', description='Transactions')
posting_model = api.model('Posting', {
'account': fields.String(required=True, description='Account of the posting'),
'amount': fields.Arbitrary(description='Amount'),
'currency': fields.String(description='Currency'),
'cost': fields.Arbitrary(description='Cost'),
'costCurrency': fields.String(description='Cost Currency'),
})
trx_add_model = api.model('TransactionAdd', {
'filename': fields.String(required=True, description='Filename of the file'),
'date': fields.Date(required=True, description='Date of the transaction'),
'flag': fields.String(enum=['*', '!'], default='*', description='Flag for the transaction'),
'payee': fields.String('Payee of the transaction'),
'naration': fields.String('Naration of the transaction'),
'postings' : fields.List(fields.Nested(posting_model)),
})
@ns.route('/')
class Transaction(Resource):
@api.expect(trx_add_model, validate=True)
def test_arbitrary_field_with_default(self):
prop = field_to_property(fields.Arbitrary(default=0.5))
self.assertEqual(prop, {'type': 'number', 'default': 0.5})
def stream_data_model(stream_api):
data_descriptor = stream_api.model(
'DataDescriptor', {
'type': rest_fields.String(required=True),
'unit': rest_fields.String(required=True)
})
input_parameters = stream_api.model(
'InputParameters', {
'window_size': rest_fields.Integer(required=False),
'window_offset': rest_fields.Integer(required=False),
'low_level_threshold': rest_fields.Float(required=False),
'high_level_threshold': rest_fields.Float(required=False)
})
input_streams = stream_api.model(
'InputStreams', {
'identifier': rest_fields.String(required=True),
'name': rest_fields.String(required=True)
})
output_streams = stream_api.model(
'OutputStreams', {
'identifier': rest_fields.String(required=True),
'name': rest_fields.String(required=True)
})
algorithm_reference = stream_api.model(
'AlgorithmReference', {'url': rest_fields.String(required=False)})
algorithm = stream_api.model(
'Algorithm', {
'method':
rest_fields.String(required=True),
'description':
rest_fields.String(required=True),
'authors':
rest_fields.Arbitrary(required=True),
'version':
rest_fields.String(required=True),
'reference':
rest_fields.List(rest_fields.Nested(algorithm_reference),
required=False)
})
processing_module = stream_api.model(
'ProcessingModule', {
'name':
rest_fields.String(required=True),
'description':
rest_fields.String(required=True),
'input_parameters':
rest_fields.Nested(input_parameters, required=False),
'input_streams':
rest_fields.List(rest_fields.Nested(input_streams),
required=False),
'output_streams':
rest_fields.List(rest_fields.Nested(output_streams),
required=False),
'algorithm':
rest_fields.List(rest_fields.Nested(algorithm), required=False)
})
execution_context = stream_api.model(
'Execution Context',
{'processing_module': rest_fields.Nested(processing_module)})
annotations = stream_api.model(
'Annotation',
{
'name': rest_fields.String(required=True),
'identifier': rest_fields.String(required=True)
# "pattern": "^[a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}$"
})
data = stream_api.model(
'Data', {
'start_time': rest_fields.DateTime(required=True),
'end_time': rest_fields.DateTime(),
'sample': rest_fields.String(required=True)
})
stream = stream_api.model(
'Stream', {
'identifier':
rest_fields.String(required=True),
'owner':
rest_fields.String(required=True),
'name':
rest_fields.String(required=True),
'data_descriptor':
rest_fields.List(rest_fields.Nested(data_descriptor),
required=False),
'execution_context':
rest_fields.Nested(execution_context, required=True),
'annotations':
rest_fields.List(rest_fields.Nested(annotations)),
'data':
rest_fields.List(rest_fields.Nested(data), required=True)
})
return stream
def test_arbitrary_field_with_readonly(self):
prop = field_to_property(fields.Arbitrary(readonly=True))
self.assertEqual(prop, {'type': 'number', 'readOnly': True})
def test_arbitrary_field_with_required(self):
prop = field_to_property(fields.Arbitrary(required=True))
self.assertEqual(prop, {'type': 'number', 'required': True})
def test_arbitrary_field_with_title(self):
prop = field_to_property(fields.Arbitrary(title='A title'))
self.assertEqual(prop, {'type': 'number', 'title': 'A title'})
def test_arbitrary_field_with_description(self):
prop = field_to_property(fields.Arbitrary(description='A description'))
self.assertEqual(prop, {
'type': 'number',
'description': 'A description'
})
authentication = api.model(
'User Authentication', {
'email': fields.String(required=True, description='E-Mail Address'),
'token': fields.String(required=True,
description='Authentication Token')
})
location = api.model(
'Location', {
'lat': fields.Fixed(decimals=7, required=True, description='Latitude'),
'lon': fields.Fixed(decimals=7, required=True, description='Longitude')
})
spot = api.inherit('Parking Spot', location, {})
tariff = api.model(
'Tariff',
{'pricePerMinute': fields.Arbitrary(description="Price per Minute")})
lot = api.model(
'ParkingLot', {
'lot_id':
fields.String(required=True, description=''),
'name':
fields.String(required=True, description=''),
'total_spots':
fields.String(required=True, description=''),
'longitude':
fields.String(required=True, description=''),
'latitude':
fields.String(required=True, description=''),
'tax':
fields.String(required=True, description='Tax (€/h)'),
'max_tax':
from beancount.core.number import D
from beancount.core import amount, data
ns = api.namespace('price', description='Prices')
price_model = api.model(
'Price', {
'date':
fields.Date(required=True, description='Date of the price'),
'quoteCurrency':
fields.String(required=True, description='Currency to be priced'),
'baseCurrency':
fields.String(required=True,
description='Base currency the price is in'),
'price':
fields.Arbitrary(required=True, description='Price')
})
prices_update_model = api.model(
'PriceUpdate', {
'filename':
fields.String(required=True, description='Filename of the price file'),
'prices':
fields.List(fields.Nested(price_model)),
})
@ns.route('/')
class Price(Resource):
@api.expect(prices_update_model, validate=True)
def post(self):
def test_value(self, value, expected):
self.assert_field(fields.Arbitrary(), value, expected)
def test_arbitrary_field_with_min_max(self):
prop = field_to_property(fields.Arbitrary(min=0, max=5))
self.assertEqual(prop, {'type': 'number', 'minimum': 0, 'maximum': 5})
contact_email='*****@*****.**',
doc='/documentacao',
prefix='/eee')
rest_app = Api(app, **app_infos)
db_model = rest_app.model(
'Variáveis usadas no primeiro modelo', {
'array':
fields.List(cls_or_instance=fields.Float,
required=True,
description="String que contem um array: 1,9,8",
help="Ex. 1,9,8"),
'argumento_2':
fields.Arbitrary(
required=False,
description=
"Só para exemplificar que podemos ter mais entradas de dados.")
})
## Vamos organizar os endpoints por aqui!
# link gerado será: http://127.0.0.1:5000/primeiro_endpoint_swagger
nome_do_endpoint = rest_app.namespace(
'primeiro_endpoint_swagger',
description='Esse endpoint é responsável por fazer uma análise estatística.'
)
@nome_do_endpoint.route("/")
class Classe_que_contem_funcoes(Resource):
@rest_app.expect(db_model)
def post(self):
from flask_restplus import fields
from app import rest_api
product = rest_api.model(
'Product', {
'uuid':
fields.String(readOnly=True,
description='The unique identifier of a product',
allow_null=False),
'name':
fields.String(
required=True, description='product name', allow_null=False),
'price':
fields.Arbitrary(
required=True, description='product price', allow_null=False),
})
product_update = rest_api.model(
'ProductUpdate', {
'name':
fields.String(
required=False, description='product name', allow_null=False),
'price':
fields.Arbitrary(
required=False, description='product price', allow_null=False),
})
