Merge pull request #24 from tmeiczin/tjm/auth

Tjm/auth

Author: tmeiczin

src/reliqua/example/resources/form.py

@@ -0,0 +1,36 @@
+"""
+Reliqua Framework.
+
+Copyright 2016-2024.
+"""
+
+from reliqua.resources.base import Resource
+
+
+class Contact(Resource):
+    """User resource."""
+
+    __routes__ = {
+        "/contact": {},
+    }
+
+    __tags__ = [
+        "contact",
+    ]
+
+    no_auth = True
+
+    def on_post(self, req, resp):
+        """
+        Send contact message.
+
+        :param str subject:      [in=form required=True]     Subject
+        :param str email:        [in=form required=True]     Sender email
+        :param str message:      [in=form required=True]     Message contents
+
+        :accepts form:
+        :return json:
+        """
+        p = req.params
+        if p.get("subject"):
+            resp.media = {"success": True}

src/reliqua/example/resources/users.py

@@ -88,7 +88,7 @@ class Users(Resource):
         "users",
     ]
 
-    __auth2__ = {
+    __auth__ = {
         "GET": ["admin"],
         "POST": ["admin"],
         "DELETE": ["admin"],
@@ -101,9 +101,10 @@ def on_get(self, req, resp):
         Return users.
 
         :param str username:      [in=query]  Username
-        :param str email:         [in=query default=ted@invalid.com]  Email
+        :param str email:         [in=query default=ted@nowhere.com]  Email
         :param list[int] ids:     [in=query] List of IDs
         :response 200 users:      Users were retrieved
+        :response 401:            Invalid Authorization
 
         :return json:
         """

src/reliqua/middleware.py

@@ -290,6 +290,24 @@ def process(self, request, parameters):
                 transform=transform,
             )
 
+    def process_form(self, form):
+        """
+        Process form data.
+
+        Process the fields from the form data.
+
+        :param MultipartForm form:    The multi-part form
+        """
+        data = {}
+
+        for part in form:
+            if part.content_type == "text/plain":
+                data[part.name] = part.text
+            if part.content_type == "application/json":
+                data[part.name] = part.get_media()
+
+        return data
+
     def process_resource(self, request, _response, resource, params):
         """
         Process resource.
@@ -308,6 +326,9 @@ def process_resource(self, request, _response, resource, params):
         for media_params in [params, request.get_media(default_when_empty=None)]:
             if isinstance(media_params, dict):
                 request.params.update(media_params)
+            elif isinstance(media_params, falcon.media.multipart.MultipartForm):
+                media_params = self.process_form(media_params)
+                request.params.update(media_params)
 
         # if resource has no schema, skip further processing
         if not schema:

src/reliqua/openapi.py

@@ -27,6 +27,7 @@ def camelcase(string):
     "jpeg": "image/jpeg",
     "png": "image/png",
     "gif": "image/gif",
+    "form": "multipart/form-data",
     "*/*": "*/*",
 }
 
@@ -114,6 +115,8 @@ def __init__(
         if self.location == "path":
             self.required = True
 
+        print(f"Parameter: {self.name} {self.location}")
+
     @property
     def datatype(self):
         """Return the parameter datatype."""
@@ -171,7 +174,7 @@ def in_request_body(self):
 
         :return bool:     True if in request body
         """
-        if self.location == "body":
+        if self.location in ["body", "form"]:
             return True
 
         return False
@@ -289,8 +292,18 @@ def __init__(
         self.parameters = [Parameter(**x) for x in parameters or []]
         self.responses = [Response(**x) for x in responses or []]
         self.return_type = return_type
-        self.accepts = accepts or "*/*"
-        self.body = {x.name: x.dict() for x in self.parameters if x.in_request_body()}
+        self._accepts = accepts
+        self.request_body_parameters = {x.name: x.dict() for x in self.parameters if x.in_request_body()}
+
+    @property
+    def accepts(self):
+        """Return accepts type."""
+        if self._accepts:
+            return self._accepts
+        if self.has_form():
+            return "form"
+
+        return "*/*"
 
     def binary_body(self):
         """Return binary body."""
@@ -306,20 +319,30 @@ def binary_body(self):
             }
         }
 
-    def json_body(self):
-        """Return JSON body."""
+    def has_form(self):
+        """
+        Return whether operation has form data.
+
+        Return `True` if the operation has form data parameters.
+
+        :return bool:     True if has form data
+        """
+        return [x for x in self.parameters if x.location == "form"] != []
+
+    def body(self):
+        """Return request body."""
         accepts = CONTENT_MAP.get(self.accepts)
         return {
             "description": self.description,
-            "content": {accepts: {"schema": {"type": "object", "properties": self.body}}},
+            "content": {accepts: {"schema": {"type": "object", "properties": self.request_body_parameters}}},
         }
 
     def request_body(self):
         """Return request body."""
-        if self.accepts == "binary":
+        if self.accepts in ["binary"]:
             return self.binary_body()
 
-        return self.json_body()
+        return self.body()
 
     def dict(self):
         """Return dict of data."""
@@ -331,7 +354,7 @@ def dict(self):
             "parameters": [x.dict() for x in self.parameters if not x.in_request_body()],
             "responses": {x.code: x.dict() for x in self.responses},
         }
-        if self.body:
+        if self.request_body_parameters:
             operation["requestBody"] = self.request_body()
 
         return {self.operation: operation}

src/reliqua/sphinx_parser.py

@@ -14,10 +14,10 @@
     r"^(:param.*?:.*?)(?:(?=:param)|(?=:return)|(?=:response)|(?=:accepts))",
     re.MULTILINE | re.DOTALL,
 )
-RESPONSE_ITER_REGEX = re.compile(r":response\s+(?P<code>\d+)\s*(?P<schema>\w+)?:\s+(?P<description>\w+)")
-RETURN_REGEX = re.compile(r"return\s+(\w+):|:return:\s+(\w+)")
+RESPONSE_ITER_REGEX = re.compile(r":response\s+(?P<code>\d+)\s*(?P<schema>\w+)?:\s+(?P<description>.*)")
+RETURN_REGEX = re.compile(r"return\s+(\w+):|:return:\s+(.*)")
 ACCEPT_REGEX = re.compile(r"accepts\s+(\w+):|:accepts:\s+(\w+)")
-KEYVALUE_REGEX = re.compile(r"(?P<key>\w+)=(?P<value>\w+)")
+KEYVALUE_REGEX = re.compile(r"(?P<key>\w+)=(?P<value>\S+)")
 OPERATION_REGEX = re.compile(r"on_(delete|get|patch|post|put)")
 SUFFIX_REGEX = re.compile(r"on_(?:delete|get|patch|post|put)_([a-zA-Z0-9_]+)")