# app.run(debug=True) import json from datetime import datetime from flask.ext.restful import Resource, fields, marshal_with, marshal # 基本例子 resource_fields = { 'name': fields.String, 'address': fields.String, 'date_updated': fields.DateTime(dt_format='rfc822'), } class UserInfo(object): def __init__(self, name, address, date_updated=datetime.now()): self.name = name self.address = address self.date_updated = date_updated print json.dumps(marshal(UserInfo('magi', 'beijing'), resource_fields)) # # class Todo(Resource): # @marshal_with(resource_fields, envelope='resource') # def get(self, **kwargs):
'id': fields.Integer, 'subscribed': fields.Boolean, 'favicon': fields.String, 'categories': DictList(fields.Integer(attribute='id')) } essential_journal_fields = { 'title': fields.String, 'id': fields.Integer, 'favicon': fields.String } common_paper_fields = { 'title': fields.String(attribute='paper.title'), 'id': fields.Integer(attribute='paper.id'), 'authors': fields.String(attribute='paper.authors'), 'journalId': fields.Integer(attribute='paper.journal.id'), 'score': fields.Integer, 'created': fields.DateTime, 'readAt': fields.DateTime(attribute='read_at') } paper_fields = dict(common_paper_fields) paper_fields['abstract'] = Ellipsis(attribute='paper.abstract') full_paper_fields = dict(common_paper_fields) full_paper_fields['abstract'] = fields.String(attribute='paper.abstract') full_paper_fields['url'] = fields.String(attribute='paper.url') full_paper_fields['reference'] = fields.String(attribute='paper.ref') full_paper_fields['doi'] = fields.String(attribute='paper.doi')
risk_fields = dict(id=fields.Integer, agent_id=fields.Integer, hazard=fields.String, hazard_category=fields.String, location=fields.String, coordinates=PointToLatLng(attribute='coordinates'), radius=fields.Integer, operational_status=fields.String, method_of_use=fields.String, risk_type=fields.String, severity=fields.String, likelihood=fields.Integer, risk_level=fields.Integer, status=fields.String, proposed_datetime=fields.DateTime("iso8601"), agent=fields.Nested(agent_fields, allow_null=False)) assessment_risk_fields = dict(id=fields.Integer, risk_assessment_id=fields.Integer, risk_id=fields.Integer, risk=fields.Nested(risk_fields, allow_null=False), date_created=fields.DateTime("iso8601"), date_modified=fields.DateTime("iso8601")) assessment_risk_create_fields = dict(status=fields.String, message=fields.String, assessment_risk=fields.Nested( assessment_risk_fields, allow_null=False))
from flask.ext.restful import fields from flask.ext.restful import marshal_with from datetime import datetime user_fields = { 'id': fields.Integer, 'name': fields.String, 'email': fields.String, 'uri': fields.Url('user', absolute=True), } group_fields = { 'id': fields.Integer, 'name': fields.String, 'date_created': fields.DateTime(dt_format='rfc822'), 'uri': fields.Url('group', absolute=True), } parser = reqparse.RequestParser() parser.add_argument('name', type=str) parser.add_argument('email', type=str) def createJSON(input_list): result_list = [] for i in input_list: dictionary = {} dictionary[str(i[0])] = i[1] result_list.append(json.dumps(dictionary)) return result_list
from flask.ext.restful import fields client_fields = dict( id=fields.Integer, first_name=fields.String, last_name=fields.String, middle_name=fields.String, full_name=fields.String, gender=fields.String, date_of_birth=fields.DateTime("iso8601"), age=fields.String, address=fields.String, date_created=fields.DateTime("iso8601"), date_modified=fields.DateTime("iso8601") ) client_create_fields = dict( status=fields.String, message=fields.String, client=fields.Nested(client_fields, allow_null=False) )
asset_type=fields.String, department=fields.Nested(department_fields, allow_null=False)) type_fields = dict(id=fields.Integer, name=fields.String, icon=fields.String) incident_fields = dict( id=fields.Integer, incident_type_id=fields.Integer, risk_type_id=fields.Integer, title=fields.String, events_description=fields.String, immediate_actions=fields.String, location=fields.String, location_coordinates=PointToLatLng(attribute='location_coordinates'), incident_datetime=fields.DateTime("iso8601"), status=fields.String, incident_type=fields.Nested(type_fields, allow_null=False), risk_type=fields.Nested(type_fields, allow_null=False)) incident_create_fields = dict(status=fields.String, message=fields.String, incident=fields.Nested(incident_fields, allow_null=False)) incident_people_fields = dict(id=fields.Integer, incident_id=fields.Integer, emp_id=fields.Integer, first_name=fields.String, last_name=fields.String, middle_name=fields.String,
from flask import request from flask.ext.restful import Resource, fields, abort from webargs.flaskparser import use_kwargs, parser from models import Programme from resources.paginator import Paginator programme_fields = { 'id': fields.Integer, 'title': fields.String(255), 'title_lang': fields.String(10), 'begin': fields.DateTime('iso8601'), 'end': fields.DateTime('iso8601'), 'duration': fields.DateTime('iso8601'), 'description': fields.String, 'description_lang': fields.String(10), 'channel_id': fields.Integer } @parser.error_handler def handle_request_parsing_error(err): abort(422, errors=err.messages) class ProgrammeResources(Resource, Paginator): @use_kwargs(Paginator.args) def get(self, maxResults, pageToken): parser.parse(self.args, request) return self.get_paginated_list(Programme, maxResults, programme_fields, pageToken)
# class Date(fields.Raw): # def format(self, value): # return str(value) # Parser for RevenueAPI arguments revenue_list_parser = RequestParser() revenue_list_parser.add_argument('page', type=int, default=0) revenue_list_parser.add_argument('per_page_num', type=int, default=100) revenue_list_parser.add_argument('years', type=int, action='append') revenue_list_parser.add_argument('code') # Fields for RevenueAPI data marshal revenue_fields = { 'id': fields.Integer(), 'date': fields.DateTime(dt_format='iso8601'), 'description': fields.String(), 'code': fields.String(attribute='original_code'), 'monthly_predicted': fields.Float(), 'monthly_outcome': fields.Float() } class RevenueApi(restful.Resource): @restful.marshal_with(revenue_fields) def get(self): # Extract the argumnets in GET request args = revenue_list_parser.parse_args() page = args['page'] per_page_num = args['per_page_num'] years = args['years']
from flask.ext.restful import fields from app.utils.gis_json_fields import PolygonToLatLng from app.fields.deceased_fields import deceased_fields from app.fields.client_fields import client_fields from copy import copy section_basic_fields = dict(id=fields.Integer, name=fields.String, area=PolygonToLatLng(attribute='area'), date_created=fields.DateTime("iso8601"), date_modified=fields.DateTime("iso8601")) block_basic_fields = dict(id=fields.Integer, section_id=fields.Integer, name=fields.String, area=PolygonToLatLng(attribute='area'), section=fields.Nested(section_basic_fields)) lot_fields = dict(id=fields.Integer, block_id=fields.Integer, client_id=fields.Integer, block=fields.Nested(block_basic_fields), name=fields.String, area=PolygonToLatLng(attribute='area'), dimension=fields.String, lot_area=fields.Float, price_per_sq_mtr=fields.Float, amount=fields.Float, or_no=fields.String, date_purchased=fields.DateTime("iso8601"),
from db import session from flask.ext.restful import reqparse from flask.ext.restful import abort from flask.ext.restful import Resource from flask.ext.restful import fields from flask.ext.restful import marshal_with event_fields = { 'id': fields.Integer, 'name': fields.String, 'description': fields.String, 'venue': fields.String, 'organizer': fields.String, 'registeration_fees': fields.Integer, 'start_date_time': fields.DateTime(dt_format='rfc822'), 'end_date_time': fields.DateTime(dt_format='rfc822'), } parser = reqparse.RequestParser() parser.add_argument('name', type=str) parser.add_argument('description', type=str) parser.add_argument('venue', type=str) parser.add_argument('organizer', type=str) parser.add_argument('registeration_fees', type=int) parser.add_argument('start_date_time', type=str) parser.add_argument('end_date_time', type=str) class EventsResource(Resource): @marshal_with(event_fields)
from flask.ext.restful import fields, marshal_with, reqparse from flask import abort, g, Blueprint import logging from pebbles.models import db, Notification, User from pebbles.forms import NotificationForm from pebbles.server import restful from pebbles.views.commons import auth from pebbles.utils import requires_admin notifications = Blueprint('notifications', __name__) notification_fields = { 'id': fields.String, 'broadcasted': fields.DateTime(dt_format='iso8601'), 'subject': fields.String, 'message': fields.String } def get_current_user(): user = g.user if not user: abort(400) current_user = User.query.filter_by(id=user.id).first() if not current_user: abort(400) return current_user
from flask.ext.restful import fields from app.home.fields import employee_fields role_fields = dict(name=fields.String) user_fields = dict(id=fields.Integer, username=fields.String, employee_name=fields.String, account_status=fields.String, account_created_datetime=fields.DateTime("iso8601"), last_login_datetime=fields.DateTime("iso8601"), employee=fields.Nested(employee_fields, allow_null=False), role=fields.Nested(role_fields, allow_null=False))
from flask.ext.restful import Resource, fields, marshal_with from wfdb.models import db, Actor from .parsers import actor_post_parser, actor_put_parser from .auth import abort_if_no_admin_auth nested_role_fields = { 'movie_id': fields.Integer(), 'role_name': fields.String() } actor_fields = { 'id': fields.Integer(), 'first_name': fields.String(), 'last_name': fields.String(), 'birthday': fields.DateTime(dt_format='iso8601'), 'deathday': fields.DateTime(dt_format='iso8601'), 'hometown': fields.String(), 'bio': fields.String(), 'roles': fields.List(fields.Nested(nested_role_fields)), } class ActorAPI(Resource): @marshal_with(actor_fields) def get(self, actor_id=None): if actor_id: return Actor.query.get_or_404(actor_id) else: return Actor.query.all()
from flask import request, url_for from flask.ext.restful import reqparse, fields, marshal from cred.database import db from cred.exceptions import EventNotFound from cred.common import util from cred.models.event import Event as EventModel full_event_fields = { 'id': fields.Integer, 'device': fields.String(attribute='client.device'), 'name': fields.String, 'location': fields.String, 'action': fields.String, 'value': fields.String, 'time': fields.DateTime(dt_format='rfc822'), 'uri': fields.Url('events_item', absolute=True) } simple_event_fields = { 'id': fields.Integer, 'uri': fields.Url('events_item', absolute=True) } def get_subscribed_events(request, client): # Get the events that the client subscribes to subscribes = client.subscribes # Put all events into a list of events events = [] for subscribtion in subscribes: # Get all events that match the subscribtion event name
success_fields = dict(status=fields.String, message=fields.String) work_permit_hazard_fields = dict(id=fields.Integer, permit_id=fields.Integer, hazard_id=fields.String, hazard=fields.Nested(hazard_complete_fields, allow_null=False)) work_permit_fields = dict(id=fields.Integer, requestor_user_id=fields.Integer, approver_user_id=fields.Integer, type=fields.String, location=fields.String, coordinates=PointToLatLng(attribute='coordinates'), start_datetime=fields.DateTime("iso8601"), end_datetime=fields.DateTime("iso8601"), job_description_summary=fields.String, status=fields.String, requestor=fields.Nested(user_fields), approver=fields.Nested(user_fields), hazards=fields.List( fields.Nested(work_permit_hazard_fields))) work_permit_create_fields = dict(status=fields.String, message=fields.String, work_permit=fields.Nested(work_permit_fields, allow_null=False)) work_permit_step_fields = dict(id=fields.Integer, permit_id=fields.Integer,
mod = Blueprint('certificates', __name__) api = Api(mod) FIELDS = { 'name': fields.String, 'id': fields.Integer, 'bits': fields.Integer, 'deleted': fields.String, 'issuer': fields.String, 'serial': fields.String, 'owner': fields.String, 'chain': fields.String, 'san': fields.String, 'active': fields.Boolean, 'description': fields.String, 'notBefore': fields.DateTime(dt_format='iso8601', attribute='not_before'), 'notAfter': fields.DateTime(dt_format='iso8601', attribute='not_after'), 'cn': fields.String, 'signingAlgorithm': fields.String(attribute='signing_algorithm'), 'status': fields.String, 'body': fields.String } def valid_authority(authority_options): """ Defends against invalid authorities :param authority_options: :return: :raise ValueError: """
library_list = { 'items': fields.List(fields.Nested(library_fields)), 'next': fields.String, 'prev': fields.String, 'total': fields.Integer, 'pages_count': fields.Integer, 'current_page': fields.Integer, 'count': fields.Integer, } logs_info_fields = { 'id': fields.Integer, 'user_id': fields.Integer, 'user_name': fields.String(attribute=lambda x: x.user.name), 'book_id': fields.Integer, 'book_title': fields.String(attribute=lambda x: x.book.title), 'borrow_timestamp': fields.DateTime(dt_format='rfc822'), 'return_timestamp': fields.DateTime(dt_format='rfc822'), 'cost': fields.Integer, 'returned': fields.Boolean, 'uri': fields.String(attribute=lambda x: url_for('api.log', log_id=x.id, _external=True)), } logs_info_list = { 'items': fields.List(fields.Nested(logs_info_fields)), 'next': fields.String, 'prev': fields.String, 'total': fields.Integer, 'pages_count': fields.Integer, 'current_page': fields.Integer, 'count': fields.Integer, } comment_fields = {
from flask.ext.restful import Resource, fields, marshal_with from webapp.models import db, User, Post, Tag from .parsers import (post_get_parser, post_post_parser, post_put_parser, post_delete_parser) from .fields import HTMLField nested_tag_fields = {'id': fields.Integer(), 'title': fields.String()} post_fields = { 'id': fields.Integer(), 'author': fields.String(attribute=lambda x: x.user.username), 'title': fields.String(), 'text': HTMLField(), 'tags': fields.List(fields.Nested(nested_tag_fields)), 'publish_date': fields.DateTime(dt_format='iso8601') } class PostApi(Resource): @marshal_with(post_fields) def get(self, post_id=None): if post_id: post = Post.query.get(post_id) if not post: abort(404) return post else: args = post_get_parser.parse_args() page = args['page'] or 1
# 资源服务器端 # 数据模型 class Test1Data(object): def __init__(self, client_id, expires, salt, user_id): self.client_id = client_id self.expires = expires self.salt = salt self.user_id = user_id # marshal-蒙版 resource_fields = { 'client_id': fields.String(default=''), 'expires': fields.Float(default=0.0), 'salt': fields.Float(default=0.0), 'user_id': fields.String(default=''), 'date': fields.DateTime(default=str(datetime.now())) } # 新的资源服务器 class Test1(restful.Resource): @marshal_with(resource_fields) def get(self): token = request.args.get('token') ret = verify_token(token) if ret: return ret else: return 'error' api.add_resource(Test1, '/test1')
from internal.activity_log import get_num_activity_logs from rest import AuthenticatedResource from rest import get_pagination_params from rest import user_fields class ActivityLogMessage(fields.Raw): def output(self, key, obj): return get_activity_log_text(obj) activity_log_fields = { #'uri': fields.Url(endpoint='activity_log'), #TODO: Figure this out 'id': fields.String(), 'actor': fields.Nested(user_fields), 'event_message': ActivityLogMessage(), 'timestamp': fields.DateTime(), } class ActivityLogResourceList(AuthenticatedResource): """ REST endpoint to serve up a list of activity logs """ @marshal_with(activity_log_fields) def get(self): page, page_size = get_pagination_params() logs = get_all_activity_logs(page_size, (page - 1) * page_size) return logs
from constants import HTTP_STATUS from internal import public_key as pub_key_api from rest import AuthenticatedResource pub_key_fields = { #'uri': fields.Url(endpoint='public_key'), #TODO: Figure this out 'id': fields.String(), 'owner': fields.String(), 'value': fields.String(), 'expire_date': fields.String(), 'username': fields.String(), 'key_name': fields.String(), 'creation_date': fields.DateTime(), 'modified_date': fields.DateTime(), } pub_key_parser = reqparse.RequestParser() pub_key_parser.add_argument("key_name", type=str, location='json') pub_key_parser.add_argument("value", type=str, location='json') class PublicKeyResource(AuthenticatedResource): """ REST endpoint to serve up details of a specific Public Key from the database. """ @marshal_with(pub_key_fields) def get(self, pub_key_id): return pub_key_api.get_public_key(pub_key_id)