__schema_type__ = ['string', 'null']
__schema_example__ = 'nullable string'
class PrivateString(fields.String):
def format(self, value):
return None
api = Namespace('connections', description='Connection related operations')
dto = api.model(
'connection',
{
'id':
fields.Integer(readonly=True, example=1),
'name':
fields.String(required=True, example='arbitrary-unique-name'),
'type':
fields.String(required=True, example='s3'),
'bucket':
OptionalString(required=False, example='my-bucket-name'),
's3_access_key_id':
OptionalString(required=False, example='KJRHJKHWEIUJDSJKDC2J'),
's3_secret_access_key':
OptionalString(required=False,
example='jksldASDLASdak+asdSDASDKjasldkjadASDAasd'),
's3_region':
OptionalString(required=False, example='us-west-2'),
's3_aws_session_token':
OptionalString(required=False, example='you session token'),
#pylint: disable=unused-argument
from flask import g, jsonify, abort, send_file
from flask_restplus import Resource, fields
from pyinfraboxutils.ibflask import auth_required, check_job_belongs_to_project
from pyinfraboxutils.ibrestplus import api
from pyinfraboxutils.storage import storage
ns = api.namespace('api/v1/projects/<project_id>/jobs',
description='Job related operations',
tag="test")
limits_model = api.model(
'LimitsModel', {
'cpu': fields.Integer(min=1, attribute='cpu'),
'memory': fields.Integer(min=128, attribute='memory')
})
dependency_model = api.model(
'DependencyModel', {
'on': fields.List(fields.String),
'job': fields.String,
'job-id': fields.String
})
resource_model = api.model('ResourceModel',
{'limits': fields.Nested(limits_model)})
job_model = api.model(
'JobModel', {
'id': fields.String,
@api.route('/with-query-string')
class Temps(Resource):
@api.expect(example3_parser)
def get(self):
"""List images"""
example3_parser = reqparse.RequestParser()
example3_parser.add_argument('q')
args = example3_parser.parse_args()
query_string_value = args.get('q')
return {'query_string_value': city_value}
example4_fields = api.model('MyModel', {
'name': fields.String,
'age': fields.Integer(min=0)
})
# GET does not support fields.
@api.route('/with-fields')
class Temps(Resource):
@api.expect(example4_fields)
def post(self):
"""
Documentation for the method
goes here
"""
payload = api.payload
return {'name': payload['name'], 'age': str(payload['age'])}
from app.common import (logging)
# using namespace to organized all the routing related to car_details into single level
ns_cars = Namespace('cars', description='namespace for the cars data')
# restplus model for marshalling with the database records
car_model = ns_cars.model(
'Cars', {
'chassis_no':
fields.String(required=True, example='12345A'),
'make':
fields.String(required=True, example='Nissan'),
'model':
fields.String(required=True, example='Micra'),
'year':
fields.Integer(required=True, example='2004'),
'id':
fields.Integer(required=True, example='101'),
'last_updated':
fields.DateTime(required=True, example='2018-02-09 10:11:11'),
'price':
fields.Float(required=True, example='500.0')
})
# restplus model for considering 'model' and 'make' for finding average price
price_model = ns_cars.model(
'Average_Price', {
'make': fields.String(required=True, example='Nissan'),
'model': fields.String(required=True, example='Micra')
})
api = Namespace('basket', description='Customer Basket/Checkout System')
RABBIT_USER = os.getenv('RABBIT_USER', 'guest')
RABBIT_PASSWORD = os.getenv('RABBIT_PASSWORD', 'guest')
RABBIT_HOST = os.getenv('RABBIT_HOST', '127.0.0.1')
RABBIT_PORT = os.getenv('RABBIT_PORT', '5672')
amqp_uri = 'amqp://{}:{}@{}:{}'.format(RABBIT_USER, RABBIT_PASSWORD,
RABBIT_HOST, RABBIT_PORT)
CONFIG_RPC = {'AMQP_URI': amqp_uri}
basket_item = api.model(
'Basket Item',
dict(product_id=fields.Integer(required=True),
product_name=fields.String(),
unit_price=fields.Float(),
old_unit_price=fields.Float(),
quantity=fields.Integer))
basket = api.model(
'Basket',
dict(buyer_id=fields.String(required=True),
items=fields.List(fields.Nested(basket_item))))
checkout_basket = api.model(
'BasketCheckout',
dict(buyer_id=fields.String(),
buyer=fields.String(),
city=fields.String(required=True),
'Symptom', {
'name':
fields.String(
required=True, example='Fatigue', description='Symptom name'),
})
allData = api.model(
'data', {
'symptoms':
fields.List(fields.Nested(symptom)),
'sex':
fields.String(required=False,
example='female',
description='male, female, other'),
'age':
fields.Integer(readOnly=True, example=32, description='The users age')
})
model = joblib.load('model_rf.pkl')
mlb = joblib.load('mlb_simple.pkl')
def loadFeatures():
filein = open('features_rf.txt', 'r')
featureList = []
for feature in filein:
if (feature.rstrip('\n') in featureList):
print feature
featureList.append(feature.rstrip('\n'))
return featureList
* Licence: MIT, see LICENSE
'''
from flask_restplus import fields
from src.api.apiConfig import api
from src.api.fitcrack.endpoints.package.responseModels import job_model
from src.api.fitcrack.responseModels import pagination, host_short_model, package_short_model, boincHost_model, \
user_model
page_of_hosts_model = api.inherit(
'Page of hosts', pagination,
{'items': fields.List(fields.Nested(boincHost_model))})
jobWithPackage_model = api.inherit(
'Job with package', job_model,
{'job': fields.Nested(package_short_model, attribute='package')})
boincHostDetail_model = api.model(
'Host detail boinc', {
'id': fields.Integer(readOnly=True, required=False),
'domain_name': fields.String(),
'p_model': fields.String(),
'user': fields.Nested(user_model),
'os_name': fields.String(),
'fc_host': fields.Nested(host_short_model),
'active': fields.Boolean(),
'workunits': fields.List(fields.Nested(jobWithPackage_model)),
'jobs': fields.List(fields.Nested(package_short_model))
})
import logging
ns = api.namespace('ping', description="Run ping tests")
host = api.model(
'host', {
'hostname': fields.String(description='Hostname',
example='edge_node1'),
'ip': fields.String(description='IP of Host', example='10.0.0.1')
})
host_list = api.model(
'hosts', {
'threads_num':
fields.Integer(description='Number of threads to run ping with',
example=1,
default=1),
'seconds':
fields.String(description='seconds to run each ping for', example='4'),
'hosts':
fields.List(fields.Nested(host))
})
@ns.route('')
class PingList(Resource):
@api.doc(responses={200: 'Everything ok', 201: 'No known hosts'})
def get(self):
"""
Returns dict of latencies to known hosts
"""
"This API provides endpoints such as Historical and Forecast in combination with and[or] without parameters"
)
weatherAPI = Namespace('HistoricalWeather', description='Historical Weather')
api.add_namespace(weatherAPI)
parser = reqparse.RequestParser()
parser.add_argument('DATE')
parser.add_argument('TMAX')
parser.add_argument('TMIN')
postModel = api.model(
'AccountModel', {
'DATE': fields.String(required=True,
description='Date in YYYYMMDD format'),
'TMAX': fields.Integer(required=True, description='Max temp'),
'TMIN': fields.Integer(required=True, description='Min temp'),
})
args1 = {
'DATE': fields.String(required=True,
description='Date in YYYYMMDD format'),
'TMAX': fields.Integer(required=True, description='Max temp'),
'TMIN': fields.Integer(required=True, description='Min temp')
}
class WeatherApplication(Resource):
def get(self):
return "/Historical/ , /Historical/'<DATE>' and /Forecast/'<DATE>' as GET Requests \n /Historical/ with date as POST and Delete Requests"
'ingredients': fields.List(fields.Nested(ingredient_model))
})
categories_model = api.model(
'categories_model', {
'categories': fields.List(fields.Nested(category_ingredient_model)),
})
ingredients_recipe_model = api.model(
'ingredients_recipe_model', {
'name': fields.String(required=True, example='Cheese'),
'quantity': fields.String(required=True, example='500 grams')
})
recipe_id_model = api.model(
'recipe_id_model', {'recipe_id': fields.Integer(required=True, min=0)})
tag_model = api.model(
'tag_model', {'tag': fields.String(required=True, example='Breakfast')})
tags_model = api.model('tags_model',
{'tags': fields.List(fields.Nested(tag_model))})
ingredients_tags_model = api.model(
'ingredients_tags_model', {
'ingredients': fields.List(fields.Nested(ingredient_model)),
'tags': fields.List(fields.Nested(tag_model))
})
recipe_name_tags_model = api.model(
'recipe_name_tags_model', {
min_length=3,
max_length=32,
description='MQTT username'),
'password':
fields.String(required=True,
min_length=3,
max_length=32,
description='MQTT password'),
'server':
fields.String(required=True,
min_length=3,
max_length=64,
default='93.118.34.190',
description='MQTT server address'),
'port':
fields.Integer(
required=True, default=1883, description='MQTT server port'),
'keep_alive':
fields.Integer(
required=True, default=60, description='MQTT keep alive')
})
mqtt_account_patch = api.model(
'MQTT account patch', {
'username':
fields.String(required=False,
min_length=3,
max_length=32,
description='MQTT username'),
'password':
fields.String(required=False,
min_length=3,
from flask import request
from flask_restplus import Namespace, Resource, fields
from http import HTTPStatus
namespace = Namespace('entities', 'Entities fake endpoints')
entity_model = namespace.model(
'Entity', {
'id': fields.Integer(readonly=True, description='Entity identifier'),
'name': fields.String(required=True, description='Entity name')
})
entity_list_model = namespace.model(
'EntityList', {
'entities':
fields.Nested(
entity_model, description='List of entities', as_list=True),
'total_records':
fields.Integer(description='Total number of entities', ),
})
entity_example = {'id': 1, 'name': 'Entity name'}
@namespace.route('')
class entities(Resource):
'''Get entities list and create new entities'''
@namespace.response(500, 'Internal Server error')
@namespace.marshal_list_with(entity_list_model)
def get(self):
'''List with all the entities'''
# Scan result structure
scan_result = api.model(
'ScanResultStructure', {
'req':
fields.String(description=u'Requirement ShortName'),
'result':
fields.Nested(
api.model(
'ScanResult', {
'status':
fields.String(
description=
u'Requirement fulfilled? (PASSED/FAILED/ERROR/IN_PROGRESS)'
),
'confidenceLevel':
fields.Integer(description=u'Value in percent'),
'message':
fields.String(description=u'Result message')
})),
})
### Scanning class
@api.route('/scanapi/tests', methods=['POST'])
class Scan(Resource):
@api.doc(responses={200: 'Test result'})
@api.expect(scan_definition)
@api.marshal_list_with(scan_result)
def post(self):
request_params = api.payload
target_url = request_params['testProperties']['appUrl']
from cleanup import clean_images
IMAGE_DIR = "{}/api/static/cleaned-images".format(os.getcwd())
# flask app configuration
app = Flask(__name__, static_folder='static')
api = Api(app, doc="/swagger/")
# image gnerator
generator = ImageGenerator()
UPLOAD_DIRECTORY = "./api/static/images"
fields = api.model(
'NewPokemonImageRequestBody', {
'id1': fields.Integer(description='pokedex id', required=True, min=1),
'id2': fields.Integer(description='pokedex id', required=True, min=1),
})
@api.route("/home")
class Home(Resource):
@api.doc("home")
def get(self):
return jsonify("Welcome to PokeMate image generator!")
@api.route("/image-generator")
class Generator(Resource):
@api.doc(model='NewPokemonImageRequestBody')
def post(self):
from controller.book_copy_checker import BookCopyChecker
from controller.note_checker import NoteChecker
ns = Namespace('books', description='Book operations')
note_marshaller = ns.model(
'Note', {
'note_title':
fields.String(required=True, description='Unique title of note'),
'note':
fields.String(required=True, description='Note about a book.')
})
return_note_marshaller = ns.inherit('ReturnNote', note_marshaller, {
'book_id':
fields.Integer(description='Book id note is associated with.')
})
amend_note_marshaller = ns.model(
'AmendNote', {
'note':
fields.String(required=True, description='Text of note to be amended.')
})
author_marshaller = ns.model(
'Author', {
'author_id':
fields.Integer(required=False, description='Id for an author record'),
'first_name':
fields.String(required=True, description='First name of an author'),
'last_name':
from flask_restplus import fields
from rest_api_demo.api.restplus import api
authn_role = api.model(
'AuthnRole', {
'id':
fields.Integer(required=True, description='The id of the user'),
'role_name':
fields.String(required=True, description='The name of the role')
})
authn_account_request = api.model(
'Account', {
'id':
fields.Integer(readonly=True,
description='The unique identifier of an account'),
'account_name':
fields.String(required=True, description='Account title'),
})
authn_orgunit_request = api.model(
'Organizational Unit', {
'id':
fields.Integer(readonly=True,
description='The unique identifier of an orgunit'),
'account_id':
fields.Integer(required=True,
description='Account associated with org unit'),
'orgunit_name':
fields.String(required=True, description='Organizational Unit title'),
})
from flask_restplus import fields
from lost.api.api import api
template_element = api.model(
'Template element', {
'peN': fields.Integer(description="Number of element."),
'peOut': fields.List(fields.Integer, description='Elements output.'),
'datasource': fields.Raw(),
'script': fields.Raw(),
'annoTask': fields.Raw(),
'loop': fields.Raw(),
'dataExport': fields.Raw(),
})
template = api.model(
'Template',
{
'id':
fields.Integer(readOnly=True,
description="The identifier of the pipeline template."),
'description':
fields.String(readOnly=True,
description="The description of the pipeline template."),
'author':
fields.String(readOnly=True,
description="The author of the pipeline template."),
'namespace':
fields.String(readOnly=True,
description="The namespace of the pipeline template."),
'name':
fields.String(readOnly=True,
description="The name of the pipeline template."),
from automoticz.utils import rest
from . import namespace as api
wsdevices_reguest = api.model('WS devices GET request', {
'access_token': rest.access_token_field,
})
base_model = api.model('WS Device GET base response', rest.response_base)
WSCommand_model = api.model(
'WS Command model', {
'description': fields.String(description='Command description'),
'name': fields.String(description='Command name'),
'id': fields.String(description='Command ID'),
'device_id': fields.Integer(description='Device ID'),
})
WSState_model = api.model(
'WS State model', {
'value': fields.String(description='State value'),
'description': fields.String(description='State description'),
'name': fields.String(description='State name'),
'id': fields.String(description='State ID'),
})
WSDevice_list_item = api.model(
'WS Device list item', {
'id': rest.wsdevice_id_field,
'name': rest.wsdevice_name_field,
'description': rest.wsdevice_description_field,
placebp = Blueprint('place', __name__)
ns_place = Namespace(
'similar',
description='Get places with simlar Revenue,Tax,Expenditures etc.,')
api = Api(placebp,
version='1.0',
title='TruthTree ML API',
description='APIs supported by ML')
api.add_namespace(ns_place)
year_range = ns_place.model(
'Year range', {
'start': fields.Integer(default=1977, description="Starting year"),
'end': fields.Integer(default=2016, description="Ending year")
})
PlaceSingle = ns_place.model(
'Similar places for single attribute', {
'id':
fields.Integer(required=True, description="Place ID"),
'place_type':
fields.Integer(
required=True,
description="Type of place, Ex. state(0), county(1), city(2)"),
'attribute':
fields.Integer(required=True, description="Attribute ID"),
'normalize_by':
fields.Integer(
from app.utils import get_logger, auth
from . import base_query_fields, ARLResource, get_arl_parser
ns = Namespace('site', description="站点信息")
logger = get_logger()
base_search_fields = {
'site': fields.String(required=False, description="站点URL"),
'hostname': fields.String(description="主机名"),
'ip': fields.String(description="ip"),
'title': fields.String(description="标题"),
'http_server': fields.String(description="Web servers"),
'headers': fields.String(description="headers"),
'finger.name': fields.String(description="指纹"),
'status': fields.Integer(description="状态码"),
'favicon.hash': fields.Integer(description="favicon hash"),
'task_id': fields.String(description="任务 ID"),
}
base_search_fields.update(base_query_fields)
@ns.route('/')
class ARLSite(ARLResource):
parser = get_arl_parser(base_search_fields, location='args')
@auth
@ns.expect(parser)
def get(self):
"""
'dateUpdated': fields.DateTime()
})
a_user = api.model(
'user', {
'name': fields.Nested(a_user_name),
'details': fields.Nested(a_user_details),
'auth': fields.Nested(a_auth)
})
A_USER_EMPLOYEE = api.model(
'User Employee',
{
'name': fields.Nested(a_user_name),
'details': fields.Nested(a_user_details),
# 'username': fields.String(),
'webUrl': fields.String()
})
a_user_details = api.model(
'users', {
'id': fields.Integer(),
'name': fields.Nested(a_user_name),
'auth': fields.Nested(a_auth_hashed),
'details': fields.Nested(a_user_details),
'timestamp': fields.Nested(a_user_timestamp)
})
A_USER_EMPLOYEE_PASSWORD = api.model('User Password',
{'password': fields.String()})
from flask_restplus import fields
from cortex.api import api_manager
pagination = api_manager.model(
'A page of results', {
'page':
fields.Integer(description='Number of this page of results'),
'pages':
fields.Integer(description='Total number of pages of results'),
'per_page':
fields.Integer(description='Number of items per page of results'),
'total':
fields.Integer(description='Total number of results'),
})
)
# A NameSpace is a top level collection of paths. The only namespace in this applicaton is Addresses
ns = api.namespace(
'Addresses',
description='APIs for validating and obtaining maling address info.')
# Models are schema definitions for JSON objects passed into and out of operations in bodies.
# There are two approaches to defining a model. 1) api.model, 2) JSON Schema.
# https://json-schema.org/
# Data returned in the body of a verification check.
address = api.model(
'Address', {
'delivery_point_parcode':
fields.Integer(required=True,
description='Barcode number identifying mail point'),
'street':
fields.String(required=True, description='Street name'),
'city':
fields.String(required=True, description='City name'),
'state':
fields.String(required=True, description='State name'),
'zipcode':
fields.String(required=True, description='State name'),
'more fields':
fields.String(required=True, description='Blah, blah ...')
})
# Information about an individual zipcode returns in a zipcode lookup.
zipcode_info = api.model(
'ZipCodeInfo', {
from random import *
from flask import Flask, redirect, render_template, request, url_for
from flask_restplus import Resource, Api, fields
from table import UserTable
flask_app = Flask(__name__)
api = Api(app=flask_app,
version='1.0',
title='WP User API',
description='WP User API Site')
ns = api.namespace('userapi', description='Main APIs')
user_model = api.model(
'UserModel', {
'id':
fields.Integer(
required=True, description="user ID", help="BIGINT(20) UNSIGNED"),
'user_login':
fields.String(
required=True, description="login ID", help="VARCHAR(60)"),
'user_pass':
fields.String(
required=True, description="login PW", help="VARCHAR(64) MD5"),
'user_nicename':
fields.String(
required=True, description="user Nice Name", help="VARCHAR(50)"),
'user_email':
fields.String(
required=True, description="user Email", help="VARCHAR(100)"),
'display_name':
fields.String(required=True,
description="user Display Name",
from flask import request
from flask_restplus import Namespace, Resource, fields, reqparse
from .utils import clean_data, SingleResource, db
from app.models import Song, Album, Artist, Genre
api = Namespace("songs", description="Endpoint to query a Songs")
serializer = api.model("song",{
"id" : fields.String(description="Public ID of Song", attribute="public_id", readonly=True),
"name" : fields.String(description="Name of Song"),
"url" : fields.String(description="URL ID of Song"),
"year" : fields.Integer(description="Year of Song", min=1960),
"track number": fields.Integer(description="Number of Track in Album", attribute="track_number"),
"featuring": fields.List(fields.String, description="Artists featured on Song"),
"album": fields.String(description="Album song belongs to"),
"genre": fields.String(description="Genre song belongs to"),
"artist": fields.String(description="Artists of Song"),
"reviews": fields.List(fields.String, description="Reviews of Song", readonly=True),
})
parser = reqparse.RequestParser()
parser.add_argument("name", type=str, help="Name of Song", location="form")
parser.add_argument("url", type=str, help="URL of Song resource", location="form")
parser.add_argument("year", type=int, help="Year Song was released", location="form")
parser.add_argument("track number", type=int, help="Track Number of Song if in an Album", dest="track_number", location="form")
parser.add_argument("album", type=str, help="Album name if Song is in an Album", location="form")
parser.add_argument("artist", type=str, help="Artist of Song", location="form")
parser.add_argument("genre", type=str, help="Genre Song belongs to", location="form")
parser.add_argument("featuring", type=str, help="List of Artists featured on Song", action="append", location="form")
class MinerDto:
namespace = Namespace('miner', description='miner related operations')
miner = namespace.model(
'miner', {
'id':
fields.String(required=False, description="the miners UUID"),
'name':
fields.String(required=False,
description="name of the miner set by the user"),
'user_id':
fields.String(
required=False,
description="user id of the user that the miner belongs to"),
})
share = namespace.model(
'share', {
'miner_id':
fields.String(required=False, description="the miners UUID"),
'gpu_no':
fields.Integer(
required=True,
description="the gpu that the share was generated on"),
'time':
fields.DateTime(
required=True,
description="the time at which the share was generated"),
'type':
fields.String(enum=[enum.name for enum in ShareType],
description="invalid, valid or stale"),
})
share_aggregate = namespace.model(
'share_aggregate', {
'start':
fields.DateTime(
required=True,
description="the time at which the aggregation starts"),
'duration':
fields.Integer(
required=True,
description="the length of the aggregation period, in minutes"
),
'gpu_no':
fields.Integer(
required=True,
description="the gpu that the share was generated on"),
'valid':
fields.Integer(required=False,
description="# of shares generated of this type"),
'invalid':
fields.Integer(required=False,
description="# of shares generated of this type"),
})
health = namespace.model(
'health', {
'miner_id':
fields.String(required=False, description="the miners UUID"),
'gpu_no':
fields.Integer(
required=True,
description="the gpu that the share was generated on"),
'time':
fields.DateTime(
required=True,
description="the time at which the share was generated"),
'temperature':
fields.Integer(required=False,
description="the gpus temperature in C"),
'power':
fields.Integer(required=False,
description="the gpus power usage in watts"),
'hashrate':
fields.Float(required=False,
description="the gpus hashrate in megahash"),
})
class StatsQuerySchema(Schema):
start = fields.DateTime(required=False)
end = fields.DateTime(required=False)
from flask_restplus import fields
from blog_app.api import api
blog_article = api.model(
'Blog Article', {
'id':
fields.Integer(readOnly=True,
description='unique identifier for an article'),
'title':
fields.String(required=True, description='article title'),
'content':
fields.String(required=True, description='article content'),
'category_id':
fields.Integer(attribute='category_id'),
'pub_date':
fields.Integer(attribute='pub_date'),
})
pagination = api.model(
'A page of results', {
'page':
fields.Integer(
description='number of the current page of the results'),
'pages':
fields.Integer(description='total number of pages of results'),
'per_page':
fields.Integer(description='number of articles per page of results')
})
category = api.model(
######################################################################
# Configure Swagger before initilaizing it
######################################################################
api = Api(app,
version='1.0.0',
title='Pet Demo REST API Service',
description='This is a sample server Pet store server.',
default='pets',
default_label='Pet shop operations',
doc='/' # default also could use doc='/apidocs/'
# prefix='/api'
)
# Define the model so that the docs reflect what can be sent
pet_model = api.model('Pet', {
'id': fields.Integer(readOnly=True,
description='The unique id assigned internally by service'),
'name': fields.String(required=True,
description='The name of the Pet'),
'category': fields.String(required=True,
description='The category of Pet (e.g., dog, cat, fish, etc.)'),
'available': fields.Boolean(required=True,
description='Is the Pet avaialble for purchase?')
})
# query string arguments
pet_args = reqparse.RequestParser()
pet_args.add_argument('category', type=str, required=False, help='List Pets by category')
######################################################################
# Special Error Handlers
######################################################################
from typing import List
from flask import current_app
from flask_jwt_extended import jwt_required
from flask_restplus import Namespace, fields, Resource
from flask_sqlalchemy_session import current_session
from app.models import District
api = Namespace('districts',
description='(Проверку на цикличность дистриктов не делал)',
decorators=[jwt_required])
district_model = api.model(
'District', {
'district_id': fields.Integer(),
'name': fields.String(),
'parent_district_id': fields.Integer(),
})
district_payload_model = api.model('District Payload', {
'name': fields.String(),
'parent_district_id': fields.Integer(),
})
district_tree_model = api.model(
'District Tree', {
'districts_tree':
fields.List(
fields.Nested(
api.model(
from flask_restplus import fields
from mtm.api.restplus import api
# Chart item object used in endpoint responses
chartItemResponseModel = api.model(
'ChartItem', {
'rank':
fields.Integer(
required=True, description='Rank position of the song', example=1),
'startDate':
fields.Date(required=True, description='Rank position of the song'),
'endDate':
fields.Date(required=True, description='Rank position of the song'),
'songId':
fields.String(readOnly=True,
description='Unique identifier of a song',
example='1'),
'song.name':
fields.String(readOnly=True,
description='Unique identifier of a song',
example='Bad Romance'),
'song.artist':
fields.String(readOnly=True,
description='Unique identifier of a song',
example='Lady Gaga'),
})
# Response wrapper for list of chart item objects
chartResponseModel = api.inherit(
'Chart response',
{'data': fields.List(fields.Nested(chartItemResponseModel))})
