django-auth-recovery-codes 1.0.0__py3-none-any.whl

django_auth_recovery_codes/checks.py

@@ -0,0 +1,265 @@
+from django.conf import settings
+from django.core.checks import register, Error, Warning, CheckMessage
+from typing import Any, Dict, List, Optional
+from django.apps import AppConfig
+
+from django_auth_recovery_codes.conf import FLAG_VALIDATORS
+
+
+@register()
+def check_app_settings(
+    app_configs: Optional[List[AppConfig]], **kwargs: Any
+) -> List[CheckMessage]:
+    """
+    System check to validate all application settings flags defined in
+    FLAG_VALIDATORS.
+
+    Iterates through each flag in FLAG_VALIDATORS, ensuring it exists
+    in Django settings and is of the correct type. Missing or invalid
+    flags are collected as warnings or errors.
+
+    Args:
+        app_configs (list[AppConfig] | None): The list of installed app
+            configurations (unused in this check).
+        **kwargs: Arbitrary keyword arguments passed by the Django
+            system check framework.
+
+    Returns:
+        list[CheckMessage]:
+            A list of warnings or errors generated during the check.
+    """
+    errors: List[CheckMessage] = []
+
+    # Fl
+    flags_to_skip = [] 
+                  
+                     
+
+    for flag_name, config in FLAG_VALIDATORS.items():
+        if flag_name not in flags_to_skip:
+            _check_flag(flag_name, config, errors)
+
+    return errors
+
+
+@register
+def check_app_format_setting(app_configs: Optional[List[AppConfig]], **kwargs: Any
+) -> List[CheckMessage]:
+    """
+    System check to validate the recovery codes default format setting.
+
+    Ensures that the value of the setting
+    `DJANGO_AUTH_RECOVERY_CODES_DEFAULT_FORMAT` (if defined) is one of
+    the allowed formats: 'txt', 'pdf', or 'csv'.
+
+    Args:
+        app_configs (list[AppConfig] | None): The list of installed app
+            configurations (unused in this check).
+        **kwargs: Arbitrary keyword arguments passed by the Django
+            system check framework.
+
+    Returns:
+        list[CheckMessage]:
+            A list containing a warning if the format is invalid,
+            otherwise an empty list.
+    """
+    errors: List[CheckMessage] = []
+    
+    value: Optional[str] = getattr(settings, "DJANGO_AUTH_RECOVERY_CODES_DEFAULT_FORMAT")
+    if value:
+        ext = value.strip()
+        if ext not in ("txt", "pdf", "csv"):
+            errors.append(
+                Warning(
+                    "DJANGO_AUTH_RECOVERY_CODES_DEFAULT_FORMAT",
+                    f"The format must be either pdf, txt or csv but got {ext}"
+                )
+            )
+    return errors
+
+
+@register()
+def check_app_max_deletions_per_run(app_configs: Optional[List[Any]] = None, **kwargs: Any) -> List[CheckMessage]:
+    """
+    Checks if the `DJANGO_AUTH_RECOVERY_CODES_MAX_DELETIONS_PER_RUN` in the settings is valid.
+
+    A valid value is either an int or None.
+    """
+    errors: List[CheckMessage] = []
+
+    raw = getattr(settings, "DJANGO_AUTH_RECOVERY_CODES_MAX_DELETIONS_PER_RUN")
+
+    if not isinstance(raw, int):
+   
+        errors.append(
+            Warning(
+                f"`DJANGO_AUTH_RECOVERY_CODES_MAX_DELETIONS_PER_RUN` must be an int or None. got type {type(raw).__name__}",
+                hint="Set it to a positive integer or 0 for unlimited deletions.",
+                id="django_auth_recovery_codes.W001",
+            )
+        )
+
+    return errors
+
+
+@register
+def check_app_format_setting(app_configs: Optional[List[AppConfig]], **kwargs: Any
+) -> List[CheckMessage]:
+    """"""
+    max_code_visible = settings.DJANGO_AUTH_RECOVERY_CODE_MAX_VISIBLE 
+    codes_per_page   = settings.DJANGO_AUTH_RECOVERY_CODE_PER_PAGE 
+    errors           = []
+
+    if (max_code_visible <= 0 and codes_per_page <= 0):
+        errors.append(
+            Error(
+                f"One of more of the flags is 0",
+                f"The flags cannot be 0 because they are needed for pagination and to display the number of items per page",
+                f'DJANGO_AUTH_RECOVERY_CODE_MAX_VISIBLE value is {max_code_visible}',
+                f'DJANGO_AUTH_RECOVERY_CODE_PER_PAGE value is {codes_per_page}',
+            )
+        )
+        return errors
+    
+    if codes_per_page > max_code_visible:
+        errors.append(
+            Error(
+                  f'DJANGO_AUTH_RECOVERY_CODE_PER_PAGE cannot be greater than DJANGO_AUTH_RECOVERY_CODE_MAX_VISIBLE',
+                  f'DJANGO_AUTH_RECOVERY_CODE_PER_PAGE value is {codes_per_page}',
+                  f'DJANGO_AUTH_RECOVERY_CODE_MAX_VISIBLE value is {max_code_visible}'
+                  )
+        )
+    return errors
+
+
+def _check_flag(flag_name: str, config: Dict[str, Any], errors: List[CheckMessage]) -> None:
+    """
+    Helper function to validate a single settings flag.
+
+    Checks whether the flag is present in Django settings and matches
+    the expected type as defined in its config dictionary.
+
+    Args:
+        flag_name (str): The name of the setting flag to validate.
+        config (dict): The validation configuration for the flag,
+            containing:
+              - "type": The expected Python type.
+              - "warning_if_missing": Message if the flag is missing.
+              - "warning_id": System check ID for the missing warning.
+              - "error_if_wrong_type": Message if the type is invalid.
+              - "error_id": System check ID for the type error.
+        errors (list[CheckMessage]): A mutable list to which warnings or
+            errors will be appended.
+
+    Returns:
+        None
+    """
+    if not hasattr(settings, flag_name):
+        errors.append(Warning(config["warning_if_missing"], id=config["warning_id"]))
+        return
+
+    value: Any = getattr(settings, flag_name)
+    expected_type: type = config["type"]
+
+    if not isinstance(value, expected_type):
+        errors.append(Error(config["error_if_wrong_type"], id=config["error_id"]))
+
+
+def check_email_success_setting(
+    app_configs: Optional[List[AppConfig]] = None, **kwargs: Any
+) -> List[CheckMessage]:
+    """
+    Validates the Django setting for the recovery code success email message.
+
+    This setting is the notification shown to users after they
+    have successfully emailed themselves a copy of their recovery codes.
+
+    This check ensures that the setting is a string (can be empty) and not some other type.
+
+    Args:
+        app_configs (Optional[List[AppConfig]]): Standard Django argument for system checks.
+        **kwargs: Additional keyword arguments (ignored).
+
+    Returns:
+        List[CheckMessage]: A list of Django CheckMessages indicating any errors
+                            or inconsistencies in the email success message setting.
+    """
+   
+    email_msg = settings.DJANGO_AUTH_RECOVERY_CODE_EMAIL_SUCCESS_MSG
+    errors = []
+
+    if not isinstance(email_msg, str):
+        errors.append(
+            Warning(
+                "DJANGO_AUTH_RECOVERY_CODE_EMAIL_SUCCESS_MSG must be a string.",
+                hint="Leave as an empty string to use the default message.",
+                id="django_auth_recovery_codes.W002",
+            )
+        )
+
+    return errors
+
+@register
+def check_ttl_setting(app_configs: Optional[List[AppConfig]], **kwargs: Any) -> List[CheckMessage]:
+    """
+    Validates the Django settings for recovery code caching.
+
+    This check ensures that the cache configuration is sensible:
+    1. CACHE_TTL, CACHE_MIN, and CACHE_MAX must be positive values.
+    2. CACHE_MIN cannot exceed CACHE_MAX.
+    3. CACHE_TTL must lie within the range defined by CACHE_MIN and CACHE_MAX.
+
+    These checks prevent misconfiguration that could lead to recovery codes
+    expiring too quickly or remaining in the cache indefinitely.
+
+    Returns:
+        List[CheckMessage]: A list of Django CheckMessages indicating any errors
+                            or inconsistencies in the cache settings.
+    """
+    cache_ttl = settings.DJANGO_AUTH_RECOVERY_CODES_CACHE_TTL
+    cache_min = settings.DJANGO_AUTH_RECOVERY_CODES_CACHE_MIN
+    cache_max = settings.DJANGO_AUTH_RECOVERY_CODES_CACHE_MAX
+    errors = []
+
+    # Check for zero or negative values
+    if cache_min <= 0 or cache_max <= 0 or cache_ttl <= 0:
+        errors.append(
+            Error(
+                "One or more cache settings is zero or negative.",
+                "All cache settings must be positive as they determine how long "
+                "recovery codes remain in the cache.",
+                hint=(
+                    f"Current values: TTL={cache_ttl}, MIN={cache_min}, MAX={cache_max}. "
+                    "Consider setting them to positive integers, e.g., TTL=300, MIN=60, MAX=600."
+                )
+            )
+        )
+        return errors
+
+    # Ensure min is not greater than max
+    if cache_min > cache_max:
+        errors.append(
+            Error(
+                "CACHE_MIN cannot be greater than CACHE_MAX.",
+                "The minimum cache duration must not exceed the maximum.",
+                hint=(
+                    f"Current values: MIN={cache_min}, MAX={cache_max}, TTL={cache_ttl}. "
+                    "Swap the values or adjust them so that MIN <= MAX."
+                )
+            )
+        )
+
+    # Ensure TTL is within min and max range
+    if not (cache_min <= cache_ttl <= cache_max):
+        errors.append(
+            Error(
+                "CACHE_TTL is outside the min-max range.",
+                "The TTL should be between CACHE_MIN and CACHE_MAX to ensure proper caching behaviour.",
+                hint=(
+                    f"Current values: TTL={cache_ttl}, MIN={cache_min}, MAX={cache_max}. "
+                    "Adjust TTL to fall within the range defined by MIN and MAX."
+                )
+            )
+        )
+
+    return errors

django_auth_recovery_codes/conf.py

@@ -0,0 +1,245 @@
+# ------------------------------------------------------------------------------
+# FLAG_VALIDATORS
+# ------------------------------------------------------------------------------
+#
+# Central registry of all configurable settings (flags) for django_auth_recovery_codes.
+#
+# This dictionary is consumed by a Django system check registered via
+# `python manage.py check` to validate project settings.
+#
+# Each entry defines:
+#   - type: The expected Python type for the flag.
+#   - warning_if_missing: Message if the flag is not set in settings.py.
+#   - error_if_wrong_type: Message if the flag is defined but not of the expected type.
+#   - error_id / warning_id: Unique system check IDs for precise identification.
+#
+# Checks performed:
+#   1. Required flags exist in settings.py.
+#   2. Flags are of the correct type.
+#   3. Optional: Cross-flag consistency (e.g., PER_PAGE <= MAX_VISIBLE)
+#
+# Example usage:
+#   - DJANGO_AUTH_RECOVERY_CODE_MAX_VISIBLE (int):
+#       Maximum number of recovery codes a user can view in total, even if more exist.
+#   - DJANGO_AUTH_RECOVERY_CODE_PER_PAGE (int):
+#       Number of recovery codes shown per page in the UI. Must not exceed MAX_VISIBLE.
+#
+# Adding new flags:
+#   Append a new entry to FLAG_VALIDATORS with the expected type and
+#   error/warning metadata. Add additional "consistency rules" in the
+#   validator function if flags interact with each other.
+# ------------------------------------------------------------------------------
+
+
+FLAG_VALIDATORS = {
+    
+     # ---logout redirect ---
+    "DJANGO_AUTH_RECOVERY_CODE_REDIRECT_VIEW_AFTER_LOGOUT": {
+        "type": str,
+        "warning_if_missing": "DJANGO_AUTH_RECOVERY_CODE_REDIRECT_VIEW_AFTER_LOGOUT is not set in settings.py.",
+        "error_if_wrong_type": "DJANGO_AUTH_RECOVERY_CODE_REDIRECT_VIEW_AFTER_LOGOUT must be an string.",
+        "error_id": "django_auth_recovery_codes.E000",
+        "warning_id": "django_auth_recovery_codes.W000",
+    },
+
+    # --- Cache Settings ---
+    "DJANGO_AUTH_RECOVERY_CODES_CACHE_TTL": {
+        "type": int,
+        "warning_if_missing": "DJANGO_AUTH_RECOVERY_CODES_CACHE_TTL is not set in settings.py.",
+        "error_if_wrong_type": "DJANGO_AUTH_RECOVERY_CODES_CACHE_TTL must be an integer.",
+        "error_id": "django_auth_recovery_codes.E001",
+        "warning_id": "django_auth_recovery_codes.W001",
+    },
+    "DJANGO_AUTH_RECOVERY_CODES_CACHE_MIN": {
+        "type": int,
+        "warning_if_missing": "DJANGO_AUTH_RECOVERY_CODES_CACHE_MIN is not set in settings.py.",
+        "error_if_wrong_type": "DJANGO_AUTH_RECOVERY_CODES_CACHE_MIN must be an integer.",
+        "error_id": "django_auth_recovery_codes.E002",
+        "warning_id": "django_auth_recovery_codes.W002",
+    },
+    "DJANGO_AUTH_RECOVERY_CODES_CACHE_MAX": {
+        "type": int,
+        "warning_if_missing": "DJANGO_AUTH_RECOVERY_CODES_CACHE_MAX is not set in settings.py.",
+        "error_if_wrong_type": "DJANGO_AUTH_RECOVERY_CODES_CACHE_MAX must be an integer.",
+        "error_id": "django_auth_recovery_codes.E003",
+        "warning_id": "django_auth_recovery_codes.W003",
+    },
+
+    # --- Cooldown Settings ---
+    "DJANGO_AUTH_RECOVERY_CODES_BASE_COOLDOWN": {
+        "type": int,
+        "warning_if_missing": "DJANGO_AUTH_RECOVERY_CODES_BASE_COOLDOWN is not set in settings.py.",
+        "error_if_wrong_type": "DJANGO_AUTH_RECOVERY_CODES_BASE_COOLDOWN must be an integer.",
+        "error_id": "django_auth_recovery_codes.E004",
+        "warning_id": "django_auth_recovery_codes.W004",
+    },
+    "DJANGO_AUTH_RECOVERY_CODES_COOLDOWN_MULTIPLIER": {
+        "type": int,
+        "warning_if_missing": "DJANGO_AUTH_RECOVERY_CODES_COOLDOWN_MULTIPLIER is not set in settings.py.",
+        "error_if_wrong_type": "DJANGO_AUTH_RECOVERY_CODES_COOLDOWN_MULTIPLIER must be an integer.",
+        "error_id": "django_auth_recovery_codes.E005",
+        "warning_id": "django_auth_recovery_codes.W005",
+    },
+    "DJANGO_AUTH_RECOVERY_CODES_COOLDOWN_CUTOFF_POINT": {
+        "type": int,
+        "warning_if_missing": "DJANGO_AUTH_RECOVERY_CODES_COOLDOWN_CUTOFF_POINT is not set in settings.py.",
+        "error_if_wrong_type": "DJANGO_AUTH_RECOVERY_CODES_COOLDOWN_CUTOFF_POINT must be an integer.",
+        "error_id": "django_auth_recovery_codes.E006",
+        "warning_id": "django_auth_recovery_codes.W006",
+    },
+
+    # --- Admin / Email Settings ---
+    "DJANGO_AUTH_RECOVERY_CODES_ADMIN_SENDER_EMAIL": {
+        "type": str,
+        "warning_if_missing": "DJANGO_AUTH_RECOVERY_CODES_ADMIN_SENDER_EMAIL is not set in settings.py.",
+        "error_if_wrong_type": "DJANGO_AUTH_RECOVERY_CODES_ADMIN_SENDER_EMAIL must be a string.",
+        "error_id": "django_auth_recovery_codes.E007",
+        "warning_id": "django_auth_recovery_codes.W007",
+    },
+
+    # --- Format Settings ---
+    "DJANGO_AUTH_RECOVERY_CODES_DEFAULT_FORMAT": {
+        "type": str,
+        "warning_if_missing": "DJANGO_AUTH_RECOVERY_CODES_DEFAULT_FORMAT is not set in settings.py.",
+        "error_if_wrong_type": "DJANGO_AUTH_RECOVERY_CODES_DEFAULT_FORMAT must be a string.",
+        "error_id": "django_auth_recovery_codes.E008",
+        "warning_id": "django_auth_recovery_codes.W008",
+    },
+
+    # --- File / Key Settings ---
+    "DJANGO_AUTH_RECOVERY_CODES_DEFAULT_FILE_NAME": {
+        "type": str,
+        "warning_if_missing": "DJANGO_AUTH_RECOVERY_CODES_DEFAULT_FILE_NAME is not set in settings.py.",
+        "error_if_wrong_type": "DJANGO_AUTH_RECOVERY_CODES_DEFAULT_FILE_NAME must be a string.",
+        "error_id": "django_auth_recovery_codes.E009",
+        "warning_id": "django_auth_recovery_codes.W009",
+    },
+    
+    "DJANGO_AUTH_RECOVERY_KEY": {
+        "type": str,
+        "warning_if_missing": "DJANGO_AUTH_RECOVERY_KEY is not set in settings.py.",
+        "error_if_wrong_type": "DJANGO_AUTH_RECOVERY_KEY must be a string.",
+        "error_id": "django_auth_recovery_codes.E010",
+        "warning_id": "django_auth_recovery_codes.W010",
+    },
+
+    # --- Audit / Retention Settings ---
+    "DJANGO_AUTH_RECOVERY_CODE_AUDIT_RETENTION_DAYS": {
+        "type": int,
+        "warning_if_missing": "DJANGO_AUTH_RECOVERY_CODE_AUDIT_RETENTION_DAYS is not set in settings.py.",
+        "error_if_wrong_type": "DJANGO_AUTH_RECOVERY_CODE_AUDIT_RETENTION_DAYS must be an integer.",
+        "error_id": "django_auth_recovery_codes.E011",
+        "warning_id": "django_auth_recovery_codes.W011",
+    },
+    "DJANGO_AUTH_RECOVERY_CODE_AUDIT_ENABLE_AUTO_CLEANUP": {
+        "type": bool,
+        "warning_if_missing": "DJANGO_AUTH_RECOVERY_CODE_AUDIT_ENABLE_AUTO_CLEANUP is not set in settings.py.",
+        "error_if_wrong_type": "DJANGO_AUTH_RECOVERY_CODE_AUDIT_ENABLE_AUTO_CLEANUP must be a boolean.",
+        "error_id": "django_auth_recovery_codes.E012",
+        "warning_id": "django_auth_recovery_codes.W012",
+    },
+    "DJANGO_AUTH_RECOVERY_CODE_PURGE_DELETE_RETENTION_DAYS": {
+        "type": int,
+        "warning_if_missing": "DJANGO_AUTH_RECOVERY_CODE_PURGE_DELETE_RETENTION_DAYS is not set in settings.py.",
+        "error_if_wrong_type": "DJANGO_AUTH_RECOVERY_CODE_PURGE_DELETE_RETENTION_DAYS must be an integer.",
+        "error_id": "django_auth_recovery_codes.E013",
+        "warning_id": "django_auth_recovery_codes.W013",
+    },
+
+    # --- Admin Email Settings ---
+    "DJANGO_AUTH_RECOVERY_CODE_ADMIN_EMAIL_HOST_USER": {
+        "type": str,
+        "warning_if_missing": "DJANGO_AUTH_RECOVERY_CODE_ADMIN_EMAIL_HOST_USER is not set in settings.py.",
+        "error_if_wrong_type": "DJANGO_AUTH_RECOVERY_CODE_ADMIN_EMAIL_HOST_USER must be a string.",
+        "error_id": "django_auth_recovery_codes.E014",
+        "warning_id": "django_auth_recovery_codes.W014",
+    },
+    # --- Logger / Email Log Settings ---
+    "DJANGO_AUTH_RECOVERY_CODE_PURGE_DELETE_SCHEDULER_USE_LOGGER": {
+        "type": bool,
+        "warning_if_missing": "DJANGO_AUTH_RECOVERY_CODE_PURGE_DELETE_SCHEDULER_USE_LOGGER is not set in settings.py.",
+        "error_if_wrong_type": "DJANGO_AUTH_RECOVERY_CODE_PURGE_DELETE_SCHEDULER_USE_LOGGER must be a boolean.",
+        "error_id": "django_auth_recovery_codes.E017",
+        "warning_id": "django_auth_recovery_codes.W017",
+    },
+    "DJANGO_AUTH_RECOVERY_CODE_STORE_EMAIL_LOG": {
+        "type": bool,
+        "warning_if_missing": "DJANGO_AUTH_RECOVERY_CODE_STORE_EMAIL_LOG is not set in settings.py.",
+        "error_if_wrong_type": "DJANGO_AUTH_RECOVERY_CODE_STORE_EMAIL_LOG must be a boolean.",
+        "error_id": "django_auth_recovery_codes.E018",
+        "warning_id": "django_auth_recovery_codes.W018",
+    },
+
+     # --- Pagination / Display Settings ---
+    "DJANGO_AUTH_RECOVERY_CODE_MAX_VISIBLE": {
+        "type": int,
+        "warning_if_missing": "DJANGO_AUTH_RECOVERY_CODE_MAX_VISIBLE is not set in settings.py.",
+        "error_if_wrong_type": "DJANGO_AUTH_RECOVERY_CODE_MAX_VISIBLE must be an integer.",
+        "error_id": "django_auth_recovery_codes.E019",
+        "warning_id": "django_auth_recovery_codes.W019",
+    },
+
+    "DJANGO_AUTH_RECOVERY_CODE_PER_PAGE": {
+        "type": int,
+        "warning_if_missing": "DJANGO_AUTH_RECOVERY_CODE_PER_PAGE is not set in settings.py.",
+        "error_if_wrong_type": "DJANGO_AUTH_RECOVERY_CODE_PER_PAGE must be an integer.",
+        "error_id": "django_auth_recovery_codes.E020",
+        "warning_id": "django_auth_recovery_codes.W020",
+    },
+
+
+    # --- Max login attempts / Display Settings ---
+    "DJANGO_AUTH_RECOVERY_CODES_MAX_LOGIN_ATTEMPTS":  {
+        "type": int,
+        "warning_if_missing": "DJANGO_AUTH_RECOVERY_CODE_PER_PAGE is not set in settings.py.",
+        "error_if_wrong_type": "DJANGO_AUTH_RECOVERY_CODE_PER_PAGE must be an integer.",
+        "error_id": "django_auth_recovery_codes.E021",
+        "warning_id": "django_auth_recovery_codes.W021",
+    },
+   
+   # --- writes to cache if true on any failed login attempts / Cache Settings ---
+   'DJANGO_AUTH_RECOVERY_CODES_AUTH_RATE_LIMITER_USE_CACHE': {
+        "type": bool,
+        "warning_if_missing": "DJANGO_AUTH_RECOVERY_CODES_AUTH_RATE_LIMITER_USE_CACHE is not set in settings.py.",
+        "error_if_wrong_type": "DJANGO_AUTH_RECOVERY_CODES_AUTH_RATE_LIMITER_USE_CACHE must be a boolean.",
+        "error_id": "django_auth_recovery_codes.E022",
+        "warning_id": "django_auth_recovery_codes.W022",
+    },
+
+     # --- Deletes the code in chunks instead of all at once / Delete batch  Settings ---
+    'DJANGO_AUTH_RECOVERY_CODES_BATCH_DELETE_SIZE' : {
+        "type": int,
+        "warning_if_missing": "DJANGO_AUTH_RECOVERY_CODES_BATCH_DELETE_SIZE is not set in settings.py.",
+        "error_if_wrong_type": "DJANGO_AUTH_RECOVERY_CODES_BATCH_DELETE_SIZE must be a boolean.",
+        "error_id": "django_auth_recovery_codes.E023",
+        "warning_id": "django_auth_recovery_codes.W023",
+    },
+
+    # --- Site name used in recovery emails / Site Settings ---
+    'DJANGO_AUTH_RECOVERY_CODES_SITE_NAME': {
+        "type": str,
+        "warning_if_missing": "DJANGO_AUTH_RECOVERY_CODES_SITE_NAME is not set in settings.py.",
+        "error_if_wrong_type": "DJANGO_AUTH_RECOVERY_CODES_SITE_NAME must be a string.",
+        "error_id": "django_auth_recovery_codes.E024",
+        "warning_id": "django_auth_recovery_codes.W024",
+    },
+
+     # --- Cap deletions per scheduler run (None = unlimited) / Cap deletion Settings ---
+    'DJANGO_AUTH_RECOVERY_CODES_MAX_DELETIONS_PER_RUN': {
+        "type": int,
+        "warning_if_missing": "DJANGO_AUTH_RECOVERY_CODES_MAX_DELETIONS_PER_RUN is not set in settings.py.",
+        "error_if_wrong_type": "DJANGO_AUTH_RECOVERY_CODES_MAX_DELETIONS_PER_RUN must be a int or none.",
+        "error_id": "django_auth_recovery_codes.E025",
+        "warning_id": "django_auth_recovery_codes.W025",
+    },
+
+     # --- Email successsful sent message / Email successful message Settings ---
+    'DJANGO_AUTH_RECOVERY_CODE_EMAIL_SUCCESS_MSG': {
+        "type": str,
+        "warning_if_missing": "DJANGO_AUTH_RECOVERY_CODE_EMAIL_SUCCESS_MSG is not set in settings.py.",
+        "error_if_wrong_type": "DJANGO_AUTH_RECOVERY_CODE_EMAIL_SUCCESS_MSG must be a string or none.",
+        "error_id": "django_auth_recovery_codes.E025",
+        "warning_id": "django_auth_recovery_codes.W025",
+    },
+
+}

django_auth_recovery_codes/context_processors.py

@@ -0,0 +1,6 @@
+from django.conf import settings
+from django_auth_recovery_codes.models_choices import Status
+
+def request(request):
+    SITE_NAME = getattr(settings, "DJANGO_AUTH_RECOVERY_CODES_SITE_NAME", None)
+    return {'request': request,  "site_name": SITE_NAME, "Status": Status}

django_auth_recovery_codes/enums.py

@@ -0,0 +1,39 @@
+from enum import Enum
+
+class CreatedStatus(Enum):
+    NOT_CREATED     = "The resource has not been created yet."
+    CREATED         = "The resource was successfully created."
+    ALREADY_CREATED = "The resource has already been created."
+
+
+class BackendConfigStatus(Enum):
+    NOT_CONFIGURED     = "The models associated with the codes have not been configured correctly."
+    CONFIGURED         = "The models associated with the codes have been configured successfully."
+    ALREADY_CONFIGURED = "The models associated with the codes are already configured."
+
+
+class SetupCompleteStatus(Enum):
+    NOT_COMPLETE     = "The test setup was not completed successfully."
+    COMPLETE         = "The test setup has been completed successfully."
+    ALREADY_COMPLETE = "The test setup was already completed."
+
+
+class ValidityStatus(Enum):
+    INVALID = "The provided data is invalid."
+    VALID   = "The provided data is valid."
+
+
+class UsageStatus(Enum):
+    SUCCESS = "You can now begin using your 2FA recovery codes, please remember to keep them safe"
+    FAILURE = "The test failed, check the codes entered and try again or delete your current codes, regenerate new ones, and then try again"
+
+
+class TestSetupStatus(Enum):
+    SUCCESS                          = True
+    CREATED                          = "Test successful: recovery codes have been created successfully."
+    BACKEND_CONFIGURATION_SUCCESS    = "The backend has been configured successfully."
+    BACKEND_CONFIGURATION_UNSUCCESS  = "Failed to configure the backend. Please review the setup."
+    SETUP_COMPLETE                   = "The setup process was completed successfully."
+    SETUP_FAILED                     = "The setup process failed. Please try again."
+    VALIDATION_COMPLETE              = "Validation successful: the recovery code and recovery batch are set up correctly."
+    VALIDATION_UNSUCCESS             = "Validation failed: the recovery code and recovery batch could not be set up correctly."

django_auth_recovery_codes/forms/login_form.py

@@ -0,0 +1,26 @@
+from django import forms
+
+class LoginForm(forms.Form):
+    email  = forms.EmailField(max_length=40, widget=forms.EmailInput(attrs={
+        "placeholder": "Add email...",
+        "id": "login-email-id",
+        "autocomplete": "off",
+        "autocapitalize": "none",
+    }))
+    recovery_code = forms.CharField(
+        label="Recovery code",
+        max_length=41,
+        min_length=41,
+        widget=forms.TextInput(
+            attrs={
+                "placeholder": "987A-CCSSS-9875-125468-14789D",
+                "spellcheck": "false",
+                "autocorrect": "off",
+                "autocomplete": "off",
+                "autocapitalize": "none",
+                "id": "recovery-code-input",
+              
+            }
+        ),
+         initial="",
+    )

django_auth_recovery_codes/forms/schedule_form.py

@@ -0,0 +1,49 @@
+from django import forms
+from django_auth_recovery_codes.models import RecoveryCodeCleanUpScheduler, RecoveryCodeAuditScheduler
+from django_auth_recovery_codes.base_models import AbstractBaseModel
+
+class RecoveryCodeCleanUpSchedulerForm(forms.ModelForm):
+    
+    class Meta:
+        model = RecoveryCodeCleanUpScheduler
+        fields = "__all__"
+        help_texts = {
+            "next_run": "Defaults to the calculated schedule time, but you may override it. "
+                        "Must not be earlier than Run At.",
+        }
+
+    def clean_next_run(self):
+        """
+        Validate that `next_run` is not earlier than `run_at`.
+        If `next_run` is None, sets it to the model's default schedule.
+        """
+        cleaned_data = super().clean()
+
+        run_at   = cleaned_data.get("run_at")
+        next_run = cleaned_data.get("next_run")
+
+        if not run_at:
+            raise forms.ValidationError("The run at time cannot be None")
+        
+        if next_run is None:
+            next_run = self.instance.next_run_schedule()
+        
+        if (run_at > next_run):
+            raise forms.ValidationError("The next run cannot be less than run at")
+        return next_run
+    
+   
+
+    
+
+class RecoveryCodeAuditForm(forms.ModelForm):
+    class Meta:
+        model = RecoveryCodeAuditScheduler
+        fields = "__all__"
+
+    def clean_name(self):
+        name = self.cleaned_data.get("name")
+        if RecoveryCodeAuditScheduler.objects.filter(name=name).exists():
+            raise forms.ValidationError("A scheduler with this name already exists. Please choose another.")
+        return name
+