class WorkingDto:
working_dto = api.model(
'Working_DTO',
{
'node_name': fields.String(required=True, desription='Node name that did action')
}
)
class UsageDto:
usage_dto = api.model(
'Usage_DTO', {
'date':
fields.String(description='Analysed date'),
'duration':
fields.Integer(desription='How many second node was is use')
})
class NodeUsageDto:
node_usage_dto = api.model(
'Node_Usage_DTO', {
'node_name':
fields.String(description='Node name'),
'usages':
fields.List(fields.Nested(UsageDto.usage_dto),
description='Node usage')
})
class SponsorCatalog(Resource):
@token_required
@api.marshal_with(catalog)
def get(self):
id = get_id(request.headers['X-API-KEY'])
cont = CatalogController()
out = cont.fetch_catalog_items(id)
print(out)
del cont
return out
@token_required
@api.expect(catalog_item)
def post(self):
id = get_id(request.headers['X-API-KEY'])
item = api.payload
cont = CatalogController()
try:
added = cont.insert(item, id)
del cont
if added:
return {'message': 'Item added'}, 200
else:
return {'message': 'Item not added'}, 400
except ItemInDB:
return {'message': 'Item already in database'}, 400
del cont
if added:
return {'message': 'Item added'}, 200
else:
return {'message': 'Item not added'}, 400
@token_required
@api.expect(api.model('Listing', {'listing_id': fields.Integer}))
def delete(self):
id = get_id(request.headers['X-API-KEY'])
listing = api.payload['listing_id']
cont = CatalogController()
val = cont.remove(id, listing)
del cont
if val:
return {'message': 'Item removed'}
else:
return {'message': 'Item not removed'}
class Requests(Resource):
a_request = api.model(
'Request', {
'submitter': fields.String('The submitter name'),
'corpType': fields.String('The corporation type'),
'reqType': fields.String('The name request type')
})
@api.errorhandler(AuthError)
def handle_auth_error(ex):
# response = jsonify(ex.error)
# response.status_code = ex.status_code
# return response, 401
return {}, 401
# noinspection PyUnusedLocal,PyUnusedLocal
@api.expect(a_request)
@cors.crossdomain(origin='*')
# @auth_services.requires_auth
@oidc.accept_token(require_token=True)
def post(self, *args, **kwargs):
json_input = request.get_json()
if not json_input:
return {'message': 'No input data provided'}, 400
try:
data = request_schema.load(json_input)
except ValidationError as err:
return jsonify({'errors': err.messages}), 422
nrd = RequestDAO(submitter=data[0].submitter,
corpType=data[0].corpType,
reqType=data[0].reqType)
try:
nrd.save_to_db()
message = 'Successfully created Name Request: {0}'.format(nrd.nr)
except exc.SQLAlchemyError:
logging.log(logging.ERROR, 'error in saving NR {0}'.format(nrd))
return {
"message": "An error occurred creating the Name Request."
}, 500
return {"nr": nrd.nr, "message": message}, 201
"""Views.py Reviews"""
from flask_restplus import Resource, fields
from app import api
from app.models.business import Business
from app.models.review import BusinessReviews
review_model = api.model('Review', {'review': fields.String('Business Review')})
review_out_model = api.model('Review_out', {'review': fields.String('Business review'),
'business_id': fields.String('Business ID'),
'date_created': fields.DateTime(dt_format='rfc822')})
class BusinessReviewsOperations(Resource):
@api.doc(responses={400: 'Bad Request', 200: 'Success', 201: 'Created', 401: 'Unauthorised', 500: 'Database Error'})
def get(self,business_id):
"""Method to get all business reviews"""
reviews = BusinessReviews.get_all_reviews(business_id=business_id)
return reviews
@api.doc(responses={400: 'Bad Request', 200: 'Success', 201: 'Created', 401: 'Unauthorised', 500: 'Database Error'})
@api.expect(review_model)
def post(self, business_id):
"""Method to add a business review"""
review = api.payload
review = review.get('review')
if not review:
return {"Message": "No Review has been added, Please add a review", "Status": "Fail"}, 200
business = Business.query.filter_by(business_id=business_id).first()
if not business:
return {"Message": "Business to add a review to does not exist. Please ensure"
#!/usr/bin/env python
# -*- coding: utf-8 -*-
from flask_restplus import fields, Model
from app import api
users_fields_attributes = api.model('UsersFieldsAttributes', {
'admin': fields.Boolean(default=False),
'username': fields.String,
'name': fields.String,
'email': fields.String,
'registered_on': fields.DateTime(dt_format='rfc822')
})
users_fields_attributes_post = api.model('UsersFieldsAttributesPost', {
'admin': fields.Boolean(default=False),
'username': fields.String(required=True, pattern='^(?!\s*$).+'),
'name': fields.String(required=True, pattern='^(?!\s*$).+'),
'email': fields.String(pattern=r'(^[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\.[a-zA-Z0-9-.]+$)'),
'password': fields.String(required=True, pattern='^(?!\s*$).+')
})
users_fields_attributes_put = api.model('UsersFieldsAttributesPut', {
'admin': fields.Boolean,
'name': fields.String(pattern='^(?!\s*$).+'),
'email': fields.String(pattern=r'(^[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\.[a-zA-Z0-9-.]+$)'),
'password': fields.String(pattern='^(?!\s*$).+')
})
users_fields_with_relationships_post_put = api.model('UsersFieldsWithRelationshipsPost', {
'relationships': fields.Nested(api.model('UsersRelationshipsPost', {
from app import api
from flask_restplus import fields
comment_details = api.model(
'comment_details', {
"author": fields.String(example="Becky"),
"published": fields.String(example="1539476785.0"),
"comment": fields.String(example="Cute Photo!")
})
token_details = api.model('token_details', {'token': fields.String()})
post_id_details = api.model('post_id_details', {"post_id": fields.String()})
post_meta_details = api.model(
'post_meta_details', {
"author": fields.String(),
"description_text": fields.String(),
"published": fields.String(),
"likes": fields.List(fields.Integer())
})
post_details = api.model(
'post_details', {
"id": fields.Integer(),
"meta": fields.Nested(post_meta_details),
"thumbnail": fields.String(),
"src": fields.String(),
"comments": fields.List(fields.Nested(comment_details))
})
from app import api
from flask_restplus import fields
case_model = api.model('Case', {'name': fields.String(required=True)})
#!/usr/bin/env python
# -*- coding: utf-8 -*-
from flask_restplus import fields
from app import api
abilities_fields_attributes = api.model('AbilitiesFieldsAttributes', {
'name': fields.String
})
abilities_fields_with_relationships_put = api.model('AbilitiesFieldsWithRelationshipsPost', {
'relationships': fields.Nested(api.model('AbilitiesRelationshipsPost', {
'groups': fields.Nested(api.model('AbilitiesDataPost', {
'data': fields.Nested(api.model('AbilitiesPostData', {
'type': fields.String,
'id': fields.Integer
}), as_list=True)
})),
}))
})
_abilities_fields_get = api.inherit('AbilitiesFieldsGet', abilities_fields_with_relationships_put, {
'type': fields.String(default='abilities'),
'id': fields.Integer,
'attributes': fields.Nested(abilities_fields_attributes),
})
_abilities_fields_put = api.inherit('AbilitiesFieldsPut', abilities_fields_with_relationships_put, {
'type': fields.String(pattern='abilities', default='abilities'),
})
from app import api
from flask_restplus import Resource, fields
import lib.shovel_service as shovel_service
shovel_route = api.namespace('Shovel',
description='Shovel to register and unregister \
a compute node from RackHD with Ironic')
# models
register_model = api.model(
'Register', {
'uuid': fields.String(required=True, description='rackhd node id'),
'driver': fields.String(required=True, description='ironic driver'),
'ipmihost': fields.String(required=False),
'ipmiuser': fields.String(required=False),
'ipmipass': fields.String(required=False),
'name': fields.String(required=True, description='node name'),
'kernel': fields.String(required=True),
'ramdisk': fields.String(required=True),
'port': fields.String(required=True)
})
@shovel_route.route('/register')
class register(Resource):
@shovel_route.expect(register_model)
def post(self):
'''register RackHd node with Ironic'''
return shovel_service.register(api.payload)
#!/usr/bin/env python
# -*- coding: utf-8 -*-
from flask_restplus import fields
from app import api
auth_fields_get = api.model('AuthGet', { 'access_token': fields.String })
auth_fields_post = api.model('AuthPost', {
'username': fields.String(required=True),
'password': fields.String(required=True)
}
)
staff_list_response_model = api.schema_model('Staff-List-Response-Model', {
"type": "object",
"required": ["staff_list"],
"properties": {
"staff_list": {
"type": "array",
"items": {
"type": "object",
"required": ["id", "name", "username", "staff_type"],
"properties": {
"id": { "type": "integer" },
"name": { "type": "string" },
"username": { "type": "string" },
"staff_type": { "type": "string" }
}
}
}
}
})
edit_staff_request_model = api.model('Edit-Staff-Request-Model', {
"staff_id": fields.Integer(description="staff_id"),
"name": fields.String(description='Name'),
"username": fields.String(description='Username'),
"staff_type_id": fields.Integer(description='Staff_type_id')
})
delete_staff_request_model = api.model('Delete-Staff-Request-Model', {
"staff_id": fields.Integer(description="staff_id")
})
def get_input_model_from_parser(parser, model_name, fields_mapping=base_fields_mapping):
new_model = api.model(model_name, {arg.name: fields_mapping[arg.type] for arg in parser.args})
return new_model
def get_input_model_from_cerberus_schema(schema, model_name, fields_mapping=schema_fields_mapping):
model = {arg_name: get_field_type_from_schema(arg_name, arg_schema, model_name, fields_mapping)
for arg_name, arg_schema in schema.items()}
return api.model(model_name, model)
# coding=utf-8
from app import api
from flask.ext.restplus import fields
from utils.cerberus_utils import get_input_model_from_cerberus_schema
voice_schema = {
u'text': {'type': 'string', 'required': True, 'nullable': False, 'empty': False}
}
voice_input_fields = get_input_model_from_cerberus_schema(voice_schema, u'VoiceInput')
voice_fields = api.model(u'VoiceModel', {
u'id': fields.String,
u'text': fields.String
})
# coding=utf-8
from app import api
from flask.ext.restplus import fields
from utils.cerberus_utils import get_input_model_from_cerberus_schema
picture_schema = {
u'text': {'type': 'string', 'required': True, 'nullable': False, 'empty': False}
}
picture_input_fields = get_input_model_from_cerberus_schema(picture_schema, u'PictureInput')
picture_fields = api.model(u'PictureModel', {
u'id': fields.String,
u'text': fields.String
})
from flask_restplus import fields
from app import api
fire = api.model('Spark', {
'id': fields.Integer(readOnly=True, description='The unique identifier'),
'sparks': fields.List(fields.Integer())
})
"""
Module defines models of json body in post requests
"""
from flask_restx import fields, model
from app import api
wishlist_post_args = api.model(
"Wishlist", {"name": fields.String(description="Wishlist name")})
wishlist_item_post_args = api.model(
"Wishlist item", {"text": fields.String(description="Wishlist item text")})
wishlist_item_put_args = api.inherit(
"Wishlist item put", wishlist_item_post_args, {
"is_reserved":
fields.Boolean(
description=
"if is_reserved is set to True you can't delete this item"),
})
share_wishlist_put_args = api.inherit(
"Wishlist share put", {
"wishlist_id":
fields.String(description="Id of wishlist you want to share"),
"user_id":
fields.String(
description="Id of user with whom you want to share wishlist"),
})
# coding=utf-8
from app import api
from flask.ext.restplus import fields
from utils.cerberus_utils import get_input_model_from_cerberus_schema
vocabularity_schema = {
u'text': {'type': 'string', 'required': True, 'nullable': False, 'empty': False}
}
vocabularity_input_context_fields = get_input_model_from_cerberus_schema(vocabularity_schema, u'GroupInput')
vocabularity_context_fields = api.model(u'TranslationModel', {
u'text': fields.String,
u'context': fields.String
})
#!/usr/bin/env python
# -*- coding: utf-8 -*-
from flask_restplus import fields, Model
from app import api
users_fields_attributes = api.model('UsersFieldsAttributes', {
'admin': fields.Boolean(default=False),
'username': fields.String,
'name': fields.String,
'email': fields.String,
'registered_on': fields.DateTime(dt_format='rfc822')
})
users_fields_attributes_post = api.model('UsersFieldsAttributesPost', {
'admin': fields.Boolean(default=False),
'username': fields.String(required=True, pattern='^(?!\s*$).+'),
'name': fields.String(required=True, pattern='^(?!\s*$).+'),
'email': fields.String(pattern=r'(^[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\.[a-zA-Z0-9-.]+$)'),
'password': fields.String(required=True, pattern='^(?!\s*$).+')
})
users_fields_attributes_put = api.model('UsersFieldsAttributesPut', {
'admin': fields.Boolean,
'name': fields.String(pattern='^(?!\s*$).+'),
'email': fields.String(pattern=r'(^[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\.[a-zA-Z0-9-.]+$)'),
'password': fields.String(pattern='^(?!\s*$).+')
})
users_fields_with_relationships_post_put = api.model('UsersFieldsWithRelationshipsPost', {
'relationships': fields.Nested(api.model('UsersRelationshipsPost', {
from app import api
from flask.ext.restplus import fields
from utils.cerberus_utils import get_input_model_from_cerberus_schema
__author__ = 'Warlock'
card_schema = {
u'foreign': {'type': 'string', 'required': True, 'nullable': False, 'empty': False},
u'native': {'type': 'string', 'required': True, 'nullable': False, 'empty': False},
u'transcription': {'type': 'string', 'required': False, 'nullable': True, 'empty': True},
u'context': {'type': 'string', 'required': False, 'nullable': True, 'empty': True},
u'group_id': {'type': 'string', 'required': True, 'nullable': False, 'empty': False}
}
card_input_fields = get_input_model_from_cerberus_schema(card_schema, 'CardInput')
card_list_fields = api.model(u'CardList', {
u'id': fields.String,
u'user_id': fields.String,
u'group_id': fields.String,
u'foreign': fields.String,
u'native': fields.String,
u'transcription': fields.String,
u'context': fields.String,
u'is_studying': fields.Boolean,
u'is_done': fields.Boolean
})
card_fields = card_list_fields
from app import api
from flask_restplus import fields
login_model = api.model(
'LoginModel', {
'username':
fields.String(description='The username to log in as', required=True),
'password':
fields.String(description='The password associated with the user',
required=True)
})
login_model_response = api.model(
'LoginModelResponse',
{'access_token': fields.String(description='The JWT access token')})
from app import api
from flask.ext.restplus import fields
from utils.cerberus_utils import get_input_model_from_cerberus_schema
from api.resources.cards.models import card_fields
group_schema = {
u'name': {'type': 'string', 'required': True, 'nullable': False, 'empty': False},
u'description': {'type': 'string', 'required': False, 'nullable': True, 'empty': True}
}
group_input_fields = get_input_model_from_cerberus_schema(group_schema, u'GroupInput')
# Group
group_fields = api.model(u'GroupModel', {
u'id': fields.String,
u'name': fields.String,
u'description': fields.String,
u'cards_count': fields.Integer,
u'cards_studying_count': fields.Integer
})
# Group with cards
group_fields_ext = api.model(u'GroupExtModel', {
u'id': fields.String,
u'name': fields.String,
u'description': fields.String,
u'cards_count': fields.Integer,
u'cards_studying_count': fields.Integer,
u'cards': fields.List(fields.Nested(card_fields))
})
from flask_restx import fields
from app import api
conf_serializer = api.model(
'Configuration',
{
'contour_threshold': fields.Float,
'min_area_threshold': fields.Integer
}
)
processing_serializer = api.model(
'Processing',
{
'logo': fields.String(required=True),
'video': fields.String(required=True)
}
)
lxc_container_conf = api.model('LxcContainerConf', {
'aa_allow_incomplete': fields.Integer(default=0),
'aa_profile': fields.String,
'arch': fields.String,
'autodev': fields.Integer(default=1),
'cap': fields.Nested(api.model('LxcCap', {
'drop': fields.List(fields.String),
'keep': fields.List(fields.String)
})),
'cgroup': fields.Nested(api.model('LxcCgroup', {
'memory': fields.Nested(api.model('LxcCgroupMemory', {
'limit_in_bytes': fields.List(fields.String),
'memsw': fields.Nested(api.model('LxcCgroupMemoryMemsw', {
'limit_in_bytes': fields.List(fields.String)
}))
})),
'cpu': fields.Nested(api.model('LxcCgroupCpu', {
'shares': fields.Integer(default=1024)
})),
'cpuset': fields.Nested(api.model('LxcCgroupCpuset', {
'cpus': fields.List(fields.String)
}))
})),
'console': fields.Nested(api.model('LxcConsole', {
'_': fields.String,
'logfile': fields.String
})),
'devttydir': fields.String,
'environment': fields.List(fields.String),
'ephemeral': fields.Integer(default=0),
'group': fields.List(fields.String),
'haltsignal': fields.String(default='SIGPWR'),
'hook': fields.Nested(api.model('LxcHook', {
'autodev': fields.List(fields.String),
'clone': fields.List(fields.String),
'destroy': fields.List(fields.String),
'mount': fields.List(fields.String),
'post-stop': fields.List(fields.String),
'pre-mount': fields.List(fields.String),
'pre-start': fields.List(fields.String),
'start': fields.List(fields.String),
'stop': fields.List(fields.String)
})),
'id_map': fields.String,
'include': fields.String,
'init_cmd': fields.String,
'init_gid': fields.Integer(default=0),
'init_uid': fields.Integer(default=0),
'kmsg': fields.Integer(default=0),
'logfile': fields.String,
'loglevel': fields.Integer(default=5),
'monitor': fields.Nested(api.model('LxcMonitor', {
'unshare': fields.Integer(default=0)
})),
'mount': fields.Nested(api.model('LxcMount', {
'_': fields.String,
'auto': fields.String,
'entry': fields.List(fields.String)
})),
'network': fields.Nested(api.model('LxcNetwork', {
'type': fields.String,
'veth': fields.Nested(api.model('LxcNetworkVeth', {
'pair': fields.Integer
})),
'vlan': fields.Nested(api.model('LxcNetworkVlan', {
'id': fields.Integer
})),
'macvlan': fields.Nested(api.model('LxcNetworkMacvlan', {
'mode': fields.String
})),
'flags': fields.String,
'link': fields.String,
'mtu': fields.Integer,
'name': fields.String,
'hwaddr': fields.String,
'ipv4': fields.Nested(api.model('LxcNetworkIpv4', {
'_': fields.List(fields.String),
'gateway': fields.String
})),
'ipv6': fields.Nested(api.model('LxcNetworkIpv6', {
'_': fields.List(fields.String),
'gateway': fields.String
})),
'script': fields.Nested(api.model('LxcNetworkScript', {
'up': fields.String,
'down': fields.String
}))
}), as_list=True),
'no_new_privs': fields.Integer(default=0),
'pts': fields.String,
'rebootsignal': fields.String(default='SIGINT'),
'rootfs': fields.Nested(api.model('LxcRootfs', {
'_': fields.String,
'mount': fields.String,
'options': fields.String,
'backend': fields.String
})),
'se_context': fields.String,
'seccomp': fields.String,
'start': fields.Nested(api.model('LxcStart', {
'auto': fields.String(default='0'),
'delay': fields.String(default=None),
'order': fields.String(default=None)
})),
'stopsignal': fields.String(default='SIGKILL'),
'syslog': fields.String,
'tty': fields.String,
'utsname': fields.String
})
from app.file_system.helpers import FileSystem
from app.workspace_system.helpers import workspace_exists, active_contribution_required, visibility_required
from app.auth_system.helpers import login_required
from app.activity_stream.helpers import *
from app import api, db
import os
import pathlib
import app
file_system_ns = Namespace("File System",
description="File System Endpoints",
path="/file_system")
folder_models = api.model(
"Folder Model", {
"files": fields.List(fields.String),
"folders": fields.List(fields.String),
"cwd": fields.String
})
@file_system_ns.route("/file")
class FileSystemAPI(Resource):
@api.doc(
responses={
200: "Valid Data",
400: "Invalid Input",
401: "Authantication Problem",
404: "User if not found",
403: "Forbidden Path"
})
@api.expect(file_get_parser)
from flask_restplus import fields
from app import api
message = api.model('message', {
'id': fields.Integer(readOnly=True, description='The unique identifier'),
'body': fields.String(required=True, description='The Title of the spark'),
'owner': fields.Nested(fields.Integer()),
'rouse_user_list': fields.List(fields.Integer()),
'douse_user_list': fields.List(fields.Integer()),
})
#!/usr/bin/env python
# -*- coding: utf-8 -*-
from flask_restplus import fields
from app import api
_servers_fields_post = api.model(
'LXDServersPost', {
'name': fields.String(required=True),
'address': fields.String(required=True),
'password': fields.String(required=True),
'verify': fields.String(required=False),
'exec_address': fields.String(required=True)
})
servers_fields_with_relationships_get = api.model(
'ServersFieldsWithRelationshipsGet', {
'relationships':
fields.Nested(
api.model(
'ServersRelationshipsGet', {
'instances':
fields.Nested(api.model('ContainersDataGet', {
'id': fields.Integer,
'name': fields.String
}),
as_list=True)
}))
})
_servers_fields_get = api.inherit(
'LXDServersGet', servers_fields_with_relationships_get, {
user_schema = {
'login': {'type': 'string', 'required': True, 'nullable': False, 'empty': False, 'validator': validate_user_login},
'password': {'type': 'string', 'required': True, 'nullable': False, 'empty': False},
'email': {'type': 'string', 'required': True, 'nullable': False, 'empty': False},
'first_name': {'type': 'string', 'required': False, 'nullable': True, 'empty': True},
'last_name': {'type': 'string', 'required': False, 'nullable': True, 'empty': True}
}
user_input_fields = get_input_model_from_cerberus_schema(user_schema, 'UserInput')
user_fields = api.model(u'User', {
u'auth_token': fields.String,
u'login': fields.String,
u'first_name': fields.String,
u'last_name': fields.String,
u'foreign_lng': fields.String,
u'native_lng': fields.String
})
user_list_fields = api.model(u'UserList', {
u'id': fields.String,
u'email': fields.String,
u'password': fields.String,
u'login': fields.String,
u'first_name': fields.String,
u'last_name': fields.String,
u'foreign_lng': fields.String,
u'native_lng': fields.String
})
from project.common.RedisLibrary import RedisLibrary
from project.service.AccountService import AccountService
requestPostParser = reqparse.RequestParser()
requestPostParser.add_argument('User-Agent', type=str,
location='header') # get request header
requestPostParser.add_argument(
'id', type=str,
location='json') # get request param ( get -> query string)
requestPostParser.add_argument('password', type=str, location='json')
reponseModel = api.model(
'ResponseModel', {
'Seq': fields.Integer,
'Id': fields.String,
'Password': fields.String,
'Salt': fields.String,
'Status': fields.String,
'AddTime': fields.String
})
responseBody = api.model(
'ResponseBody',
{
'uri': fields.Url(),
'code': fields.Integer,
'msg': fields.String,
'data': fields.List(
fields.Nested(reponseModel)), # data 안에 json list 형식으로 설정
})
host_stats_fields_attributes = api.model('HostStats', {
'uptime': fields.Nested(api.model('HostUptime', {
'days': fields.Integer,
'hours': fields.Integer,
'minutes': fields.Integer,
'seconds': fields.Integer,
'total_seconds': fields.Integer
})),
'hostname': fields.String,
'distrib': fields.String,
'disk': fields.Nested(api.model('HostDiskUsage', {
'name': fields.String,
'total': fields.Integer,
'used': fields.Integer,
'free': fields.Integer,
'percent': fields.Float
}), as_list=True),
'cpu': fields.Nested(api.model('HostCpuUsage', {
'usage': fields.Float,
'model': fields.String,
'logical': fields.Integer,
'physical': fields.Integer
})),
'memory': fields.Nested(api.model('HostMemoryUsage', {
'virtual': fields.Nested(api.model('HostMemoryVirtual', {
'total': fields.Integer,
'percent': fields.Float,
'free': fields.Integer,
'used': fields.Integer
})),
'swap': fields.Nested(api.model('HostMemorySwap', {
'total': fields.Integer,
'percent': fields.Float,
'free': fields.Integer,
'used': fields.Integer
}))
})),
'kernel': fields.String,
'lxc': fields.Nested(api.model('LXC', {
'version': fields.String,
'lxcpath': fields.String,
'default_config': fields.String
}))
})
from app import api
from flask_restplus import fields
sample_model = api.model('sample', {
'type': fields.String(required=True),
'value': fields.Float(required=True)
})
from app import api
from flask.ext.restplus import fields
class EntityId(fields.Integer):
def output(self, key, obj):
return obj.key.id()
class SessionToken(fields.String):
def output(self, key, obj):
return obj.get_session_token()
public_user = api.model('User', {
'id': EntityId,
'created_at': fields.DateTime(dt_format='rfc822'),
'updated_at': fields.DateTime(dt_format='rfc822'),
})
private_user = api.model('User', {
'id': EntityId,
'created_at': fields.DateTime(dt_format='rfc822'),
'updated_at': fields.DateTime(dt_format='rfc822'),
'email': fields.String
})
token_user = api.model('User', {
'id': EntityId,
'session_token': SessionToken,
'created_at': fields.DateTime(dt_format='rfc822'),
'updated_at': fields.DateTime(dt_format='rfc822'),
'email': fields.String
})
from app import api
from flask import render_template
import flask.views
from flask import Flask, request, jsonify
import intent_classify
from intent_classify import classify_intent
import json
from flask_restplus import Resource, fields
namespace = api.namespace('classify_intent',
description="Detect intent of the text.")
single_model = api.model('Input Single Text Model', {
'text': fields.String,
'lang': fields.String
})
multiple_model = api.model('Input Multiple Texts Model',
{'texts': fields.List(fields.Nested(single_model))})
@namespace.route('/')
class IntentClassify(Resource):
@api.doc(responses={200: 'OK'})
def get(self):
return """This service gives you an intent detecting functionality. Use post query with thr following structure:
{'text': <...>, 'lang': <...>}
or use JSON key 'texts': [<array of texts>]."""
@api.doc(responses={200: 'OK', 400: 'Bad Request'})
@api.expect(multiple_model)
def post(self):
data = json.loads(request.data)
from app.recommendation_system.forms import *
from app.recommendation_system.models import *
from app import api, db
import math
recommendation_system_ns = Namespace(
"Recommendation System",
description="Recommendation System Endpoints",
path="/recommendation_system")
user_model = api.model(
'User Recommendation', {
'id': fields.Integer,
'name': fields.String,
'surname': fields.String,
'profile_photo': fields.String,
"job": fields.String,
"institution": fields.String,
"is_private": fields.Integer
})
contributor_model = api.model("Contributor", {
"id": fields.Integer,
"name": fields.String,
"surname": fields.String,
})
workspace_model = api.model(
'Workspace', {
"id": fields.Integer,
"title": fields.String,
from app import api
from flask_restplus import fields
comment_details = api.model('comment_details',{
"author": fields.String(example="Becky"),
"published": fields.String(example="1539476785.0"),
"comment": fields.String(example="Cute Photo!")
})
token_details = api.model('token_details',{
'token': fields.String()
})
post_id_details = api.model('post_id_details',{
"post_id": fields.String()
})
post_meta_details = api.model('post_meta_details',{
"author": fields.String(),
"description_text": fields.String(),
"published": fields.String(),
"likes": fields.List(fields.Integer())
})
post_details = api.model('post_details',{
"id": fields.Integer(),
"meta": fields.Nested(post_meta_details),
"thumbnail": fields.String(),
"src": fields.String(),
"comments": fields.List(fields.Nested(comment_details))
})
from app import api
from flask_restplus import fields
message_model = api.model(
'Message', {
"reciever_id": fields.String(required=True),
"content": fields.String(required=True)
})
from flask_restplus import fields, Model
from app import api
pagination_model = api.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"),
"has_prev": fields.Integer(description="Is prev page?"),
"has_next": fields.Integer(description="Is next page?"),
})
user_model = api.model("user_model", {
"id": fields.Integer,
"username": fields.String(required=True, description="User name"),
"email": fields.String(description="User email"),
"password": fields.String(description="User password"),
"role_id": fields.Integer,
"role": fields.String(attributes="role.name"),
})
user_model_list = api.inherit("Page of blog posts", pagination_model,
{"items": fields.List(
fields.Nested(user_model))},
)
post_model = api.model("post_model", {
"id": fields.Integer,
"title": fields.String(required=True),
"content": fields.String,
"author": fields.String,
# coding=utf-8
from app import api
from flask.ext.restplus import fields
from utils.cerberus_utils import get_input_model_from_cerberus_schema
translation_schema = {
u'text': {'type': 'string', 'required': True, 'nullable': False, 'empty': False}
}
translation_input_fields = get_input_model_from_cerberus_schema(translation_schema, u'GroupInput')
translation_fields = api.model(u'TranslationModel', {
u'text': fields.String,
u'direction': fields.String,
u'variations': fields.List(fields.String)
})
translation_detect_fields = api.model(u'TranslationDetectModel', {
u'lang': fields.String
})
host_stats_fields_attributes = api.model(
'HostStats', {
'uptime':
fields.Nested(
api.model(
'HostUptime', {
'days': fields.Integer,
'hours': fields.Integer,
'minutes': fields.Integer,
'seconds': fields.Integer,
'total_seconds': fields.Integer
})),
'hostname':
fields.String,
'distrib':
fields.String,
'disk':
fields.Nested(api.model(
'HostDiskUsage', {
'name': fields.String,
'total': fields.Integer,
'used': fields.Integer,
'free': fields.Integer,
'percent': fields.Float
}),
as_list=True),
'cpu':
fields.Nested(
api.model(
'HostCpuUsage', {
'usage': fields.Float,
'model': fields.String,
'logical': fields.Integer,
'physical': fields.Integer
})),
'memory':
fields.Nested(
api.model(
'HostMemoryUsage', {
'virtual':
fields.Nested(
api.model(
'HostMemoryVirtual', {
'total': fields.Integer,
'percent': fields.Float,
'free': fields.Integer,
'used': fields.Integer
})),
'swap':
fields.Nested(
api.model(
'HostMemorySwap', {
'total': fields.Integer,
'percent': fields.Float,
'free': fields.Integer,
'used': fields.Integer
}))
})),
'kernel':
fields.String,
'lxc':
fields.Nested(
api.model(
'LXC', {
'version': fields.String,
'lxcpath': fields.String,
'default_config': fields.String
}))
})
host_stats_fields_attributes = api.model('HostStats', {
'uptime': fields.Nested(api.model('HostUptime', {
'days': fields.Integer,
'hours': fields.Integer,
'minutes': fields.Integer,
'seconds': fields.Integer
})),
'hostname': fields.String,
'distrib': fields.String,
'disk': fields.Nested(api.model('HostDiskUsage', {
'name': fields.String,
'total': fields.Integer,
'used': fields.Integer,
'free': fields.Integer,
'percent': fields.Float
}), as_list=True),
'cpu': fields.Nested(api.model('HostCpuUsage', {
'usage': fields.Float,
'model': fields.String,
'logical': fields.Integer,
'physical': fields.Integer
})),
'memory': fields.Nested(api.model('HostMemoryUsage', {
'virtual': fields.Nested(api.model('HostMemoryVirtual', {
'total': fields.Integer,
'percent': fields.Float,
'free': fields.Integer,
'used': fields.Integer
})),
'swap': fields.Nested(api.model('HostMemorySwap', {
'total': fields.Integer,
'percent': fields.Float,
'free': fields.Integer,
'used': fields.Integer
}))
})),
'kernel': fields.String
})
from flask_restplus import fields
from app import api
model = api.model(
'demo', {
'name': fields.String('Enter Name'),
'email': fields.String('Enter Email'),
'password': fields.String('Enter Password')
})
from flask import request
from flask_restx import fields
from app import api
from project.common.AuthException import AuthException
from project.common.ErrorCode import ErrorCode
from project.common.LoggingData import LoggingData
##Exception 발생시 api는 정상 응답처리 해야하므로 uri, code는 포맷에 맞게 고정
responseBody = api.model(
'ResponseBody',
{
'uri': fields.Url(),
'code': fields.Integer,
'message': fields.
String # python error message는 핸들러단에서 무조건 노출하는것으로 가공하려면 응답 필드 고정해야함
})
## ExceptionHandler : Exception발생시 해당 에러 핸들러를 통해 일괄 처리할수 있음.
@api.errorhandler(AuthException)
@api.marshal_with(responseBody) # response model set
def serverErrorHandler(exception):
errorCode = exception.errorCode
errorMsg = exception.errorMsg
if errorCode is None:
errorCode = ErrorCode.SERVER_ERROR.errorCode
if errorMsg is None:
errorMsg = ErrorCode.SERVER_ERROR.errorMsg
#!/usr/bin/env python
# -*- coding: utf-8 -*-
from flask_restplus import fields
from app import api
groups_fields_attributes = api.model('GroupsFieldsAttributes', {
'name': fields.String
})
groups_fields_attributes_post = api.model('GroupsFieldsAttributesPost', {
'name': fields.String(required=True, pattern='^(?!\s*$).+')
})
groups_fields_with_relationships_post_put = api.model('GroupsFieldsWithRelationshipsPost', {
'relationships': fields.Nested(api.model('GroupsRelationshipsPost', {
'users': fields.Nested(api.model('GroupsDataPost', {
'data': fields.Nested(api.model('GroupsPostData', {
'type': fields.String,
'id': fields.Integer
}), as_list=True)
})),
'abilities': fields.Nested(api.model('ContainersDataPost', {
'data': fields.Nested(api.model('ContainersPostData', {
'type': fields.String,
'id': fields.Integer
}), as_list=True)
}))
}))
})
from app.workspace_system.models import Contribution, Workspace, Milestone, Issue, IssueAssignee
from app import app, api
import math
from datetime import datetime
upcoming_events_ns = Namespace("Upcoming Events",
description="Upcoming Events Endpoints",
path="/upcoming_events")
upcoming_event_model = api.model(
'Upcoming Event', {
"id": fields.Integer,
"acronym": fields.String,
"title": fields.String,
"location": fields.String,
"link": fields.String,
"date": fields.String,
"deadline": fields.String
})
upcoming_events_model = api.model(
'Upcoming Event List', {
"number_of_pages": fields.Integer,
'upcoming_events': fields.List(fields.Nested(upcoming_event_model))
})
@upcoming_events_ns.route("")
class UpcomingEventsAPI(Resource):
@api.doc(responses={500: 'Database Connection Problem'})
from app.activity_stream.models import *
from app.follow_system.models import *
from app.workspace_system.models import *
from app.activity_stream.forms import *
from app.auth_system.helpers import *
from app.activity_stream.helpers import *
from sqlalchemy import desc
activity_stream_ns = Namespace("Activity Stream",
description="Activity Stream Endpoints",
path="/activity_stream")
activity_stream_item_context_model = api.model('Activity Stream Item Context',
{
"@vocab": fields.String,
"@language": fields.String
})
activity_stream_item_image_model = api.model('Activity Stream Item Image', {
"type": fields.String,
"url": fields.String
})
activity_stream_item_actor_model = api.model(
'Activity Stream Item Actor', {
"type": fields.String,
"id": fields.Integer,
"name": fields.String,
"image": fields.Nested(activity_stream_item_image_model)
})
from app import api
from flask_restplus import Resource, fields
from ..models import Bucketlist, db, User, Bucketitems
from flask import request, abort
from .parsers import pagination_arg
bucket = api.namespace('bucketlists', description="Bucketlist Endpoints")
bucket_item = api.model(
'bucket_item', {
'id': fields.Integer(required=True, readOnly=True),
'name': fields.String(required=True),
'date_created': fields.DateTime,
'date_modified': fields.DateTime,
'done': fields.Boolean,
})
bucket_item_update = api.model(
'bucket_item_update', {
'name': fields.String(description='Name of the bucketlist item'),
'done': fields.Boolean(description='Status of the bucketlist item')
})
buckett = api.model(
'Buckett', {
'id':
fields.Integer(required=True, readOnly=True),
'name':
fields.String(required=True,
description='This is the name of the bucketlist'),
'items':
