jaaql-middleware-python 4.31.0__tar.gz → 4.32.1__tar.gz

{jaaql-middleware-python-4.31.0 → jaaql_middleware_python-4.32.1}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: jaaql-middleware-python
-Version: 4.31.0
+Version: 4.32.1
 Summary: The jaaql package, allowing for rapid development and deployment of RESTful HTTP applications
 Home-page: https://github.com/JAAQL/JAAQL-middleware-python
 Author: Software Quality Measurement and Improvement bv
@@ -10,7 +10,7 @@ Description-Content-Type: text/markdown
 License-File: LICENSE.txt
 Requires-Dist: jaaql-monitor~=1.6.3
 Requires-Dist: psycopg[binary]~=3.1.18
-Requires-Dist: Pillow~=10.3.0
+Requires-Dist: Pillow~=11.2.1
 Requires-Dist: cryptography~=44.0.2
 Requires-Dist: flask~=3.1.0
 Requires-Dist: coverage~=7.4.3
@@ -33,6 +33,15 @@ Requires-Dist: jwcrypto~=1.5.6
 Requires-Dist: jinja2~=3.1.6
 Requires-Dist: idna~=3.10
 Requires-Dist: certifi~=2025.1.31
+Dynamic: author
+Dynamic: author-email
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: summary
 
 # JAAQL-middleware-python
 Please navigate to docker/docker.md to see setup instructions  

{jaaql-middleware-python-4.31.0 → jaaql_middleware_python-4.32.1}/jaaql/constants.py

@@ -45,6 +45,14 @@ KEY__registered = "registered"
 KEY__restrictions = "restrictions"
 KEY__command = "command"
 KEY__args = "args"
+KEY__document_id = "document_id"
+KEY__as_attachment = "as_attachment"
+KEY__create_file = "create_file"
+KEY__attachment_name = "name"
+KEY__filename = "filename"
+KEY__completed = "completed"
+KEY__content = "content"
+KEY__render_as = "render_as"
 
 CRON_minute = "minute"
 CRON_hour = "hour"
@@ -183,5 +191,5 @@ ROLE__postgres = "postgres"
 
 PROTOCOL__postgres = "postgresql://"
 
-VERSION = "4.31.0"
+VERSION = "4.32.1"
 

{jaaql-middleware-python-4.31.0 → jaaql_middleware_python-4.32.1}/jaaql/documentation/documentation_public.py

@@ -423,3 +423,113 @@ DOCUMENTATION__webhook = SwaggerDocumentation(
         )
     ]
 )
+
+EXAMPLE__document_id = "b47dc954-d608-4e1b-8a8c-d8b754ee554b"
+
+ARG_RES__document_id = SwaggerArgumentResponse(
+    name=KEY__document_id,
+    description="A document that can be used to fetch the document",
+    arg_type=str,
+    example=EXAMPLE__document_id
+)
+
+ARG_RES__renderable_document = [
+    SwaggerArgumentResponse(
+        name=KEY__attachment_name,
+        description="The name of the renderable document in the database",
+        arg_type=str,
+        example=["my_pdf_template"]
+    ),
+    SwaggerArgumentResponse(
+        name=KEY__parameters,
+        description="Any parameters to pass to the url as http GET parameters",
+        arg_type=ARG_RESP__allow_all
+    )
+]
+
+DOCUMENTATION__document = SwaggerDocumentation(
+    tags="Documents",
+    methods=[
+        SwaggerMethod(
+            name="Triggers a document render",
+            description="Triggers a render of a document which can then be downloaded. Document is available for 5 minutes after the document has "
+            "been rendered",
+            method=REST__POST,
+            body=ARG_RES__renderable_document + [
+                SwaggerArgumentResponse(
+                    name=KEY__create_file,
+                    description="Whether or not to create the file. You will then be provided with a URL when it is ready which can be downloaded "
+                                "from. Otherwise you will be sent back a boolean",
+                    arg_type=bool
+                ),
+                SwaggerArgumentResponse(
+                    name=KEY__application,
+                    description="The application of the document template",
+                    arg_type=str,
+                    example=["out-and-about"]
+                )
+            ],
+            response=SwaggerResponse(
+                description="A document id",
+                response=ARG_RES__document_id
+            )
+        ),
+        SwaggerMethod(
+            name="Download document",
+            description="Downloads the document. Can also be used as a polling endpoint to see if the document is ready",
+            method=REST__GET,
+            arguments=[
+                ARG_RES__document_id,
+                SwaggerArgumentResponse(
+                    name=KEY__as_attachment,
+                    description="Whether in the browser the 'Content-Disposition' header should be set as attachment",
+                    arg_type=bool,
+                    required=False,
+                    condition="Defaults to false"
+                )
+            ],
+            response=[
+                SwaggerFlatResponse(
+                    description="A link to the raw file data. This URL is called with GET and no security parameters. Can only be called once",
+                    body="https://www.jaaql.io/api/rendered_documents/" + EXAMPLE__document_id + ".pdf"
+                ),
+                SwaggerFlatResponse(
+                    description="The url to the document. Will be deleted after 5 minutes",
+                    code=HTTPStatus.CREATED,
+                    body="https://www.jaaql.io/rendered_documents/" + EXAMPLE__document_id + ".pdf"
+                ),
+                SwaggerFlatResponse(
+                    description="Document still rendering",
+                    code=HTTPStatus.TOO_EARLY,
+                    body=ERR__document_still_rendering
+                ),
+                SwaggerFlatResponse(
+                    description="Document id not found. Either expired or did not exist",
+                    body=ERR__document_id_not_found,
+                    code=HTTPStatus.NOT_FOUND
+                )
+            ]
+        )
+    ]
+)
+
+DOCUMENTATION__rendered_document = SwaggerDocumentation(
+    tags="Documents",
+    security=False,
+    methods=SwaggerMethod(
+        name="Stream rendered document",
+        description="Streams a rendered document as a downlaod",
+        method=REST__GET,
+        arguments=[ARG_RES__document_id, SwaggerArgumentResponse(
+            name=KEY__as_attachment,
+            description="Whether in the browser the 'Content-Disposition' header should be set as attachment",
+            arg_type=bool,
+            required=False,
+            condition="Defaults to false"
+        )],
+        response=SwaggerFlatResponse(
+            description="The raw file data. Cannot be re-downloaded after this",
+            body=BODY__file
+        )
+    )
+)

{jaaql-middleware-python-4.31.0 → jaaql_middleware_python-4.32.1}/jaaql/email/email_manager_service.py

@@ -1,7 +1,8 @@
-import os
 import traceback
 import uuid
 import time
+from http import HTTPStatus
+from urllib.parse import urlparse
 
 from selenium.common.exceptions import NoSuchElementException
 from datetime import datetime
@@ -67,6 +68,15 @@ KEY__attachment_application = "application"
 KEY__template_base = "template_base"
 
 
+QUERY__purge_rendered_documents = "DELETE FROM document_request rd USING document_template able WHERE rd.template = able.name AND completed is not null and completed > current_timestamp + interval '5 minutes' RETURNING rd.uuid as document_id, rd.create_file, 'pdf' as render_as"
+QUERY__fetch_unrendered_document = "SELECT able.content_path as url, a.base_url, 'pdf' as render_as, rd.uuid as document_id, rd.encrypted_parameters as parameters, rd.create_file, rd.encrypted_access_token as oauth_token FROM document_request rd INNER JOIN document_template able ON rd.template = able.name INNER JOIN application a ON rd.application = a.name WHERE rd.completed is null ORDER BY rd.request_timestamp LIMIT 1"
+QUERY__mark_rendered_document_completed = "UPDATE document_request SET completed = current_timestamp, file_name = :file_name, content = :content WHERE uuid = :document_id"
+QUERY__mark_rendered_document_completed_with_error = "UPDATE document_request SET completed = current_timestamp WHERE uuid = :document_id"
+
+
+CHROME_DEBUGGING = True
+
+
 class DrivenChrome:
     def __init__(self, db_interface: DBInterface, db_key: bytes, is_deployed: bool):
         self.attachments = Queue()
@@ -79,9 +89,21 @@ class DrivenChrome:
         self.db_key = db_key
         self.template_dir_path = os.path.join(DIR__www, DIR__render_template)
 
-        self.a4_params = {'landscape': False, 'paperWidth': 8.27, 'paperHeight': 11.69, 'printBackground': True}
+        self.a4_params = {
+            "landscape": False,
+            "paperWidth": 8.27,  # A-4 portrait
+            "paperHeight": 11.69,
+            "marginTop": 0,  # remove default 1 cm margins
+            "marginBottom": 0,
+            "marginLeft": 0,
+            "marginRight": 0,
+            "scale": 0.8,
+            "printBackground": True,  # keep gradient / images
+            "preferCSSPageSize": True  # honour @page { size:A4; margin:0 }
+        }
 
         threading.Thread(target=self.start_chrome, daemon=True).start()
+        threading.Thread(target=self.purge_rendered_documents, daemon=True).start()
 
     def parameters_to_get_str(self, access_token: str, parameters: dict):
         if parameters is None:
@@ -90,9 +112,25 @@ class DrivenChrome:
 
         return "?" + "&".join([key + "=" + quote(itm if isinstance(itm, bytes) else itm.encode("UTF-8")) for key, itm in parameters.items()])
 
-    def chrome_page_to_pdf(self, url: str, access_token: str, parameters: dict):
+    def chrome_page_to_pdf(self, url: str, access_token: str, parameters: dict, document_id: str):
         with self.chrome_lock:
-            self.driver.get(url + self.parameters_to_get_str(access_token, parameters))
+            origin = "{uri.scheme}://{uri.netloc}".format(uri=urlparse(url))
+            self.driver.execute_cdp_cmd(
+                "Storage.clearDataForOrigin",
+                {
+                    "origin": origin,
+                    "storageTypes": "local_storage,session_storage"
+                }
+            )
+
+            old_handle = self.driver.current_window_handle
+            self.driver.switch_to.new_window('tab')
+            self.driver.switch_to.window(old_handle)
+            self.driver.close()
+            survivor_handles = [h for h in self.driver.window_handles if h != old_handle]
+            self.driver.switch_to.window(survivor_handles[0])
+
+            self.driver.get(url + self.parameters_to_get_str(access_token, parameters) + "&BS_document_id=" + document_id)
             start_time = datetime.now()
             while True:
                 passed = False
@@ -122,13 +160,79 @@ class DrivenChrome:
 
                     if time_delta_ms(start_time, datetime.now()) > TIMEOUT__attachment_render:
                         raise HttpStatusException(ERR__attachment_timeout_render)
+                    else:
+                        time.sleep(0.1)
 
-            return filename, base64.b64decode(self.driver.execute_cdp_cmd("Page.printToPDF", self.a4_params)["data"])
+            pdf_data = base64.b64decode(self.driver.execute_cdp_cmd("Page.printToPDF", self.a4_params)["data"])
+            self.driver.execute_cdp_cmd("HeapProfiler.collectGarbage", {})
+            return filename, pdf_data
+
+    def purge_rendered_documents(self):
+        while True:
+            resp = execute_supplied_statement(self.db_interface, QUERY__purge_rendered_documents, as_objects=True)
+            for to_purge in resp:
+                if to_purge[KEY__create_file]:
+                    try:
+                        os.remove(os.path.join(self.template_dir_path,
+                                               str(to_purge[KEY__document_id]) + "." + to_purge[KEY__render_as]))
+                    except FileNotFoundError:
+                        pass
+            time.sleep(5)
+
+    def render_document_requests(self):
+        while True:
+            resp = None
+            try:
+                resp = execute_supplied_statement_singleton(self.db_interface, QUERY__fetch_unrendered_document,
+                                                            as_objects=True,
+                                                            decrypt_columns=[KEY__parameters, KEY__oauth_token],
+                                                            encryption_key=self.db_key)
+                parameters = {}
+                if resp[KEY__parameters]:
+                    parameters = json.loads(resp[KEY__parameters])
+
+                base_url = EmailAttachment.static_format_attached_url(resp[KG__application__base_url] + "/" + resp["url"], self.is_deployed)
+
+                filename, content = self.chrome_page_to_pdf(base_url, resp[KEY__oauth_token], parameters, str(resp[KEY__document_id]))
+
+                inputs = {KEY__document_id: resp[KEY__document_id], KEY__content: None, KG__document_request__file_name: filename}
+                if resp[KEY__create_file]:
+                    if not os.path.exists(self.template_dir_path):
+                        os.mkdir(self.template_dir_path)
+                    with open(os.path.join(self.template_dir_path,
+                                           str(resp[KEY__document_id]) + "." + resp[KEY__render_as]), "wb") as f:
+                        f.write(content)
+                else:
+                    inputs[KEY__content] = content
+
+                execute_supplied_statement(self.db_interface, QUERY__mark_rendered_document_completed, inputs)
+            except HttpStatusException as ex:
+                if ex.response_code == HTTPStatus.UNPROCESSABLE_ENTITY:
+                    if resp is not None:
+                        execute_supplied_statement(self.db_interface,
+                            QUERY__mark_rendered_document_completed_with_error,
+                            { KEY__document_id: resp[KEY__document_id] })
+                    time.sleep(0.25)
+                else:
+                    traceback.print_exc()
 
     def start_chrome(self):
         options = Options()
         options.add_argument("--window-size=1920,1080")
-        options.headless = True
+        options.add_argument("--force-color-profile=srgb")
+        options.add_argument("--font-render-hinting=none")
+        options.add_argument("--disable-gpu")
+        options.add_argument("--disable-dev-shm-usage")  # ✱ stop /dev/shm exhaustion
+        options.add_argument("--disable-extensions")
+        options.add_argument("--headless=new")
+        if CHROME_DEBUGGING:
+            options.add_argument("--enable-logging=stderr")
+            options.add_argument("--v=1")
+            options.set_capability(
+                "goog:loggingPrefs",
+                {"browser": "ALL", "performance": "ALL"}
+            )
+
         service_args = []
 
         if self.is_deployed:
@@ -136,6 +240,7 @@ class DrivenChrome:
 
         with webdriver.Chrome(options=options, service=Service(service_args=service_args)) as driver:
             self.driver = driver
+            threading.Thread(target=self.render_document_requests, daemon=True).start()
             while True:
                 current_attachment: 'EmailAttachment' = self.attachments.get()
                 try:
@@ -144,7 +249,7 @@ class DrivenChrome:
                     if not content_path.endswith(".html"):
                         content_path += ".html"
                     content_path = current_attachment.template_base + "/" + content_path
-                    filename, content = self.chrome_page_to_pdf(content_path, current_attachment.access_token, current_attachment.parameters)
+                    filename, content = self.chrome_page_to_pdf(content_path, current_attachment.access_token, current_attachment.parameters, str(uuid.uuid4()))
                     current_attachment.content = content
                     current_attachment.filename = filename
                 except HttpStatusException as ex:

{jaaql-middleware-python-4.31.0 → jaaql_middleware_python-4.32.1}/jaaql/mvc/controller.py

@@ -182,3 +182,14 @@ class JAAQLController(BaseJAAQLController):
         @self.publish_route('/.well-known/jwks', DOCUMENTATION__jwks)
         def fetch_jwks():
             return self.model.fetch_jwks()
+
+        @self.publish_route('/documents', DOCUMENTATION__document)
+        def documents(http_inputs: dict, auth_token: str, ip_address: str, response: JAAQLResponse):
+            if self.is_get():
+                return self.model.fetch_document(http_inputs, response)
+            else:
+                return self.model.render_document(http_inputs, auth_token, ip_address)
+
+        @self.publish_route('/rendered_documents', DOCUMENTATION__rendered_document)
+        def documents(http_inputs: dict):
+            return self.model.fetch_document_stream(http_inputs)

{jaaql-middleware-python-4.31.0 → jaaql_middleware_python-4.32.1}/jaaql/mvc/exception_queries.py

@@ -1,5 +1,5 @@
 """
-This script was generated from jaaql.exceptions.fxli at 2025-04-14, 14:08:43
+This script was generated from jaaql.exceptions.fxli at 2025-05-21, 11:25:44
 """
 
 from jaaql.utilities.crypt_utils import get_repeatable_salt

{jaaql-middleware-python-4.31.0 → jaaql_middleware_python-4.32.1}/jaaql/mvc/generated_queries.py

@@ -1,5 +1,5 @@
 """
-This script was generated from build_and_run.fxls at 2025-04-14, 14:08:43
+This script was generated from build_and_run.fxls at 2025-05-21, 11:25:44
 """
 
 from jaaql.db.db_interface import DBInterface
@@ -717,17 +717,18 @@ KG__document_request__render_timestamp = "render_timestamp"
 KG__document_request__create_file = "create_file"
 KG__document_request__file_name = "file_name"
 KG__document_request__content = "content"
+KG__document_request__completed = "completed"
 
 # Generated queries for table 'document_request'
 QG__document_request_delete = "DELETE FROM document_request WHERE uuid = :uuid"
 QG__document_request_insert = """
-    INSERT INTO document_request (application, template, uuid,
-        encrypted_access_token, encrypted_parameters, render_timestamp,
-        create_file, file_name, content)
-    VALUES (:application, :template, :uuid,
-        :encrypted_access_token, :encrypted_parameters, :render_timestamp,
-        :create_file, :file_name, :content)
-    RETURNING request_timestamp
+    INSERT INTO document_request (application, template, encrypted_access_token,
+        encrypted_parameters, render_timestamp, create_file,
+        file_name, content, completed)
+    VALUES (:application, :template, :encrypted_access_token,
+        :encrypted_parameters, :render_timestamp, :create_file,
+        :file_name, :content, :completed)
+    RETURNING uuid, request_timestamp
 """
 QG__document_request_select_all = "SELECT * FROM document_request"
 QG__document_request_select = "SELECT * FROM document_request WHERE uuid = :uuid"
@@ -743,7 +744,8 @@ QG__document_request_update = """
         render_timestamp = COALESCE(:render_timestamp, render_timestamp),
         create_file = COALESCE(:create_file, create_file),
         file_name = COALESCE(:file_name, file_name),
-        content = COALESCE(:content, content)
+        content = COALESCE(:content, content),
+        completed = COALESCE(:completed, completed)
     WHERE
         uuid = :uuid
 """
@@ -769,6 +771,7 @@ def document_request__update(
     application=None, template=None, request_timestamp=None,
     encrypted_access_token=None, encrypted_parameters=None, render_timestamp=None,
     create_file=None, file_name=None, content=None,
+    completed=None,
     encryption_salts=None
 ):
     execute_supplied_statement(
@@ -786,7 +789,8 @@ def document_request__update(
             KG__document_request__render_timestamp: render_timestamp,
             KG__document_request__create_file: create_file,
             KG__document_request__file_name: file_name,
-            KG__document_request__content: content
+            KG__document_request__content: content,
+            KG__document_request__completed: completed
         }, encryption_key=encryption_key, encryption_salts=encryption_salts, encrypt_parameters=[
             KG__document_request__encrypted_access_token,
             KG__document_request__encrypted_parameters
@@ -826,10 +830,10 @@ def document_request__select_all(
 
 def document_request__insert(
     connection: DBInterface, encryption_key: bytes,
-    application, template, uuid,
-    encrypted_access_token, create_file,
+    application, template, encrypted_access_token,
+    create_file,
     encrypted_parameters=None, render_timestamp=None, file_name=None,
-    content=None,
+    content=None, completed=None,
     encryption_salts=None
 ):
     return execute_supplied_statement_singleton(
@@ -837,13 +841,13 @@ def document_request__insert(
         {
             KG__document_request__application: application,
             KG__document_request__template: template,
-            KG__document_request__uuid: uuid,
             KG__document_request__encrypted_access_token: encrypted_access_token,
             KG__document_request__encrypted_parameters: encrypted_parameters,
             KG__document_request__render_timestamp: render_timestamp,
             KG__document_request__create_file: create_file,
             KG__document_request__file_name: file_name,
-            KG__document_request__content: content
+            KG__document_request__content: content,
+            KG__document_request__completed: completed
         }, encryption_key=encryption_key, encryption_salts=encryption_salts, encrypt_parameters=[
             KG__document_request__encrypted_access_token,
             KG__document_request__encrypted_parameters

{jaaql-middleware-python-4.31.0 → jaaql_middleware_python-4.32.1}/jaaql/mvc/model.py

@@ -13,6 +13,8 @@ import re
 
 import jwt
 from jwcrypto import jwe
+from io import BytesIO
+from flask import send_file
 
 from jwt import PyJWKClient
 
@@ -112,6 +114,10 @@ SIGNUP__completed = 3
 
 KEY__is_the_anonymous_user = "is_the_anonymous_user"
 
+QUERY__ins_rendered_document = "INSERT INTO document_request (encrypted_parameters, encrypted_access_token, template, create_file, application) VALUES (:parameters, :oauth_token, :name, :create_file, :application) RETURNING uuid as document_id"
+QUERY__purge_rendered_document = "DELETE FROM document_request WHERE completed is not null and uuid = :document_id RETURNING content"
+QUERY__fetch_rendered_document = "SELECT app.base_url, rd.uuid as document_id, 'pdf' as render_as, rd.file_name, rd.create_file, rd.completed, rd.encrypted_access_token as oauth_token FROM document_request rd INNER JOIN document_template able ON rd.template = able.name INNER JOIN application app ON app.name = rd.application WHERE rd.uuid = :document_id"
+
 
 class JAAQLModel(BaseJAAQLModel):
     VERIFICATION_QUEUE = None
@@ -1255,6 +1261,53 @@ WHERE
             KEY__username: account[KG__account__username]
         }
 
+    def fetch_document(self, inputs: dict, response: JAAQLResponse):
+        res = execute_supplied_statement_singleton(self.jaaql_lookup_connection, QUERY__fetch_rendered_document,
+                                                   {KEY__document_id: inputs[KEY__document_id]}, singleton_message=ERR__document_id_not_found,
+                                                   as_objects=True)
+
+        if not res[KEY__completed]:
+            raise HttpStatusException(ERR__document_still_rendering, HTTPStatus.TOO_EARLY)
+
+        if res[KEY__create_file]:
+            if inputs[KEY__as_attachment] is not None:
+                raise HttpStatusException(ERR__as_attachment_unexpected)
+            response.response_code = HTTPStatus.CREATED
+            return res[KG__application__base_url] + "/" + DIR__render_template + "/" + str(res[KEY__document_id]) + "." + res[KEY__render_as]
+        else:
+            return res[KG__application__base_url] + "/api/rendered_documents/" + res[KEY__document_id]
+
+    def fetch_document_stream(self, inputs: dict):
+        res = execute_supplied_statement_singleton(self.jaaql_lookup_connection, QUERY__fetch_rendered_document,
+                                                   {KEY__document_id: inputs[KEY__document_id]}, singleton_message=ERR__document_id_not_found,
+                                                   as_objects=True)
+
+        if not res[KEY__completed]:
+            raise HttpStatusException(ERR__document_still_rendering, HTTPStatus.TOO_EARLY)
+
+        if res[KEY__create_file]:
+            raise HttpStatusException(ERR__document_created_file)
+        else:
+            content = execute_supplied_statement_singleton(self.jaaql_lookup_connection, QUERY__purge_rendered_document,
+                                                           {KEY__document_id: inputs[KEY__document_id]}, as_objects=True)[KEY__content]
+            as_attachment = False
+            if inputs[KEY__as_attachment]:
+                as_attachment = True
+
+            buffer = BytesIO()
+            buffer.write(content)
+            buffer.seek(0)
+
+            return send_file(buffer, as_attachment=as_attachment, download_name=res[KEY__filename])
+
+    def render_document(self, inputs: dict, auth_token: str, ip_address: str):
+        inputs[KEY__oauth_token] = self.refresh_auth_token(auth_token, ip_address)
+        if inputs[KEY__parameters] is not None:
+            inputs[KEY__parameters] = json.dumps(inputs[KEY__parameters])
+        return execute_supplied_statement_singleton(self.jaaql_lookup_connection, QUERY__ins_rendered_document, inputs,
+                                                    encryption_key=self.get_db_crypt_key(), encrypt_parameters=[KEY__parameters, KEY__oauth_token],
+                                                    as_objects=True)
+
     def send_email(self, is_the_anonymous_user: bool, account_id: str, inputs: dict, username: str, auth_token: str):
         app = application__select(self.jaaql_lookup_connection, inputs[KEY__application])
 

{jaaql-middleware-python-4.31.0 → jaaql_middleware_python-4.32.1}/jaaql/scripts/01.install_domains.generated.sql

@@ -1,7 +1,7 @@
 --  This installation module was generated from ..\..\Packages/DBMS/Postgres/15/domains.jsql.fxlp for Postgres/15
 
 CREATE DOMAIN encrypted__email_server_password AS character varying(256);
-CREATE DOMAIN encrypted__access_token AS character varying(64);
+CREATE DOMAIN encrypted__access_token AS text;
 CREATE DOMAIN encrypted__oidc_client_id AS character varying(200);
 CREATE DOMAIN encrypted__oidc_client_secret AS character varying(200);
 CREATE DOMAIN encrypted__oidc_sub AS character varying(200);

{jaaql-middleware-python-4.31.0 → jaaql_middleware_python-4.32.1}/jaaql/scripts/04.install_jaaql_data_structures.generated.sql

@@ -143,7 +143,7 @@ create table document_template (
 create table document_request (
 	application internet_name not null,
 	template object_name not null,
-	uuid uuid not null,
+	uuid uuid not null default gen_random_uuid(),
 	request_timestamp timestamptz not null default current_timestamp,
 	encrypted_access_token encrypted__access_token not null,
 	encrypted_parameters text,
@@ -151,6 +151,7 @@ create table document_request (
 	create_file bool not null,
 	file_name file_name,
 	content bytea,
+	completed timestamptz,
 	primary key (uuid) );
 -- federation_procedure...
 create table federation_procedure (

{jaaql-middleware-python-4.31.0 → jaaql_middleware_python-4.32.1}/jaaql_middleware_python.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: jaaql-middleware-python
-Version: 4.31.0
+Version: 4.32.1
 Summary: The jaaql package, allowing for rapid development and deployment of RESTful HTTP applications
 Home-page: https://github.com/JAAQL/JAAQL-middleware-python
 Author: Software Quality Measurement and Improvement bv
@@ -10,7 +10,7 @@ Description-Content-Type: text/markdown
 License-File: LICENSE.txt
 Requires-Dist: jaaql-monitor~=1.6.3
 Requires-Dist: psycopg[binary]~=3.1.18
-Requires-Dist: Pillow~=10.3.0
+Requires-Dist: Pillow~=11.2.1
 Requires-Dist: cryptography~=44.0.2
 Requires-Dist: flask~=3.1.0
 Requires-Dist: coverage~=7.4.3
@@ -33,6 +33,15 @@ Requires-Dist: jwcrypto~=1.5.6
 Requires-Dist: jinja2~=3.1.6
 Requires-Dist: idna~=3.10
 Requires-Dist: certifi~=2025.1.31
+Dynamic: author
+Dynamic: author-email
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: summary
 
 # JAAQL-middleware-python
 Please navigate to docker/docker.md to see setup instructions  

{jaaql-middleware-python-4.31.0 → jaaql_middleware_python-4.32.1}/jaaql_middleware_python.egg-info/requires.txt

@@ -1,6 +1,6 @@
 jaaql-monitor~=1.6.3
 psycopg[binary]~=3.1.18
-Pillow~=10.3.0
+Pillow~=11.2.1
 cryptography~=44.0.2
 flask~=3.1.0
 coverage~=7.4.3