class Base(Resource):
fields = {
'task_id': fields.String,
}
decorators = [marshal_with(fields)]
def __init__(self):
self.reqparse = reqparse.RequestParser()
self.reqparse.add_argument('loadbalance', type=str, required=True)
self.reqparse.add_argument('user', type=str, required=True)
self.uuid = str(uuid.uuid4())
super(Base, self).__init__()
def persist_and_send(self, name, action, args):
# convert from flask-ized object to dict for transport safety
#args = dict(args)
message = {
'task_id': self.uuid,
'status': 'init',
'user': args.pop('user'),
'creation_time': datetime.utcnow().isoformat(),
'loadbalance': args.pop('loadbalance'),
'action': action,
'object': name,
'arguments': json.dumps(args)
}
LOGGER.debug('sending to kvs and mq')
netscaler_api.redis_store.hmset(self.uuid, message)
message['arguments'] = args
netscaler_api.queue.send_message(message)
return message
class GetStaff(Resource):
method_decorators = [marshal_with(staff_structure)]
def get(self):
if parser_staff.parse_args().get('passportID') is None:
return self.list_staff
else:
return [
staff for staff in self.list_staff if
parser_staff.parse_args().get('passportID') == staff.passportID
]
def put(self, some_id):
for staff in self.list_staff:
if staff.passportID == some_id:
staff.salary = parser_staff.parse_args().get('salary')
return staff, 200
else:
return 404
def delete(self):
for staff in list_staff:
if parser_staff.parse_args().get("passportID") == staff.passportID:
list_staff.remove(staff)
return list_staff, 200
else:
return 404
def format_response_with(spec_fields):
format_response_fields = {
"code": fields.Integer,
"message": fields.String,
"object": fields.Nested(spec_fields),
}
return marshal_with(format_response_fields)
class FilmsResource(Resource):
method_decorators = [marshal_with(films_structure)]
def get(self):
return Films.query.all()
def post(self):
body = json.loads(request.data)
film = Films(**body)
db.session.add(film)
db.session.commit()
return Films.query.all(), 201
def put(self, value):
body = json.loads(request.data)
film = Films.query.get(value)
film.name = body.get('name')
db.session.commit()
return Films.query.all()
def delete(self, value):
film = Films.query.get(value)
db.session.delete(film)
db.session.commit()
return Films.query.all()
class ObjListEndpoint(Resource):
decorators = [marshal_with(resource_fields)]
def get(self):
"""
获取 obj 列表
"""
args = request.args.to_dict()
bucket = args.pop("bucket")
extra_info = args
objs = Obj.list_obj(bucket, **extra_info)
objs = [obj.to_json() for obj in objs] if objs else None
return APIResponse(data=objs)
def delete(self):
"""
批量删除 obj
"""
bucket = request.get_json().get("bucket")
name_list = request.get_json().get("name_list")
if not (bucket and name_list and isinstance(name_list, (tuple, list))):
return APIResponse(code=BAD_REQUEST)
Obj.remove_objs(bucket, name_list)
return APIResponse()
class DemoResource(Resource):
method_decorators = {'get': [marshal_with(fields)]}
def get(self):
user = User()
return user
class GetTenants(Resource):
method_decorators = [marshal_with(tenants_structure)]
def get(self):
if parser_tenant.parse_args().get('passportID') is None:
return list_tenants
else:
return [
ten for ten in list_tenants if parser_tenant.parse_args().get(
'passportID') == ten.passportID
]
def put(self, some_id):
for ten in list_tenants:
if ten.passportID == some_id:
ten.room = parser_tenant.parse_args().get('room')
return ten, 200
else:
return 404
def delete(self):
for ten in list_tenants:
if parser_tenant.parse_args().get('passportID') == ten.passportID:
list_tenants.remove(ten)
return list_tenants, 200
else:
return 404
class SignUpEndpoint(Resource):
decorators = [marshal_with(resource_fields)]
def post(self):
"""
@api {POST} /api/signup 注册账号
@apiName SignUp
@apiGroup User
@apiExample 参数
{
"account":"olivetree",
"cipher": "123456"
}
@apiExample 返回值
{
"code": 0,
"message": null,
"data": null
}
"""
params = request.get_json()
if not params:
return APIResponse(code=BAD_REQUEST)
status = User.is_exists(params["account"])
if status:
return APIResponse(code=ACCOUNT_DUPLICATE)
cipher = User.cipher_encypt(params["cipher"])
user = User.create_data(account=params["account"], cipher=cipher)
return APIResponse(data=user)
def __init__(self,
query,
arguments: List[Argument] = None,
searchable=None,
order=None,
fs: Optional[Dict[str, type]] = None,
envelope: Optional[str] = None):
self.query = query
if arguments:
self.parser = reqparse.RequestParser()
for arg in arguments:
self.parser.add_argument(arg)
self.get_parser = reqparse.RequestParser()
if searchable:
self.get_parser.add_argument('q',
required=False,
type=QueryChk(searchable, self.query))
if order:
pass #TODO add order option
if fields:
self.method_decorators = {'get': [marshal_with(fs, envelope)]}
class Component(flask_restful.Resource):
method_decorators = [flask_restful.marshal_with(component_fields)]
def get(self, component_id):
return db.get_or_404(db.Component, component_id)
@db.with_transaction
def _perform_update(self, component_id):
component = db.get_or_404(db.Component, component_id)
update_by = flask.request.json
component.name = update_by.get('name', component.name)
res_definitions = update_by.get('resource_definitions')
if res_definitions is not None:
ids = [data['id'] for data in res_definitions]
resources = library.load_objects(db.ResourceDefinition, ids)
component.resource_definitions = resources
def put(self, component_id):
return self.patch(component_id)
def patch(self, component_id):
self._perform_update(component_id)
return None, 204
@db.with_transaction
def delete(self, component_id):
component = db.get_or_404(db.Component, component_id)
db.db.session.delete(component)
return None, 204
class HostEndpoint(Resource):
decorators = [marshal_with(resource_fields)]
def get(self, uid):
"""
获取主机信息
"""
host = Host.get_by_uid(uid)
host = host.to_json() if host else None
return APIResponse(code=0, data=host)
def post(self):
"""
添加主机
"""
params = request.get_json()
if not params:
return APIResponse(code=BAD_REQUEST)
name = params.get("name")
path = params.get("path")
port = params.get("port")
ip_addr = params.get("ip_addr")
username = params.get("username")
password = params.get("password")
host = Host.create_host(name, path, ip_addr, port, username, password)
host = host.to_json() if host else None
return APIResponse(code=0, data=host)
class BucketEndpoint(Resource):
decorators = [marshal_with(resource_fields)]
def get(self):
"""
获取 bucket 信息
"""
name = request.args.get("name")
if not name:
return APIResponse(code=BAD_REQUEST)
b = Bucket.get_by_name(name)
b = b.to_json() if b else None
return APIResponse(data=b)
def post(self):
"""
创建 bucket
"""
data = request.get_json()
name = data.pop("name", None)
desc = data.pop("desc", None)
public = data.pop("public", 0)
extra_info = data
if extra_info and not isinstance(extra_info, dict):
return APIResponse(code=BAD_REQUEST)
if not (name and public in [0, 1]):
return APIResponse(code=BAD_REQUEST)
b = Bucket.add(name=name,
public=public,
desc=desc,
extra_info=extra_info)
r = b.to_json() if b else None
return APIResponse(data=r)
def put(self):
"""
更新 bucket
"""
data = request.get_json()
name = data.pop("name", None)
desc = data.pop("desc", None)
public = data.pop("public", 0)
extra_info = data
if not (name and public in [0, 1, None]):
return APIResponse(code=BAD_REQUEST)
b = Bucket.renew(name=name,
public=public,
desc=desc,
extra_info=extra_info)
r = b.to_json() if b else None
return APIResponse(data=r)
def delete(self, uid):
"""
删除 bucket
"""
Bucket.remove(uid)
return APIResponse()
class Environment(flask_restful.Resource):
method_decorators = [flask_restful.marshal_with(environment_fields)]
def get(self, environment_id):
env = db.get_or_404(db.Environment, environment_id)
return prepare_env_for_output(env), 200
def _update_components(self, environment, components):
if components is not None:
new_components = library.load_objects_by_id_or_name(
db.Component, components)
environment.components = new_components
def _update_hierarchy_levels(self, environment, hierarchy_levels_names):
if hierarchy_levels_names is not None:
old_hierarchy_levels = db.EnvironmentHierarchyLevel.query.filter(
db.EnvironmentHierarchyLevel.environment_id ==
environment.id).all()
new_hierarchy_levels = []
for level_name in hierarchy_levels_names:
level = db.get_or_create(db.EnvironmentHierarchyLevel,
name=level_name,
environment=environment)
new_hierarchy_levels.append(level)
parent_id = None
for level in new_hierarchy_levels:
level.parent_id = parent_id
parent_id = level.id
for old_level in old_hierarchy_levels:
if old_level not in new_hierarchy_levels:
db.db.session.delete(old_level)
environment.hierarchy_levels = new_hierarchy_levels
@db.with_transaction
def _perform_update(self, environment_id):
environment = db.get_or_404(db.Environment, environment_id)
update_by = flask.request.json
components = update_by.get('components')
self._update_components(environment, components)
hierarchy_levels = update_by.get('hierarchy_levels')
self._update_hierarchy_levels(environment, hierarchy_levels)
def put(self, environment_id):
return self.patch(environment_id)
def patch(self, environment_id):
self._perform_update(environment_id)
return None, 204
@db.with_transaction
def delete(self, environment_id):
environment = db.get_or_404(db.Environment, environment_id)
db.db.session.delete(environment)
return None, 204
class EnvironmentHierarchyLevelsCollection(flask_restful.Resource):
method_decorators = [
flask_restful.marshal_with(environment_hierarchy_level_fields)
]
def get(self, environment_id):
env = db.get_or_404(db.Environment, environment_id)
return db.EnvironmentHierarchyLevel.get_for_environment(env)
def __init__(self,
arguments: List[Argument],
fs: Optional[Dict[str, type]] = None,
envelope: Optional[str] = None):
self.parser = reqparse.RequestParser()
for arg in arguments:
self.parser.add_argument(arg)
if fields:
self.method_decorators = {'get': [marshal_with(fs, envelope)]}
class Review(Resource):
marshal_with(review_fields)
def get(self, id):
return add_course(review_or_404(id))
def put(self, id):
return jsonify({"course": 1, "rating": 5})
def delete(self, id):
return jsonify({"course": 1, "rating": 5})
class HostListEndpoint(Resource):
decorators = [marshal_with(resource_fields)]
def get(self):
"""
获取主机列表
"""
host_list = Host.list()
host_list = [host.to_json() for host in host_list]
return APIResponse(code=0, data=host_list)
class MineEndpoint(Resource):
decorators = [marshal_with(resource_fields)]
def post(self):
params = request.get_json()
if not (params and params["proof"]):
return {}
status = blockChain.validate_proof(params["proof"])
if not status:
return {}
block = blockChain.transction("system", "you", 1)
return APIResponse(data=block.json())
class BucketListEndpoint(Resource):
decorators = [marshal_with(resource_fields)]
def get(self):
"""
获取 bucket 列表
"""
data = request.args.to_dict()
status = data.pop("status", True)
bks = Bucket.filter_bucket(status=status, **data)
bks = [b.to_json() for b in bks]
return APIResponse(data=bks)
class SchoolResource(Resource):
method_decorators = [marshal_with(fields_structure)]
def get(self):
return "Ok"
def post(self):
data = request.json
obj = Model(**data)
db.session.add(obj)
db.session.commit()
return Model.query.all(), 201
class SchoolResource(Resource):
method_decorators = [marshal_with(fields_structure)]
def get(self):
return "Ok"
def post(self):
data = request.json
school = School(**data)
db.session.add(school)
db.session.commit()
return School.query.first(), 201
class ComponentsCollection(flask_restful.Resource):
method_decorators = [flask_restful.marshal_with(component_fields)]
def get(self):
return db.Component.query.order_by(db.Component.id).all()
@db.with_transaction
def post(self):
component = db.Component(name=flask.request.json['name'])
component.resource_definitions = []
for res_def_data in flask.request.json.get('resource_definitions', []):
res_def = db.ResourceDefinition(
name=res_def_data['name'], content=res_def_data.get('content'))
component.resource_definitions.append(res_def)
db.db.session.add(component)
return component, 201
class EnvironmentsCollection(flask_restful.Resource):
method_decorators = [flask_restful.marshal_with(environment_fields)]
def get(self):
envs = db.Environment.query.order_by(db.Environment.id).all()
result = []
for env in envs:
result.append(prepare_env_for_output(env))
return result, 200
def _check_components(self, components):
identities = set()
duplicates = set()
id_names = ('id', 'name')
for component in components:
for id_name in id_names:
value = getattr(component, id_name)
if value not in identities:
identities.add(value)
else:
duplicates.add(value)
if duplicates:
raise errors.TuningboxIntegrityError(
"Components duplicates: {0}".format(duplicates))
@db.with_transaction
def post(self):
component_ids = flask.request.json['components']
components = [
db.Component.query.get_by_id_or_name(i) for i in component_ids
]
self._check_components(components)
hierarchy_levels = []
level = None
for name in flask.request.json['hierarchy_levels']:
level = db.EnvironmentHierarchyLevel(name=name, parent=level)
hierarchy_levels.append(level)
environment = db.Environment(components=components,
hierarchy_levels=hierarchy_levels)
if 'id' in flask.request.json:
environment.id = flask.request.json['id']
db.db.session.add(environment)
return prepare_env_for_output(environment), 201
class GetRooms(Resource):
method_decorators = [marshal_with(rooms_structure)]
def get(self):
get_rooms = {
"number": [
room for room in list_rooms
if parser_room.parse_args().get('number') == room.number
],
"status": [
room for room in list_rooms
if parser_room.parse_args().get('status') == room.status
]
}
for key, value in parser_room.parse_args().items():
if value is not None:
return get_rooms.get(key)
else:
return list_rooms
def post(self):
for obj_room in list_rooms:
if obj_room.number == parser_room.parse_args().get('number'):
return "such number already exists"
if parser_room.parse_args().get(
'number') <= 0 or parser_room.parse_args().get('price') <= 0:
return "number cannot have a negative value"
list_rooms.append(Rooms(**parser_room.parse_args()))
return "ok"
def put(self, id_room):
for room in list_rooms:
if room.number == id_room:
room.status = parser_room.parse_args().get('status')
return "ok", 200
else:
return 404
def delete(self):
for room in list_rooms:
if parser_room.parse_args().get('number') == room.number:
list_rooms.remove(room)
return "ok", 200
else:
return 404
class DemoResource(Resource):
method_decorators = {'post': [marshal_with(fields)]}
def get(self):
user1 = User()
# marshal函数可以按照指定的序列化规则将 模型对象 转为 字典
# envelope参数可以对序列化数据进行外层包装
return marshal(user1, fields, envelope='data')
def post(self):
user1 = User()
# 如果使用了marshal_with装饰器, 则可以直接返回模型对象
return user1
def put(self):
user1 = User()
return user1.to_dict()
class RouteAPI(Resource):
decorators = [auth.login_required, marshal_with(route_fields)]
# @marshal_with(route_fields)
def get(self, id):
route = Route.get(id)
if not route:
abort(404)
return route
def put(self, id):
district_id = request.json.get('district_id')
route_name = request.json.get('route_name')
route = Route.get(id)
if not route:
abort(404)
route.district_id = district_id
route.route_name = route_name
db.session.add(route)
db.session.commit()
return route, 201
@auth.login_required
def delete(self, id):
route = Route.get(id)
if route:
try:
Route.delete(id)
return jsonify({'success': u'删除成功'})
except IntegrityError, e:
response = jsonify({'error': u'存在引用的外鍵'})
response.status_code = 422
# if delete failed
# if not Route.get(id):
# return jsonify({'success': u'删除成功'})
# response = jsonify({'error': u'存在引用的外鍵'})
# response.status_code = 422
# return response
else:
class LoginEndpoint(Resource):
decorators = [marshal_with(resource_fields)]
def post(self):
"""
@api {POST} /api/login 登陆
@apiName LogIn
@apiGroup User
@apiExample 参数
{
"account":"olivetree",
"cipher": "123456"
}
@apiExample 返回值
{
"code": 0,
"message": null,
"data": null
}
"""
params = request.get_json()
if not params:
return APIResponse(code=BAD_REQUEST)
status = User.is_exists(params["account"])
if not status:
return APIResponse(code=ACCOUNT_NOT_FOUND)
user = User.cipher_validate(account=params["account"],
cipher=params["cipher"])
if not user:
return APIResponse(code=LOGIN_FAILED)
user = user.json()
user.pop("cipher", None)
token = uuid.uuid4().hex
user["token"] = token
cache.set_token(token, user["uid"])
return APIResponse(data=user)
class TodoListResource(Resource):
decorators = [fjwte.jwt_required, marshal_with(todo_fields)]
def __init__(self):
self.reqparse = parsers.todo_insert_parser
super(TodoListResource, self).__init__()
def get(self):
"""
Returns given user's Todo objects
Returns:
objects(list): Todo objects list
"""
current_user = fjwte.get_current_user()
return Todo.get_items_by_user_id(current_user.id)
def post(self):
"""
Creates Todo object
Params:
name(str): name
is_done(bool): it is already done or not
due_date(date): due date of todo
Returns:
object(todo)
"""
data = self.reqparse.parse_args()
new_todo = Todo(name=data['name'], user_id=fjwte.get_current_user().id)
for key, value in data.items():
if value is not None:
setattr(new_todo, key, value)
# if is_done True set completed_date as now
if data.get('is_done'):
new_todo.completed_date = datetime.utcnow()
new_todo.save()
return new_todo, 201
def get(self):
data = {}
city_fields = {}
vill_fields = {
'name': fields.String,
}
citys = City.query.all()
for city in citys:
print(city.name)
city_fields['name'] = city.name
city_fields['area'] = fields.List(fields.Nested(vill_fields))
vills = city.villages
print(vills)
data['area'] = vills
# data['city'] = fields.List(fields.Nested(city_fields))
# data['name'] = city.provice
result = marshal_with(data,city_fields)
return {'data':result}
class EnvironmentHierarchyLevels(flask_restful.Resource):
method_decorators = [
flask_restful.marshal_with(environment_hierarchy_level_fields)
]
def get(self, environment_id, level):
level = db.find_or_404(db.EnvironmentHierarchyLevel,
environment_id=environment_id,
name=level)
return level
@db.with_transaction
def _do_update(self, environment_id, level):
level = db.find_or_404(db.EnvironmentHierarchyLevel,
environment_id=environment_id,
name=level)
level.name = flask.request.json.get('name', level.name)
def put(self, environment_id, level):
return self.patch(environment_id, level)
def patch(self, environment_id, level):
self._do_update(environment_id, level)
return None, 204
update $ curl http://localhost:5000/todos/todo3 -d "task=something different" -X PUT -v
add $ curl http://localhost:5000/todos -d "task=something new" -X POST -v
delete $ curl http://localhost:5000/todos/todo2 -X DELETE -v
get $ curl http://localhost:5000/todos
//return object
Data Formatting
By default, all fields in your return iterable will be rendered as-is. While this works great
when you’re just dealing with Python data structures, it can become very frustrating when working
with objects. To solve this problem, Flask-RESTful provides the fields module and
the marshal_with() decorator. Similar to the Django ORM and WTForm, you use the fields module
to describe the structure of your response.
from collections import OrderedDict
from flask_restful import fields, marshal_with
resource_fields = {
'task': fields.String,
'uri': fields.Url('todo_ep')
}
class TodoDao(object):
def __init__(self, todo_id, task):
self.todo_id = todo_id
self.task = task
