import tornado.ioloop
from tornado.web import RequestHandler, HTTPError
-from tornado_swagger import swagger
+from tornado_swagger_ui.tornado_swagger import swagger
DEFAULT_REPRESENTATION = "application/json"
HTTP_BAD_REQUEST = 400
swagger.docs()
-@swagger.model
+@swagger.model()
class PropertySubclass:
def __init__(self, sub_property=None):
self.sub_property = sub_property
-@swagger.model
+@swagger.model()
class Item:
"""
@description:
self.property3 = property3
self.property4 = property4
+ def format_http(self):
+ return {
+ "property1": self.property1,
+ "property2": self.property2,
+ "property3": self.property3,
+ "property4": self.property4,
+ }
+
+ @staticmethod
+ def item_from_dict(item_dict):
+
+ if item_dict is None:
+ return None
+
+ t = Item(None)
+ t.property1 = item_dict.get('property1')
+ t.property2 = item_dict.get('property2')
+ t.property3 = item_dict.get('property3')
+ t.property4 = item_dict.get('property4')
+
+ return t
+
+ @classmethod
+ def test_classmethod(cls):
+ pass
+
+
items = {}
"""
@param body: create a item.
@type body: L{Item}
+ @in body: body
@return 200: item is created.
@raise 400: invalid input
"""
property1 = self.json_args.get('property1')
- items[property1] = self.json_args
- self.finish_request(items[property1])
+ item = Item.item_from_dict(self.json_args)
+ items[property1] = item
+ Item.test_classmethod()
+ self.finish_request(item.format_http())
@swagger.operation(nickname='list')
def get(self):
"""
@rtype: L{Item}
"""
- self.finish_request(items)
+ res = []
+ for key, value in items.iteritems():
+ res.append(value.format_http())
+ self.finish_request(res)
def options(self):
"""
This will be added to the Implementation Notes.It lets you put very long text in your api.
"""
- self.finish_request(items[arg])
+ self.finish_request(items[arg].format_http())
@swagger.operation(nickname='delete')
def delete(self, arg):
self.write("success")
+class ItemQueryHandler(GenericApiHandler):
+ @swagger.operation(nickname='query')
+ def get(self):
+ """
+ @param property1:
+ @type property1: L{string}
+ @in property1: query
+ @required property1: False
+
+ @param property2:
+ @type property2: L{string}
+ @in property2: query
+ @required property2: True
+ @rtype: L{Item}
+ @notes: GET /item?property1=1&property2=1
+ """
+ property1 = self.get_query_argument("property1", None)
+ property2 = self.get_query_argument("property2", None)
+
+ res = []
+ if property1 is None:
+ for key, value in items.iteritems():
+ if property2 is None:
+ res.append(value.format_http())
+ elif value.property2 == property2:
+ res.append(value.format_http())
+ elif items.has_key(property1):
+ if items.get(property1).property2 == property2:
+ res.append(items.get(property1).format_http())
+
+ self.finish_request(res)
+
+
def make_app():
return swagger.Application([
+ (r"/item", ItemQueryHandler),
(r"/items", ItemNoParamHandler),
(r"/items/([^/]+)", ItemHandler),
(r"/items/([^/]+)/cases/([^/]+)", ItemOptionParamHandler),
parser = {
'param': self._parse_param,
'type': self._parse_type,
+ 'in': self._parse_in,
+ 'required': self._parse_required,
'rtype': self._parse_rtype,
'property': self._parse_property,
'ptype': self._parse_ptype,
self.params.setdefault(arg, {}).update({
'name': arg,
'description': body,
- 'paramType': arg,
- 'required': True,
- 'allowMultiple': False
})
if 'paramType' not in self.params[arg]:
'dataType': body
})
+ def _parse_in(self, **kwargs):
+ arg = kwargs.get('arg', None)
+ body = self._get_body(**kwargs)
+ self.params.setdefault(arg, {}).update({
+ 'name': arg,
+ 'paramType': body
+ })
+
+ def _parse_required(self, **kwargs):
+ arg = kwargs.get('arg', None)
+ body = self._get_body(**kwargs)
+ self.params.setdefault(arg, {}).update({
+ 'name': arg,
+ 'required': False if body in ['False', 'false'] else True
+ })
+
def _parse_rtype(self, **kwargs):
body = self._get_body(**kwargs)
self.responseClass = body
class model(DocParser):
- def __init__(self, cls=None, *args, **kwargs):
+ def __init__(self, *args, **kwargs):
super(model, self).__init__()
- self.id = cls.__name__
self.args = args
self.kwargs = kwargs
self.required = []
+ self.cls = None
+
+ def __call__(self, *args, **kwargs):
+ if self.cls:
+ return self.cls
+ cls = args[0]
+ self._parse_model(cls)
+
+ return cls
+
+ def _parse_model(self, cls):
+ self.id = cls.__name__
+ self.cls = cls
if '__init__' in dir(cls):
self._parse_args(cls.__init__)
self.parse_docstring(inspect.getdoc(cls))
self.properties.setdefault(arg, {'type': 'string', "default": default})
-
class operation(DocParser):
def __init__(self, nickname=None, **kwds):
super(operation, self).__init__()
Code Review / releng.git / commitdiff