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