utils/test/result_collection_api/tornado_swagger_ui/example/basic.py

   1 import json
   2
   3 import tornado.ioloop
   4 from tornado.web import RequestHandler, HTTPError
   5 from tornado_swagger_ui.tornado_swagger import swagger
   6
   7 DEFAULT_REPRESENTATION = "application/json"
   8 HTTP_BAD_REQUEST = 400
   9 HTTP_FORBIDDEN = 403
  10 HTTP_NOT_FOUND = 404
  11
  12 swagger.docs()
  13
  14
  15 @swagger.model()
  16 class PropertySubclass:
  17     def __init__(self, sub_property=None):
  18         self.sub_property = sub_property
  19
  20
  21 @swagger.model()
  22 class Item:
  23     """
  24         @description:
  25             This is an example of a model class that has parameters in its constructor
  26             and the fields in the swagger spec are derived from the parameters to __init__.
  27         @notes:
  28             In this case we would have property1, name as required parameters and property3 as optional parameter.
  29         @property property3: Item description
  30         @ptype property3: L{PropertySubclass}
  31         @ptype property4: C{list} of L{PropertySubclass}
  32     """
  33     def __init__(self, property1, property2=None, property3=None, property4=None):
  34         self.property1 = property1
  35         self.property2 = property2
  36         self.property3 = property3
  37         self.property4 = property4
  38
  39     def format_http(self):
  40         return {
  41             "property1": self.property1,
  42             "property2": self.property2,
  43             "property3": self.property3,
  44             "property4": self.property4,
  45         }
  46
  47     @staticmethod
  48     def item_from_dict(item_dict):
  49
  50         if item_dict is None:
  51             return None
  52
  53         t = Item(None)
  54         t.property1 = item_dict.get('property1')
  55         t.property2 = item_dict.get('property2')
  56         t.property3 = item_dict.get('property3')
  57         t.property4 = item_dict.get('property4')
  58
  59         return t
  60
  61     @classmethod
  62     def test_classmethod(cls):
  63         pass
  64
  65
  66 items = {}
  67
  68
  69 class GenericApiHandler(RequestHandler):
  70     """
  71     The purpose of this class is to take benefit of inheritance and prepare
  72     a set of common functions for
  73     the handlers
  74     """
  75
  76     def initialize(self):
  77         """ Prepares the database for the entire class """
  78         pass
  79
  80     def prepare(self):
  81         if not (self.request.method == "GET" or self.request.method == "DELETE"):
  82             if self.request.headers.get("Content-Type") is not None:
  83                 if self.request.headers["Content-Type"].startswith(DEFAULT_REPRESENTATION):
  84                     try:
  85                         self.json_args = json.loads(self.request.body)
  86                     except (ValueError, KeyError, TypeError) as error:
  87                         raise HTTPError(HTTP_BAD_REQUEST,
  88                                         "Bad Json format [{}]".
  89                                         format(error))
  90                 else:
  91                     self.json_args = None
  92
  93     def finish_request(self, json_object):
  94         self.write(json.dumps(json_object))
  95         self.set_header("Content-Type", DEFAULT_REPRESENTATION)
  96         self.finish()
  97
  98
  99 class ItemNoParamHandler(GenericApiHandler):
 100     @swagger.operation(nickname='create')
 101     def post(self):
 102         """
 103             @param body: create a item.
 104             @type body: L{Item}
 105             @in body: body
 106             @return 200: item is created.
 107             @raise 400: invalid input
 108         """
 109         property1 = self.json_args.get('property1')
 110         item = Item.item_from_dict(self.json_args)
 111         items[property1] = item
 112         Item.test_classmethod()
 113         self.finish_request(item.format_http())
 114
 115     @swagger.operation(nickname='list')
 116     def get(self):
 117         """
 118            @rtype: L{Item}
 119         """
 120         res = []
 121         for key, value in items.iteritems():
 122             res.append(value.format_http())
 123         self.finish_request(res)
 124
 125     def options(self):
 126         """
 127         I'm not visible in the swagger docs
 128         """
 129         self.finish_request("I'm invisible in the swagger docs")
 130
 131
 132 class ItemHandler(GenericApiHandler):
 133     @swagger.operation(nickname='get')
 134     def get(self, arg):
 135         """
 136             @rtype: L{Item}
 137             @description: get information of a item
 138             @notes:
 139                 get a item,
 140
 141                 This will be added to the Implementation Notes.It lets you put very long text in your api.
 142         """
 143         self.finish_request(items[arg].format_http())
 144
 145     @swagger.operation(nickname='delete')
 146     def delete(self, arg):
 147         """
 148             @description: delete a item
 149             @notes:
 150                 delete a item in items
 151
 152                 This will be added to the Implementation Notes.It lets you put very long text in your api.
 153         """
 154         del items[arg]
 155         self.finish_request("success")
 156
 157
 158 class ItemOptionParamHandler(GenericApiHandler):
 159     @swagger.operation(nickname='create')
 160     def post(self, arg1, arg2=''):
 161         """
 162         @return 200: case is created
 163         """
 164         print("ProjectHandler.post: %s -- %s -- %s" % (arg1, arg2, self.request.full_url()))
 165         fs = open("/home/swagger/tornado-rest-swagger/%s/%s" % (arg1, arg2), "wb")
 166         fs.write(self.request.body)
 167         self.write("success")
 168
 169
 170 class ItemQueryHandler(GenericApiHandler):
 171     @swagger.operation(nickname='query')
 172     def get(self):
 173         """
 174            @param property1:
 175            @type property1: L{string}
 176            @in property1: query
 177            @required property1: False
 178
 179            @param property2:
 180            @type property2: L{string}
 181            @in property2: query
 182            @required property2: True
 183            @rtype: L{Item}
 184            @notes: GET /item?property1=1&property2=1
 185         """
 186         property1 = self.get_query_argument("property1", None)
 187         property2 = self.get_query_argument("property2", None)
 188
 189         res = []
 190         if property1 is None:
 191             for key, value in items.iteritems():
 192                 if property2 is None:
 193                     res.append(value.format_http())
 194                 elif value.property2 == property2:
 195                     res.append(value.format_http())
 196         elif items.has_key(property1):
 197             if items.get(property1).property2 == property2:
 198                 res.append(items.get(property1).format_http())
 199
 200         self.finish_request(res)
 201
 202
 203 def make_app():
 204     return swagger.Application([
 205         (r"/item", ItemQueryHandler),
 206         (r"/items", ItemNoParamHandler),
 207         (r"/items/([^/]+)", ItemHandler),
 208         (r"/items/([^/]+)/cases/([^/]+)", ItemOptionParamHandler),
 209     ])
 210
 211
 212 if __name__ == "__main__":
 213     app = make_app()
 214     app.listen(711)
 215     tornado.ioloop.IOLoop.current().start()