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