class JSONFields(object): social_fields = { 'nick_name': fields.String, 'experience': fields.Integer, 'uri': fields.Url('api.user_social_info', absolute=False), } im_config_fields = { 'uri': fields.Url('api.user_im_config', absolute=False), 'token': fields.String, 'chat_room_limit': fields.String, 'chat_group_limit': fields.String } push_config_fields = { 'uri': fields.Url('api.user_push_config', absolute=False), 'not_allow_ad': fields.Integer } user_fields = { 'uuid': fields.String, 'type': fields.String(default='personal'), 'uri': fields.Url('api.user') } token_fields = { 'id': fields.String(default=''), 'token': fields.String(default=''), 'uri': fields.Url(endpoint='api.token') }
class AppField: code_hname_to_eng = { "단축코드": "code", "확장코드": "extend_code", "종목명": "name", "시장구분": "market", "ETF구분": "is_etf", "주문수량단위": "memedan", "기업인수목적회사구분": "is_spac" } price_hname_to_eng = { "날짜": "date", "종가": "close", "시가": "open", "고가": "high", "저가": "low", "전일대비": "diff", "전일대비구분": "diff_type" } code_fields = { "code": fields.String, "extend_code": fields.String, "name": fields.String, "memedan": fields.Integer, "market": fields.String, "is_etf": fields.String, "is_spac": fields.String, "uri": fields.Url("code") } code_list_short_fields = {"code": fields.String, "name": fields.String} code_list_fields = { "count": fields.Integer, "code_list": fields.List(fields.Nested(code_fields)), "uri": fields.Url("codes") } price_fields = { "date": fields.Integer, "start": fields.Integer, "close": fields.Integer, "open": fields.Integer, "high": fields.Integer, "low": fields.Integer, "diff": fields.Float, "diff_type": fields.Integer } price_list_fields = { "count": fields.Integer, "price_list": fields.List(fields.Nested(price_fields)), }
class ModelWithResourceFields: resource_fields = { 'a_url': fields.Url() } resource_fields = { 'a_string': fields.String() }
def test_url_without_endpoint_absolute_scheme(self): app = Flask(__name__) app.add_url_rule("/<hey>", "foobar", view_func=lambda x: x) field = fields.Url(absolute=True, scheme='https') with app.test_request_context("/hey", base_url="http://localhost"): self.assertEqual("https://localhost/3", field.output("hey", Foo()))
class LandingController(BaseController): marshal_fields = { 'id': fields.Integer, 'url': fields.Url(absolute=True), 'http_method': fields.String(attribute='request_method'), 'datetime': fields.DateTime, 'timestamp': TimestampField } def _get_response_data(self): return { 'id': self.context.request.view_args.get('id', None), 'url': self.context.request.url, 'request_method': self.context.request.method, 'datetime': datetime.now(), 'timestamp': datetime.now(), } def get_response(self): response_data = self._get_response_data() # Logging examples LOGGER.debug('debug log statement') LOGGER.info('info log statement') LOGGER.warn('warn log statement') LOGGER.error('error log statement') LOGGER.critical('critical log statement') return response_data
def test_url_without_endpoint(self): app = Flask(__name__) app.add_url_rule("/<hey>", "foobar", view_func=lambda x: x) field = fields.Url() with app.test_request_context("/hey"): self.assertEqual("/3", field.output("hey", Foo()))
def test_url_invalid_object(self): app = Flask(__name__) app.add_url_rule("/<hey>", "foobar", view_func=lambda x: x) field = fields.Url("foobar") with app.test_request_context("/"): self.assertRaises(MarshallingException, lambda: field.output("hey", None))
class TaskApi(TasksApi): taskFiled = { 'id': fields.Integer, 'title': fields.String, 'description': fields.String, 'uri': fields.Url('taskapi') } def __init__(self): super(TaskApi, self).__init__() self.reparse.args[0].required = False #modify title required attr def get(self, id): task = if_exists_id(id) return {'task': marshal(task, TaskApi.taskFiled)}, 200 # curl -i http://127.0.0.1:5000/index/api/tasks/1 def put(self, id): task = if_exists_id(id) args = self.reparse.parse_args(strict=True) task['title'] = args.get('title') or task['title'] task['description'] = args.get('description') or task['description'] return {'task': marshal(task, TaskApi.taskFiled)}, 200
def test_url_absolute(self): app = Flask(__name__) app.add_url_rule("/<hey>", "foobar", view_func=lambda x: x) field = fields.Url("foobar", absolute=True) with app.test_request_context("/"): self.assertEquals("http://localhost/3", field.output("hey", Foo()))
def link_field(endpoint, rel_type='self', absolute=True): _link_field = { 'rel': rel_type, 'href': fields.Url(endpoint, absolute=absolute) } return _link_field
def test_url_superclass_kwargs(self): app = Flask(__name__) app.add_url_rule("/<hey>", "foobar", view_func=lambda x: x) field = fields.Url(absolute=True, attribute='hey') with app.test_request_context("/hey"): self.assertEqual("http://localhost/3", field.output("hey", Foo()))
def test_url_absolute_scheme(self): """Url.scheme should override current_request.scheme""" app = Flask(__name__) app.add_url_rule("/<hey>", "foobar", view_func=lambda x: x) field = fields.Url("foobar", absolute=True, scheme='https') with app.test_request_context("/", base_url="http://localhost"): self.assertEqual("https://localhost/3", field.output("hey", Foo()))
def test_url_with_blueprint(self): app = Flask(__name__) bp = Blueprint("foo", __name__, url_prefix="/foo") bp.add_url_rule("/<hey>", "foobar", view_func=lambda x: x) app.register_blueprint(bp) field = fields.Url() with app.test_request_context("/foo/hey"): self.assertEqual("/foo/3", field.output("hey", Foo()))
def test_url_with_blueprint_invalid_object(self): app = Flask(__name__) bp = Blueprint("foo", __name__, url_prefix="/foo") bp.add_url_rule("/<hey>", "foobar", view_func=lambda x: x) app.register_blueprint(bp) field = fields.Url() with app.test_request_context("/foo/hey"): self.assertRaises(MarshallingException, lambda: field.output("hey", None))
def test_url_with_blueprint_absolute_scheme(self): app = Flask(__name__) bp = Blueprint("foo", __name__, url_prefix="/foo") bp.add_url_rule("/<hey>", "foobar", view_func=lambda x: x) app.register_blueprint(bp) field = fields.Url(absolute=True, scheme='https') with app.test_request_context("/foo/hey", base_url="http://localhost"): self.assertEquals("https://localhost/foo/3", field.output("hey", Foo()))
def getResourceURL(endpoint, selector_name = None, selector_value = None, absolute = False): if selector_name is None and selector_value is None: selector_name = "dummy_RDCH106" selector_value = "dummy_RDCH106" uri_field = {'url': fields.Url(endpoint)} selector = {selector_name: selector_value} if absolute: return getDomain(request) + marshal(selector, uri_field)["url"] else: return marshal(selector, uri_field)["url"]
class GetUser(Resource): @marshal_with( { 'firebase_id': fields.String, 'firebase_name': fields.String, 'admin': fields.Integer, 'uri': fields.Url('getuser', absolute=True) }, envelope='user') def get(self, id): return User.query.get(id)
class GetUserDiscoveries(Resource): @marshal_with( { 'filter_params': fields.String, 'timestamp': fields.DateTime(dt_format='rfc822'), 'uri': fields.Url('getdiscovery', absolute=True), 'discovery_title': fields.String, 'num_datasets': fields.Integer }, envelope='discoveries') def get(self, id): owner = User.query.filter_by(firebase_id=id).first() return Discovery.query.filter_by(owner_id=owner.id).all()
def get_serializable_entries(self, entries): endpoint = format_endpoint(GetEntry, self.dict_id) marshaled_entries = [] for entry in entries: entry.content['entry_id'] = entry.content['id'] entry_fields = { 'content': fields.Raw(default=entry.content['content']), 'id': fields.String(), 'name': fields.String(), 'references': fields.Raw(default=entry.content['references']), 'url': fields.Url(endpoint=endpoint, absolute=True), } marshaled_entries.append(marshal(entry.content, entry_fields)) return marshaled_entries
class GetDiscovery(Resource): @marshal_with( { 'filter_params': fields.String, 'timestamp': fields.DateTime(dt_format='rfc822'), 'discovery_title': fields.String, 'discovery_description': fields.String, 'uri': fields.Url('getdiscovery', absolute=True), 'owner': fields.Nested({ 'firebase_id': fields.String, 'firebase_name': fields.String, 'uri': fields.Url('getuser', absolute=True) }) }, envelope='discovery') def get(self, id): return Discovery.query.get(id)
class GetAllDiscoveries(Resource): @marshal_with( { 'filter_params': fields.String, 'timestamp': fields.DateTime(dt_format='rfc822'), 'discovery_title': fields.String, 'uri': fields.Url('getdiscovery', absolute=True), 'num_datasets': fields.Integer, 'owner': fields.Nested({ 'firebase_id': fields.String, 'firebase_name': fields.String, 'uri': fields.Url('getuser', absolute=True) }) }, envelope='discoveries') def get(self): return Discovery.query.all()
class UserApi(Resource): parser = reqparse.RequestParser() parser.add_argument('id', type=int, required=False, help='必须提供一个id') parser.add_argument('name', type=str, required=False) user_fields = { "id": fields.Integer, "name": fields.String, "phone": fields.String, "url": fields.Url(endpoint='upload', absolute=True, scheme='https') } out_fields = { "status": fields.String(default='fail'), "data": fields.Nested(user_fields) } def get(self): self.parser.parse_args() users = dao.query(User).all() respJson = json.dumps( marshal(data={ "status": "ok", "data": users }, fields=self.out_fields)) print(respJson) resp = make_response(respJson) resp.set_cookie('token', 'aaadd2212333kkdooo') return resp def put(self): id = request.form.get('id') user = dao.get(User, int(id)) user.phone = request.form.get('phone') dao.add(user) return jsonify({"status": "ok", "msg": "更新手机号成功!"}) def post(self): user = User() user.name = request.form.get('name') user.phone = request.form.get('phone') dao.add(user) return jsonify({"status": "ok", "msg": "新增用户成功!"})
from app.resources import auth from flask import abort from flask_restful import Resource, reqparse, fields, marshal_with from app.models.schedule import Schedule from app.models.cleaner import Cleaner from app.common.utils import assign from datetime import date schedule_fields = { 'year': fields.String, 'week': fields.String, 'day_of_week': fields.String, 'start_time': fields.String, 'end_time': fields.String, 'cleaner': fields.Url('cleaner', absolute=False) } schedule_list_fields = schedule_fields.copy() schedule_list_fields['url'] = fields.Url('schedule', absolute=False) class ScheduleAPI(Resource): """ Resource to manage cleaner individual schedule """ def __init__(self): self.parser = reqparse.RequestParser() self.parser.add_argument('year', type=str, required=False, location='json')
#coding:utf-8 from flask import Flask, request from flask_restful import Resource, Api from flask_restful import reqparse app = Flask(__name__) api = Api(app) 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 # This field will not be sent in the response self.status = 'active' class Todo(Resource): @marshal_with(resource_fields) def get(self, **kwargs): return TodoDao(todo_id='my_todo', task='Remember the milk') class Todo1(Resource): def get(self, todo_id): # Default to 200 OK
from flask import jsonify from flask_restful import Resource, reqparse, fields, marshal_with, marshal from indoor_position.models.user import User from indoor_position.common.error_handler import InvalidModelUsage, InvalidAPIUsage, USER_ERROR user_record = { 'user_id': fields.Integer, 'user_name': fields.String, 'uri': fields.Url('api.user', absolute=True), 'created_at': fields.Integer, 'updated_at': fields.Integer } user_fields = {'user': user_record} class UserAPI(Resource): """The user api.""" @marshal_with(user_fields) def get(self, user_id): """Return a user.""" u = User.get_by_user_id(user_id) if u is None: raise InvalidAPIUsage('get user fail, %d no exists!' % user_id, error_code=USER_ERROR) return u @marshal_with(user_fields) def post(self, user_id): """Create a user."""
def insert_message(self, message): self.__class__.last_id += 1 message.id = self.__class__.last_id self.messages[self.__class__.last_id] = message def get_message(self, id): return self.messages[id] def delete_message(self, id): del self.messages[id] message_fields = { 'id': fields.Integer, 'uri': fields.Url('message_endpoint'), 'message': fields.String, 'duration': fields.Integer, 'creation_date': fields.DateTime, 'message_category': fields.String, 'printed_times': fields.Integer, 'printed_once': fields.Boolean } message_manager = MessageManager() class Message(Resource): def abort_if_message_doesnt_exist(self, id): if id not in message_manager.messages: abort(status.HTTP_404_NOT_FOUND,
auth = HTTPBasicAuth() #TODO make password auth to be same for all resource @auth.get_password def get_password(username): if username == 'ansible': return 'default' return None host_fields = { 'host': fields.String, 'port': fields.String, 'groups': fields.String, 'uri': fields.Url('host') } module = dispatcher.use_module() hosts = dispatcher.HostsList(module) class HostsAPI(Resource): """ """ decorators = [auth.login_required] def __init__(self): self.reqparse = reqparse.RequestParser() self.reqparse.add_argument('host', type=str,
'description': u'Make the thing, or A thing', 'done': False }, { 'id': 2, 'title': u'Learn the thing', 'description': u'Learn to do the thing!', 'done': False } ] task_fields = { 'title': fields.String, 'description': fields.String, 'done': fields.Boolean, 'uri': fields.Url('task'), 'id': fields.Integer } class TaskListAPI(Resource): def __init__(self): self.reqparse = reqparse.RequestParser() self.reqparse.add_argument( 'title', type=str, required=True, help='Task property Title not provided', location='json' ) self.reqparse.add_argument(
from flask_restful import Resource, reqparse, fields, marshal_with from new_atm_dns_api_app.globals import GLOBALS from new_atm_dns_api_app.infoblox.Session import Session as infoblox_session import new_atm_dns_api_app.infoblox.errors ######### # Ignore this for now ######### record_host_fields = { 'fqdn': fields.String, 'address': fields.String, 'comment': fields.String, 'disable': fields.Boolean, 'view': fields.String, 'link': fields.Url('by_ref', absolute=False) } class record_host_object(object): __slots__ = [ 'name', 'domain', 'address', 'comment', 'disable', 'extattrs', 'view', 'link' ] def __init__(self, **kwargs): # Has the side effect of ignoring bad keywords for fieldName in self.__slots__: setattr(self, fieldName, kwargs.get(fieldName)) def __str__(self):
api.add_resource(getBase1, '/api/base/1') api.add_resource(getBase2, '/api/bases/2') api.add_resource(getBase3, '/api/bases/3') api.add_resource(getDrone1,'api/drone/1') api.add_resource(getDrone1,'api/drone/2') api.add_resource(getDrone1,'api/drone/3') api.add_resource(getDrone1,'api/drone/4') api.add_resource(getDrone1,'api/drone/5') api.add_resource(getDrone1,'api/drone/6') api.add_resource(getDrone1,'api/drone/7') api.add_resource(getDrone1,'api/drone/8') api.add_resource(getDrone1,'api/drone/9') api.add_resource(getDrone1,'api/drone/10') resource_fields = { 'task': fields.String, 'uri': fields.Url('todo_ep') } if __name__ == '__main__': app_api.run(host="127.0.0.1",debug=True, port=80) '''class getDrones(Resource): def get(self): # Default to 200 OK return { 'BlueDrones': '/blue', 'RedDrones': '/red', }, 200 class getBases(Resource): def get(self):