Ejemplo n.º 1
0
        "id": fields.String(
            title="Database ID",
            description="Used to identify a database.",
            required=True,
            example="hyrise-1",
        )
    },
)

model_throughput = monitor.clone(
    "Throughput",
    model_database,
    {
        "throughput": fields.Integer(
            title="Throughput",
            description="Query throughput of a given time interval.",
            required=True,
            example=7381,
        )
    },
)

model_detailed_throughput = monitor.clone(
    "Detailed Throughput",
    model_database,
    {
        "detailed_throughput": fields.List(
            fields.Nested(
                monitor.model(
                    "Throughput per query",
                    {
                        "workload_type": fields.String(
Ejemplo n.º 2
0
from flask_restx import fields
from dollar.api.restx import api

order = api.model(
    'Order', {
        'id_company': fields.Integer(readOnly=True),
        'delivery_time': fields.Integer(),
        'delivery_cost': fields.Integer(),
        'good': fields.Integer(),
        'bad': fields.Integer(),
        'feedback': fields.Integer(),
        'call': fields.Integer(),
    })

product = api.model(
    'Product', {
        'id_company': fields.Integer(readOnly=True),
        'price': fields.Integer(),
        'sale': fields.Integer(),
        'views': fields.Integer(),
    })

company = api.model(
    'Company', {
        'id': fields.Integer(readOnly=True,
                             description='The unique identifier'),
        'company': fields.String(readOnly=True, description='Company name'),
        'category': fields.Integer(readOnly=True),
        'verification': fields.Integer(readOnly=True),
        'own': fields.Integer(readOnly=True),
        'days_online': fields.Integer(readOnly=True),
Ejemplo n.º 3
0
        'in': 'path',
        'required': False,
        'default': 0
    }),
    ('filter_{type}[{field}]', {
        'description': 'Filter for field with specified type. Type can be one of [like,in,nin,gt,lt,gte,lte,eq,neq]',
        'type': 'string',
        'in': 'path',
        'required': False,
        'default': None
    })
])

datasource_rows_metadata = ns_conf.model('RowsResponse', {
    'data': fields.List(fields.Raw, required=False, description='rows of datasource data'),
    'rowcount': fields.Integer(required=False, description='Count of rows in dataset')
})

EXAMPLES = [{
    'data': [
        {
            'name': 'Mercury',
            'mass': 0.055,
            'radius': 0.3829
        }, {
            'name': 'Venus',
            'mass': 0.815,
            'radius': 0.9499
        }, {
            'name': 'Earth',
            'mass': 1.0,
Ejemplo n.º 4
0
GNU Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License
along with py-ispyb. If not, see <http://www.gnu.org/licenses/>.
"""

__license__ = "LGPLv3+"

from marshmallow import Schema, fields as ma_fields
from flask_restx import fields as f_fields
from marshmallow_jsonschema import JSONSchema

from app.extensions.api import api_v1 as api

dict_schema = {
    "eventTrainId": f_fields.Integer(required=True, description=""),
    "name": f_fields.String(required=False, description=""),
    "timeOn": f_fields.Float(required=False, description="sec"),
    "duration": f_fields.Float(required=False, description="sec"),
    "period": f_fields.Float(required=False, description=""),
    "numberOfRepetitions": f_fields.Float(required=False, description=""),
    "nameInEventLog": f_fields.String(required=False, description=""),
    "triggerDevice": f_fields.String(required=False, description=""),
}


class EventTrainSchema(Schema):
    """Marshmallows schema class representing EventTrain table"""

    eventTrainId = ma_fields.Integer()
    name = ma_fields.String()
Ejemplo n.º 5
0
client = Cloudant.iam(api_access['username'],
                      api_access['apikey'],
                      connect=True)

product_ns = api.namespace('product',
                           description='User CIR Product Operations')

# Define the API models we will use (these will show up in the Swagger Specification).

rating = api.model(
    'Rating', {
        'efficiency':
        fields.Integer(
            required=False,
            description=
            'The efficiency-in-use rating (0-9, where 0 is best) of this item'
        ),
        'energy':
        fields.Float(required=False,
                     description='The energy (J) to produce this item'),
        'CO2':
        fields.Float(required=False,
                     description='The CO2 released (Kg) to produce this item'),
        'otherGG':
        fields.Float(
            required=False,
            description=
            'The other green house gases released (Kg) to produce this item'),
        'water':
        fields.Float(
Ejemplo n.º 6
0
from flask_restx import fields

from cortex.api import api_manager

dns_serializer = api_manager.model(
    'DNS', {
        'ip':
        fields.String(required=True, description='Host IP Address'),
        'hostname':
        fields.String(required=True, description='Host name'),
        'error':
        fields.String(required=False, description='Error Resposne'),
        'success':
        fields.Integer(
            required=True,
            description='DNS Lookup Status - 0: failure 1: success'),
    })
Ejemplo n.º 7
0
app = Flask(__name__, static_url_path='')

api = Api(
    app,
    'todos',
    description='Operações ligadas as suas tarefas',
)
ns = Namespace('todos', description='Operações ligadas as suas tarefas')
api.add_namespace(ns)

todo = api.model(
    'Todo',
    {
        'id':
        fields.Integer(readonly=True,
                       description='Identificador único da tarefa'),
        'tittle':
        fields.String(required=True, description='Nome da Tarefa'),
        'description':
        fields.String(required=True, description='Descrição da tarefa'),
        'done':
        fields.Boolean(required=True, description='A tarefa será concluída?'),
    },
)


@app.errorhandler(400)
def not_found(error):
    return make_response(jsonify({'error': 'Bad request'}), 400)

Ejemplo n.º 8
0
from core import token
from core.cache import get_discovery_cache
from google.oauth2.credentials import Credentials

logger = logging.getLogger('tpf-backend')

api = Namespace('users', description='Users')
apimodel = api.model(
    'User', {
        'email': fields.String(required=True,
                               description='User primary email'),
        'name': fields.String(description='Full name'),
        'title': fields.String(description='Job title'),
        'photo': fields.String(description='Photo'),
        'photo_mimetype': fields.String(description='Photo MIME type'),
        'photo_width': fields.Integer(description='Photo width in pixels'),
        'photo_height': fields.Integer(description='Photo height in pixels'),
    })


def _escape_query_arg(query):
    return query.replace('"', '\\"')


class Users:
    def get_namespace(config):
        UsersList.customer_id = config['config']['cloudIdentityCustomerId']
        User.customer_id = config['config']['cloudIdentityCustomerId']
        UsersList.config = config
        User.config = config
        return api
Ejemplo n.º 9
0
from flask_restx import Namespace, Resource, fields
from ..Configuration import get_configuration

api = Namespace('storages', description='Energy storages')

storage = api.model(
    'Storage', {
        'id':
        fields.Integer(required=True, description='ID of the storage'),
        'name':
        fields.String(required=True, description='Name of the storage'),
        'image':
        fields.String(required=False,
                      description='URL of the image for the storage'),
        'type':
        fields.String(required=True, description='Type of the storage'),
        'currentStorageCapacityInPercent':
        fields.Float(
            required=False,
            description='Current Storage capacity in percent',
            attribute=lambda x: x['adapter'].get_current_storage_capacity())
    })


@api.route('/')
class StorageList(Resource):
    @api.doc('list_storages')
    @api.marshal_list_with(storage)
    def get(self):
        return get_configuration()['storages']
Ejemplo n.º 10
0
# Authors     : Benoit HERARD <benoit.herard(at)orange.com>
#
# Description :
#     Public data model definitions
# -------------------------------------------------------
# History     :
# 1.0.0 - 2017-02-20 : Release of the file
#
from flask_restx import fields
from api.restx import API

# Model desecription for methods parameters
POWER_POST = API.model(
    'powerPost', {
        'power':
        fields.Integer(required=True,
                       description='Power consumption in Watts'),
        'time':
        fields.Integer(required=False, description='Measurment time stamp'),
        'environment':
        fields.String(required=True,
                      description='Recorder environment \
                                              identifier'),
    })
MEASUREMENT = API.model(
    "measurement", {
        'sensor':
        fields.String(required=True, description="Sensor/measurment name"),
        'unit':
        fields.String(required=True, description='Measurement unit'),
        'value':
        fields.Float(required=True, decription='Measurement value'),
Ejemplo n.º 11
0
from flask_restx import Resource, fields, Model

magstats_model = Model(
    "Magstats",
    {
        "fid": fields.Integer(description="Filter ID (1=g; 2=r, 3=i"),
        "stellar": fields.Boolean(
            description="whether the object appears to be unresolved in the given band"
        ),
        "corrected": fields.Boolean(
            description="whether the corrected photometry should be used"
        ),
        "ndet": fields.Integer(
            description="number of detections in the given band"
        ),
        "ndubious": fields.Integer(
            description="number of dubious corrections"
        ),
        "magmean": fields.Float(
            description="the mean magnitude for the given fid"
        ),
        "magmedian": fields.Float(
            description="the median magnitude for the given fid"
        ),
        "magmax": fields.Float(
            description="the max magnitude for the given fid"
        ),
        "magmin": fields.Float(
            description="the min magnitude for the given fid"
        ),
        "magsigma": fields.Float(
Ejemplo n.º 12
0
scenariosNamespace = Namespace('scenario')

parser = reqparse.RequestParser()
parser.add_argument('skip', type=int, help='skip tasks')
parser.add_argument('maximum', type=int, help='maximum tasks returned')
parser.add_argument('id', type=str, help='task id')

scenario_model = scenariosNamespace.model(
    'Scenario', {
        'title': fields.String(description="Scenarios title"),
        'description': fields.String(description="Scenarios description"),
        'userId': fields.String(description='users id'),
        'emissions': fields.List(fields.String,
                                 description="Scenarios emissions"),
        'date': fields.Integer(description="Scenarios date of creation")
    })


def token_required(f):
    @wraps(f)
    def decorated(*args, **kwargs):
        token = None
        if 'Authorization' in request.headers:
            token = request.headers['Authorization']
            token = token.split(" ")[1]
        if not token:
            return {'message': 'Token is missing.'}, 401
        if oidc.validate_token(token) is True:
            # try:
            #     userid = oidc.user_getfield('sub', token)
        "type": fields.String(description='Contract type'),
    })

CardModel = api.model(
    'Card', {
        "ksi": fields.String(description='Key Session Identifier'),
        "number": fields.String(description='Card number'),
        "state": fields.String(description='Contract status'),
        "balance": fields.Fixed(description="Current balance", decimals=2),
        "lastTimeUsed": fields.String(description='Last time used'),
    })

UseModel = api.model(
    'Use', {
        "month": fields.String(description='Month name'),
        "uses": fields.Integer(description='Month uses count'),
        "amount": fields.Fixed(description="Month amount", decimals=2),
    })

ChargeModel = api.model(
    'Charge', {
        "month": fields.String(description='Month name'),
        "charges": fields.Integer(description='Month charges count'),
        "amount": fields.Fixed(description="Month amount", decimals=2),
    })

ResumeModel = api.model(
    'Resume', {
        'uses': fields.List(fields.Nested(UseModel)),
        'charges': fields.List(fields.Nested(ChargeModel)),
    })
Ejemplo n.º 14
0
GNU Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License
along with py-ispyb. If not, see <http://www.gnu.org/licenses/>.
"""

__license__ = "LGPLv3+"

from marshmallow import Schema, fields as ma_fields
from flask_restx import fields as f_fields
from marshmallow_jsonschema import JSONSchema

from pyispyb.app.extensions.api import api_v1 as api

dict_schema = {
    'eventTrainId': f_fields.Integer(required=True, description=''),
    'name': f_fields.String(required=False, description=''),
    'timeOn': f_fields.Float(required=False, description='sec'),
    'duration': f_fields.Float(required=False, description='sec'),
    'period': f_fields.Float(required=False, description=''),
    'numberOfRepetitions': f_fields.Float(required=False, description=''),
    'nameInEventLog': f_fields.String(required=False, description=''),
    'triggerDevice': f_fields.String(required=False, description=''),
}


class EventTrainSchema(Schema):
    """Marshmallows schema class representing EventTrain table"""

    eventTrainId = ma_fields.Integer()
    name = ma_fields.String()
Ejemplo n.º 15
0
from flask_restx import fields, reqparse
from rest import api

from utils import parser_utils

CategorySchema = api.model(
    'Category', {
        'id':
        fields.Integer(required=False, description='Category id.'),
        'name':
        fields.String(required=True,
                      description='Category name min 3, max 50.'),
    })

CategoryParser = reqparse.RequestParser()
CategoryParser.add_argument('name',
                            type=parser_utils.validate_string(50, 3),
                            required=True,
                            location='json')
Ejemplo n.º 16
0
from flask_restx import fields
from flask_restx.fields import MarshallingError
from flask_restx.marshalling import marshal

from .common import ns

playlist_identifier = ns.model(
    "playlist_identifier",
    {
        # Use `FormattedString`s in these models to act as a constant via the source string arg ("playlist" here)
        "type": fields.FormattedString("playlist"),
        "playlist_id": fields.Integer(required=True),
    },
)

explore_playlist_identifier = ns.model(
    "explore_playlist_identifier",
    {
        "type": fields.FormattedString("explore_playlist"),
        "playlist_id": fields.String(required=True),
    },
)


class PlaylistLibraryIdentifier(fields.Raw):
    def format(self, value):
        try:
            if value.get("type") == "playlist":
                return marshal(value, playlist_identifier)
            if value.get("type") == "explore_playlist":
                return marshal(value, explore_playlist_identifier)
Ejemplo n.º 17
0
from .utils import HtContext

_LOGGER = logging.getLogger(__name__)

api = Namespace(
    "timeprog",
    description="Operations related to the time programs of the heat pump.")

time_prog_model = api.model(
    "time_prog_model",
    {
        "index":
        fields.Integer(
            min=0,
            description="index of the time program",
            required=False,
            readonly=True,
            example=0,
        ),
        "name":
        fields.String(
            description="name of the time program",
            required=False,
            readonly=True,
            example="Warmwasser",
        ),
        "ead":
        fields.Integer(
            min=0,
            description="number of entries a day of the time program",
            required=False,
Ejemplo n.º 18
0
You should have received a copy of the GNU Lesser General Public License
along with py-ispyb. If not, see <http://www.gnu.org/licenses/>.
"""

__license__ = "LGPLv3+"

from marshmallow import Schema, fields as ma_fields
from flask_restx import fields as f_fields
from marshmallow_jsonschema import JSONSchema

from app.extensions.api import api_v1 as api

dict_schema = {
    "micrographId":
    f_fields.Integer(required=True, description=""),
    "crystalSlurryId":
    f_fields.Integer(required=True, description=""),
    "url":
    f_fields.String(required=False, description=""),
    "objectSidePixelSize":
    f_fields.String(required=False, description="comma separated two floats"),
    "descriptionJson":
    f_fields.String(required=False, description=""),
}


class MicrographSchema(Schema):
    """Marshmallows schema class representing Micrograph table"""

    micrographId = ma_fields.Integer()
Ejemplo n.º 19
0
from flask_restx import Namespace, Resource, fields
from webargs.flaskparser import use_kwargs
from werkzeug.exceptions import NotFound
from ..utils import (get_json_from_file_resource,
                     get_dict_of_elements_from_json_file_list, validate_id,
                     PAGINATION_ARGUMENTS, DOC_PAGINATION_ARGUMENTS,
                     OFFICES_FILENAME)

api = Namespace('offices', description='Offices')

OFFICE_RESOURCE_KEY = "office"
OFFICE_ID_FIELD_KEY = "id"
office_model = api.model(
    'Office', {
        OFFICE_ID_FIELD_KEY:
        fields.Integer(required=True, description='The office identifier'),
        'city':
        fields.String(description='The office city'),
        'country':
        fields.String(description='The office country'),
        'address':
        fields.String(description='The office address'),
    })


@api.route('')
class Offices(Resource):
    @api.doc('list_offices', params=DOC_PAGINATION_ARGUMENTS)
    @api.marshal_list_with(office_model)
    @use_kwargs(PAGINATION_ARGUMENTS, location="query")
    def get(self, limit, offset):
Ejemplo n.º 20
0
from flask import Blueprint
from flask_restx import Api, fields

from train_model import get_model

api = Api(version='1.0', title='ML API Example', validate=False)
ns = api.namespace('heart', description='Heart disease')
_, model_info = get_model()
feature_row = api.model('featues', {
    feat: fields.Float(required=True)
    for feat in model_info['required_cols']
})

information = api.model(
    'model information', {
        'model_name': fields.String(required=True),
        'f1-score': fields.Float(required=True),
        'required_cols': fields.List(fields.String())
    })

prediction = api.model('prediction', {'prediction': fields.Integer()})

api_blueprint = Blueprint('api', __name__)
Ejemplo n.º 21
0
                     ('root', 'example'))
cors = CORS(app)

db = client.weather
collection = db.temperature

temperature = api.model(
    'Temperature',
    {
        # '_id' : fields.String(),
        'id_station': fields.String(required=True, description='@MAC Station'),
        'id_sonde': fields.String(required=True, description='@MAC Sonde'),
        'latitude': fields.Float(required=True, description='Latitude'),
        'longitude': fields.Float(required=True, description='Longitude'),
        'ville': fields.String(required=True, description='ville'),
        'timestamp': fields.Integer(required=True, description='Timestamp'),
        'temperature': fields.Float(required=True, description='Temperature'),
        'humidite': fields.Float(required=True, description='Humidite')
    })

app.config['CORS_HEADERS'] = 'Content-Type'


@app.route("/")
@cross_origin()
def helloWorld():
    return "Hello, cross-origin-world!"


@app.after_request  # blueprint can also be app~~
def after_request(response):
Ejemplo n.º 22
0
# app/api/users.py
# APIs for users

from flask import request
from flask_restx import Namespace, Resource, fields

from app.api.utils import (add_user, delete_user, get_all_users,
                           get_user_by_email, get_user_by_id, update_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),
        # "password": 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."""
You should have received a copy of the GNU Lesser General Public License
along with py-ispyb. If not, see <http://www.gnu.org/licenses/>.
"""

__license__ = "LGPLv3+"

from marshmallow import Schema, fields as ma_fields
from flask_restx import fields as f_fields
from marshmallow_jsonschema import JSONSchema

from app.extensions.api import api_v1 as api

dict_schema = {
    'autoProcScalingStatisticsId':
    f_fields.Integer(required=True,
                     description='Primary key (auto-incremented)'),
    'autoProcScalingId':
    f_fields.Integer(
        required=False,
        description='Related autoProcScaling item (used by foreign key)'),
    'scalingStatisticsType':
    f_fields.String(
        required=True,
        description='Scaling statistics typeenum(overall,innerShell,outerShell)'
    ),
    'comments':
    f_fields.String(required=False, description='Comments...'),
    'resolutionLimitLow':
    f_fields.Float(required=False, description='Low resolution limit'),
    'resolutionLimitHigh':
    f_fields.Float(required=False, description='High resolution limit'),
Ejemplo n.º 24
0
    credentials = f.read()
    api_access = ast.literal_eval(credentials)

client = Cloudant.iam(api_access['username'],
                      api_access['apikey'],
                      connect=True)

project_ns = api.namespace('project',
                           description='User Cloud Project Operations')

# Define the API models we will use (these will show up in the Swagger Specification).

project = api.model(
    'Project', {
        'id':
        fields.Integer(readonly=True, description="Carbon offset project UID"),
        'name':
        fields.String(required=True,
                      description="The name of the carbon offset project"),
        'description':
        fields.String(required=True,
                      description="Description of the carbon offset project"),
        'location':
        fields.String(
            required=True,
            description="The country in which the project is located"),
        'cost':
        fields.Float(
            required=True,
            description=
            "The cost per tonne of carbon eliminated associated with this project"
Ejemplo n.º 25
0
from flask_restx import fields, Model

todo_model = Model(
    'todo', {
        'id':
        fields.Integer(readonly=True,
                       description='The task unique identifier'),
        'task':
        fields.String(required=True, description='The task details')
    })
Ejemplo n.º 26
0
class RequestDto:
    api = Namespace("request", path="/request")

    no_pattern = "([1-9]|1[012])-([1-9]|([1-9][0-9]))+"
    # date_pattern = "(\d{4}-\d{2}-\d{2} ([2][0-3]|[0-1][0-9]|[1-9]):[0-5][0-9]:([0-5][0-9]|[6][0]))"
    date_pattern = "\d{4}-\d{2}-\d{2}"
    photo_fn_pattern = "(.*/)*.+\.(png|jpg|jpeg|PNG|JPG|JPEG)"
    id_pattern = "[a-f0-9]{8}-?[a-f0-9]{4}-?4[a-f0-9]{3}-?[89ab][a-f0-9]{3}-?[a-f0-9]{12}"

    request = api.model(
        "request", {
            "id":
            fields.String(),
            "no":
            fields.String(required=True, pattern=no_pattern),
            "date":
            fields.String(
                dt_format="rfc822", required=True, pattern=date_pattern),
            "detail":
            fields.String(),
            "result":
            fields.Integer(required=True, min=0, max=2),
            "rating":
            fields.Integer(required=True, min=0, max=5),
            "photo_fn":
            fields.String(required=True, pattern=photo_fn_pattern),
            "client":
            fields.Nested(api.model(
                "client", {
                    "id":
                    fields.String(required=True,
                                  attribute="client_id",
                                  pattern=id_pattern),
                    "name":
                    fields.String(attribute="client_name")
                }),
                          required=True),
            "approach":
            fields.Nested(api.model(
                "approach", {
                    "id":
                    fields.String(required=True,
                                  attribute="approach_id",
                                  pattern=id_pattern),
                    "name":
                    fields.String(attribute="approach_name")
                }),
                          required=True),
            "type":
            fields.Nested(api.model(
                "type", {
                    "id":
                    fields.String(required=True,
                                  attribute="type_id",
                                  pattern=id_pattern),
                    "name":
                    fields.String(attribute="type_name")
                }),
                          required=True),
            "fixers":
            fields.List(fields.Nested(api.model(
                "fixer", {
                    "id":
                    fields.String(required=True,
                                  attribute="fixer_id",
                                  pattern=id_pattern),
                    "name":
                    fields.String(attribute="fixer_name")
                }),
                                      required=True),
                        min_items=1)
        })
Ejemplo n.º 27
0
from flask_restx import fields, Model

base_resp = Model(
    'Body', {
        'return_code':
        fields.Integer(
            title='返回码', description='200为成功', example=200, required=True),
        'return_msg':
        fields.String(title='返回信息',
                      description='成功时可为空字符串',
                      example='Success',
                      required=True)
    })
resource_model = Model(
    'ResourceModel', {
        'created_by':
        fields.Integer(title='创建者ID', example=1, required=True),
        'created_at':
        fields.String(
            title='创建时间', example='2020-01-01 08:00:00', required=True),
        'updated_by':
        fields.Integer(title='更新者ID', example=1),
        'updated_at':
        fields.String(title='更新时间', example='2020-01-01 08:00:01')
    })
user_model = resource_model.clone(
    'user', {
        "user_id":
        fields.Integer(title="用户ID"),
        'user_name':
        fields.String(title="用户名"),
Ejemplo n.º 28
0
class SMEDTO:
    sme_api = Namespace("SME", description="SME related operations")
    sme_list = sme_api.model(
        "sme_list",
        {
            "name": fields.String(required=True, description="SME name"),
            "postal_address": fields.String(
                required=True, description="SME postal address"
            ),
            "location": fields.String(required=True, description="SME location"),
            "telephone": fields.String(required=True, description="SME telephone"),
            "email": fields.String(required=True, description="SME email address"),
            "description": fields.String(required=True, description="SME description"),
            "sector": fields.String(required=True, description="SME sector"),
            "principal_product_service": fields.String(
                required=True, description="SME principal product/service",
            ),
            "other_product_service": fields.String(
                required=True, description="SME other products/services"
            ),
            "age": fields.String(required=True, description="SME age"),
            "establishment_date": fields.Date(description="SME establishment date"),
            "ownership_type": fields.String(
                required=True, description="SME ownership type"
            ),
            "bank_account_details": fields.String(
                required=True, description="SME bank account details"
            ),
            "employees_number": fields.Integer(
                required=True, description="SME employees_number"
            ),
            "client": fields.Nested(
                ClientDTO().client, description="SME representative"
            ),
        },
    )

    sme = sme_api.model(
        "sme",
        {
            "name": fields.String(required=True, description="SME name"),
            "postal_address": fields.String(
                required=True, description="SME postal address"
            ),
            "location": fields.String(required=True, description="SME location"),
            "telephone": fields.String(required=True, description="SME telephone"),
            "email": fields.String(required=True, description="SME email address"),
            "description": fields.String(required=True, description="SME description"),
            "sector": fields.String(required=True, description="SME sector"),
            "principal_product_service": fields.String(
                required=True, description="SME principal product/service",
            ),
            "other_product_service": fields.String(
                required=True, description="SME other products/services"
            ),
            "age": fields.String(required=True, description="SME age"),
            "establishment_date": fields.Date(description="SME establishment date"),
            "ownership_type": fields.String(
                required=True, description="SME ownership type"
            ),
            "bank_account_details": fields.String(
                required=True, description="SME bank account details"
            ),
            "employees_number": fields.Integer(
                required=True, description="SME employees_number"
            ),
            "client_email": fields.String(required=True, description="Client email"),
        },
    )
Ejemplo n.º 29
0
from flask_restx import fields

from cortex.api import api_manager
from cortex.api.serializers import pagination

tasks_serializer = api_manager.model(
    'task', {
        'id':
        fields.Integer(required=True, description='Task ID.'),
        'module':
        fields.String(required=True,
                      description='The module that started the task'),
        'username':
        fields.String(required=True,
                      description='The user that started the task'),
        'start':
        fields.DateTime(required=False,
                        description='The date and time this task was started'),
        'end':
        fields.DateTime(required=False,
                        description='The date and time this task finished'),
        'status':
        fields.Integer(
            required=True,
            description=
            'The status of the task - 0: in progress, 1: success, 2: failure, 3: warnings'
        ),
        'description':
        fields.String(required=False,
                      description='The description of the task'),
    })
if str(app.config['SPRING_PROFILES_ACTIVE']).__contains__('kubernetes'):
    initialize_kubernetes_client(app)
else:
    initialize_consul_client(app)

initialize_db(app)
api = initialize_api(app)

ns = api.namespace('api/products', description='Product operations')
nsReceipt = api.namespace('api/receipts', description='Receipt operations')

productModel = api.model(
    'Product', {
        'name': fields.String(required=True, description='Name'),
        'quantity': fields.Integer(required=True, description='Quantity'),
        'category': fields.String(required=True, description='Category Name'),
    })

upload_parser = api.parser()
upload_parser.add_argument('file',
                           location='files',
                           type=FileStorage,
                           required=True)

# Create configuration object with enabled logging and sampling of all requests.
config = Config(
    config={
        'sampler': {
            'type': 'const',
            'param': 1