'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')