jaaql-middleware-python 4.24.0__tar.gz → 4.24.2__tar.gz

{jaaql-middleware-python-4.24.0/jaaql_middleware_python.egg-info → jaaql-middleware-python-4.24.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: jaaql-middleware-python
-Version: 4.24.0
+Version: 4.24.2
 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
@@ -8,9 +8,9 @@ Author-email: aaron.tasker@sqmi.nl
 License: Mozilla Public License Version 2.0 with Commons Clause
 Description-Content-Type: text/markdown
 License-File: LICENSE.txt
-Requires-Dist: jaaql-monitor~=1.3.5
+Requires-Dist: jaaql-monitor~=1.4.17
 Requires-Dist: psycopg[binary]~=3.1.18
-Requires-Dist: Pillow~=10.2.0
+Requires-Dist: Pillow~=10.3.0
 Requires-Dist: cryptography~=42.0.5
 Requires-Dist: flask~=3.0.2
 Requires-Dist: coverage~=7.4.3

{jaaql-middleware-python-4.24.0 → jaaql-middleware-python-4.24.2}/jaaql/constants.py

@@ -180,5 +180,5 @@ ROLE__postgres = "postgres"
 
 PROTOCOL__postgres = "postgresql://"
 
-VERSION = "4.24.0"
+VERSION = "4.24.2"
 

jaaql-middleware-python-4.24.2/jaaql/migrations/migrations.py

@@ -0,0 +1,87 @@
+import os
+
+from jaaql.db.db_interface import DBInterface
+from jaaql.utilities.utils import time_delta_ms, get_jaaql_root
+from datetime import datetime
+from os.path import join
+from os import listdir
+from monitor.main import initialise, MARKER__bypass, MARKER__jaaql_bypass, DEFAULT_CONNECTION
+from jaaql.constants import USERNAME__jaaql, USERNAME__super_db, DB__jaaql, DB__postgres, USERNAME__superuser
+from jaaql.mvc.generated_queries import jaaql__select, KG__jaaql__migration_version, jaaql__update
+
+
+MIGRATION_HISTORY = "migration_history"
+
+
+QUERY_LOAD_TABLE = "SELECT * FROM %s WHERE project_name = :project_name" % MIGRATION_HISTORY
+ATTR_PROJECT_NAME = "project_name"
+QUERY_INS_TABLE = "INSERT INTO %s (project_name, installed_rank, version, description, script, checksum, execution_time) VALUES (:project_name, :installed_rank, :version, :description, :script, :checksum, :execution_time)" % MIGRATION_HISTORY
+ATTR_INSTALLED_RANK = "installed_rank"
+ATTR_VERSION = "version"
+ATTR_DESCRIPTION = "description"
+ATTR_SCRIPT = "script"
+ATTR_CHECKSUM = "checksum"
+ATTR_EXECUTION_TIME = "execution_time"
+PATH_MIGRATIONS = "migrations"
+PATH_SCRIPTS = "scripts"
+SCRIPT_MIGRATION_HISTORY = "migration_history.sql"
+EXTENSION_JAAQL = ".jaaql"
+
+VERSION_SPLIT = "__"
+WORD_SPLIT = "_"
+
+
+def compare_versions(version1, version2):
+    # Split the version strings into major, minor, and patch
+    v1_parts = [int(part) for part in version1.split('.')]
+    v2_parts = [int(part) for part in version2.split('.')]
+
+    # Pad the versions to ensure both have the same length (e.g., handle cases like '1.0' vs '1.0.0')
+    while len(v1_parts) < len(v2_parts):
+        v1_parts.append(0)
+    while len(v2_parts) < len(v1_parts):
+        v2_parts.append(0)
+
+    # Compare major, minor, and patch versions
+    for i in range(len(v1_parts)):
+        if v1_parts[i] < v2_parts[i]:
+            return -1
+        elif v1_parts[i] > v2_parts[i]:
+            return 1
+
+    return 0
+
+
+def run_migrations(host: str, bypass_super: str, bypass_jaaql: str, db_interface: DBInterface):
+    migration_folder = join(get_jaaql_root(), PATH_MIGRATIONS, PATH_SCRIPTS)
+    print("Launching migration manager on folder: " + migration_folder)
+
+    jaaql_singleton = jaaql__select(db_interface)
+    migration_from_version = "0.0.0"
+    if KG__jaaql__migration_version in jaaql_singleton:
+        migration_from_version = jaaql_singleton[KG__jaaql__migration_version]
+
+    script_files = sorted([script_file for script_file in listdir(migration_folder) if
+                           script_file.endswith(EXTENSION_JAAQL)])
+    for script_file in script_files:
+        script_file_version = ".".join(script_file.split(".")[:-1]).split("__")[0]
+        if compare_versions(migration_from_version, script_file_version) >= 0:
+            print("Migration " + script_file_version + " already installed")
+            continue
+
+        print("Installing migration " + script_file_version)
+
+        actual_file_name = join(migration_folder, script_file)
+
+        encoded_configs = [[DEFAULT_CONNECTION, host, USERNAME__jaaql, MARKER__jaaql_bypass + bypass_jaaql, DB__jaaql],
+                           [USERNAME__jaaql, host, USERNAME__jaaql, MARKER__jaaql_bypass + bypass_jaaql, DB__jaaql],
+                           ["dba", host, USERNAME__jaaql, MARKER__jaaql_bypass + bypass_jaaql, DB__jaaql],
+                           ["dba_db", host, USERNAME__jaaql, MARKER__jaaql_bypass + bypass_jaaql, DB__jaaql],
+                           [USERNAME__superuser, host, USERNAME__super_db, MARKER__bypass + bypass_super, DB__postgres]]
+
+        start_time = datetime.now()
+        initialise(actual_file_name, configs=[], encoded_configs=encoded_configs, override_url=host)
+
+        execution_time = time_delta_ms(start_time, datetime.now())
+        print("Executed migration " + script_file + " in " + str(execution_time) + "ms")
+        jaaql__update(db_interface, migration_version=script_file_version)

{jaaql-middleware-python-4.24.0 → jaaql-middleware-python-4.24.2}/jaaql/mvc/exception_queries.py

@@ -1,245 +1,245 @@
-"""
-This script was generated from jaaql.exceptions.fxli at 2024-10-05, 00:26:34
-"""
-
-from jaaql.utilities.crypt_utils import get_repeatable_salt
-from .generated_queries import *
-
-
-def add_account_password(
-    connection: DBInterface, encryption_key: bytes, vault_repeatable_salt: str,
-    account__id, account_password__hash
-):
-    account_password__uuid = account_password__insert(
-        connection, encryption_key, account__id, 
-        account_password__hash, 
-        encryption_salts={KG__account_password__hash: get_repeatable_salt(vault_repeatable_salt, account__id)}
-    )[KG__account_password__uuid]
-
-    account__update(
-        connection, encryption_key, account__id,
-        most_recent_password=account_password__uuid
-    )
-
-
-QUERY__fetch_most_recent_password = """
-    SELECT
-        A.id,
-        P.uuid,
-        P.hash
-    FROM account_password P
-    INNER JOIN account A ON P.uuid = A.most_recent_password
-    WHERE
-        A.id = :id
-"""
-
-
-def fetch_most_recent_password(
-    connection: DBInterface, encryption_key: bytes, account__id
-):
-    return execute_supplied_statement_singleton(
-        connection, QUERY__fetch_most_recent_password, {KG__account__id: account__id},
-        decrypt_columns=[KG__account_password__hash], encryption_key=encryption_key, as_objects=True
-    )[KG__account_password__hash]
-
-
-QUERY__fetch_most_recent_password_from_username = """
-    SELECT
-        A.id,
-        P.uuid,
-        P.hash
-    FROM account_password P
-    INNER JOIN account A ON P.uuid = A.most_recent_password
-    WHERE
-        A.username = :username
-"""
-
-
-def fetch_most_recent_password_from_username(
-    connection: DBInterface, encryption_key: bytes, vault_repeatable_salt: str,
-    account__username, singleton_code: int = None, singleton_message: str = None
-):
-    return execute_supplied_statement_singleton(
-        connection, QUERY__fetch_most_recent_password_from_username, {KG__account__username: account__username},
-        encryption_key=encryption_key, encrypt_parameters=[KG__account__username], encryption_salts={
-            KG__account__username: get_repeatable_salt(vault_repeatable_salt)
-        },
-        decrypt_columns=[KG__account_password__hash], as_objects=True, singleton_code=singleton_code, singleton_message=singleton_message
-    )
-
-
-QUERY__fetch_account_from_username = "SELECT * FROM account WHERE username = :username"
-
-
-def fetch_account_from_username(
-    connection: DBInterface, encryption_key: bytes, vault_repeatable_salt: str,
-    username, singleton_code: int = None, singleton_message: str = None
-):
-    return execute_supplied_statement_singleton(
-        connection, QUERY__fetch_account_from_username, {KG__account__username: username},
-        encryption_key=encryption_key, encrypt_parameters=[KG__account__username], encryption_salts={
-            KG__account__username: get_repeatable_salt(vault_repeatable_salt)
-        }, as_objects=True, singleton_code=singleton_code, singleton_message=singleton_message
-    )
-
-
-QUERY__mark_account_registered = "SELECT mark_account_registered(:id)"
-
-
-def mark_account_registered(
-    connection: DBInterface, _id
-):
-    execute_supplied_statement_singleton(
-        connection, QUERY__mark_account_registered, {
-            KG__account__id: _id
-        }
-    )
-
-
-QUERY__create_account = "SELECT create_account(:username, :attach_as, :already_exists, :is_the_anonymous_user, :allow_already_exists) as account_id"
-KEY__attach_as = "attach_as"
-KEY__already_exists = "already_exists"
-KEY__allow_already_exists = "allow_already_exists"
-KEY__username = "username"
-KEY__is_the_anonymous_user = "is_the_anonymous_user"
-KEY__account_id = "account_id"
-
-
-def create_account(
-    connection: DBInterface, encryption_key: bytes, vault_repeatable_salt: str,
-    username, attach_as=None, already_exists=False, is_the_anonymous_user=False,
-    allow_already_exists=False
-):
-    return execute_supplied_statement_singleton(
-        connection, QUERY__create_account, {
-            KEY__username: username,
-            KEY__attach_as: attach_as,
-            KEY__already_exists: already_exists,
-            KEY__is_the_anonymous_user: is_the_anonymous_user,
-            KEY__allow_already_exists: allow_already_exists
-        }, encryption_salts={
-            KG__account__username: get_repeatable_salt(vault_repeatable_salt)
-        }, as_objects=True, encryption_key=encryption_key, encrypt_parameters=[KG__account__username]
-    )[KEY__account_id]
-
-
-QUERY__validate_most_recent_password = "SELECT * FROM account WHERE id = :id AND most_recent_password = :most_recent_password"
-
-
-def validate_is_most_recent_password(
-    connection: DBInterface, account,
-    uuid, singleton_code: int = None, singleton_message: str = None
-):
-    return execute_supplied_statement_singleton(
-        connection, QUERY__validate_most_recent_password, {
-            KG__account__id: account,
-            KG__account__most_recent_password: uuid
-        }, singleton_code=singleton_code, singleton_message=singleton_message, skip_commit=True
-    )
-
-
-QUERY__exists_matching_validated_ip_address = "SELECT COUNT(*) FROM validated_ip_address WHERE encrypted_salted_ip_address = :encrypted_salted_ip_address"
-KEY__count = "count"
-
-
-def exists_matching_validated_ip_address(
-    connection: DBInterface, encrypted_salted_ip_address
-):
-    return execute_supplied_statement_singleton(
-        connection, QUERY__exists_matching_validated_ip_address, {
-            KG__validated_ip_address__encrypted_salted_ip_address: encrypted_salted_ip_address
-        }, as_objects=True
-    )[KEY__count] == 1
-
-
-QUERY___add_or_update_validated_ip_address = "INSERT INTO validated_ip_address (account, encrypted_salted_ip_address) VALUES (:account, :encrypted_salted_ip_address) ON CONFLICT ON CONSTRAINT validated_ip_address_encrypted_salted_ip_address_key DO UPDATE SET last_authentication_timestamp = current_timestamp RETURNING uuid as uuid"
-
-
-QUERY__fetch_application_schemas = "SELECT S.name, S.database, (A.default_schema = S.name) as is_default, A.is_live FROM application_schema S INNER JOIN application A ON A.name = S.application WHERE S.application = :application"
-KEY__is_default = "is_default"
-
-QUERY__count_security_events_of_type_in_24hr_window = """
-    SELECT
-        COUNT(*) as count
-    FROM security_event S
-    INNER JOIN email_template E ON E.name = S.email_template AND E.application = S.application
-    WHERE E.type IN (:type_one, :type_two) AND ((:account::postgres_role is not null AND account = :account) OR (:fake_account::encrypted__jaaql_username is not null AND fake_account = :fake_account)) AND (creation_timestamp + interval '24 hour') > current_timestamp
-"""
-
-
-def count_for_security_event(
-    connection: DBInterface, encryption_key: bytes, vault_repeatable_salt: str,
-    type_one: str, type_two: str,
-    account, fake_account=None
-):
-    return execute_supplied_statement_singleton(
-        connection, QUERY__count_security_events_of_type_in_24hr_window, {
-            "type_one": type_one, "type_two": type_two,
-            KG__security_event__account: account,
-            KG__security_event__fake_account: fake_account
-        }, as_objects=True, encryption_key=encryption_key, encrypt_parameters=[KG__security_event__fake_account],
-        encryption_salts={KG__security_event__fake_account: get_repeatable_salt(vault_repeatable_salt, fake_account)}
-    )[KEY__count]
-
-
-RPC_ACCESS__private = "P"
-RPC_ACCESS__public = "U"
-RPC_ACCESS__webhook = "W"
-
-KEY__type_one = "type_one"
-KEY__type_two = "type_two"
-
-EMAIL_TYPE__signup = "S"
-EMAIL_TYPE__already_signed_up = "A"
-EMAIL_TYPE__reset_password = "R"
-EMAIL_TYPE__unregistered_password_reset = "U"
-EMAIL_TYPE__general = "G"
-
-KEY__key_fits = "key_fits"
-QUERY__check_security_event_unlock = """
-    UPDATE
-        security_event S
-    SET
-        wrong_key_attempt_count = S.wrong_key_attempt_count + (case when (S.unlock_code = :unlock_code OR S.unlock_key = :unlock_key OR S.wrong_key_attempt_count >= 3) then 0 else 1 end)
-    FROM application A
-    WHERE
-        S.application = A.name AND
-        (S.event_lock = :event_lock OR S.unlock_key = :unlock_key) AND S.finish_timestamp is null AND
-        S.creation_timestamp + (A.unlock_key_validity_period || ' seconds')::interval > current_timestamp
-    RETURNING S.*, A.unlock_code_validity_period, (S.unlock_code = :unlock_code OR S.unlock_key = :unlock_key) as key_fits
-"""
-
-
-def check_security_event_unlock(
-    connection: DBInterface, event_lock, unlock_code,
-    unlock_key, singleton_code: int = None, singleton_message: str = None
-):
-    return execute_supplied_statement_singleton(
-        connection, QUERY__check_security_event_unlock, {
-            KG__security_event__event_lock: event_lock,
-            KG__security_event__unlock_code: unlock_code,
-            KG__security_event__unlock_key: unlock_key
-        }, as_objects=True, singleton_code=singleton_code, singleton_message=singleton_message
-    )
-
-
-QUERY__fetch_document_templates_for_email_template = """
-    SELECT
-        *
-    FROM
-        document_template T
-    WHERE
-        T.application = :application AND
-        T.email_template = :email_template
-"""
-
-
-def fetch_document_templates_for_email_template(
-    connection: DBInterface, application, email_template
-):
-    return execute_supplied_statement(
-        connection, QUERY__fetch_document_templates_for_email_template, {
-            KG__document_template__application: application,
-            KG__document_template__email_template: email_template
-        }, as_objects=True
-    )
+"""
+This script was generated from jaaql.exceptions.fxli at 2024-10-05, 22:03:06
+"""
+
+from jaaql.utilities.crypt_utils import get_repeatable_salt
+from .generated_queries import *
+
+
+def add_account_password(
+    connection: DBInterface, encryption_key: bytes, vault_repeatable_salt: str,
+    account__id, account_password__hash
+):
+    account_password__uuid = account_password__insert(
+        connection, encryption_key, account__id, 
+        account_password__hash, 
+        encryption_salts={KG__account_password__hash: get_repeatable_salt(vault_repeatable_salt, account__id)}
+    )[KG__account_password__uuid]
+
+    account__update(
+        connection, encryption_key, account__id,
+        most_recent_password=account_password__uuid
+    )
+
+
+QUERY__fetch_most_recent_password = """
+    SELECT
+        A.id,
+        P.uuid,
+        P.hash
+    FROM account_password P
+    INNER JOIN account A ON P.uuid = A.most_recent_password
+    WHERE
+        A.id = :id
+"""
+
+
+def fetch_most_recent_password(
+    connection: DBInterface, encryption_key: bytes, account__id
+):
+    return execute_supplied_statement_singleton(
+        connection, QUERY__fetch_most_recent_password, {KG__account__id: account__id},
+        decrypt_columns=[KG__account_password__hash], encryption_key=encryption_key, as_objects=True
+    )[KG__account_password__hash]
+
+
+QUERY__fetch_most_recent_password_from_username = """
+    SELECT
+        A.id,
+        P.uuid,
+        P.hash
+    FROM account_password P
+    INNER JOIN account A ON P.uuid = A.most_recent_password
+    WHERE
+        A.username = :username
+"""
+
+
+def fetch_most_recent_password_from_username(
+    connection: DBInterface, encryption_key: bytes, vault_repeatable_salt: str,
+    account__username, singleton_code: int = None, singleton_message: str = None
+):
+    return execute_supplied_statement_singleton(
+        connection, QUERY__fetch_most_recent_password_from_username, {KG__account__username: account__username},
+        encryption_key=encryption_key, encrypt_parameters=[KG__account__username], encryption_salts={
+            KG__account__username: get_repeatable_salt(vault_repeatable_salt)
+        },
+        decrypt_columns=[KG__account_password__hash], as_objects=True, singleton_code=singleton_code, singleton_message=singleton_message
+    )
+
+
+QUERY__fetch_account_from_username = "SELECT * FROM account WHERE username = :username"
+
+
+def fetch_account_from_username(
+    connection: DBInterface, encryption_key: bytes, vault_repeatable_salt: str,
+    username, singleton_code: int = None, singleton_message: str = None
+):
+    return execute_supplied_statement_singleton(
+        connection, QUERY__fetch_account_from_username, {KG__account__username: username},
+        encryption_key=encryption_key, encrypt_parameters=[KG__account__username], encryption_salts={
+            KG__account__username: get_repeatable_salt(vault_repeatable_salt)
+        }, as_objects=True, singleton_code=singleton_code, singleton_message=singleton_message
+    )
+
+
+QUERY__mark_account_registered = "SELECT mark_account_registered(:id)"
+
+
+def mark_account_registered(
+    connection: DBInterface, _id
+):
+    execute_supplied_statement_singleton(
+        connection, QUERY__mark_account_registered, {
+            KG__account__id: _id
+        }
+    )
+
+
+QUERY__create_account = "SELECT create_account(:username, :attach_as, :already_exists, :is_the_anonymous_user, :allow_already_exists) as account_id"
+KEY__attach_as = "attach_as"
+KEY__already_exists = "already_exists"
+KEY__allow_already_exists = "allow_already_exists"
+KEY__username = "username"
+KEY__is_the_anonymous_user = "is_the_anonymous_user"
+KEY__account_id = "account_id"
+
+
+def create_account(
+    connection: DBInterface, encryption_key: bytes, vault_repeatable_salt: str,
+    username, attach_as=None, already_exists=False, is_the_anonymous_user=False,
+    allow_already_exists=False
+):
+    return execute_supplied_statement_singleton(
+        connection, QUERY__create_account, {
+            KEY__username: username,
+            KEY__attach_as: attach_as,
+            KEY__already_exists: already_exists,
+            KEY__is_the_anonymous_user: is_the_anonymous_user,
+            KEY__allow_already_exists: allow_already_exists
+        }, encryption_salts={
+            KG__account__username: get_repeatable_salt(vault_repeatable_salt)
+        }, as_objects=True, encryption_key=encryption_key, encrypt_parameters=[KG__account__username]
+    )[KEY__account_id]
+
+
+QUERY__validate_most_recent_password = "SELECT * FROM account WHERE id = :id AND most_recent_password = :most_recent_password"
+
+
+def validate_is_most_recent_password(
+    connection: DBInterface, account,
+    uuid, singleton_code: int = None, singleton_message: str = None
+):
+    return execute_supplied_statement_singleton(
+        connection, QUERY__validate_most_recent_password, {
+            KG__account__id: account,
+            KG__account__most_recent_password: uuid
+        }, singleton_code=singleton_code, singleton_message=singleton_message, skip_commit=True
+    )
+
+
+QUERY__exists_matching_validated_ip_address = "SELECT COUNT(*) FROM validated_ip_address WHERE encrypted_salted_ip_address = :encrypted_salted_ip_address"
+KEY__count = "count"
+
+
+def exists_matching_validated_ip_address(
+    connection: DBInterface, encrypted_salted_ip_address
+):
+    return execute_supplied_statement_singleton(
+        connection, QUERY__exists_matching_validated_ip_address, {
+            KG__validated_ip_address__encrypted_salted_ip_address: encrypted_salted_ip_address
+        }, as_objects=True
+    )[KEY__count] == 1
+
+
+QUERY___add_or_update_validated_ip_address = "INSERT INTO validated_ip_address (account, encrypted_salted_ip_address) VALUES (:account, :encrypted_salted_ip_address) ON CONFLICT ON CONSTRAINT validated_ip_address_encrypted_salted_ip_address_key DO UPDATE SET last_authentication_timestamp = current_timestamp RETURNING uuid as uuid"
+
+
+QUERY__fetch_application_schemas = "SELECT S.name, S.database, (A.default_schema = S.name) as is_default, A.is_live FROM application_schema S INNER JOIN application A ON A.name = S.application WHERE S.application = :application"
+KEY__is_default = "is_default"
+
+QUERY__count_security_events_of_type_in_24hr_window = """
+    SELECT
+        COUNT(*) as count
+    FROM security_event S
+    INNER JOIN email_template E ON E.name = S.email_template AND E.application = S.application
+    WHERE E.type IN (:type_one, :type_two) AND ((:account::postgres_role is not null AND account = :account) OR (:fake_account::encrypted__jaaql_username is not null AND fake_account = :fake_account)) AND (creation_timestamp + interval '24 hour') > current_timestamp
+"""
+
+
+def count_for_security_event(
+    connection: DBInterface, encryption_key: bytes, vault_repeatable_salt: str,
+    type_one: str, type_two: str,
+    account, fake_account=None
+):
+    return execute_supplied_statement_singleton(
+        connection, QUERY__count_security_events_of_type_in_24hr_window, {
+            "type_one": type_one, "type_two": type_two,
+            KG__security_event__account: account,
+            KG__security_event__fake_account: fake_account
+        }, as_objects=True, encryption_key=encryption_key, encrypt_parameters=[KG__security_event__fake_account],
+        encryption_salts={KG__security_event__fake_account: get_repeatable_salt(vault_repeatable_salt, fake_account)}
+    )[KEY__count]
+
+
+RPC_ACCESS__private = "P"
+RPC_ACCESS__public = "U"
+RPC_ACCESS__webhook = "W"
+
+KEY__type_one = "type_one"
+KEY__type_two = "type_two"
+
+EMAIL_TYPE__signup = "S"
+EMAIL_TYPE__already_signed_up = "A"
+EMAIL_TYPE__reset_password = "R"
+EMAIL_TYPE__unregistered_password_reset = "U"
+EMAIL_TYPE__general = "G"
+
+KEY__key_fits = "key_fits"
+QUERY__check_security_event_unlock = """
+    UPDATE
+        security_event S
+    SET
+        wrong_key_attempt_count = S.wrong_key_attempt_count + (case when (S.unlock_code = :unlock_code OR S.unlock_key = :unlock_key OR S.wrong_key_attempt_count >= 3) then 0 else 1 end)
+    FROM application A
+    WHERE
+        S.application = A.name AND
+        (S.event_lock = :event_lock OR S.unlock_key = :unlock_key) AND S.finish_timestamp is null AND
+        S.creation_timestamp + (A.unlock_key_validity_period || ' seconds')::interval > current_timestamp
+    RETURNING S.*, A.unlock_code_validity_period, (S.unlock_code = :unlock_code OR S.unlock_key = :unlock_key) as key_fits
+"""
+
+
+def check_security_event_unlock(
+    connection: DBInterface, event_lock, unlock_code,
+    unlock_key, singleton_code: int = None, singleton_message: str = None
+):
+    return execute_supplied_statement_singleton(
+        connection, QUERY__check_security_event_unlock, {
+            KG__security_event__event_lock: event_lock,
+            KG__security_event__unlock_code: unlock_code,
+            KG__security_event__unlock_key: unlock_key
+        }, as_objects=True, singleton_code=singleton_code, singleton_message=singleton_message
+    )
+
+
+QUERY__fetch_document_templates_for_email_template = """
+    SELECT
+        *
+    FROM
+        document_template T
+    WHERE
+        T.application = :application AND
+        T.email_template = :email_template
+"""
+
+
+def fetch_document_templates_for_email_template(
+    connection: DBInterface, application, email_template
+):
+    return execute_supplied_statement(
+        connection, QUERY__fetch_document_templates_for_email_template, {
+            KG__document_template__application: application,
+            KG__document_template__email_template: email_template
+        }, as_objects=True
+    )