Merge pull request #6 from feliphebueno/develop

Promoção

Author: feliphebueno

CHANGELOG

@@ -1,3 +1,7 @@
+Version 1.15.2:
+Update v1.15.2
+Adição do sistema de log
+
 Version 1.12.0:
 Update v1.12.0
 Adição de documentação

README.md

@@ -2,7 +2,7 @@
 
 Django-based REST Framework
 
-# Requires
+# Install requires
 
 ```PHP
 pip install rinzler
@@ -12,30 +12,45 @@ pip install rinzler
 ```Python
 
 # urls.py
+
+import os
+import rinzler
+
+from rinzler.core.main_controller import MainController
 from your_controller import Controller
-from rinzler.core.url_assembler import UrlAssembler
 
-assembler = UrlAssembler()
+BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+
+app = rinzler.boot(BASE_DIR)
+assembler = app['url_assembler']
 
 urlpatterns = [
-    assembler.mount('', Controller)
+    assembler.mount('hello', Controller),
+    assembler.mount('', MainController),
 ]
 
+```
 
+```Python
 # your_controller.py
+from collections import OrderedDict
 
 from django.http.request import HttpRequest
 from django.views.generic import TemplateView
 
 from rinzler.core.response import Response
 
+
 class Controller(TemplateView):
 
     def connect(self, app):
 
         router = app['router']
 
-        router.get('/', self.hello_world)
+        # Definir end-points aqui
+        router.get('/world/', self.hello_world)
+        router.get('/{name}/', self.hello_user)
+
         return app
 
     # end-point callbacks here:
@@ -48,10 +63,82 @@ class Controller(TemplateView):
         :param params dict url params, if present
         :rtype: Response
         """
-        response = {
-            "status": True,
-            "data": "Hello World!"
-        }
+        try:
+            response = OrderedDict()
+            response["status"] = True
+            response["data"] = "Hello World!"
+
+            return Response(response, content_type="application/json")
+        except BaseException as e:
+            response = OrderedDict()
+            response["status"] = False
+            response["mensagem"] = str(e)
+
+            return Response(response, content_type="application/json", status=500)\
+
+    @staticmethod
+    def hello_user(request: HttpRequest, app: dict(), **params: dict):
+        """
+        Default route callback
+        :param request HttpRequest
+        :param app Rinzler's object
+        :param params dict url params, if present
+        :rtype: Response
+        """
+        try:
+            user = params['name']
+            response = OrderedDict()
+            response["status"] = True
+            response["data"] = "Hello {0}!".format(user)
+
+            return Response(response, content_type="application/json")
+        except BaseException as e:
+            response = OrderedDict()
+            response["status"] = False
+            response["mensagem"] = str(e)
+
+            return Response(response, content_type="application/json", status=500)
 
-        return Response(response, content_type="application/json")
 ```
+### Run django
+```shell
+python manage.py runserver
+August 02, 2017 - 18:48:00
+Django version 1.10.4, using settings 'Demo.settings'
+Starting development server at http://127.0.0.1:8000/
+Quit the server with CONTROL-C.
+```
+
+### Sample requests
+
+```shell
+curl http://localhost:8000/
+<center><h1>HTTP/1.1 200 OK RINZLER FRAMEWORK</h1></center>
+
+curl http://localhost:8000/hello/world/
+{
+  "status": true,
+  "data": "Hello World!"
+}
+
+curl http://localhost:8000/hello/bob/
+{
+  "status": true,
+  "data": "Hello bob!"
+}
+
+curl http://localhost:8000/foo/bar/
+{
+  "status": false,
+  "exceptions": {
+    "message": "No route found for GET foo/bar/"
+  },
+  "request": {
+    "content": "",
+    "method": "GET",
+    "path_info": "foo/bar/"
+  },
+  "message": "We are sorry, but something went terribly wrong."
+}
+
+```

rinzler/__init__.py

@@ -1,3 +1,20 @@
+import os
+
+from .logger.log import Log
+from .core.url_assembler import UrlAssembler
+
 __name__ = "Rinzler REST Framework"
 __version__ = "1.12.0"
 __author__ = "Rinzler"
+
+
+def boot(base_path: str()):
+    logger = Log(os.path.realpath(base_path) + "/log").get_logger()
+    url_assembler = UrlAssembler().set_logger(logger)
+
+    logger.info("App booted =)")
+
+    return {
+        'url_assembler': url_assembler,
+        'log': logger
+    }

rinzler/core/router.py

@@ -1,6 +1,8 @@
 """
 CallbackResolver service module
 """
+import codecs
+import os
 import re
 from collections import OrderedDict
 
@@ -18,9 +20,10 @@ class Router(TemplateView):
     __request = None
     __callable = None
     __app = dict()
-    __route = None
-    __uri = None
-    __method = None
+    __route = str()
+    __end_point_uri = str()
+    __uri = str()
+    __method = str()
     __bound_routes = dict()
     __auth_service = None
     __allowed_headers = "Authorization, Content-Type, If-Match, If-Modified-Since, If-None-Match, If-Unmodified-Since," \
@@ -30,7 +33,6 @@ class Router(TemplateView):
     def __init__(self, route, controller):
         self.__route = route
         self.__callable = controller
-        self.__app['router'] = object()
 
     @csrf_exempt
     def route(self, request: HttpRequest):
@@ -44,28 +46,33 @@ def route(self, request: HttpRequest):
         self.__method = request.method
         self.__app['router'] = RouteMapping()
         self.__bound_routes = dict()
+        self.__app['log'].set_signature(codecs.encode(os.urandom(3), "hex").decode("utf-8").upper())
 
         routes = self.__callable().connect(self.__app)
 
         self.__bound_routes = routes['router'].get__routes()
 
-        end_point = self.get_end_point_uri()
-        acutal_params = self.get_url_params(end_point)
-
         request_headers = request.META
         indent = 2 if re.match("[Mozilla]{7}", request_headers['HTTP_USER_AGENT']) else 0
 
+        if self.set_end_point_uri() is False:
+            return self.set_response_headers(self.no_route_found(self.__request).render(indent))
+
+        acutal_params = self.get_url_params(self.get_end_point_uri())
+
         try:
             response = self.exec_route_callback(acutal_params)
             if type(response) == Response:
                 return self.set_response_headers(response.render(indent))
             else:
                 return self.set_response_headers(response)
         except AuthException as e:
+            self.__app['log'].warning("< {0}: 403".format(str(e)), exc_info=True)
             response = Response(OrderedDict({"status": False, "message": str(e)}), content_type="application/json",
                                 status=403, charset="utf-8")
             return self.set_response_headers(response.render(indent))
         except BaseException as e:
+            self.__app['log'].error("< {0}: 500".format(str(e)), exc_info=True)
             response = Response(OrderedDict({"status": False, "message": str(e)}), content_type="application/json",
                                 status=500, charset="utf-8")
             return self.set_response_headers(response.render(indent))
@@ -74,7 +81,7 @@ def exec_route_callback(self, actual_params):
         """
         Executes the resolved end-point callback, or its fallback
         :param actual_params dict
-        :rtype: Object
+        :rtype: object
         """
         if self.__method.lower() in self.__bound_routes:
             for bound in self.__bound_routes[self.__method.lower()]:
@@ -83,6 +90,7 @@ def exec_route_callback(self, actual_params):
                 expected_params = self.get_url_params(route)
 
                 if self.request_matches_route(self.get_end_point_uri(), route):
+                    self.__app['log'].info("> {0} {1}".format(self.__method, self.__uri))
                     authenticate = self.authenticate(route, actual_params)
                     if authenticate:
                         pattern_params = self.get_callback_pattern(expected_params, actual_params)
@@ -91,6 +99,7 @@ def exec_route_callback(self, actual_params):
                         return authenticate
 
         if self.__method == "OPTIONS":
+            self.__app['log'].info("Route matched: {0} {1}".format(self.__method, self.__uri))
             return self.default_route_options(self.__request)
 
         if self.__route == '' and self.__uri == '':
@@ -131,7 +140,8 @@ def authenticate(self, bound_route, actual_params):
             auth_route = "{0}_{1}{2}".format(self.__method, self.__route, bound_route)
             auth_data = self.__auth_service.authenticate(self.__request, auth_route, actual_params)
             self.__app['auth_data'] = auth_data
-            return True
+
+        return True
 
     @staticmethod
     def get_callback_pattern(expected_params, actual_params):
@@ -171,12 +181,29 @@ def get_url_params(end_point):
             return params
 
     def get_end_point_uri(self):
+        """
+        Returns the value of __end_point_uri
+        :rtype: str
+        """
+        return self.__end_point_uri
+
+    def set_end_point_uri(self):
         """
         Gets the route from the accessed URL
         :rtype: str
         """
+        expected_parts = self.__route.split("/")
+        actual_parts = self.__uri.split("/")
+
+        i = 0
+        for part in expected_parts:
+            if part != actual_parts[i]:
+                return False
+            i = i + 1
+
         uri_prefix = len(self.__route)
-        return self.__uri[uri_prefix:]
+        self.__end_point_uri = self.__uri[uri_prefix:]
+        return True
 
     def no_route_found(self, request):
         """
@@ -240,6 +267,10 @@ def set_response_headers(self, response: HttpResponse):
         for key in response_headers:
             response[key] = response_headers[key]
 
+        status = response.status_code
+        if status != 404:
+            self.__app['log'].info("< {0}".format(status))
+
         return response
 
     def auth_config(self, auth_service: object):
@@ -250,3 +281,12 @@ def auth_config(self, auth_service: object):
         """
         self.__auth_service = auth_service
         return self
+
+    def register(self, name: str(), handler: object(), force=False):
+        if name in self.__app:
+            if force is True:
+                self.__app[name] = handler
+        else:
+            self.__app[name] = handler
+
+        return self

rinzler/core/url_assembler.py

@@ -6,13 +6,18 @@
 class UrlAssembler(object):
 
     auth_service = None
+    base_path = str()
+    logger = object
 
     def mount(self, route, callback):
         """
         Mounts a route with the given params
         :rtype: urls
         """
-        return url(r'{0}'.format(route), Router(route, callback).auth_config(self.auth_service).route)
+        return url(
+            r'{0}'.format(route),
+            Router(route, callback).register('log', self.logger).auth_config(self.auth_service).route
+        )
 
     def set_auth_service(self, auth_service):
         """
@@ -21,3 +26,7 @@ def set_auth_service(self, auth_service):
         """
         self.auth_service = auth_service
         return self
+
+    def set_logger(self, logger: object()):
+        self.logger = logger
+        return self