django-forms-workflows 0.36.2__tar.gz → 0.36.4__tar.gz

{django_forms_workflows-0.36.2 → django_forms_workflows-0.36.4}/CHANGELOG.md

@@ -7,6 +7,25 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.36.4] - 2026-03-26
+
+### Added
+- **Dynamic dropdown choices from database** — select, multiselect, multiselect_list, radio, and checkboxes fields can now have their options populated live from any SQL query defined in `FORMS_WORKFLOWS_DATABASE_QUERIES`. Mark a query with `"return_choices": True` (and no user parameter) to return multiple rows; each row's first column becomes the option value and the second column (if present) becomes the display label. Wire it up by pointing the field's PrefillSource at the query key — the stored `choices` JSON is used as a fallback if the DB is unavailable.
+- `DatabaseDataSource.execute_choices_query(query_key)` — new method that executes a choices query without a user parameter and returns `[(value, label), ...]`.
+- `_get_choices_from_prefill_source(field_def)` — new helper on both form classes that detects `return_choices` queries and calls `execute_choices_query`; returns `None` when not applicable so callers fall back to stored choices.
+- `execute_custom_query` now warns and returns `None` if called on a `return_choices` query, preventing accidental single-value use.
+
+## [0.36.3] - 2026-03-26
+
+### Fixed
+- **Cross-instance sync missing newer fields** — `sync_api.serialize_form` and `_serialize_field` were not including several fields added after the serializer was first written, meaning push/pull/diff silently dropped their values on the receiving instance:
+  - `FormDefinition.allow_batch_import` (spreadsheet/Excel batch upload toggle, migration 0062)
+  - `FormDefinition.is_listed` (hide-from-list-page flag, migration 0051)
+  - `FormDefinition.allow_resubmit` (re-submission from rejected/withdrawn, migration 0024)
+  - `FormDefinition.api_enabled` (REST API exposure flag, migration 0063)
+  - `FormField.formula` (formula expression for Calculated field types, migration 0056)
+  All five fields are now serialized on export and restored on import. The diff summary in `diff_views._build_summary` is also updated to detect changes to all four FormDefinition flags.
+
 ## [0.33.1] - 2026-03-23
 
 ### Fixed

{django_forms_workflows-0.36.2 → django_forms_workflows-0.36.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: django-forms-workflows
-Version: 0.36.2
+Version: 0.36.4
 Summary: Enterprise-grade, database-driven form builder with approval workflows and external data integration
 License: LGPL-3.0-only
 License-File: LICENSE

{django_forms_workflows-0.36.2 → django_forms_workflows-0.36.4}/django_forms_workflows/data_sources/database_source.py

@@ -428,6 +428,16 @@ class DatabaseDataSource(DataSource):
                 )
                 return None
 
+            # Choices queries (return_choices=True) return multiple rows for
+            # populating dropdown options and require no user parameter.
+            # Use execute_choices_query() for those instead.
+            if query_config.get("return_choices"):
+                logger.warning(
+                    f"Database query '{query_key}' has return_choices=True. "
+                    "Use execute_choices_query() to get dropdown options."
+                )
+                return None
+
             # Get user's lookup value
             user_id = self._get_user_id(user, user_field)
             if not user_id:
@@ -461,6 +471,76 @@ class DatabaseDataSource(DataSource):
             logger.error(f"Error executing custom query '{query_key}': {e}")
             return None
 
+    def execute_choices_query(self, query_key: str) -> list[tuple] | None:
+        """
+        Execute a reference-data query and return all rows as (value, label) tuples
+        for populating dropdown / select / radio field options.
+
+        Unlike execute_custom_query(), this method requires no user parameter and
+        always fetches all rows. The query config must have ``return_choices: True``.
+
+        If the query returns two columns, the first is used as the option value and
+        the second as the display label. If only one column is returned, both value
+        and label are set to that column's value.
+
+        Args:
+            query_key: Key from FORMS_WORKFLOWS_DATABASE_QUERIES setting.
+
+        Returns:
+            List of (value, label) tuples, or None on configuration/query error.
+        """
+        try:
+            queries = getattr(settings, "FORMS_WORKFLOWS_DATABASE_QUERIES", {})
+            if query_key not in queries:
+                logger.error(
+                    f"Database query key '{query_key}' not found in "
+                    "FORMS_WORKFLOWS_DATABASE_QUERIES setting"
+                )
+                return None
+
+            query_config = queries[query_key]
+
+            if not query_config.get("return_choices"):
+                logger.error(
+                    f"Database query '{query_key}' does not have return_choices=True. "
+                    "Use execute_custom_query() for single-value prefill queries."
+                )
+                return None
+
+            query_text = query_config.get("query")
+            db_alias = query_config.get("db_alias")
+
+            if not query_text or not db_alias:
+                logger.error(
+                    f"Database choices query '{query_key}' missing 'query' or 'db_alias'"
+                )
+                return None
+
+            databases = getattr(settings, "DATABASES", {})
+            if db_alias not in databases:
+                logger.error(f"Database alias '{db_alias}' not configured")
+                return None
+
+            with connections[db_alias].cursor() as cursor:
+                cursor.execute(query_text)
+                rows = cursor.fetchall()
+
+            results = []
+            for row in rows:
+                if len(row) >= 2:
+                    value = str(row[0] or "").strip()
+                    label = str(row[1] or "").strip()
+                else:
+                    value = label = str(row[0] or "").strip()
+                if value:
+                    results.append((value, label))
+
+            return results
+
+        except Exception as e:
+            logger.error(f"Error executing choices query '{query_key}': {e}")
+            return None
+
     def is_available(self) -> bool:
         """
         Check if database source is configured.

{django_forms_workflows-0.36.2 → django_forms_workflows-0.36.4}/django_forms_workflows/diff_views.py

@@ -150,13 +150,17 @@ def _build_summary(forms_data):
             "description",
             "instructions",
             "is_active",
+            "is_listed",
             "allow_save_draft",
             "allow_withdrawal",
+            "allow_resubmit",
+            "allow_batch_import",
             "requires_login",
             "enable_multi_step",
             "enable_auto_save",
             "auto_save_interval",
             "pdf_generation",
+            "api_enabled",
         ]
         for key in meta_keys:
             if b_form.get(key) != o_form.get(key):

{django_forms_workflows-0.36.2 → django_forms_workflows-0.36.4}/django_forms_workflows/forms.py

@@ -276,6 +276,31 @@ class DynamicForm(forms.Form):
 
         return []
 
+    def _get_choices_from_prefill_source(self, field_def):
+        """
+        Return a list of (value, label) tuples from a database choices query when the
+        field's PrefillSource points to a query with ``return_choices=True``.
+
+        Returns None if the field has no such source (so the caller can fall back to
+        the stored ``field_def.choices``). Returns [] if the query ran but was empty.
+        """
+        prefill_key = field_def.get_prefill_source_key()
+        if not prefill_key or not prefill_key.startswith("dbquery."):
+            return None
+
+        query_key = prefill_key[len("dbquery.") :]
+
+        from django.conf import settings
+
+        queries = getattr(settings, "FORMS_WORKFLOWS_DATABASE_QUERIES", {})
+        if not queries.get(query_key, {}).get("return_choices"):
+            return None
+
+        from .data_sources import DatabaseDataSource
+
+        source = DatabaseDataSource()
+        return source.execute_choices_query(query_key)
+
     def add_field(self, field_def, initial_data):
         """Add a field to the form based on field definition"""
 
@@ -402,19 +427,34 @@ class DynamicForm(forms.Form):
             self.fields[field_def.field_name] = forms.URLField(**field_args)
 
         elif field_def.field_type == "select":
-            choices = [("", "-- Select --")] + self._parse_choices(field_def.choices)
+            _db_choices = self._get_choices_from_prefill_source(field_def)
+            choices = [("", "-- Select --")] + (
+                _db_choices
+                if _db_choices is not None
+                else self._parse_choices(field_def.choices)
+            )
             self.fields[field_def.field_name] = forms.ChoiceField(
                 choices=choices, **field_args
             )
 
         elif field_def.field_type == "multiselect":
-            choices = self._parse_choices(field_def.choices)
+            _db_choices = self._get_choices_from_prefill_source(field_def)
+            choices = (
+                _db_choices
+                if _db_choices is not None
+                else self._parse_choices(field_def.choices)
+            )
             self.fields[field_def.field_name] = forms.MultipleChoiceField(
                 choices=choices, widget=forms.CheckboxSelectMultiple, **field_args
             )
 
         elif field_def.field_type == "multiselect_list":
-            choices = self._parse_choices(field_def.choices)
+            _db_choices = self._get_choices_from_prefill_source(field_def)
+            choices = (
+                _db_choices
+                if _db_choices is not None
+                else self._parse_choices(field_def.choices)
+            )
             self.fields[field_def.field_name] = forms.MultipleChoiceField(
                 choices=choices,
                 widget=forms.SelectMultiple(attrs={"class": "form-select"}),
@@ -422,7 +462,12 @@ class DynamicForm(forms.Form):
             )
 
         elif field_def.field_type == "radio":
-            choices = self._parse_choices(field_def.choices)
+            _db_choices = self._get_choices_from_prefill_source(field_def)
+            choices = (
+                _db_choices
+                if _db_choices is not None
+                else self._parse_choices(field_def.choices)
+            )
             self.fields[field_def.field_name] = forms.ChoiceField(
                 choices=choices, widget=forms.RadioSelect, **field_args
             )
@@ -436,7 +481,12 @@ class DynamicForm(forms.Form):
             )
 
         elif field_def.field_type == "checkboxes":
-            choices = self._parse_choices(field_def.choices)
+            _db_choices = self._get_choices_from_prefill_source(field_def)
+            choices = (
+                _db_choices
+                if _db_choices is not None
+                else self._parse_choices(field_def.choices)
+            )
             self.fields[field_def.field_name] = forms.MultipleChoiceField(
                 choices=choices,
                 widget=forms.CheckboxSelectMultiple,
@@ -1057,7 +1107,12 @@ class ApprovalStepForm(forms.Form):
             self.fields[field_def.field_name] = forms.EmailField(**field_args)
 
         elif field_def.field_type == "select":
-            choices = [("", "-- Select --")] + self._parse_choices(field_def.choices)
+            _db_choices = self._get_choices_from_prefill_source(field_def)
+            choices = [("", "-- Select --")] + (
+                _db_choices
+                if _db_choices is not None
+                else self._parse_choices(field_def.choices)
+            )
             if widget_attrs:
                 field_args["widget"] = forms.Select(attrs=widget_attrs)
             self.fields[field_def.field_name] = forms.ChoiceField(
@@ -1065,7 +1120,12 @@ class ApprovalStepForm(forms.Form):
             )
 
         elif field_def.field_type == "multiselect":
-            choices = self._parse_choices(field_def.choices)
+            _db_choices = self._get_choices_from_prefill_source(field_def)
+            choices = (
+                _db_choices
+                if _db_choices is not None
+                else self._parse_choices(field_def.choices)
+            )
             self.fields[field_def.field_name] = forms.MultipleChoiceField(
                 choices=choices,
                 widget=forms.CheckboxSelectMultiple,
@@ -1073,7 +1133,12 @@ class ApprovalStepForm(forms.Form):
             )
 
         elif field_def.field_type == "multiselect_list":
-            choices = self._parse_choices(field_def.choices)
+            _db_choices = self._get_choices_from_prefill_source(field_def)
+            choices = (
+                _db_choices
+                if _db_choices is not None
+                else self._parse_choices(field_def.choices)
+            )
             self.fields[field_def.field_name] = forms.MultipleChoiceField(
                 choices=choices,
                 widget=forms.SelectMultiple(attrs={"class": "form-select"}),
@@ -1081,7 +1146,12 @@ class ApprovalStepForm(forms.Form):
             )
 
         elif field_def.field_type == "radio":
-            choices = self._parse_choices(field_def.choices)
+            _db_choices = self._get_choices_from_prefill_source(field_def)
+            choices = (
+                _db_choices
+                if _db_choices is not None
+                else self._parse_choices(field_def.choices)
+            )
             self.fields[field_def.field_name] = forms.ChoiceField(
                 choices=choices,
                 widget=forms.RadioSelect(attrs=widget_attrs),
@@ -1195,6 +1265,29 @@ class ApprovalStepForm(forms.Form):
             return [(c.strip(), c.strip()) for c in choices.split(",") if c.strip()]
         return []
 
+    def _get_choices_from_prefill_source(self, field_def):
+        """
+        Return (value, label) tuples from a database choices query when the field's
+        PrefillSource points to a query with ``return_choices=True``, or None if the
+        field has no such source (so the caller falls back to stored choices).
+        """
+        prefill_key = field_def.get_prefill_source_key()
+        if not prefill_key or not prefill_key.startswith("dbquery."):
+            return None
+
+        query_key = prefill_key[len("dbquery.") :]
+
+        from django.conf import settings
+
+        queries = getattr(settings, "FORMS_WORKFLOWS_DATABASE_QUERIES", {})
+        if not queries.get(query_key, {}).get("return_choices"):
+            return None
+
+        from .data_sources import DatabaseDataSource
+
+        source = DatabaseDataSource()
+        return source.execute_choices_query(query_key)
+
     def _build_layout_fields(self, field_defs):
         """Convert a list of field definitions into crispy layout elements,
         respecting half / third / fourth width settings."""

{django_forms_workflows-0.36.2 → django_forms_workflows-0.36.4}/django_forms_workflows/sync_api.py

@@ -216,6 +216,7 @@ def _serialize_field(field):
         "choices": field.choices,
         "prefill_source_config": _serialize_prefill_source(field.prefill_source_config),
         "default_value": field.default_value,
+        "formula": field.formula,
         "conditional_rules": field.conditional_rules,
         "validation_rules": field.validation_rules,
         "field_dependencies": field.field_dependencies,
@@ -373,18 +374,22 @@ def serialize_form(form_definition):
             "description": form_definition.description,
             "instructions": form_definition.instructions,
             "is_active": form_definition.is_active,
+            "is_listed": form_definition.is_listed,
             "version": form_definition.version,
             "submit_groups": _group_names(form_definition.submit_groups),
             "view_groups": _group_names(form_definition.view_groups),
             "admin_groups": _group_names(form_definition.admin_groups),
             "allow_save_draft": form_definition.allow_save_draft,
             "allow_withdrawal": form_definition.allow_withdrawal,
+            "allow_resubmit": form_definition.allow_resubmit,
+            "allow_batch_import": form_definition.allow_batch_import,
             "requires_login": form_definition.requires_login,
             "enable_multi_step": form_definition.enable_multi_step,
             "form_steps": form_definition.form_steps,
             "enable_auto_save": form_definition.enable_auto_save,
             "auto_save_interval": form_definition.auto_save_interval,
             "pdf_generation": form_definition.pdf_generation,
+            "api_enabled": form_definition.api_enabled,
         },
         "fields": [
             _serialize_field(f) for f in form_definition.fields.all().order_by("order")
@@ -521,16 +526,20 @@ def import_form(form_data, conflict="update", category_cache=None):
         "description": fd.get("description", ""),
         "instructions": fd.get("instructions", ""),
         "is_active": fd.get("is_active", True),
+        "is_listed": fd.get("is_listed", True),
         "version": fd.get("version", 1),
         "category": category,
         "allow_save_draft": fd.get("allow_save_draft", False),
         "allow_withdrawal": fd.get("allow_withdrawal", False),
+        "allow_resubmit": fd.get("allow_resubmit", False),
+        "allow_batch_import": fd.get("allow_batch_import", False),
         "requires_login": fd.get("requires_login", True),
         "enable_multi_step": fd.get("enable_multi_step", False),
         "form_steps": fd.get("form_steps"),
         "enable_auto_save": fd.get("enable_auto_save", False),
         "auto_save_interval": fd.get("auto_save_interval", 30),
         "pdf_generation": fd.get("pdf_generation", False),
+        "api_enabled": fd.get("api_enabled", False),
     }
 
     form_obj, created = FormDefinition.objects.update_or_create(

{django_forms_workflows-0.36.2 → django_forms_workflows-0.36.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "django-forms-workflows"
-version = "0.36.2"
+version = "0.36.4"
 description = "Enterprise-grade, database-driven form builder with approval workflows and external data integration"
 license = "LGPL-3.0-only"
 readme = "README.md"