Feature/5074 transform selectboxes data

src/openforms/forms/models/form.py

@@ -25,6 +25,7 @@
 from openforms.authentication.registry import register as authentication_register
 from openforms.config.models import GlobalConfiguration
 from openforms.data_removal.constants import RemovalMethods
+from openforms.formio.datastructures import FormioConfigurationWrapper
 from openforms.formio.validators import variable_key_validator
 from openforms.payments.fields import PaymentBackendChoiceField
 from openforms.payments.registry import register as payment_register
@@ -609,6 +610,17 @@ def iter_components(self, recursive=True):
         for form_step in self.formstep_set.select_related("form_definition"):
             yield from form_step.iter_components(recursive=recursive)
 
+    def get_total_configuration(self) -> FormioConfigurationWrapper:
+        """
+        Return the total joined FormIO configuration of all FormSteps belonging to this Form
+        """
+        raw_configs = self.formstep_set.select_related("form_definition").values_list(
+            "form_definition__configuration", flat=True
+        )
+        configs = [FormioConfigurationWrapper(config) for config in raw_configs]
+        configuration = sum(configs, FormioConfigurationWrapper({"components": []}))
+        return configuration
+
     @transaction.atomic
     def restore_old_version(
         self, form_version_uuid: str, user: User | None = None

src/openforms/registrations/tests/test_registration_hook.py

@@ -381,6 +381,112 @@ def test_registration_hook_with_failed_and_completed_payments(self):
         failed_payments = submission.payments.filter(status=PaymentStatus.failed)
         self.assertEqual(failed_payments.count(), 1)
 
+    def test_register_submission_transform_selectboxes_data(self):
+        register = Registry()
+
+        submission = SubmissionFactory.from_components(
+            components_list=[
+                {
+                    "key": "selectboxes",
+                    "label": "Selectboxes",
+                    "type": "selectboxes",
+                    "openForms": {
+                        "dataSrc": "manual",
+                        "translations": {},
+                        "transformData": True,
+                    },
+                    "values": [
+                        {"value": "foo", "label": "foo"},
+                        {"value": "bar", "label": "bar"},
+                        {"value": "baz", "label": "baz"},
+                    ],
+                }
+            ],
+            submitted_data={"selectboxes": {"foo": True, "bar": False, "baz": True}},
+            completed=True,
+            form__registration_backend="callback",
+            form__registration_backend_options={
+                "string": "some-option",
+                "service": self.service.id,
+            },
+        )
+
+        # register the callback, including the assertions
+        test_closure = self
+
+        @register("callback")
+        class Plugin(BasePlugin):
+            verbose_name = "Assertion callback"
+            configuration_options = OptionsSerializer
+
+            def register_submission(self, submission, options):
+                state = submission.load_submission_value_variables_state()
+                data_to_submit = state.get_data()
+                test_closure.assertEqual(
+                    data_to_submit, {"selectboxes": ["baz", "foo"]}
+                )
+                return {"result": "ok"}
+
+        # call the hook for the submission, while patching the model field registry
+        model_field = FormRegistrationBackend._meta.get_field("backend")
+        with patch_registry(model_field, register):
+            register_submission(submission.id, PostSubmissionEvents.on_completion)
+
+        submission.refresh_from_db()
+        self.assertEqual(
+            submission.registration_result,
+            {"result": "ok"},
+        )
+
+    def test_register_submission_transform_data_function_undefined(self):
+        register = Registry()
+
+        submission = SubmissionFactory.from_components(
+            components_list=[
+                {
+                    "key": "textfield",
+                    "label": "Field that has no transform function defined",
+                    "type": "text",
+                    "openForms": {
+                        "translations": {},
+                        "transformData": True,
+                    },
+                }
+            ],
+            submitted_data={"textfield": "foo"},
+            completed=True,
+            form__registration_backend="callback",
+            form__registration_backend_options={
+                "string": "some-option",
+                "service": self.service.id,
+            },
+        )
+
+        # register the callback, including the assertions
+        test_closure = self
+
+        @register("callback")
+        class Plugin(BasePlugin):
+            verbose_name = "Assertion callback"
+            configuration_options = OptionsSerializer
+
+            def register_submission(self, submission, options):
+                state = submission.load_submission_value_variables_state()
+                data_to_submit = state.get_data()
+                test_closure.assertEqual(data_to_submit, {"textfield": "foo"})
+                return {"result": "ok"}
+
+        # call the hook for the submission, while patching the model field registry
+        model_field = FormRegistrationBackend._meta.get_field("backend")
+        with patch_registry(model_field, register):
+            register_submission(submission.id, PostSubmissionEvents.on_completion)
+
+        submission.refresh_from_db()
+        self.assertEqual(
+            submission.registration_result,
+            {"result": "ok"},
+        )
+
 
 class NumRegistrationsTest(TestCase):
     @patch("openforms.plugins.plugin.GlobalConfiguration.get_solo")

src/openforms/submissions/models/submission_value_variable.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import logging
 from dataclasses import dataclass, field
 from datetime import date, datetime, time
 from typing import TYPE_CHECKING, Any, Literal, overload
@@ -11,6 +12,8 @@
 from django.utils.functional import empty
 from django.utils.translation import gettext_lazy as _
 
+from glom import glom
+
 from openforms.formio.service import FormioData
 from openforms.forms.models.form_variable import FormVariable
 from openforms.typing import DataMapping, JSONEncodable, JSONObject, JSONSerializable
@@ -19,11 +22,14 @@
 from openforms.variables.service import VariablesRegistry, get_static_variables
 
 from ..constants import SubmissionValueVariableSources
+from ..transform_data import TRANSFORM_DATA_MAPPING
 from .submission import Submission
 
 if TYPE_CHECKING:
     from .submission_step import SubmissionStep
 
+logger = logging.getLogger(__name__)
+
 
 class ValueEncoder(DjangoJSONEncoder):
     def default(self, obj: JSONEncodable | JSONSerializable) -> JSONEncodable:
@@ -94,6 +100,8 @@ def get_data(
             )
 
         formio_data = FormioData()
+        configuration = self.submission.form.get_total_configuration()
+
         for variable_key, variable in submission_variables.items():
             if (
                 variable.value is None
@@ -104,7 +112,24 @@ def get_data(
                 continue
 
             if variable.source != SubmissionValueVariableSources.sensitive_data_cleaner:
-                formio_data[variable_key] = variable.value
+                component_configuration = configuration[variable.key]
+
+                if glom(
+                    component_configuration, "openForms.transformData", default=None
+                ):
+                    transform_function = TRANSFORM_DATA_MAPPING.get(
+                        component_configuration["type"]
+                    )
+                    if not transform_function:
+                        logger.warning(
+                            "Incorrect configuration, component of type `%s` has `openForms.transformData` "
+                            "set to true, but no transform function is defined in TRANSFORM_DATA_MAPPING",
+                            component_configuration["type"],
+                        )
+                        transform_function = lambda value: value
+                    formio_data[variable_key] = transform_function(variable.value)
+                else:
+                    formio_data[variable_key] = variable.value
         return formio_data if as_formio_data else formio_data.data
 
     def get_variables_in_submission_step(

src/openforms/submissions/transform_data.py

@@ -0,0 +1,8 @@
+def transform_selectboxes_data(value: dict[str, bool] | None) -> list[str] | None:
+    if value:
+        return sorted([key for key, value in value.items() if value])
+
+
+TRANSFORM_DATA_MAPPING = {
+    "selectboxes": transform_selectboxes_data,
+}