'pdf': fields.String,
'title_cn': fields.String,
'abstract_cn': fields.String,
'introduction': fields.String,
'introduction_cn': fields.String,
'conclusion': fields.String,
'conclusion_cn': fields.String,
'course': fields.String,
'catalog_id': fields.Integer,
'created_at': fields.String
}
paper_list_fields = {
'pagination': fields.Nested(paginate_fields),
'list': fields.List(fields.Nested(paper_fields))
}
sortable_fields = ['id',]
paper_post_parser = reqparse.RequestParser()
paper_post_parser.add_argument('title', type=str, )
paper_post_parser.add_argument('abstract', type=str, )
paper_post_parser.add_argument('authors', type=str, )
paper_post_parser.add_argument('keywords', type=str, )
paper_post_parser.add_argument('url', type=str, )
paper_post_parser.add_argument('Published_year', type=int, )
paper_post_parser.add_argument('pdf', type=str, )
paper_post_parser.add_argument('title_cn', type=str, )
paper_post_parser.add_argument('abstract_cn', type=str, )
paper_post_parser.add_argument('introduction', type=str, )
class GroupSettingsApi(Resource):
"""
Api class for single group settings
"""
@login_required
@marshal_with({
'id':
fields.Integer,
'name':
fields.String,
'printers':
fields.List(fields.Nested({
"id": fields.Integer,
"name": fields.String
}),
attribute="printer"),
'users':
fields.List(fields.Nested({
"id":
fields.Integer(attribute="user.id"),
"username":
fields.String(attribute="user.username"),
"role":
fields.String
}),
attribute="group_user")
})
def get(self, group_id):
"""Gets settings of group"""
group = g.user.get_editable_group_id(group_id)
if group:
return group, 200
return "Missing right for group", 403
@login_required
def put(self, group_id):
"""Modifies settings of group"""
group = g.user.get_editable_group_id(group_id)
if not group:
return "Missing right for group", 403
args = request.json
group.name = args["name"]
printer_ids = [x["id"] for x in args["printers"]]
printers = Printer.query.filter(
Printer.id.in_(printer_ids)) if printer_ids else [
] # associate group with printers in request
group.printer = printers
usernames = [x["username"] for x in args["users"]]
users = User.query.filter(
User.username.in_(usernames)).all() if usernames else []
group.group_user = []
for input in args[
"users"]: # associate group with users trough class GroupUser in request, creating new
# users in database
found = None
for user in users:
if user.username == input["username"]:
found = user
if found is None:
found = User(input["username"])
group.group_user.append(GroupUser(group, found, input["role"]))
db.session.commit()
return "", 200
"pub_dict_record_field", "pub_dict_record_fields",
"pub_dict_records_fields"
]
# local fields
#
pub_dict_record_field = {
"id": fields.Integer,
"name": fields.String,
"disabled": fields.Boolean,
"category": fields.String,
"operator_id": fields.Integer,
"operator_name": fields.String,
"operate_time": fields.DateTime(dt_format="iso8601"),
"note": fields.String,
}
# API fields
#
pub_dict_record_fields = {
"msg": fields.String(default="ok"),
"code": fields.Integer,
"data": fields.Nested(pub_dict_record_field),
}
pub_dict_records_fields = {
"msg": fields.String(default="ok"),
"code": fields.Integer,
"data": fields.List(fields.Nested(pub_dict_record_field)),
}
from flask_restful import Resource, abort, marshal_with, fields
from sfo_common.models import SfoClusterNodes
from sfo_datahandler import db
from sfo_server.models import SfoClusterNodesMethod, SfoTasksListMethod, SfoHostInfoMethod
from sfo_utils.apscheduler_utils import scheduler
from sfo_server.decorate import login_required, permission_required
cluster_node_fields_map = {
"status": fields.Integer,
"message": fields.String,
"data": fields.List(fields.Nested({
"guid": fields.String,
"cluster_name": fields.String,
"node_host_name": fields.String,
"node_inet_ip": fields.String,
"node_replicate_ip": fields.String,
"node_role": fields.String,
"node_stat": fields.String,
"add_time": fields.String,
}))
}
def get_node_list(cluster_name):
"""
通过集群名获取当前集群中的节点列表
:param cluster_name:
:return:
"""
data = []
status = ''
)
list_fields = {
'hairprd_id': fields.Integer,
'hairprd_nm': fields.String,
'price': fields.Integer,
'capacity': fields.String,
'like_cnt': fields.Integer,
'reg_date': fields.DateTime,
'brnd_id': fields.Integer,
}
result_fields = {
'msg': fields.String,
'count': fields.Integer,
'results': fields.List(fields.Nested(list_fields))
}
def fetch_list(owner_id, limit, offset, ordering):
conn = cnx_pool.get_connection()
cursor = conn.cursor()
query = """
SELECT a.hairprd_id, a.hairprd_nm, a.price, a.capacity, a.like_cnt, a.reg_date, a.brnd_id
FROM TBHAIRPRD a, TBLIKE b
WHERE b.category = 2
AND b.owner_id = %s
AND a.hairprd_id = b.hairprd_id
"""
query = query + 'ORDER BY ' + ordering + ' DESC \n'
parser = reqparse.RequestParser()
parser.add_argument(name='blog_title',
type=str,
required=True,
help='博客的标题不能够为空')
userinfo = {
'id': fields.Integer,
'name': fields.String,
}
bloginfo = {'blogtitle': fields.String, 'blogcontent': fields.String}
user_blog = {
'user': fields.List(fields.Nested(userinfo)),
'blog': fields.Nested(bloginfo),
}
class CollectBlogforallUser(Resource):
def post(self):
parse = parser.parse_args()
blog_title = parse.get("blog_title")
blogs = Blog.query.filter(Blog, blog_title == blog_title)
if blogs.count() > 0:
blog = blogs.first()
collects = Collection.query.filter(Collection.b_id == Blog.id)
if collects.count() > 0:
collect = collects.all()
user = User.quert.filter(User.id == collect.u_id)
def response_fields(cls):
fields = super(DeploymentUpdate, cls).response_fields
fields['steps'] = flask_fields.List(
flask_fields.Nested(DeploymentUpdateStep.response_fields))
return fields
...
],
'B': []
}
}
"""
city_fields = { # 具体城市信息
"id": fields.Integer,
"parentId": fields.Integer,
"regionName": fields.String,
"cityCode": fields.Integer,
"pinYin": fields.String
}
letter_fields = {
'A': fields.List(fields.Nested(city_fields)),
'B': fields.List(fields.Nested(city_fields)),
}
result_fields = {
'msg': fields.String,
'status': fields.Integer,
'date': fields.String,
'data': fields.Nested(letter_fields)
}
class CityResource(Resource):
@marshal_with(result_fields)
def get(self):
"""
self.age = 18
self.height = 1.75
self.scores = [80, 90]
self.info = {
'gender': True,
'level': 8
}
# 序列化规则
fields = {
'username': fields.String(attribute='name'),
'age': fields.Integer(default=20),
'height': fields.Float(),
# 列表类型属性,要求列表中元素类型唯一
'scores': fields.List(fields.Integer),
'info': fields.Nested({'gender': fields.Boolean,
'level': fields.Integer})
}
class DemoResource(Resource):
def get(self):
user = User()
return marshal(user, fields, envelope='data')
api.add_resource(DemoResource, '/')
nested_user_object_field = {
'_id': fields.Integer,
'username': fields.String,
'avatar_url': fields.String,
'nickname': fields.String,
}
sub_comment_object_field = {
'_id': fields.Integer,
'content': fields.String,
'created_datetime': fields.Integer,
'approve_count': fields.Integer,
'disapprove_count': fields.Integer,
'uploader': fields.Nested(nested_user_object_field)
}
comment_object_field = {
'_id': fields.Integer,
'content': fields.String,
'created_datetime': fields.Integer,
'approve_count': fields.Integer,
'disapprove_count': fields.Integer,
'uploader': fields.Nested(nested_user_object_field),
'sub_comments': fields.List(fields.Nested(sub_comment_object_field))
}
comment_to_article_field = {
'comments': fields.List(fields.Nested(comment_object_field))
}
'id': fields.Integer,
'username': fields.String,
'password_hash': fields.String,
'uri': fields.Url('user', absolute=True),
}
interest_field = {
'id': fields.Integer,
'name': fields.String,
'description': fields.String,
'lat': fields.Float,
'long': fields.Float,
'userName': fields.String,
'type': fields.String,
'rank': fields.Integer,
'imageUrls': fields.List(fields.String(attribute='url')),
}
authBasic = HTTPBasicAuth()
authToken = HTTPTokenAuth()
class User_Poi(Resource):
parser = reqparse.RequestParser()
parser.add_argument('name', type=str)
parser.add_argument('description', type=str)
parser.add_argument('lat', type=float)
parser.add_argument('long', type=float)
parser.add_argument('type', type=str)
@marshal_with(interest_field)
'name': fields.Raw,
'created_at': FieldDateTime,
'updated_at': FieldDateTime,
'self': {
'href': fields.Url('category', absolute=True)
}
}
cause_fields = {
'id': fields.Raw,
'created_at': FieldDateTime,
'updated_at': FieldDateTime,
'self': {
'href': fields.Url('cause', absolute=True)
},
'wordings': fields.List(fields.Nested(wording_fields)),
'category': fields.Nested(category_fields, allow_null=True),
}
causes_fields = {
'causes': fields.List(fields.Nested(cause_fields)),
'meta': {}
}
one_cause_fields = {'cause': fields.Nested(cause_fields, display_null=False)}
tag_fields = {
'id': fields.Raw,
'name': fields.Raw,
'created_at': FieldDateTime,
'updated_at': FieldDateTime,
'index':
fields.Integer,
'label':
fields.String(attribute=lambda obj: obj.info.get('label')),
'fsdescription':
fields.String(attribute=lambda obj: obj.info.get('fsdescription')),
'fstype':
fields.String,
'mountpoint':
fields.String,
}
disk_fields = {
'name': fields.String(attribute='_name'),
'imagepath': fields.String(attribute=lambda obj: obj.paths[0]),
'mountpoint': fields.String,
'volumes': fields.List(fields.Nested(volume_fields)),
}
disk_mount = {
'disk_info': fields.Nested(disk_fields),
'ref_count': fields.Integer
}
class Mount(Resource):
"""A Mount object that allows you to mount and unmount images.
"""
def __init__(self):
"""Create a Mount object.
"""
current_app.logger.debug('Instantiating the Mount class')
goods_fields = {
"id": fields.Integer,
"g_name": fields.String,
"g_price": fields.Integer,
"uri": fields.Url('single_goods', absolute=True)
}
single_goods_fields = {
"data": fields.Nested(goods_fields),
"status": fields.Integer,
"msg": fields.String,
}
multi_goods_fieds = {
"status": fields.Integer,
"msg": fields.String,
"data": fields.List(fields.Nested(goods_fields))
}
parser = reqparse.RequestParser()
parser.add_argument("g_name", type=str, help="please input g_name")
parser.add_argument("g_price")
parser.add_argument("sex", action='append')
parser.add_argument("HOST", dest='host', location='headers')
class GoodsResource(Resource):
@marshal_with(multi_goods_fieds)
def get(self):
args = parser.parse_args()
print(args.get('host'))
goods_List = Goods.query.all()
# -*- coding: utf-8 -*-
from flask_restful import Resource, fields, marshal_with, abort, reqparse
from server.models.school_user import SchoolUserHelper
from server.resources.school import school_fields, visible_course_fields
from server.util import require_auth
import json
school_user_fields = {
'id': fields.Integer,
'username': fields.String,
'doc_number': fields.Integer,
'school': fields.Nested(school_fields),
'visible_doc_tree': fields.List(fields.Nested(visible_course_fields)),
'checked_nodes': fields.List(fields.Integer),
'modify_doc_tree': fields.List(fields.Nested(visible_course_fields)),
'max_doc_id':
fields.Integer # 因为选中的树节点的编号包含course的节点编号，为了过滤这些，小于等于这个值的一定是doc编号
}
class SchoolUser(Resource):
@require_auth([1, 2, 3])
@marshal_with(school_user_fields)
def get(self, user_id=None):
parser = reqparse.RequestParser()
parser.add_argument('school_id', required=False)
args = parser.parse_args()
user = SchoolUserHelper.get_by_id(user_id)
result = None
if user is not None:
"""Fields for object serialization."""
from flask_restful import fields as rest_fields
from eucaby_api.utils import fields as utils_fields
REQUEST = 'request'
NOTIFICATION = 'notification'
INDEX_FIELDS = dict(message=rest_fields.String)
FRIENDS_FIELDS = dict(
data=rest_fields.List(rest_fields.Nested(
dict(username=rest_fields.String(attribute='id'),
name=rest_fields.String()))))
SENDER_FIELDS = dict(
username=rest_fields.String,
name=rest_fields.String)
RECIPIENT_FIELDS = SENDER_FIELDS.copy()
RECIPIENT_FIELDS.update(dict(email=rest_fields.String))
LOCATION_FIELDS = dict(
lat=rest_fields.Float,
lng=rest_fields.Float(attribute='lon'))
SESSION_FIELDS = dict(
token=rest_fields.String,
complete=rest_fields.Boolean)
MESSAGE_FIELDS = dict(
return datetime.strptime(val, '%Y-%m-%dT%H:%M:%S')
tournament_fields = {
'id': fields.Integer,
'name': fields.String(default=''),
'description': fields.String(default=''),
'detail': fields.String(default=''),
'start_time': fields.DateTime(dt_format='iso8601'),
'end_time': fields.DateTime(dt_format='iso8601'),
'created_at': fields.DateTime(dt_format='iso8601'),
'updated_at': fields.DateTime(dt_format='iso8601')
}
tournament_list_fields = {
'items': fields.List(fields.Nested(tournament_fields))
}
@api.resource('/tournaments', endpoint='tournament_list')
class TournamentList(Resource):
@login_required
@admin_required
@marshal_with(tournament_fields)
def post(self):
parser = reqparse.RequestParser()
parser.add_argument('name', required=True)
parser.add_argument('description', required=True)
parser.add_argument('detail', required=True)
parser.add_argument('start_time',
type=_input_type_datetime,
privilege_fields = {
'id': fields.Integer,
'name': fields.String,
'operation': fields.Integer,
'resource_type': fields.Integer,
'resource_id': fields.Integer,
'comment': fields.String,
}
role_fields = {
'id': fields.Integer,
'name': fields.String,
'privileges': fields.List(fields.Nested(privilege_fields))
}
paginated_role_fields = {
'total': fields.Integer,
'roles': fields.List(fields.Nested(role_fields)),
'current_page': fields.Integer
}
class RoleList(Resource):
method_decorators = [admin_required, token_required]
def get(self):
"""
def response_fields(cls):
fields = super(Deployment, cls).response_fields
fields['workflows'] = flask_fields.List(
flask_fields.Nested(Workflow.resource_fields))
return fields
except Exception:
raise fields.MarshallingException(
'Can NOT format this datetime field')
# confine response structure
response_fields = {
'id': fields.Integer,
'title': fields.String,
'description': fields.String,
'expiration': ExpirationDateTimeCase,
'task_uuid': fields.String,
'is_finished': fields.Boolean
}
response_fields_list = {'tasks': fields.List(fields.Nested(response_fields))}
# debug
'''
from . import api_bp
from flask import request
@api_bp.before_request
def before_request():
headers = request.headers
method = request.method
ip = request.remote_addr
url = request.url
form = request.form # post body
args = request.args # query string in url
__all__ = [
'task_output_record_field', 'task_output_record_fields',
'task_output_records_fields'
]
# local fields
#
task_output_record_field = {
'id': fields.Integer,
'fk_task_id': fields.Integer,
'module_name': fields.String,
'key': fields.String,
'index': fields.Integer,
'data_type': fields.Integer,
'value': fields.String,
}
# API fields
#
task_output_record_fields = {
'msg': fields.String(default='ok'),
'code': fields.Integer,
'data': fields.Nested(task_output_record_field),
}
task_output_records_fields = {
'msg': fields.String(default='ok'),
'code': fields.Integer,
'data': fields.List(fields.Nested(task_output_record_field)),
}
'contest_id': fields.Integer,
'create_time': fields.DateTime(dt_format='iso8601')
}
solution_log_fields = {
'id': fields.Integer,
'status': fields.String,
'create_time': fields.DateTime('iso8601')
}
solution_detail_fields = solution_fields.copy()
solution_detail_fields.update({
'code':
fields.String,
'solution_log':
fields.List(fields.Nested(solution_log_fields))
})
solution_list_fields = {
'data': fields.List(fields.Nested(solution_fields)),
'meta': fields.Nested(meta_fields)
}
class SolutionResource(Resource):
@auth.login_required
@marshal_with(solution_fields)
def get(self, id_):
solution = Solution.get_by_id(id_)
if solution is None:
raise NotFound()
'found': fields.Boolean(),
'links': FareLinks(attribute="ticket_id")
}
journey = {
'duration': fields.Integer(),
'nb_transfers': fields.Integer(),
'departure_date_time': DateTime(),
'arrival_date_time': DateTime(),
'requested_date_time': DateTime(),
'sections': NonNullList(NonNullNested(section)),
'from': PbField(place, attribute='origin'),
'to': PbField(place, attribute='destination'),
'type': fields.String(),
'fare': NonNullNested(fare),
'tags': fields.List(fields.String),
"status": fields.String(attribute="most_serious_disruption_effect"),
"calendars": NonNullList(NonNullNested(calendar)),
"co2_emission": NonNullNested({
'value': fields.Raw,
'unit': fields.String
}),
"durations": Durations(),
"distances": Distances(),
"debug": JourneyDebugInfo(),
}
section["ridesharing_journeys"] = NonNullList(NonNullNested(journey))
ticket = {
"id": fields.String(),
"name": fields.String(),
# export
__all__ = ['task_record_field', 'task_record_fields', 'task_records_fields']
# local fields
#
task_record_field = {
'id': fields.Integer,
'fk_program_id': fields.Integer,
'fk_program_config_id': fields.Integer,
'status': fields.Integer,
'processor_id': fields.Integer,
'start_time': fields.DateTime(dt_format='iso8601'),
'finish_time': fields.DateTime(dt_format='iso8601'),
'note': fields.String,
"task_inputs": fields.List(fields.Nested(task_input_record_field)),
"task_outputs": fields.List(fields.Nested(task_output_record_field))
}
# API fields
#
task_record_fields = {
'msg': fields.String(default='ok'),
'code': fields.Integer,
'data': fields.Nested(task_record_field),
}
task_records_fields = {
'msg': fields.String(default='ok'),
'code': fields.Integer,
'data': fields.List(fields.Nested(task_record_field)),
import pytz
utc = pytz.UTC
appointment_fields = {
'id': fields.Integer,
'start': DateTimeFormat,
'end': DateTimeFormat,
'description': fields.String,
'environment_id': fields.Integer,
'is_accepted': fields.Boolean,
}
appointment_list_fields = {
'count': fields.Integer,
'appointments': fields.List(fields.Nested(appointment_fields)),
}
appointment_post_parser = reqparse.RequestParser()
appointment_post_parser.add_argument(
'environment_id',
type=inputs.positive,
required=True,
location=['json'],
help='environment_id parameter is required')
appointment_post_parser.add_argument('start_date',
type=inputs.datetime_from_iso8601,
required=True,
location=['json'],
help='start_date parameter is required')
appointment_post_parser.add_argument('end_date',
import time
from sfo_server import access_logger
from flask_restful import Resource, marshal_with, fields, request
from sfo_server.models import (SfoDiskPerformMethod,
SfoDiskPerform5MinMethod,
SfoDiskPerformHourMethod,
SfoDiskPerformDayMethod,
SfoClusterNodesMethod)
from sfo_server.resource.common import used_time, timestamp_format, group_data, is_less_than_nhours
from sfo_server.decorate import login_required, permission_required
cluster_disk_io_resource_fields = {
"status": fields.Integer,
"message": fields.String,
"data": fields.Nested({
"read_list": fields.List(fields.List(fields.String)),
"write_list": fields.List(fields.List(fields.String)),
"read_mbps_list": fields.List(fields.List(fields.String)),
"write_mbps_list": fields.List(fields.List(fields.String)),
"await_list": fields.List(fields.List(fields.String)),
})
}
def cluster_disk_io(cluster_name, starttime, endtime):
read_list = []
write_list = []
read_mbps_list = []
write_mbps_list = []
await_list = []
nodes = SfoClusterNodesMethod.query_host_list_by_cluster_name(cluster_name=cluster_name)
get_jwt_identity,
get_raw_jwt,
)
freq_fields = {
'id_result': fields.Integer,
'freqword': fields.Integer,
'count': fields.Integer,
'word': fields.String,
'id_text': fields.Integer,
'time': fields.Integer
}
freq_list_fields = {
'count': fields.Integer,
'freqs': fields.List(fields.Nested(freq_fields)),
}
freq_post_parser = reqparse.RequestParser()
freq_post_parser.add_argument('freqword',
type=int,
required=True,
location=['json'],
help='freqword parameter is required')
freq_post_parser.add_argument('count',
type=int,
required=True,
location=['json'],
help='count parameter is required')
freq_post_parser.add_argument('word',
type=str,
from flask import jsonify, Blueprint, abort
from flask_restful import (Resource, Api, reqparse, inputs, fields, marshal,
marshal_with, url_for)
import models
course_fields = {
'id': fields.Integer,
'title': fields.String,
'url': fields.String,
'reviews': fields.List(fields.String)
}
def add_reviews(course):
course.reviews = [
url_for('resources.reviews.review', id=review.id)
for review in course.review_set
]
return course
def course_or_404(course_id):
try:
course = models.Course.get(models.Course.id == course_id)
except models.Course.DoesNotExist:
abort(404)
else:
return course
from flask_restful import marshal_with, Resource, fields
from flask_restful.reqparse import RequestParser
from source.common.models import Mailbox as MailboxModel, MailboxKey, Session
from source.common.utils import get_or_404
mailbox_key_fields = {'rfid': fields.String}
detailed_mailbox_fields = {
'id': fields.String,
'keys': fields.List(fields.Nested(mailbox_key_fields)),
'has_mail': fields.Boolean,
'is_closed': fields.Boolean,
'opens_in': fields.Integer,
'display_text': fields.String
}
list_mailbox_fields = {
'id': fields.Integer,
'has_mail': fields.Boolean,
'is_closed': fields.Boolean
}
class Mailbox(Resource):
def __init__(self):
super(Mailbox, self).__init__()
self.parser = RequestParser()
self.parser.add_argument('rfid',
type=str,
dest='rfid',
location='json')
self.parser.add_argument('has_mail',
parse = reqparse.RequestParser()
parse.add_argument('address_id')
parse.add_argument('district')
parse.add_argument('movie_id')
hall_movie_fields = {
'id': fields.Integer,
'h_movie_id': fields.Integer,
'h_hall_id': fields.Integer,
'h_time': fields.DateTime
}
multi_hall_movie_fields = {
'msg': fields.String,
'status': fields.Integer,
'data': fields.List(fields.Nested(hall_movie_fields))
}
hall_fields = {
'h_address_id': fields.Integer,
'h_num': fields.Integer,
'h_seats': fields.String
}
class UserMovieHallsResource(Resource):
def get(self):
args = parse.parse_args()
address_id = args.get('address_id')
district = args.get('district')
