WIP: Field validation

.coveragerc

@@ -1,6 +1,10 @@
 [run]
 relative_files = True
 
+omit =
+    src/collective/volto/formsupport/tests/*
+    src/collective/volto/formsupport/upgrades.py
+
 [report]
 include =
     */src/collective/*

README.rst

@@ -258,6 +258,13 @@ This add-on can be seen in action at the following sites:
 
 - https://www.comune.modena.it/form/contatti
 
+Custom label mapping
+=========================
+
+In some cases, the text that is displayed for a field on the page and in the sent email may need to be different from the value that is stored internally. For example, you may want your "Yes/ No" widget to show "Accept" and "Decline" as the labels, but internally still store `True` and `False`.
+
+By storing a `display_values` dictionary for each field in the block data, you can perform these mappings.
+
 
 Translations
 ============

base.cfg

@@ -6,7 +6,7 @@ extensions =
 parts =
     instance
     test
-    code-analysis
+    # code-analysis
     coverage
     test-coverage
     createcoverage
@@ -33,6 +33,7 @@ eggs =
     Plone
     Pillow
     collective.volto.formsupport [test]
+    collective.volto.formsupport [validation]
 
 zcml-additional +=
   <configure xmlns="http://namespaces.zope.org/zope"

setup.py

@@ -69,6 +69,10 @@
         "honeypot": [
             "collective.honeypot>=2.1",
         ],
+        "validation": [
+            "Products.validation",
+            "z3c.form"
+        ],
         "test": [
             "plone.app.testing",
             # Plone KGS does not use this version, because it would break

src/collective/volto/formsupport/configure.zcml

@@ -22,6 +22,7 @@
 
   <include file="permissions.zcml" />
   <include file="upgrades.zcml" />
+  <include file="validation/validation.zcml" />
 
   <genericsetup:registerProfile
       name="default"

src/collective/volto/formsupport/datamanager/catalog.py

@@ -79,17 +79,19 @@ def add(self, data):
                 )
             )
             return None
+        fields = {}
+        for field in form_fields:
+            custom_field_id = field.get("custom_field_id")
+            field_id = custom_field_id if custom_field_id else field["field_id"]
+            fields[field_id] = field.get("label", field_id)
 
-        fields = {
-            x["field_id"]: x.get("custom_field_id", x.get("label", x["field_id"]))
-            for x in form_fields
-        }
         record = Record()
         fields_labels = {}
         fields_order = []
         for field_data in data:
-            field_id = field_data.get("field_id", "")
-            value = field_data.get("value", "")
+            field_id = field_data.field_id
+            # TODO: not nice using the protected member to access the real internal value, but easiest way.
+            value = field_data._value
             if field_id in fields:
                 record.attrs[field_id] = value
                 fields_labels[field_id] = fields[field_id]

src/collective/volto/formsupport/restapi/configure.zcml

@@ -4,6 +4,7 @@
 
   <include package="plone.restapi"  />
 
+  <include package=".deserializer" />
   <include package=".services" />
   <include package=".serializer" />
 

src/collective/volto/formsupport/restapi/deserializer/__init__.py

@@ -0,0 +1,44 @@
+from plone.base.interfaces import IPloneSiteRoot
+from plone.restapi.behaviors import IBlocks
+from plone.restapi.interfaces import IBlockFieldDeserializationTransformer
+from zope.component import adapter
+from zope.interface import implementer
+from zope.publisher.interfaces.browser import IBrowserRequest
+
+
+@adapter(IBlocks, IBrowserRequest)
+class FormBlockDeserializerBase:
+    block_type = "form"
+    order = 100
+
+    def __init__(self, context, request):
+        self.context = context
+        self.request = request
+
+    def __call__(self, block):
+        return self._process_data(block)
+
+    def _process_data(
+        self,
+        data,
+    ):
+        self._update_validations(data)
+        return data
+
+    def _update_validations(self, data):
+        for field in data.get("subblocks"):
+            if field.get("field_type") not in ["text", "textarea", "from"]:
+                field["validations"] = []
+                field["validationSettings"] = {}
+
+
+@implementer(IBlockFieldDeserializationTransformer)
+@adapter(IBlocks, IBrowserRequest)
+class FormBlockDeserializer(FormBlockDeserializerBase):
+    """Serializer for content-types with IBlocks behavior"""
+
+
+@implementer(IBlockFieldDeserializationTransformer)
+@adapter(IPloneSiteRoot, IBrowserRequest)
+class FormBlockDeserializerRoot(FormBlockDeserializerBase):
+    """Serializer for site root"""

src/collective/volto/formsupport/restapi/deserializer/configure.zcml

@@ -0,0 +1,16 @@
+<configure
+    xmlns="http://namespaces.zope.org/zope"
+    xmlns:zcml="http://namespaces.zope.org/zcml"
+    i18n_domain="plone.restapi"
+    >
+
+  <subscriber
+      factory="collective.volto.formsupport.restapi.deserializer.FormBlockDeserializer"
+      provides="plone.restapi.interfaces.IBlockFieldDeserializationTransformer"
+      />
+  <subscriber
+      factory="collective.volto.formsupport.restapi.deserializer.FormBlockDeserializerRoot"
+      provides="plone.restapi.interfaces.IBlockFieldDeserializationTransformer"
+      />
+
+</configure>

src/collective/volto/formsupport/restapi/serializer/blocks.py

@@ -1,15 +1,18 @@
 # -*- coding: utf-8 -*-
-from collective.volto.formsupport.interfaces import ICaptchaSupport
-from collective.volto.formsupport.interfaces import ICollectiveVoltoFormsupportLayer
+import os
+
 from plone import api
 from plone.restapi.behaviors import IBlocks
 from plone.restapi.interfaces import IBlockFieldSerializationTransformer
 from Products.CMFPlone.interfaces import IPloneSiteRoot
-from zope.component import adapter
-from zope.component import getMultiAdapter
+from zope.component import adapter, getMultiAdapter
 from zope.interface import implementer
 
-import os
+from collective.volto.formsupport.interfaces import (
+    ICaptchaSupport,
+    ICollectiveVoltoFormsupportLayer,
+)
+from collective.volto.formsupport.validation import get_validation_information
 
 
 class FormSerializer(object):
@@ -37,6 +40,11 @@ def __call__(self, value):
         attachments_limit = os.environ.get("FORM_ATTACHMENTS_LIMIT", "")
         if attachments_limit:
             value["attachments_limit"] = attachments_limit
+
+        # Add information on the settings for validations to the response
+        validation_settings = get_validation_information()
+        value["validationSettings"] = validation_settings
+
         if api.user.has_permission("Modify portal content", obj=self.context):
             return value
         return {k: v for k, v in value.items() if not k.startswith("default_")}

src/collective/volto/formsupport/restapi/services/submit_form/field.py

@@ -0,0 +1,158 @@
+import re
+from typing import Any
+
+from collective.volto.formsupport.validation import getValidations
+
+validation_message_matcher = re.compile("Validation failed\(([^\)]+)\): ")
+
+
+def always():
+    return True
+
+
+def value_is(value, target_value):
+    if isinstance(target_value, list):
+        return value in target_value
+    return value == target_value
+
+
+def value_is_not(value, target_value):
+    if isinstance(target_value, list):
+        return value not in target_value
+    return value != target_value
+
+
+show_when_validators = {
+    "": always,
+    "always": always,
+    "value_is": value_is,
+    "value_is_not": value_is_not,
+}
+
+
+class Field:
+    def __init__(self, field_data: dict[str, Any]):
+        def _attribute(attribute_name: str):
+            setattr(self, attribute_name, field_data.get(attribute_name))
+
+        _attribute("field_type")
+        _attribute("id")
+        _attribute("show_when_when")
+        _attribute("show_when_is")
+        _attribute("show_when_to")
+        _attribute("input_values")
+        _attribute("widget")
+        _attribute("use_as_reply_to")
+        _attribute("use_as_reply_bcc")
+        self.required = field_data.get("required")
+        self.validations = field_data.get("validations")
+        self._display_value_mapping = field_data.get("dislpay_value_mapping")
+        self._value = field_data.get("value", "")
+        self._custom_field_id = field_data.get("custom_field_id")
+        self._label = field_data.get("label")
+        self._field_id = field_data.get("field_id", "")
+
+    @property
+    def value(self):
+        if self._display_value_mapping:
+            return self._display_value_mapping.get(self._value, self._value)
+        return self._value
+
+    @value.setter
+    def value(self, value):
+        self._value = value
+
+    def should_show(self, show_when_is, target_value):
+        always_show_validator = show_when_validators["always"]
+        if not show_when_is:
+            return always_show_validator()
+        show_when_validator = show_when_validators[show_when_is]
+        if not show_when_validator:
+            return always_show_validator
+        return show_when_validator(value=self.value, target_value=target_value)
+
+    @property
+    def label(self):
+        return self._label if self._label else self.field_id
+
+    @label.setter
+    def label(self, label):
+        self._label = label
+
+    @property
+    def field_id(self):
+        if self._custom_field_id:
+            return self._custom_field_id
+        return self._field_id if self._field_id else self._label
+
+    @field_id.setter
+    def field_id(self, field_id):
+        self._field_id = field_id
+
+    @property
+    def send_in_email(self):
+        return True
+
+    def validate(self):
+        # Making sure we've got a validation that actually exists.
+        if not self._value and not self.required:
+            return
+        errors = {}
+
+        if self.required and not self.internal_value:
+            errors['required'] = 'This field is required'
+
+        available_validations = [
+            validation
+            for validationId, validation in getValidations()
+            if validationId in self.validations.keys()
+        ]
+        for validation in available_validations:
+            error = validation(self._value, **self.validations.get(validation._name))
+            if error:
+                match_result = validation_message_matcher.match(error)
+                # We should be able to clean up messages that follow the
+                #   `Validation failed({validation_id}): {message}` pattern.
+                #   No guarantees we will encounter it though.
+                if match_result:
+                    error = validation_message_matcher.sub("", error)
+
+                errors[validation._name] = error
+
+        return (
+            errors if errors else None
+        )  # Return None to match how errors normally return in z3c.form
+
+
+class YesNoField(Field):
+    @property
+    def value(self):
+        if self._display_value_mapping:
+            if self._value is True:
+                return self._display_value_mapping.get("yes")
+            elif self._value is False:
+                return self._display_value_mapping.get("no")
+        return self._value
+
+    @property
+    def send_in_email(self):
+        return True
+
+
+class AttachmentField(Field):
+    @property
+    def send_in_email(self):
+        return False
+
+
+def construct_field(field_data):
+    if field_data.get("widget") == "single_choice":
+        return YesNoField(field_data)
+    elif field_data.get("field_type") == "attachment":
+        return AttachmentField(field_data)
+
+    return Field(field_data)
+
+
+def construct_fields(fields):
+    return [construct_field(field) for field in fields]