def test_clone(self):
api = Namespace('test')
parent = api.model('Parent', {})
api.clone('Child', parent, {})
assert 'Child' in api.models
assert 'Parent' in api.models
def test_clone(self):
api = Namespace('test')
parent = api.model('Parent', {})
api.clone('Child', parent, {})
self.assertIn('Child', api.models)
self.assertIn('Parent', api.models)
def test_clone(self):
api = Namespace('test')
parent = api.model('Parent', {})
api.clone('Child', parent, {})
assert 'Child' in api.models
assert 'Parent' in api.models
def test_clone(self):
api = Namespace('test')
parent = api.model('Parent', {})
api.clone('Child', parent, {})
self.assertIn('Child', api.models)
self.assertIn('Parent', api.models)
def test_clone_with_multiple_parents(self):
api = Namespace('test')
grand_parent = api.model('GrandParent', {})
parent = api.model('Parent', {})
api.clone('Child', grand_parent, parent, {})
assert 'Child' in api.models
assert 'Parent' in api.models
assert 'GrandParent' in api.models
def test_clone_with_multiple_parents(self):
api = Namespace('test')
grand_parent = api.model('GrandParent', {})
parent = api.model('Parent', {})
api.clone('Child', grand_parent, parent, {})
assert 'Child' in api.models
assert 'Parent' in api.models
assert 'GrandParent' in api.models
from typing import List
from flask_restplus import Resource, Namespace, fields, abort
from data.product import Product
_logger = logging.getLogger()
api = Namespace('product', description='All The products we have')
add_product = api.model('AddProduct', {
'name': fields.String(required=True, description='The Name of the Product'),
'size': fields.Integer(required=True, description='Size of the object in meter'),
'description': fields.String(required=False, description='description of the product', default=None)
})
full_product = api.clone('Product', add_product, {
'id': fields.String(required=True, description='unique product id.')
})
@api.route('')
class AddProduct(Resource):
@api.expect(add_product)
def post(self) -> full_product:
new_product = api.payload
new_product['id'] = str(uuid.uuid4())
Product().add(product_id=new_product['id'], name=new_product['name'], size=new_product['size'],
description=new_product['description'])
return new_product
from sqlalchemy import Sequence
import json
import logging
questions = Namespace('questions', description='Questions related operations')
LOG = logging.getLogger(__name__)
modify_question_swagger_model = questions.model('Modify question', {
'question_text': fields.String(required=True, description=' Specify question_txt'),
'answer_text': fields.String(required=True, description=' Specify answer_txt'),
'mark': fields.Integer(required=False, description=' Specify mark'),
'max_attempts': fields.Integer(required=False, description=' Specify max_attempts')
})
add_questions_swagger_model = questions.clone('Add question', modify_question_swagger_model, {
'task_id': fields.Integer(required=True, description=' Specify task_id')
})
@notes.route('/')
class NotesList(Resource):
def get(self):
return QueryProcessor().getEntities(Note)
def post(self):
request_dict = request.get_json()
try:
id = request_dict['id']
title = request_dict['title']
content = request_dict['content']
except:
return {"Status": "Wrong parameters"}, 400
ns = Namespace('spots', description='位置')
spot_base = ns.model('地点基本信息', {
'id': fields.Integer(readonly=True, description='地点ID'),
'x': fields.Float(description='坐标x'),
'y': fields.Float(description='坐标y'),
'name': fields.String(description='地点名称'),
})
spot = ns.clone('地点详细信息', spot_base, {
'pH': fields.Float(description='pH值'),
'DO': fields.Float(description='溶解氧'),
'PP': fields.Float(description='高锰酸盐'),
'AN': fields.Float(description='氨氮'),
'P': fields.Float(description='磷'),
'Cd': fields.Float(description='镉'),
'As': fields.Float(description='砷'),
'Pb': fields.Float(description='铅'),
'level': fields.Integer(description='等级')
})
@ns.route('/')
class SpotListResource(Resource):
@ns.marshal_list_with(spot_base)
def get(self):
'''获取所有地点'''
return Spot.query.all()
@ns.route('/<int:id>')
permission_model = permission_ns.model(
"Permission",
{
BLOCKCHAIN_NAME_FIELD_NAME:
fields.String(required=True, description="The blockchain name"),
},
)
global_permission_model = permission_ns.clone(
"Global permission",
permission_model,
{
ADDRESSES_FIELD_NAME:
fields.List(
fields.String, required=True, description="list of addresses")
},
{
PERMISSIONS_FIELD_NAME:
fields.List(
fields.String, required=True, description="list of permissions")
},
)
@permission_ns.route("/grant_global_permission")
class GrantGlobalPermission(Resource):
@permission_ns.expect(global_permission_model, validate=True)
@permission_ns.doc(
responses={
status.HTTP_400_BAD_REQUEST: "BAD REQUEST",
status.HTTP_200_OK: "SUCCESS",
api = Namespace('users', description='Users', path='/') # noqa
USER = api.model(
'User', {
'id': fields.Integer(required=True),
'email': fields.String(required=True),
'username': fields.String(required=True),
'pref_wh': fields.Float(),
'full_name': fields.String(),
'is_admin': fields.Boolean(default=False),
'is_manager': fields.Boolean(default=False),
})
USER_POST = api.clone('UserPost', USER, {
'password': fields.String(required=True),
})
del USER_POST['id']
USER_PUT = api.clone('UserPut', USER_POST)
class UserDAO(BaseDAO):
def create(self, data):
# validate
data = self.validate(data)
# set password
data = self.update_password(data)
# save to database
user = self.model(**data)
if not save_to_db(user):
from .models import author_fields, article_fields, book_fields
from .primary_sources import primary_source_fields
from .parsers import req_parser
logger = logging.getLogger(__name__)
api = Namespace('authors', description='Authors related operations')
api.models[author_fields.name] = author_fields
publication_list = api.model(
'AuthoredPublications', {
'articles': fields.List(fields.Nested(article_fields)),
'books': fields.List(fields.Nested(book_fields)),
})
citing_publication_list = api.clone('CitingPublications', publication_list)
cited_publication_list = api.clone(
'CitedPublications', publication_list,
{'primary_sources': fields.List(fields.Nested(primary_source_fields))})
author_data = api.model(
'AuthorData', {
'author':
fields.Nested(author_fields, required=True),
'publications':
fields.Nested(publication_list, required=False),
'citing':
fields.Nested(citing_publication_list, required=False),
'cited':
fields.Nested(cited_publication_list, required=False),
})
person_schema = api.clone(
'Person', person_simple_schema, {
'has_died':
fields.Boolean(required=True, description='whether person has died'),
'balance':
fields.String(description='person balance'),
'picture':
fields.String(description='person profile picture url'),
'gender':
fields.String(required=True, description='person gender'),
'age':
fields.Integer(description='person age'),
'eyeColor':
fields.String(description='person eye color'),
'company_id':
fields.Integer(description='person company'),
'email':
fields.String(description='person email'),
'phone':
fields.String(description='person phone'),
'address':
fields.String(description='person address'),
'registered':
fields.DateTime(required=True, description='person registered'),
'about':
fields.String(description='person about text'),
'greeting':
fields.String(description='person greeting text'),
})
'create_dttm': fields.DateTime(),
'update_dttm': fields.DateTime(),
}
if depth:
root_json_mapping['shoots'] = (fields.List(
fields.Nested(recursive_root_model(depth - 1))))
return api.model('root_model' + str(depth), root_json_mapping)
new_root_model = api.model('root_new', {
'name': fields.String(),
'type': fields.String(),
'body': fields.String(),
})
new_shoot_model = api.clone('shoot', new_root_model,
{'root_sk': fields.Integer()})
@api.route('/')
class RootList(Resource):
@api.marshal_with(recursive_root_model(0), skip_none=True)
def get(self):
roots = roots_service.get_roots(0)
return roots, 200
@api.expect(new_root_model)
def post(self):
req = api.payload
res = roots_service.create_root(req)
current_app.logger.info(res)
return 'Success', 200
Here we deal with syncrhonous operations
"""
from flask import request
from flask_restplus import Namespace, Resource, fields
from bootstrap.repositories.collection import ObjectRepository, ObjectNotFoundError
api = Namespace('collections', description='Operations for a given collection')
# API models
resource_write = api.model('ResourceWrite', {'field': fields.String})
resource_read = api.clone(
'ResourceRead', resource_write, {
'iid': fields.Integer,
'created_on': fields.DateTime(),
'updated_on': fields.DateTime(),
})
# Error handlere
@api.errorhandler(ObjectNotFoundError)
def handle_not_found():
return {'message': 'The requested object does not exist'}, 400
@api.route('/')
class ResourceObjects(Resource):
@api.marshal_list_with(resource_read, envelope='Objects')
@api.doc(description='List all objects.')
def get(self):
from timemanager.helpers.custom_fields import DateTime
from timemanager.helpers.query_filters import parse_args
api = Namespace('tasks', description='Tasks', path='/') # noqa
TASK = api.model(
'Task', {
'id': fields.Integer(required=True),
'title': fields.String(required=True),
'minutes': fields.Integer(required=True),
'date': DateTime(required=True),
'comments': fields.String(),
'user_id': fields.Integer()
})
TASK_POST = api.clone('TaskPost', TASK, {})
del TASK_POST['id']
class TaskDAO(BaseDAO):
def fix_user_task_access(self, data):
"""
fixes the situation where a normal user tries to assign task to another user
"""
current_user = g.current_user
if data.get('user_id') is None: # give default user id
data['user_id'] = current_user.id
elif not current_user.is_admin: # not an admin and cheating
data['user_id'] = current_user.id
return data['user_id']
'full_name':
fields.String(min=2, max=100),
'is_admin':
fields.Boolean(default=False),
'is_manager':
fields.Boolean(default=False),
'is_verified':
fields.Boolean(default=False),
})
USER_MIN = api.model('UserMin', {
'id': fields.Integer(),
'username': fields.String(),
})
USER_PAGINATED = api.clone('UserPaginated', PAGINATED_MODEL,
{'results': fields.List(fields.Nested(USER))})
USER_POST = api.clone(
'UserPost', USER, {
'password': fields.String(required=True, min=6, passw=True),
})
del USER_POST['id']
USER_PUT = api.clone('UserPut', USER_POST)
del USER_PUT['is_verified']
class UserDAO(BaseDAO):
def create(self, data):
# if testing, verified already
if current_app.config['TESTING']:
