django-forms-workflows 0.35.0__tar.gz → 0.35.2__tar.gz

{django_forms_workflows-0.35.0 → django_forms_workflows-0.35.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: django-forms-workflows
-Version: 0.35.0
+Version: 0.35.2
 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.35.0 → django_forms_workflows-0.35.2}/django_forms_workflows/admin.py

@@ -6,6 +6,7 @@ configure approval workflows, and review submissions and audit logs.
 """
 
 import json
+import logging
 
 import nested_admin
 from django.contrib import admin
@@ -42,6 +43,8 @@ from .models import (
     WorkflowStage,
 )
 
+logger = logging.getLogger(__name__)
+
 
 # Inline for form fields when editing a form definition
 class FormFieldInline(nested_admin.NestedStackedInline):
@@ -655,7 +658,9 @@ class FormDefinitionAdmin(nested_admin.NestedModelAdmin):
                                 data_prefix=swc.data_prefix,
                             )
                         except SubWorkflowDefinition.DoesNotExist:
-                            pass
+                            logger.debug(
+                                "SubWorkflowDefinition not found during clone; skipping component"
+                            )
 
                     cloned_count += 1
             except Exception as e:
@@ -679,7 +684,7 @@ class FormDefinitionAdmin(nested_admin.NestedModelAdmin):
             self.message_user(
                 request, "Select at least 2 forms to diff.", level="error"
             )
-            return
+            return None
         pks = ",".join(str(pk) for pk in queryset.values_list("pk", flat=True))
         from django.urls import reverse
 
@@ -1944,10 +1949,9 @@ class ManagedFileAdmin(admin.ModelAdmin):
         """Display file size in human-readable format."""
         if obj.file_size < 1024:
             return f"{obj.file_size} B"
-        elif obj.file_size < 1024 * 1024:
+        if obj.file_size < 1024 * 1024:
             return f"{obj.file_size / 1024:.1f} KB"
-        else:
-            return f"{obj.file_size / (1024 * 1024):.1f} MB"
+        return f"{obj.file_size / (1024 * 1024):.1f} MB"
 
     file_size_display.short_description = "Size"
 

{django_forms_workflows-0.35.0 → django_forms_workflows-0.35.2}/django_forms_workflows/data_sources/database_source.py

@@ -105,7 +105,7 @@ class DatabaseDataSource(DataSource):
                 return None
 
             # Query the database
-            value = self._query_database(
+            return self._query_database(
                 database_alias=database_alias,
                 schema=schema,
                 table=table,
@@ -114,8 +114,6 @@ class DatabaseDataSource(DataSource):
                 lookup_field=lookup_field,
             )
 
-            return value
-
         except Exception as e:
             logger.error(f"Error getting database value for {field_name}: {e}")
             return None
@@ -176,11 +174,10 @@ class DatabaseDataSource(DataSource):
 
         if len(parts) == 3:
             return parts[0], parts[1], parts[2]
-        elif len(parts) == 2:
+        if len(parts) == 2:
             # Assume default schema
             return default_schema, parts[0], parts[1]
-        else:
-            return None, None, None
+        return None, None, None
 
     def _is_safe_identifier(self, identifier: str) -> bool:
         """

{django_forms_workflows-0.35.0 → django_forms_workflows-0.35.2}/django_forms_workflows/data_sources/ldap_source.py

@@ -105,9 +105,9 @@ class LDAPDataSource(DataSource):
         Query LDAP directly for a user attribute.
 
         This is used for SSO users who don't have a cached ldap_user object.
+        TLS configuration is applied via configure_ldap_connection(), which
+        respects FORMS_WORKFLOWS_LDAP_ALLOW_SELF_SIGNED and LDAP_TLS_REQUIRE_CERT.
         """
-        import os
-
         try:
             import ldap
             from ldap.filter import escape_filter_chars
@@ -140,14 +140,12 @@ class LDAPDataSource(DataSource):
             return None
 
         try:
+            from django_forms_workflows.ldap_backend import configure_ldap_connection
+
             conn = ldap.initialize(ldap_server)
-            conn.set_option(ldap.OPT_REFERRALS, 0)
             conn.set_option(ldap.OPT_PROTOCOL_VERSION, ldap.VERSION3)
-
-            # Configure TLS
-            tls_require_cert = os.getenv("LDAP_TLS_REQUIRE_CERT", "demand").lower()
-            if tls_require_cert == "never":
-                conn.set_option(ldap.OPT_X_TLS_REQUIRE_CERT, ldap.OPT_X_TLS_NEVER)
+            # Apply TLS + referral settings centrally (honours FORMS_WORKFLOWS_LDAP_ALLOW_SELF_SIGNED)
+            configure_ldap_connection(conn)
 
             if bind_dn and bind_password:
                 conn.simple_bind_s(bind_dn, bind_password)
@@ -178,7 +176,7 @@ class LDAPDataSource(DataSource):
             try:
                 conn.unbind_s()
             except Exception:
-                pass
+                logger.debug("Could not unbind LDAP connection", exc_info=True)
 
     def _get_manager_email(self, ldap_user) -> str | None:
         """

{django_forms_workflows-0.35.0 → django_forms_workflows-0.35.2}/django_forms_workflows/email_backends/gmail_api.py

@@ -78,8 +78,7 @@ def get_gmail_service(config):
         credentials = credentials.with_subject(delegated_user)
 
     # Build the Gmail service
-    service = build("gmail", "v1", credentials=credentials, cache_discovery=False)
-    return service
+    return build("gmail", "v1", credentials=credentials, cache_discovery=False)
 
 
 class GmailAPIBackend(BaseEmailBackend):

{django_forms_workflows-0.35.0 → django_forms_workflows-0.35.2}/django_forms_workflows/form_builder_views.py

@@ -210,7 +210,9 @@ def form_builder_clone(request, form_id):
                         data_prefix=swc.data_prefix,
                     )
                 except SubWorkflowDefinition.DoesNotExist:
-                    pass
+                    logger.debug(
+                        "SubWorkflowDefinition not found during clone; skipping component"
+                    )
 
             return JsonResponse(
                 {

{django_forms_workflows-0.35.0 → django_forms_workflows-0.35.2}/django_forms_workflows/forms.py

@@ -395,6 +395,14 @@ class DynamicForm(forms.Form):
                 choices=choices, widget=forms.CheckboxSelectMultiple, **field_args
             )
 
+        elif field_def.field_type == "multiselect_list":
+            choices = self._parse_choices(field_def.choices)
+            self.fields[field_def.field_name] = forms.MultipleChoiceField(
+                choices=choices,
+                widget=forms.SelectMultiple(attrs={"class": "form-select"}),
+                **field_args,
+            )
+
         elif field_def.field_type == "radio":
             choices = self._parse_choices(field_def.choices)
             self.fields[field_def.field_name] = forms.ChoiceField(
@@ -541,19 +549,19 @@ class DynamicForm(forms.Form):
                 return source.get_value(self.user, field_name) or ""
 
             # Handle ldap.* sources
-            elif prefill_source.startswith("ldap."):
+            if prefill_source.startswith("ldap."):
                 source = LDAPDataSource()
                 field_name = prefill_source.replace("ldap.", "")
                 return source.get_value(self.user, field_name) or ""
 
             # Handle dbquery.* sources (code-defined complex queries)
-            elif prefill_source.startswith("dbquery."):
+            if prefill_source.startswith("dbquery."):
                 source = DatabaseDataSource()
                 query_key = prefill_source.replace("dbquery.", "")
                 return source.execute_custom_query(self.user, query_key) or ""
 
             # Handle db.* or {{ db.* }} sources
-            elif prefill_source.startswith("db.") or prefill_source.startswith("{{"):
+            if prefill_source.startswith("db.") or prefill_source.startswith("{{"):
                 source = DatabaseDataSource()
 
                 # Build kwargs from prefill_config
@@ -1012,6 +1020,22 @@ class ApprovalStepForm(forms.Form):
                 choices=choices, **field_args
             )
 
+        elif field_def.field_type == "multiselect":
+            choices = 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)
+            self.fields[field_def.field_name] = forms.MultipleChoiceField(
+                choices=choices,
+                widget=forms.SelectMultiple(attrs={"class": "form-select"}),
+                **field_args,
+            )
+
         elif field_def.field_type == "radio":
             choices = self._parse_choices(field_def.choices)
             self.fields[field_def.field_name] = forms.ChoiceField(

{django_forms_workflows-0.35.0 → django_forms_workflows-0.35.2}/django_forms_workflows/handlers/api_handler.py

@@ -178,15 +178,14 @@ class APICallHandler(BaseActionHandler):
                         "response": response.text[:500],  # First 500 chars
                     },
                 }
-            else:
-                return {
-                    "success": False,
-                    "message": f"API call failed: {method} {url} -> {response.status_code}",
-                    "data": {
-                        "status_code": response.status_code,
-                        "response": response.text[:500],
-                    },
-                }
+            return {
+                "success": False,
+                "message": f"API call failed: {method} {url} -> {response.status_code}",
+                "data": {
+                    "status_code": response.status_code,
+                    "response": response.text[:500],
+                },
+            }
 
         except requests.exceptions.Timeout:
             return {"success": False, "message": f"API call timed out: {method} {url}"}

{django_forms_workflows-0.35.0 → django_forms_workflows-0.35.2}/django_forms_workflows/handlers/email_handler.py

@@ -338,11 +338,10 @@ class EmailHandler(BaseActionHandler):
                         "subject": subject,
                     },
                 }
-            else:
-                return {
-                    "success": False,
-                    "message": "Email send returned 0 (no emails sent)",
-                }
+            return {
+                "success": False,
+                "message": "Email send returned 0 (no emails sent)",
+            }
 
         except Exception as e:
             return {

{django_forms_workflows-0.35.0 → django_forms_workflows-0.35.2}/django_forms_workflows/handlers/file_handler.py

@@ -80,9 +80,7 @@ class FilePatternResolver:
         result = re.sub(r"\{[^}]+\}", "", result)
         # Clean up double slashes/underscores
         result = re.sub(r"//+", "/", result)
-        result = re.sub(r"__+", "_", result)
-
-        return result
+        return re.sub(r"__+", "_", result)
 
     def _get_employee_id(self):
         """Get employee ID from user profile."""
@@ -92,7 +90,9 @@ class FilePatternResolver:
             if hasattr(self.user, "profile"):
                 return getattr(self.user.profile, "employee_id", "") or ""
         except Exception:
-            pass
+            logger.debug(
+                "Could not retrieve employee_id from user profile", exc_info=True
+            )
         return ""
 
     def _get_field_name(self):
@@ -140,8 +140,7 @@ class FileOperationHandler:
 
                 logger.info(f"Renamed file from {old_path} to {new_path}")
                 return {"success": True, "message": f"Renamed to {new_filename}"}
-            else:
-                return {"success": False, "message": f"File not found: {old_path}"}
+            return {"success": False, "message": f"File not found: {old_path}"}
 
         except Exception as e:
             logger.error(f"Error renaming file: {e}", exc_info=True)
@@ -177,8 +176,7 @@ class FileOperationHandler:
 
                 logger.info(f"Moved file from {old_path} to {new_path}")
                 return {"success": True, "message": f"Moved to {new_path}"}
-            else:
-                return {"success": False, "message": f"File not found: {old_path}"}
+            return {"success": False, "message": f"File not found: {old_path}"}
 
         except Exception as e:
             logger.error(f"Error moving file: {e}", exc_info=True)
@@ -208,8 +206,7 @@ class FileOperationHandler:
 
                 logger.info(f"Copied file from {old_path} to {new_path}")
                 return {"success": True, "message": f"Copied to {new_path}"}
-            else:
-                return {"success": False, "message": f"File not found: {old_path}"}
+            return {"success": False, "message": f"File not found: {old_path}"}
 
         except Exception as e:
             logger.error(f"Error copying file: {e}", exc_info=True)
@@ -230,8 +227,7 @@ class FileOperationHandler:
 
                 logger.info(f"Deleted file: {file_path}")
                 return {"success": True, "message": f"Deleted {file_path}"}
-            else:
-                return {"success": False, "message": f"File not found: {file_path}"}
+            return {"success": False, "message": f"File not found: {file_path}"}
 
         except Exception as e:
             logger.error(f"Error deleting file: {e}", exc_info=True)
@@ -277,13 +273,12 @@ class WebhookHandler:
                     "message": f"Webhook returned {response.status_code}",
                     "data": {"status_code": response.status_code},
                 }
-            else:
-                logger.warning(f"Webhook call failed: {url} ({response.status_code})")
-                return {
-                    "success": False,
-                    "message": f"Webhook returned {response.status_code}",
-                    "data": {"status_code": response.status_code},
-                }
+            logger.warning(f"Webhook call failed: {url} ({response.status_code})")
+            return {
+                "success": False,
+                "message": f"Webhook returned {response.status_code}",
+                "data": {"status_code": response.status_code},
+            }
 
         except requests.Timeout:
             logger.error(f"Webhook timeout: {self.hook.webhook_url}")

{django_forms_workflows-0.35.0 → django_forms_workflows-0.35.2}/django_forms_workflows/handlers/ldap_handler.py

@@ -153,12 +153,13 @@ class LDAPUpdateHandler(BaseActionHandler):
                 if value:
                     placeholders[field] = value
         except Exception:
-            pass
+            logger.debug(
+                "Could not load user profile fields for LDAP DN template", exc_info=True
+            )
 
         # Replace placeholders
         try:
-            dn = template.format(**placeholders)
-            return dn
+            return template.format(**placeholders)
         except KeyError as e:
             self.log_error(f"Missing placeholder in DN template: {e}")
             return None

{django_forms_workflows-0.35.0 → django_forms_workflows-0.35.2}/django_forms_workflows/ldap_backend.py

@@ -21,37 +21,53 @@ logger = logging.getLogger(__name__)
 
 def configure_ldap_connection(conn):
     """
-    Configure LDAP connection with TLS settings from environment variables.
+    Configure LDAP connection with TLS settings.
 
-    This function applies TLS certificate verification settings based on the
-    LDAP_TLS_REQUIRE_CERT environment variable.
+    Checks the ``FORMS_WORKFLOWS_LDAP_ALLOW_SELF_SIGNED`` Django setting first.
+    When ``True``, self-signed certificates are accepted (``OPT_X_TLS_ALLOW``).
+
+    Falls back to the ``LDAP_TLS_REQUIRE_CERT`` environment variable for
+    fine-grained control:
+        - ``'never'``  – never require/verify certificates
+        - ``'allow'``  – allow self-signed / unverifiable certificates
+        - ``'try'``    – try to verify; proceed even if verification fails
+        - ``'demand'`` – require a valid certificate (default)
+
+    Django Settings:
+        FORMS_WORKFLOWS_LDAP_ALLOW_SELF_SIGNED (bool):
+            Set to ``True`` to accept self-signed LDAP/AD certificates.
+            Takes precedence over the ``LDAP_TLS_REQUIRE_CERT`` env var.
+            Default: ``False``.
 
     Args:
         conn: LDAP connection object
-
-    Environment Variables:
-        LDAP_TLS_REQUIRE_CERT: TLS certificate verification level
-            - 'never': Don't require or verify certificates (ldap.OPT_X_TLS_NEVER)
-            - 'allow': Allow connection without cert verification (ldap.OPT_X_TLS_ALLOW)
-            - 'try': Try to verify but proceed if verification fails (ldap.OPT_X_TLS_TRY)
-            - 'demand' or 'hard': Require valid certificate (ldap.OPT_X_TLS_DEMAND)
-            - Default: 'demand'
     """
-    # Configure TLS settings based on environment variable
-    tls_require_cert = os.getenv("LDAP_TLS_REQUIRE_CERT", "demand").lower()
+    # Check Django setting first — simple on/off for self-signed cert acceptance
+    allow_self_signed = getattr(
+        settings, "FORMS_WORKFLOWS_LDAP_ALLOW_SELF_SIGNED", False
+    )
 
-    if tls_require_cert == "never":
-        conn.set_option(ldap.OPT_X_TLS_REQUIRE_CERT, ldap.OPT_X_TLS_NEVER)
-        logger.debug("LDAP TLS certificate verification: NEVER")
-    elif tls_require_cert == "allow":
+    if allow_self_signed:
         conn.set_option(ldap.OPT_X_TLS_REQUIRE_CERT, ldap.OPT_X_TLS_ALLOW)
-        logger.debug("LDAP TLS certificate verification: ALLOW")
-    elif tls_require_cert == "try":
-        conn.set_option(ldap.OPT_X_TLS_REQUIRE_CERT, ldap.OPT_X_TLS_TRY)
-        logger.debug("LDAP TLS certificate verification: TRY")
-    else:  # 'demand' or 'hard' or any other value
-        conn.set_option(ldap.OPT_X_TLS_REQUIRE_CERT, ldap.OPT_X_TLS_DEMAND)
-        logger.debug("LDAP TLS certificate verification: DEMAND")
+        logger.debug(
+            "LDAP TLS certificate verification: ALLOW (FORMS_WORKFLOWS_LDAP_ALLOW_SELF_SIGNED=True)"
+        )
+    else:
+        # Fall back to env-var-based configuration for fine-grained control
+        tls_require_cert = os.getenv("LDAP_TLS_REQUIRE_CERT", "demand").lower()
+
+        if tls_require_cert == "never":
+            conn.set_option(ldap.OPT_X_TLS_REQUIRE_CERT, ldap.OPT_X_TLS_NEVER)
+            logger.debug("LDAP TLS certificate verification: NEVER")
+        elif tls_require_cert == "allow":
+            conn.set_option(ldap.OPT_X_TLS_REQUIRE_CERT, ldap.OPT_X_TLS_ALLOW)
+            logger.debug("LDAP TLS certificate verification: ALLOW")
+        elif tls_require_cert == "try":
+            conn.set_option(ldap.OPT_X_TLS_REQUIRE_CERT, ldap.OPT_X_TLS_TRY)
+            logger.debug("LDAP TLS certificate verification: TRY")
+        else:  # 'demand' or 'hard' or any other value
+            conn.set_option(ldap.OPT_X_TLS_REQUIRE_CERT, ldap.OPT_X_TLS_DEMAND)
+            logger.debug("LDAP TLS certificate verification: DEMAND")
 
     # Set other standard options
     conn.set_option(ldap.OPT_REFERRALS, 0)
@@ -339,8 +355,7 @@ def get_user_manager(user):
                         User = get_user_model()
 
                         try:
-                            manager_user = User.objects.get(username=manager_username)
-                            return manager_user
+                            return User.objects.get(username=manager_username)
                         except User.DoesNotExist:
                             logger.warning(
                                 f"Manager {manager_username} not found in Django database"

{django_forms_workflows-0.35.0 → django_forms_workflows-0.35.2}/django_forms_workflows/management/commands/sync_ldap_users.py

@@ -98,6 +98,7 @@ class Command(BaseCommand):
             self.stderr.write(self.style.ERROR(f"LDAP connection failed: {e}"))
             return
 
+        results = []
         try:
             conn.set_option(ldap.OPT_SIZELIMIT, max_results)
             results = conn.search_s(
@@ -108,9 +109,10 @@ class Command(BaseCommand):
             )
         except ldap.SIZELIMIT_EXCEEDED:
             self.stdout.write(
-                self.style.WARNING(f"Hit LDAP size limit ({max_results})")
+                self.style.WARNING(
+                    f"Hit LDAP size limit ({max_results}); results may be partial"
+                )
             )
-            results = []
         except Exception as e:
             self.stderr.write(self.style.ERROR(f"LDAP search failed: {e}"))
             conn.unbind_s()
@@ -158,7 +160,11 @@ class Command(BaseCommand):
                         defaults={"department": dept, "title": title},
                     )
                 except Exception:
-                    pass
+                    logger.debug(
+                        "UserProfile creation failed for '%s'; continuing",
+                        username,
+                        exc_info=True,
+                    )
                 created += 1
             except Exception as e:
                 errors += 1

django_forms_workflows-0.35.2/django_forms_workflows/migrations/0059_add_multiselect_list_field_type.py

@@ -0,0 +1,57 @@
+"""
+Add multiselect_list field type.
+
+Adds "Multiple Select (List)" as an alternative to the existing
+"Multiple Select (Checkboxes)" (multiselect) field type.  The new type
+renders using Django's SelectMultiple widget (<select multiple>) rather
+than CheckboxSelectMultiple.
+
+The label of the existing 'multiselect' choice is also updated from
+"Multiple Select" to "Multiple Select (Checkboxes)" to make the
+distinction clear in the admin UI.
+"""
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("django_forms_workflows", "0058_rename_assignee_email_field_add_lookup_type"),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name="formfield",
+            name="field_type",
+            field=models.CharField(
+                max_length=20,
+                choices=[
+                    ("text", "Single Line Text"),
+                    ("phone", "Phone Number"),
+                    ("textarea", "Multi-line Text"),
+                    ("number", "Whole Number"),
+                    ("decimal", "Decimal Number"),
+                    ("currency", "Currency ($)"),
+                    ("date", "Date"),
+                    ("datetime", "Date and Time"),
+                    ("time", "Time"),
+                    ("email", "Email Address"),
+                    ("url", "Website URL"),
+                    ("select", "Dropdown Select"),
+                    ("multiselect", "Multiple Select (Checkboxes)"),
+                    ("multiselect_list", "Multiple Select (List)"),
+                    ("radio", "Radio Buttons"),
+                    ("checkbox", "Single Checkbox"),
+                    ("checkboxes", "Multiple Checkboxes"),
+                    ("file", "File Upload"),
+                    ("multifile", "Multi-File Upload"),
+                    ("hidden", "Hidden Field"),
+                    ("section", "Section Header (not a field)"),
+                    ("calculated", "Calculated / Formula"),
+                    ("spreadsheet", "Spreadsheet Upload (CSV / Excel)"),
+                ],
+            ),
+        ),
+    ]
+

{django_forms_workflows-0.35.0 → django_forms_workflows-0.35.2}/django_forms_workflows/models.py

@@ -373,7 +373,7 @@ class PrefillSource(models.Model):
             if self.db_template and self.db_columns:
                 return f"{{{{ {self.db_schema}.{self.db_table}.* }}}}"
             # Single column lookup
-            elif self.db_column:
+            if self.db_column:
                 return f"{{{{ {self.db_schema}.{self.db_table}.{self.db_column} }}}}"
         elif self.source_type == "ldap" and self.ldap_attribute:
             return f"ldap.{self.ldap_attribute}"
@@ -411,7 +411,8 @@ class FormField(models.Model):
         ("email", "Email Address"),
         ("url", "Website URL"),
         ("select", "Dropdown Select"),
-        ("multiselect", "Multiple Select"),
+        ("multiselect", "Multiple Select (Checkboxes)"),
+        ("multiselect_list", "Multiple Select (List)"),
         ("radio", "Radio Buttons"),
         ("checkbox", "Single Checkbox"),
         ("checkboxes", "Multiple Checkboxes"),
@@ -825,9 +826,13 @@ class WorkflowStage(models.Model):
             "How to resolve the form field value to a system user. "
             "'Email' looks up by email address. "
             "'Username' looks up by sAMAccountName/username. "
-            "'Full name' matches against first + last name. "
-            "'LDAP lookup' searches Active Directory by display name and "
-            "auto-provisions the Django user if not yet in the system."
+            "'Full name' matches against Django User first_name + last_name (iexact), "
+            "then falls back to an LDAP search — NOTE: for Google SSO-only sites, "
+            "first_name/last_name are only populated if Google SAML sends those "
+            "attributes or users were pre-provisioned via sync_ldap_users. "
+            "'LDAP lookup' searches Active Directory directly by display name and "
+            "auto-provisions the Django user if not yet in the system — recommended "
+            "for sites where SSO does not populate first/last name."
         ),
     )
     allow_send_back = models.BooleanField(
@@ -1264,8 +1269,7 @@ class PostSubmissionAction(models.Model):
         # Check if action is locked and has already executed
         if self.is_locked:
             # Check if this action has already executed successfully for this submission
-            from django_forms_workflows.models import ActionExecutionLog
-
+            # ActionExecutionLog is defined later in this module; safe to reference at runtime
             if ActionExecutionLog.objects.filter(
                 action=self, submission=submission, success=True
             ).exists():
@@ -1277,13 +1281,13 @@ class PostSubmissionAction(models.Model):
 
             if self.condition_operator == "equals":
                 return str(field_value) == self.condition_value
-            elif self.condition_operator == "not_equals":
+            if self.condition_operator == "not_equals":
                 return str(field_value) != self.condition_value
-            elif self.condition_operator == "contains":
+            if self.condition_operator == "contains":
                 return self.condition_value in str(field_value)
-            elif self.condition_operator == "not_contains":
+            if self.condition_operator == "not_contains":
                 return self.condition_value not in str(field_value)
-            elif self.condition_operator == "greater_than":
+            if self.condition_operator == "greater_than":
                 try:
                     return float(field_value) > float(self.condition_value)
                 except (ValueError, TypeError):
@@ -2268,11 +2272,11 @@ class FileWorkflowHook(models.Model):
 
         if self.condition_operator == "equals":
             return str(field_value) == self.condition_value
-        elif self.condition_operator == "not_equals":
+        if self.condition_operator == "not_equals":
             return str(field_value) != self.condition_value
-        elif self.condition_operator == "contains":
+        if self.condition_operator == "contains":
             return self.condition_value in str(field_value)
-        elif self.condition_operator == "greater_than":
+        if self.condition_operator == "greater_than":
             try:
                 return float(field_value) > float(self.condition_value)
             except (ValueError, TypeError):