django-forms-workflows 0.2.0__py3-none-any.whl

django_forms_workflows/__init__.py

@@ -0,0 +1,11 @@
+"""
+Django Forms Workflows
+Enterprise-grade, database-driven form builder with approval workflows
+"""
+
+__version__ = '0.2.0'
+__author__ = 'Django Forms Workflows Contributors'
+__license__ = 'LGPL-3.0-only'
+
+default_app_config = 'django_forms_workflows.apps.DjangoFormsWorkflowsConfig'
+

django_forms_workflows/admin.py

@@ -0,0 +1,434 @@
+"""
+Django admin for Django Forms Workflows
+
+Provides a friendly admin interface to build forms (with fields),
+configure approval workflows, and review submissions and audit logs.
+"""
+from django.contrib import admin
+from django.utils.html import format_html
+from .models import (
+    FormDefinition,
+    FormField,
+    PrefillSource,
+    PostSubmissionAction,
+    WorkflowDefinition,
+    FormSubmission,
+    ApprovalTask,
+    AuditLog,
+    UserProfile,
+)
+
+
+# Inline for form fields when editing a form definition
+class FormFieldInline(admin.StackedInline):
+    model = FormField
+    extra = 0
+    ordering = ("order",)
+    fk_name = "form_definition"
+    fieldsets = (
+        (
+            None,
+            {
+                "fields": (
+                    ("order", "field_label", "field_name", "field_type", "required"),
+                    ("help_text", "placeholder", "width", "css_class"),
+                )
+            },
+        ),
+        (
+            "Validation",
+            {
+                "classes": ("collapse",),
+                "fields": (
+                    ("min_value", "max_value"),
+                    ("min_length", "max_length"),
+                    "regex_validation",
+                    "regex_error_message",
+                ),
+            },
+        ),
+        (
+            "Choices & Defaults",
+            {
+                "classes": ("collapse",),
+                "fields": ("choices", "prefill_source_config", "prefill_source", "default_value"),
+            },
+        ),
+        (
+            "Conditional display",
+            {
+                "classes": ("collapse",),
+                "fields": (("show_if_field", "show_if_value"),),
+            },
+        ),
+        (
+            "File upload",
+            {
+                "classes": ("collapse",),
+                "fields": ("allowed_extensions", "max_file_size_mb"),
+            },
+        ),
+    )
+
+
+@admin.register(PrefillSource)
+class PrefillSourceAdmin(admin.ModelAdmin):
+    list_display = (
+        "name",
+        "source_type",
+        "source_key",
+        "is_active",
+        "order",
+    )
+    list_filter = ("source_type", "is_active")
+    search_fields = ("name", "source_key", "description")
+    list_editable = ("order", "is_active")
+    fieldsets = (
+        (
+            None,
+            {
+                "fields": (
+                    ("name", "source_type"),
+                    "source_key",
+                    "description",
+                    ("is_active", "order"),
+                )
+            },
+        ),
+        (
+            "Database Configuration",
+            {
+                "classes": ("collapse",),
+                "fields": (
+                    "db_alias",
+                    ("db_schema", "db_table", "db_column"),
+                    ("db_lookup_field", "db_user_field"),
+                ),
+            },
+        ),
+        (
+            "LDAP Configuration",
+            {
+                "classes": ("collapse",),
+                "fields": ("ldap_attribute",),
+            },
+        ),
+        (
+            "API Configuration",
+            {
+                "classes": ("collapse",),
+                "fields": ("api_endpoint", "api_field"),
+            },
+        ),
+        (
+            "Custom Configuration",
+            {
+                "classes": ("collapse",),
+                "fields": ("custom_config",),
+            },
+        ),
+    )
+
+
+@admin.register(FormDefinition)
+class FormDefinitionAdmin(admin.ModelAdmin):
+    list_display = (
+        "name",
+        "slug",
+        "is_active",
+        "requires_login",
+        "version",
+        "created_at",
+    )
+    list_filter = ("is_active", "requires_login")
+    search_fields = ("name", "slug", "description")
+    prepopulated_fields = {"slug": ("name",)}
+    inlines = [FormFieldInline]
+    filter_horizontal = ("submit_groups", "view_groups", "admin_groups")
+
+
+@admin.register(WorkflowDefinition)
+class WorkflowDefinitionAdmin(admin.ModelAdmin):
+    list_display = (
+        "form_definition",
+        "requires_approval",
+        "approval_logic",
+        "requires_manager_approval",
+    )
+    list_filter = (
+        "requires_approval",
+        "approval_logic",
+        "requires_manager_approval",
+    )
+    search_fields = ("form_definition__name",)
+    filter_horizontal = ("approval_groups", "escalation_groups")
+    fieldsets = (
+        (
+            None,
+            {
+                "fields": (
+                    "form_definition",
+                    ("requires_approval", "approval_logic"),
+                    "approval_groups",
+                )
+            },
+        ),
+        (
+            "Manager approval",
+            {
+                "classes": ("collapse",),
+                "fields": ("requires_manager_approval", "manager_can_override_group"),
+            },
+        ),
+        (
+            "Conditional escalation",
+            {
+                "classes": ("collapse",),
+                "fields": (
+                    ("escalation_field", "escalation_threshold"),
+                    "escalation_groups",
+                ),
+            },
+        ),
+        (
+            "Timeouts",
+            {
+                "classes": ("collapse",),
+                "fields": (
+                    "approval_deadline_days",
+                    "send_reminder_after_days",
+                    "auto_approve_after_days",
+                ),
+            },
+        ),
+        (
+            "Notifications",
+            {
+                "classes": ("collapse",),
+                "fields": (
+                    (
+                        "notify_on_submission",
+                        "notify_on_approval",
+                        "notify_on_rejection",
+                        "notify_on_withdrawal",
+                    ),
+                    "additional_notify_emails",
+                ),
+            },
+        ),
+        (
+            "Post-approval DB updates",
+            {
+                "classes": ("collapse",),
+                "fields": ("enable_db_updates", "db_update_mappings"),
+            },
+        ),
+    )
+
+
+@admin.register(PostSubmissionAction)
+class PostSubmissionActionAdmin(admin.ModelAdmin):
+    list_display = (
+        "name",
+        "form_definition",
+        "action_type",
+        "trigger",
+        "is_active",
+        "order",
+    )
+    list_filter = (
+        "action_type",
+        "trigger",
+        "is_active",
+        "form_definition",
+    )
+    search_fields = (
+        "name",
+        "description",
+        "form_definition__name",
+    )
+    list_editable = ("is_active", "order")
+    ordering = ("form_definition", "order", "name")
+
+    fieldsets = (
+        (
+            None,
+            {
+                "fields": (
+                    "form_definition",
+                    "name",
+                    "description",
+                    ("action_type", "trigger"),
+                    ("is_active", "order"),
+                )
+            },
+        ),
+        (
+            "Database Update Configuration",
+            {
+                "classes": ("collapse",),
+                "fields": (
+                    ("db_alias", "db_schema", "db_table"),
+                    ("db_lookup_field", "db_user_field"),
+                    "db_field_mappings",
+                ),
+                "description": (
+                    "Configure database updates. Field mappings format: "
+                    '[{"form_field": "email", "db_column": "EMAIL_ADDRESS"}, ...]'
+                ),
+            },
+        ),
+        (
+            "LDAP Update Configuration",
+            {
+                "classes": ("collapse",),
+                "fields": (
+                    "ldap_dn_template",
+                    "ldap_field_mappings",
+                ),
+                "description": (
+                    "Configure LDAP updates. Field mappings format: "
+                    '[{"form_field": "phone", "ldap_attribute": "telephoneNumber"}, ...]'
+                ),
+            },
+        ),
+        (
+            "API Call Configuration",
+            {
+                "classes": ("collapse",),
+                "fields": (
+                    ("api_endpoint", "api_method"),
+                    "api_headers",
+                    "api_body_template",
+                ),
+                "description": (
+                    "Configure API calls. Use {field_name} in body template for form field values."
+                ),
+            },
+        ),
+        (
+            "Custom Handler Configuration",
+            {
+                "classes": ("collapse",),
+                "fields": (
+                    "custom_handler_path",
+                    "custom_handler_config",
+                ),
+                "description": (
+                    "Python path to custom handler function (e.g., 'myapp.handlers.custom_update')"
+                ),
+            },
+        ),
+        (
+            "Conditional Execution",
+            {
+                "classes": ("collapse",),
+                "fields": (
+                    "condition_field",
+                    ("condition_operator", "condition_value"),
+                ),
+                "description": (
+                    "Execute this action only when the condition is met."
+                ),
+            },
+        ),
+        (
+            "Error Handling",
+            {
+                "classes": ("collapse",),
+                "fields": (
+                    "fail_silently",
+                    ("retry_on_failure", "max_retries"),
+                ),
+            },
+        ),
+        (
+            "Metadata",
+            {
+                "classes": ("collapse",),
+                "fields": (
+                    "created_at",
+                    "updated_at",
+                ),
+            },
+        ),
+    )
+
+    readonly_fields = ("created_at", "updated_at")
+
+
+@admin.register(FormSubmission)
+class FormSubmissionAdmin(admin.ModelAdmin):
+    list_display = (
+        "id",
+        "form_definition",
+        "submitter",
+        "status",
+        "created_at",
+        "submitted_at",
+        "completed_at",
+    )
+    list_filter = ("status", "form_definition")
+    date_hierarchy = "created_at"
+    search_fields = (
+        "id",
+        "form_definition__name",
+        "submitter__username",
+        "submitter__email",
+    )
+    raw_id_fields = ("submitter",)
+    readonly_fields = ("created_at", "submitted_at", "completed_at")
+
+
+@admin.register(ApprovalTask)
+class ApprovalTaskAdmin(admin.ModelAdmin):
+    list_display = (
+        "id",
+        "submission",
+        "step_name",
+        "status",
+        "assigned_to",
+        "assigned_group",
+        "due_date",
+        "completed_at",
+    )
+    list_filter = ("status", "step_name", "assigned_group")
+    search_fields = (
+        "submission__id",
+        "submission__form_definition__name",
+        "assigned_to__username",
+    )
+    raw_id_fields = ("submission", "assigned_to", "completed_by")
+    readonly_fields = ("created_at", "reminder_sent_at")
+
+
+@admin.register(AuditLog)
+class AuditLogAdmin(admin.ModelAdmin):
+    list_display = ("created_at", "user", "action", "object_type", "object_id")
+    list_filter = ("action", "object_type")
+    date_hierarchy = "created_at"
+    search_fields = (
+        "user__username",
+        "object_type",
+        "object_id",
+        "comments",
+    )
+    readonly_fields = (
+        "created_at",
+        "user",
+        "action",
+        "object_type",
+        "object_id",
+        "user_ip",
+        "changes",
+        "comments",
+    )
+
+
+@admin.register(UserProfile)
+class UserProfileAdmin(admin.ModelAdmin):
+    list_display = ("user", "department", "title", "employee_id")
+    search_fields = ("user__username", "user__email", "department", "title")
+    raw_id_fields = ("user", "manager")
+    list_filter = ("department",)
+

django_forms_workflows/apps.py

@@ -0,0 +1,22 @@
+"""
+Django Forms Workflows App Configuration
+"""
+
+from django.apps import AppConfig
+
+
+class DjangoFormsWorkflowsConfig(AppConfig):
+    """App configuration for Django Forms Workflows"""
+    
+    default_auto_field = 'django.db.models.BigAutoField'
+    name = 'django_forms_workflows'
+    verbose_name = 'Forms Workflows'
+    
+    def ready(self):
+        """
+        Import signal handlers and perform app initialization.
+        """
+        # Import signals if you have any
+        # from . import signals
+        pass
+

django_forms_workflows/data_sources/__init__.py

@@ -0,0 +1,79 @@
+"""
+Data Source Abstraction Layer
+
+Pluggable system for prefilling form fields from external sources:
+- LDAP/Active Directory
+- External databases
+- REST APIs
+- Custom sources
+
+Usage:
+    from django_forms_workflows.data_sources import get_data_source
+    
+    source = get_data_source('ldap')
+    value = source.get_value(user, 'department')
+"""
+
+from .base import DataSource, DataSourceRegistry
+from .user_source import UserDataSource
+from .ldap_source import LDAPDataSource
+from .database_source import DatabaseDataSource
+
+# Global registry
+registry = DataSourceRegistry()
+
+# Register built-in sources
+registry.register('user', UserDataSource)
+registry.register('ldap', LDAPDataSource)
+registry.register('database', DatabaseDataSource)
+registry.register('db', DatabaseDataSource)  # Alias
+
+
+def get_data_source(source_type):
+    """
+    Get a data source instance by type.
+    
+    Args:
+        source_type: Type of data source ('user', 'ldap', 'database', etc.)
+        
+    Returns:
+        DataSource instance
+        
+    Raises:
+        ValueError: If source type is not registered
+    """
+    return registry.get(source_type)
+
+
+def register_data_source(source_type, source_class):
+    """
+    Register a custom data source.
+    
+    Args:
+        source_type: Unique identifier for the source
+        source_class: DataSource subclass
+        
+    Example:
+        from django_forms_workflows.data_sources import register_data_source, DataSource
+        
+        class SalesforceSource(DataSource):
+            def get_value(self, user, field_name, **kwargs):
+                # Query Salesforce API
+                pass
+        
+        register_data_source('salesforce', SalesforceSource)
+    """
+    registry.register(source_type, source_class)
+
+
+__all__ = [
+    'DataSource',
+    'DataSourceRegistry',
+    'UserDataSource',
+    'LDAPDataSource',
+    'DatabaseDataSource',
+    'get_data_source',
+    'register_data_source',
+    'registry',
+]
+

django_forms_workflows/data_sources/base.py

@@ -0,0 +1,119 @@
+"""
+Base classes for data source abstraction
+"""
+
+from abc import ABC, abstractmethod
+from typing import Any, Optional, Dict
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+class DataSource(ABC):
+    """
+    Abstract base class for data sources.
+    
+    All data sources must implement the get_value method.
+    """
+    
+    @abstractmethod
+    def get_value(self, user, field_name: str, **kwargs) -> Optional[Any]:
+        """
+        Get a value from the data source.
+        
+        Args:
+            user: Django User object
+            field_name: Name of the field to retrieve
+            **kwargs: Additional parameters (e.g., schema, table, column)
+            
+        Returns:
+            The field value, or None if not found
+        """
+        pass
+    
+    def is_available(self) -> bool:
+        """
+        Check if this data source is available/configured.
+        
+        Returns:
+            True if the data source can be used, False otherwise
+        """
+        return True
+    
+    def get_display_name(self) -> str:
+        """
+        Get a human-readable name for this data source.
+        
+        Returns:
+            Display name
+        """
+        return self.__class__.__name__
+
+
+class DataSourceRegistry:
+    """
+    Registry for data sources.
+    
+    Allows registration and retrieval of data source implementations.
+    """
+    
+    def __init__(self):
+        self._sources: Dict[str, type] = {}
+    
+    def register(self, source_type: str, source_class: type):
+        """
+        Register a data source.
+        
+        Args:
+            source_type: Unique identifier for the source
+            source_class: DataSource subclass
+        """
+        if not issubclass(source_class, DataSource):
+            raise ValueError(f"{source_class} must be a subclass of DataSource")
+        
+        self._sources[source_type] = source_class
+        logger.info(f"Registered data source: {source_type} -> {source_class.__name__}")
+    
+    def get(self, source_type: str) -> DataSource:
+        """
+        Get a data source instance by type.
+        
+        Args:
+            source_type: Type of data source
+            
+        Returns:
+            DataSource instance
+            
+        Raises:
+            ValueError: If source type is not registered
+        """
+        if source_type not in self._sources:
+            raise ValueError(
+                f"Unknown data source type: {source_type}. "
+                f"Available types: {', '.join(self._sources.keys())}"
+            )
+        
+        source_class = self._sources[source_type]
+        return source_class()
+    
+    def list_sources(self) -> list:
+        """
+        List all registered data source types.
+        
+        Returns:
+            List of source type names
+        """
+        return list(self._sources.keys())
+    
+    def is_registered(self, source_type: str) -> bool:
+        """
+        Check if a source type is registered.
+        
+        Args:
+            source_type: Type to check
+            
+        Returns:
+            True if registered, False otherwise
+        """
+        return source_type in self._sources
+