From 25e91c6401a8b0b535b834a2e5f7e7a9a7583d2d Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Fr=C3=A9d=C3=A9ric=20P=C3=A9ters?= <fpeters@entrouvert.com>
Date: Fri, 31 Mar 2023 18:43:02 +0200
Subject: [PATCH 01/11] misc: generate <template> tags for live error display
 (#.....)

---
 wcs/qommon/form.py                            | 98 ++++++++++++++++---
 wcs/qommon/templates/qommon/forms/widget.html |  7 ++
 2 files changed, 92 insertions(+), 13 deletions(-)

diff --git a/wcs/qommon/form.py b/wcs/qommon/form.py
index 3809f5382..ff9e857fd 100644
--- a/wcs/qommon/form.py
+++ b/wcs/qommon/form.py
@@ -176,6 +176,24 @@ def widget_get_name_for_id(self):
     return self.name.replace('$', '__')
 
 
+class ErrorMessage:
+    def __init__(self, code, label):
+        self.code = code
+        self.label = label
+
+    def camel_code(self):
+        return ''.join(x.lower() if i == 0 else x.capitalize() for i, x in enumerate(self.code.split('_')))
+
+
+def widget_get_error_messages(self):
+    for code in self.get_error_message_codes():
+        yield ErrorMessage(code, getattr(self, 'get_%s_message' % code)())
+
+
+def widget_get_error_message_codes(self):
+    yield 'value_missing'
+
+
 Widget.render = render
 Widget.cleanup = None
 Widget.render_error = render_error
@@ -184,6 +202,10 @@ Widget.render_title = render_title
 Widget.is_prefilled = is_prefilled
 Widget.render_widget_content = render_widget_content
 Widget.get_name_for_id = widget_get_name_for_id
+Widget.get_error_messages = widget_get_error_messages
+Widget.get_error_message_codes = widget_get_error_message_codes
+Widget.get_value_missing_message = lambda x: Widget.REQUIRED_ERROR
+Widget.get_invalid_value_message = lambda x: _('Invalid value')
 
 
 def file_render_content(self):
@@ -578,13 +600,21 @@ class StringWidget(QuixoteStringWidget):
         if self.value:
             self.value = self.value.strip()
             if self.maxlength and len(self.value) > self.maxlength:
-                self.error = _('Too long, value must be at most %d characters.') % self.maxlength
+                self.error = self.get_too_long_message()
             elif self.validation_function:
                 try:
                     self.validation_function(self.value)
                 except ValueError as e:
                     self.error = str(e)
 
+    def get_too_long_message(self):
+        return _('Too long, value must be at most %d characters.') % self.maxlength
+
+    def get_error_message_codes(self):
+        yield from super().get_error_message_codes()
+        if self.maxlength:
+            yield 'too_long'
+
     def render_content(self):
         attrs = {'id': 'form_' + self.get_name_for_id()}
         if self.required:
@@ -628,19 +658,26 @@ class TextWidget(QuixoteTextWidget):
     def _parse(self, request, use_validation_function=True):
         QuixoteTextWidget._parse(self, request)
         if self.value is not None:
-            try:
-                maxlength = int(self.attrs.get('maxlength', 0))
-            except (TypeError, ValueError):
-                maxlength = 0
             if maxlength:
                 if len(self.value) > maxlength:
-                    self.error = _('too many characters (limit is %d)') % maxlength
+                    self.error = self.get_too_long_message()
             if use_validation_function and self.validation_function:
                 try:
                     self.validation_function(self.value)
                 except ValueError as e:
                     self.error = str(e)
 
+    def get_too_long_message(self):
+        try:
+            maxlength = int(self.attrs.get('maxlength', 0))
+        except (TypeError, ValueError):
+            maxlength = 0
+        return _('too many characters (limit is %d)') % maxlength
+
+    def get_error_message_codes(self):
+        yield from super().get_error_message_codes()
+        yield 'too-long'
+
     def render_content(self):
         attrs = {'id': 'form_' + self.get_name_for_id()}
         if self.required:
@@ -1634,9 +1671,15 @@ class CheckboxesWidget(Widget):
         if self.required and not self.value:
             self.set_error(self.REQUIRED_ERROR)
         if self.value and self.min_choices and len(self.value) < self.min_choices:
-            self.set_error(_('You must select at least %d answers.') % self.min_choices)
+            self.set_error(self.get_too_short_message())
         if self.value and self.max_choices and len(self.value) > self.max_choices:
-            self.set_error(_('You must select at most %d answers.') % self.max_choices)
+            self.set_error(self.get_too_long_message())
+
+    def get_too_short_message(self):
+        return _('You must select at least %d answers.') % self.min_choices
+
+    def get_too_long_message(self):
+        return _('You must select at most %d answers.') % self.max_choices
 
     def set_value(self, value):
         self.value = value
@@ -1931,7 +1974,14 @@ class WidgetList(quixote.form.widget.WidgetList):
     def _parse(self, request):
         super()._parse(request)
         if self.max_items and self.value and len(self.value) > self.max_items:
-            self.set_error(_('Too many elements (maximum: %s)') % self.max_items)
+            self.set_error(self.get_too_many_message())
+
+    def get_too_many_message(self):
+        return _('Too many elements (maximum: %s)') % self.max_items
+
+    def get_error_message_codes(self):
+        yield from super().get_error_message_codes()
+        yield 'too_many'
 
     def set_value(self, value):
         for dummy in range(len(value) - len(self.element_names)):
@@ -2669,9 +2719,20 @@ class MultiSelectWidget(MultipleSelectWidget):
         finally:
             self.name = orig_name
         if self.value and self.min_choices and len(self.value) < self.min_choices:
-            self.set_error(_('You must select at least %d choices.') % self.min_choices)
+            self.set_error(self.get_too_short_message())
         if self.value and self.max_choices and len(self.value) > self.max_choices:
-            self.set_error(_('You must select at most %d choices.') % self.max_choices)
+            self.set_error(self.get_too_long_message())
+
+    def get_too_short_message(self):
+        return _('You must select at least %d choices.') % self.min_choices
+
+    def get_too_long_message(self):
+        return _('You must select at most %d choices.') % self.max_choices
+
+    def get_error_message_codes(self):
+        yield from super().get_error_message_codes()
+        yield 'too_short'
+        yield 'too_long'
 
 
 class WidgetListAsTable(WidgetList):
@@ -2869,9 +2930,16 @@ class RankedItemsWidget(CompositeWidget):
             if value is not None:
                 values[val] = value
             if value is not None and not isinstance(value, int):
-                self.get_widget(key).set_error(IntWidget.TYPE_ERROR)
+                self.get_widget(key).set_error(self.get_type_mismatch_message())
         self.value = values or None
 
+    def get_type_mismatch_message(self):
+        return _('must be a number')
+
+    def get_error_message_codes(self):
+        yield from super().get_error_message_codes()
+        yield 'type_mismatch'
+
     def set_value(self, value):
         self.value = value
         if value:
@@ -3328,11 +3396,15 @@ class MapWidget(CompositeWidget):
             try:
                 lat, lon = self.value.split(';')
             except ValueError:
-                self.set_error(_('Invalid value'))
+                self.set_error(self.get_invalid_value_message())
             else:
                 lat_lon = misc.normalize_geolocation({'lat': lat, 'lon': lon})
                 self.value = '%s;%s' % (lat_lon['lat'], lat_lon['lon']) if lat_lon else None
 
+    def get_error_message_codes(self):
+        yield from super().get_error_message_codes()
+        yield 'invalid_value'
+
     def set_value(self, value):
         super().set_value(value)
         self.get_widget('latlng').set_value(value)
diff --git a/wcs/qommon/templates/qommon/forms/widget.html b/wcs/qommon/templates/qommon/forms/widget.html
index cf0f512ae..76f48b417 100644
--- a/wcs/qommon/templates/qommon/forms/widget.html
+++ b/wcs/qommon/templates/qommon/forms/widget.html
@@ -45,4 +45,11 @@
   {% if widget.render_br %}
     <br class="content {{widget.content.content_extra_css_class}}">
   {% endif %}
+  {% block widget-error-templates %}
+    {% if not widget.readonly %}
+      {% for error_message in widget.get_error_messages %}
+        <template id="error_{{ widget.get_name_for_id }}_{{ error_message.camel_code }}">{{ error_message.label }}</template>
+      {% endfor %}
+    {% endif %}
+  {% endblock %}
 </div>
-- 
2.39.2


From dca761dd1b4c1927316f5cba199f7c4a7a69dab6 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Fr=C3=A9d=C3=A9ric=20P=C3=A9ters?= <fpeters@entrouvert.com>
Date: Sat, 1 Apr 2023 13:41:05 +0200
Subject: [PATCH 02/11] generalize error_code

---
 wcs/qommon/form.py | 118 ++++++++++++++++++++++++++-------------------
 1 file changed, 68 insertions(+), 50 deletions(-)

diff --git a/wcs/qommon/form.py b/wcs/qommon/form.py
index ff9e857fd..f342ebe53 100644
--- a/wcs/qommon/form.py
+++ b/wcs/qommon/form.py
@@ -185,6 +185,21 @@ class ErrorMessage:
         return ''.join(x.lower() if i == 0 else x.capitalize() for i, x in enumerate(self.code.split('_')))
 
 
+def widget_set_error(self, error=None, error_code=None):
+    if error and error_code:
+        self.error = error
+        self.error_code = error_code
+    elif error_code:
+        self.error = getattr(self, 'get_%s_message' % error_code)()
+        self.error_code = error_code
+    else:
+        self.error = error
+        if self.error == Widget.REQUIRED_ERROR:
+            self.error_code = 'value_missing'
+        else:
+            self.error_code = 'invalid_value'
+
+
 def widget_get_error_messages(self):
     for code in self.get_error_message_codes():
         yield ErrorMessage(code, getattr(self, 'get_%s_message' % code)())
@@ -206,6 +221,7 @@ Widget.get_error_messages = widget_get_error_messages
 Widget.get_error_message_codes = widget_get_error_message_codes
 Widget.get_value_missing_message = lambda x: Widget.REQUIRED_ERROR
 Widget.get_invalid_value_message = lambda x: _('Invalid value')
+Widget.set_error = widget_set_error
 
 
 def file_render_content(self):
@@ -600,12 +616,12 @@ class StringWidget(QuixoteStringWidget):
         if self.value:
             self.value = self.value.strip()
             if self.maxlength and len(self.value) > self.maxlength:
-                self.error = self.get_too_long_message()
+                self.set_error(error_code='too_long')
             elif self.validation_function:
                 try:
                     self.validation_function(self.value)
                 except ValueError as e:
-                    self.error = str(e)
+                    self.set_error(str(e))
 
     def get_too_long_message(self):
         return _('Too long, value must be at most %d characters.') % self.maxlength
@@ -660,12 +676,12 @@ class TextWidget(QuixoteTextWidget):
         if self.value is not None:
             if maxlength:
                 if len(self.value) > maxlength:
-                    self.error = self.get_too_long_message()
+                    self.set_error('too_long')
             if use_validation_function and self.validation_function:
                 try:
                     self.validation_function(self.value)
                 except ValueError as e:
-                    self.error = str(e)
+                    self.set_error(str(e))
 
     def get_too_long_message(self):
         try:
@@ -676,7 +692,7 @@ class TextWidget(QuixoteTextWidget):
 
     def get_error_message_codes(self):
         yield from super().get_error_message_codes()
-        yield 'too-long'
+        yield 'too_long'
 
     def render_content(self):
         attrs = {'id': 'form_' + self.get_name_for_id()}
@@ -708,7 +724,7 @@ class CheckboxWidget(QuixoteCheckboxWidget):
     def _parse(self, request):
         self.value = self.name in request.form and not request.form[self.name] in (False, '', 'False')
         if self.required and not self.value:
-            self.set_error(self.REQUIRED_ERROR)
+            self.set_error(error_code='value_missing')
 
     def set_value(self, value):
         if value in (None, False, '', 'False'):
@@ -911,7 +927,7 @@ class FileWithPreviewWidget(CompositeWidget):
             try:
                 token = get_session().add_tempfile(self.get('file'), storage=self.storage)['token']
             except UploadStorageError:
-                self.error = _('failed to store file (system error)')
+                self.set_error(_('failed to store file (system error)'))
                 return
             request.form[self.get_widget('token').get_name()] = token
         else:
@@ -930,7 +946,7 @@ class FileWithPreviewWidget(CompositeWidget):
             return
 
         if self.storage and self.storage != self.storage:
-            self.error = _('unknown storage system (system error)')
+            self.set_error(_('unknown storage system (system error)'))
             return
 
         # Don't trust the browser supplied MIME type, update the Upload object
@@ -966,7 +982,7 @@ class FileWithPreviewWidget(CompositeWidget):
         if self.max_file_size and hasattr(self.value, 'file_size'):
             # validate file size
             if self.value.file_size > self.max_file_size_bytes:
-                self.error = _('over file size limit (%s)') % self.max_file_size
+                self.set_error(_('over file size limit (%s)') % self.max_file_size)
                 return
 
         if self.file_type:
@@ -983,7 +999,7 @@ class FileWithPreviewWidget(CompositeWidget):
                     valid_file_type = True
                     break
             if not valid_file_type:
-                self.error = _('invalid file type')
+                self.set_error(_('invalid file type'))
 
         blacklisted_file_types = get_publisher().get_site_option('blacklisted-file-types')
         if blacklisted_file_types:
@@ -1003,7 +1019,7 @@ class FileWithPreviewWidget(CompositeWidget):
             os.path.splitext(self.value.base_filename)[-1].lower() in blacklisted_file_types
             or filetype in blacklisted_file_types
         ):
-            self.error = _('forbidden file type')
+            self.set_error(_('forbidden file type'))
 
 
 class EmailWidget(StringWidget):
@@ -1037,37 +1053,37 @@ class EmailWidget(StringWidget):
         if self.value is not None:
             # basic tests first
             if '@' not in self.value[1:-1]:
-                self.error = _('must be a valid email address')
+                self.set_error(_('must be a valid email address'))
                 return
             if self.value[0] != '"' and ' ' in self.value:
-                self.error = _('must be a valid email address')
+                self.set_error(_('must be a valid email address'))
                 return
             if self.value[0] != '"' and self.value.count('@') != 1:
-                self.error = _('must be a valid email address')
+                self.set_error(_('must be a valid email address'))
                 return
             user_part, domain = self.value.rsplit('@', 1)
             if not self.user_part_re.match(user_part):
-                self.error = _('must be a valid email address')
+                self.set_error(_('must be a valid email address'))
                 return
             if get_cfg('emails', {}).get('check_domain_with_dns', True):
                 # testing for domain existence
                 if [x for x in domain.split('.') if not x]:
                     # empty parts in domain, ex: @example..net, or
                     # @.example.net
-                    self.error = _('invalid address domain')
+                    self.set_error(_('invalid address domain'))
                     return
                 domain = force_str(domain, 'utf-8', errors='ignore')
                 try:
                     domain = force_str(domain.encode('idna'))
                 except UnicodeError:
-                    self.error = _('invalid address domain')
+                    self.set_error(_('invalid address domain'))
                     return
                 if domain == 'localhost':
                     return
                 try:
                     dns.resolver.query(force_str(domain), 'MX')
                 except dns.exception.DNSException:
-                    self.error = _('invalid address domain')
+                    self.set_error(_('invalid address domain'))
 
 
 class OptGroup:
@@ -1431,7 +1447,7 @@ class WcsExtraStringWidget(StringWidget):
             normalized_value = normalize(self.value)
 
         if self.value and self.validation_function and not self.validation_function(normalized_value):
-            self.error = self.validation_function_error_message or _('invalid value')
+            self.set_error(self.validation_function_error_message or _('invalid value'))
 
         if self.field and self.value and not self.error and self.field.validation:
             self.value = normalized_value
@@ -1495,19 +1511,21 @@ class DateWidget(StringWidget):
                 value = misc.get_as_datetime(self.value).timetuple()
                 self.value = strftime(self.get_format_string(), value)
             except ValueError:
-                self.error = _('invalid date')
+                self.set_error(_('invalid date'))
                 self.value = None
                 return
             if value[0] < 1500 or value[0] > 2099:
-                self.error = _('invalid date')
+                self.set_error(_('invalid date'))
                 self.value = None
             elif self.minimum_date and value[:3] < self.minimum_date.timetuple()[:3]:
-                self.error = _('invalid date: date must be on or after %s') % strftime(
-                    misc.date_format(), self.minimum_date
+                self.set_error(
+                    _('invalid date: date must be on or after %s')
+                    % strftime(misc.date_format(), self.minimum_date)
                 )
             elif self.maximum_date and value[:3] > self.maximum_date.timetuple()[:3]:
-                self.error = _('invalid date; date must be on or before %s') % strftime(
-                    misc.date_format(), self.maximum_date
+                self.set_error(
+                    _('invalid date; date must be on or before %s')
+                    % strftime(misc.date_format(), self.maximum_date)
                 )
 
     def add_media(self):
@@ -1566,7 +1584,7 @@ class TimeWidget(DateWidget):
                 value = datetime.datetime.strptime(self.value, self.get_format_string())
                 self.value = strftime(self.get_format_string(), value)
             except ValueError:
-                self.error = _('invalid time')
+                self.set_error(_('invalid time'))
                 self.value = None
                 return
 
@@ -1602,7 +1620,7 @@ class DateTimeWidget(CompositeWidget):
         try:
             misc.get_as_datetime('%s %s' % (date, time))
         except ValueError:
-            self.error = _('invalid value')
+            self.set_error(_('invalid value'))
         self.value = '%s %s' % (date, time)
         return self.value
 
@@ -1616,7 +1634,7 @@ class RegexStringWidget(StringWidget):
             try:
                 re.compile(self.value)
             except Exception:
-                self.error = _('invalid regular expression')
+                self.set_error(_('invalid regular expression'))
                 self.value = None
 
 
@@ -1669,11 +1687,11 @@ class CheckboxesWidget(Widget):
                 values.append(option['value'])
         self.value = values
         if self.required and not self.value:
-            self.set_error(self.REQUIRED_ERROR)
+            self.set_error(error_code='value_missing')
         if self.value and self.min_choices and len(self.value) < self.min_choices:
-            self.set_error(self.get_too_short_message())
+            self.set_error(error_code='too_short')
         if self.value and self.max_choices and len(self.value) > self.max_choices:
-            self.set_error(self.get_too_long_message())
+            self.set_error(error_code='too_long')
 
     def get_too_short_message(self):
         return _('You must select at least %d answers.') % self.min_choices
@@ -1707,7 +1725,7 @@ class ValidatedStringWidget(StringWidget):
         if self.regex and self.value is not None:
             match = re.match(self.regex, self.value)
             if not match or not match.group() == self.value:
-                self.error = _('wrong format')
+                self.set_error(_('wrong format'))
 
 
 class UrlWidget(ValidatedStringWidget):
@@ -1718,7 +1736,7 @@ class UrlWidget(ValidatedStringWidget):
     def _parse(self, request):
         ValidatedStringWidget._parse(self, request)
         if self.error:
-            self.error = _('must start with http:// or https:// and have a domain name')
+            self.set_error(_('must start with http:// or https:// and have a domain name'))
 
 
 class VarnameWidget(ValidatedStringWidget):
@@ -1730,7 +1748,7 @@ class VarnameWidget(ValidatedStringWidget):
     def _parse(self, request):
         ValidatedStringWidget._parse(self, request)
         if self.error:
-            self.error = _('must only consist of letters, numbers, or underscore')
+            self.set_error(_('must only consist of letters, numbers, or underscore'))
         # forbid id/text to be used as identifier, as they would clash against
         # "native" id/text keys in datasources; forbid "status" to avoid status
         # filtering being diverted to a form field.
@@ -1776,7 +1794,7 @@ class VarnameWidget(ValidatedStringWidget):
             'with',
             'yield',
         ):
-            self.error = _('this value is reserved for internal use.')
+            self.set_error(_('this value is reserved for internal use.'))
 
 
 class SlugWidget(ValidatedStringWidget):
@@ -1800,7 +1818,7 @@ class SlugWidget(ValidatedStringWidget):
     def _parse(self, request):
         super()._parse(request)
         if self.error:
-            self.error = _('wrong format: must only consist of letters, numbers, dashes, or underscores')
+            self.set_error(_('wrong format: must only consist of letters, numbers, dashes, or underscores'))
 
 
 class FileSizeWidget(ValidatedStringWidget):
@@ -1833,7 +1851,7 @@ class FileSizeWidget(ValidatedStringWidget):
     def _parse(self, request):
         ValidatedStringWidget._parse(self, request)
         if self.error:
-            self.error = _('invalid file size')
+            self.set_error(_('invalid file size'))
 
 
 class CaptchaWidget(CompositeWidget):
@@ -1883,7 +1901,7 @@ class CaptchaWidget(CompositeWidget):
             get_session().won_captcha = True
             self.value = v
         elif v['answer']:
-            self.error = _('wrong answer')
+            self.set_error(_('wrong answer'))
 
     def get_title(self):
         return self.question
@@ -1974,7 +1992,7 @@ class WidgetList(quixote.form.widget.WidgetList):
     def _parse(self, request):
         super()._parse(request)
         if self.max_items and self.value and len(self.value) > self.max_items:
-            self.set_error(self.get_too_many_message())
+            self.set_error(error_code='too_many')
 
     def get_too_many_message(self):
         return _('Too many elements (maximum: %s)') % self.max_items
@@ -2471,7 +2489,7 @@ class WysiwygTextWidget(TextWidget):
                 try:
                     self.validation_function(self.value)
                 except ValueError as e:
-                    self.error = str(e)
+                    self.set_error(str(e))
         if self.value == '':
             self.value = None
 
@@ -2563,7 +2581,7 @@ class TableWidget(CompositeWidget):
             request = get_request()
         if (request.form or request.get_method() == 'POST') and self.required:
             if not self.value:
-                self.set_error(self.REQUIRED_ERROR)
+                self.set_error(error_code='value_missing')
             else:
                 for row in self.value:
                     for column in row:
@@ -2573,7 +2591,7 @@ class TableWidget(CompositeWidget):
                         continue
                     break
                 else:
-                    self.set_error(self.REQUIRED_ERROR)
+                    self.set_error(error_code='value_missing')
         return self.value
 
     def _parse(self, request):
@@ -2719,9 +2737,9 @@ class MultiSelectWidget(MultipleSelectWidget):
         finally:
             self.name = orig_name
         if self.value and self.min_choices and len(self.value) < self.min_choices:
-            self.set_error(self.get_too_short_message())
+            self.set_error(error_code='too_short')
         if self.value and self.max_choices and len(self.value) > self.max_choices:
-            self.set_error(self.get_too_long_message())
+            self.set_error(error_code='too_long')
 
     def get_too_short_message(self):
         return _('You must select at least %d choices.') % self.min_choices
@@ -2815,7 +2833,7 @@ class TableListRowsWidget(WidgetListAsTable):
         add_element_pushed = self.get_widget('add_element').parse()
         if (request.form or request.get_method() == 'POST') and self.required:
             if not self.value and not add_element_pushed:
-                self.set_error(self.REQUIRED_ERROR)
+                self.set_error(error_code='value_missing')
             for row in self.value or []:
                 for column in row:
                     if column:
@@ -2825,7 +2843,7 @@ class TableListRowsWidget(WidgetListAsTable):
                 break
             else:
                 if not add_element_pushed:
-                    self.set_error(self.REQUIRED_ERROR)
+                    self.set_error(error_code='value_missing')
         return self.value
 
     def _parse(self, request):
@@ -2930,7 +2948,7 @@ class RankedItemsWidget(CompositeWidget):
             if value is not None:
                 values[val] = value
             if value is not None and not isinstance(value, int):
-                self.get_widget(key).set_error(self.get_type_mismatch_message())
+                self.get_widget(key).set_error(error_code='type_mismatch')
         self.value = values or None
 
     def get_type_mismatch_message(self):
@@ -3396,7 +3414,7 @@ class MapWidget(CompositeWidget):
             try:
                 lat, lon = self.value.split(';')
             except ValueError:
-                self.set_error(self.get_invalid_value_message())
+                self.set_error(error_code='invalid_value')
             else:
                 lat_lon = misc.normalize_geolocation({'lat': lat, 'lon': lon})
                 self.value = '%s;%s' % (lat_lon['lat'], lat_lon['lon']) if lat_lon else None
@@ -3444,8 +3462,8 @@ class MapMarkerSelectionWidget(MapWidget):
 
 
 class HiddenErrorWidget(HiddenWidget):
-    def set_error(self, error):
-        Widget.set_error(self, error)
+    def set_error(self, *args, **kwargs):
+        Widget.set_error(self, *args, **kwargs)
 
 
 class SingleSelectWidgetWithOther(CompositeWidget):
-- 
2.39.2


From 71b283d68e8a71a5d252062ef1e005ade962e0d0 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Fr=C3=A9d=C3=A9ric=20P=C3=A9ters?= <fpeters@entrouvert.com>
Date: Sat, 1 Apr 2023 17:02:14 +0200
Subject: [PATCH 03/11] misc: add check condition example js

---
 wcs/fields.py                                 |  5 ++-
 wcs/forms/root.py                             | 41 ++++++++++++++++++-
 wcs/qommon/static/js/qommon.forms.js          | 18 ++++++++
 wcs/qommon/templates/qommon/forms/widget.html | 17 ++++----
 4 files changed, 72 insertions(+), 9 deletions(-)

diff --git a/wcs/fields.py b/wcs/fields.py
index 408167854..b71deaaa1 100644
--- a/wcs/fields.py
+++ b/wcs/fields.py
@@ -892,6 +892,7 @@ class WidgetField(Field):
         form.add(self.widget_class, 'f%s' % self.id, title=self.label, hint=hint, **kwargs)
         widget = form.get_widget('f%s' % self.id)
         widget.field = self
+        widget.supports_check_condition = True
         if self.extra_css_class:
             if hasattr(widget, 'extra_css_class') and widget.extra_css_class:
                 widget.extra_css_class = '%s %s' % (widget.extra_css_class, self.extra_css_class)
@@ -3898,7 +3899,9 @@ class BlockField(WidgetField):
             self.block
         except KeyError:
             raise MissingBlockFieldError(self.type[6:])
-        return super().add_to_form(form, value=value)
+        widget = super().add_to_form(form, value=value)
+        widget.supports_check_condition = False
+        return widget
 
     def fill_admin_form(self, form):
         super().fill_admin_form(form)
diff --git a/wcs/forms/root.py b/wcs/forms/root.py
index dd9fab8e4..f6a92d071 100644
--- a/wcs/forms/root.py
+++ b/wcs/forms/root.py
@@ -270,6 +270,7 @@ class FormPage(FormdefDirectoryBase, FormTemplateMixin):
         'code',
         'removedraft',
         'live',
+        'check_condition',
         ('go-to-backoffice', 'go_to_backoffice'),
     ]
 
@@ -929,6 +930,9 @@ class FormPage(FormdefDirectoryBase, FormTemplateMixin):
     def create_form(self, *args, **kwargs):
         form = self.formdef.create_form(*args, **kwargs)
         form.attrs['data-live-url'] = self.formdef.get_url(language=get_publisher().current_language) + 'live'
+        form.attrs['data-check-condition-url'] = (
+            self.formdef.get_url(language=get_publisher().current_language) + 'check_condition'
+        )
         return form
 
     def create_view_form(self, *args, **kwargs):
@@ -1656,6 +1660,41 @@ class FormPage(FormdefDirectoryBase, FormTemplateMixin):
             return result_error('form deserialization failed: %s' % e)
         return FormStatusPage.live_process_fields(form, formdata, displayed_fields)
 
+    def check_condition(self):
+        get_request().ignore_session = True
+        get_response().set_content_type('application/json')
+
+        def result_error(reason):
+            return json.dumps({'result': 'error', 'reason': reason})
+
+        session = get_session()
+        if not (session and session.id):
+            return result_error('missing session')
+
+        field_ref = get_request().form.get('field')
+        parts = field_ref.split('__')
+        for field in self.formdef.fields:
+            if 'f%s' % field.id == parts[0]:
+                break
+        else:
+            return result_error('missing field')
+        if len(parts) == 3:  # block field
+            for subfield in field.block.fields:
+                if 'f%s' % subfield.id == parts[2]:
+                    break
+            else:
+                return result_error('missing sub field')
+            field = subfield
+            field.id = field_ref[1:].replace('__', '$')
+
+        form = Form()
+        widget = field.add_to_form(form)
+        widget.parse()
+        if widget.has_error():
+            return json.dumps({'err': 1, 'msg': str(widget.get_error())})
+        else:
+            return json.dumps({'err': 0})
+
     def clean_submission_context(self):
         get_publisher().substitutions.unfeed(lambda x: x.__class__.__name__ == 'ConditionVars')
         get_publisher().substitutions.unfeed(lambda x: isinstance(x, FormData))
@@ -2226,7 +2265,7 @@ class RootDirectory(AccessControlled, Directory):
 
 
 class PublicFormStatusPage(FormStatusPage):
-    _q_exports_orig = ['', 'download', 'status', 'live', 'tempfile']
+    _q_exports_orig = ['', 'download', 'status', 'live', 'tempfile', 'check_condition']
     form_page_class = FormPage
     history_templates = ['wcs/front/formdata_history.html', 'wcs/formdata_history.html']
     status_templates = ['wcs/front/formdata_status.html', 'wcs/formdata_status.html']
diff --git a/wcs/qommon/static/js/qommon.forms.js b/wcs/qommon/static/js/qommon.forms.js
index 4e42afa7d..a4dc20cae 100644
--- a/wcs/qommon/static/js/qommon.forms.js
+++ b/wcs/qommon/static/js/qommon.forms.js
@@ -756,3 +756,21 @@ $(function() {
     });
   }
 });
+
+
+function check_condition(button, widget_id) {
+  var $form = $('form[data-check-condition-url]');
+  var form_content = $form.serialize();
+  $.ajax({
+    type: 'POST',
+    url: $form.attr('data-check-condition-url') + '?field=' + widget_id,
+    data: form_content,
+    success: function(json) {
+      if (json.err === 0) {
+        button.textContent = 'ok';
+      } else {
+        button.textContent = 'err: ' + json.msg;
+      }
+    },
+  });
+}
diff --git a/wcs/qommon/templates/qommon/forms/widget.html b/wcs/qommon/templates/qommon/forms/widget.html
index 76f48b417..b5240c89e 100644
--- a/wcs/qommon/templates/qommon/forms/widget.html
+++ b/wcs/qommon/templates/qommon/forms/widget.html
@@ -45,11 +45,14 @@
   {% if widget.render_br %}
     <br class="content {{widget.content.content_extra_css_class}}">
   {% endif %}
-  {% block widget-error-templates %}
-    {% if not widget.readonly %}
-      {% for error_message in widget.get_error_messages %}
-        <template id="error_{{ widget.get_name_for_id }}_{{ error_message.camel_code }}">{{ error_message.label }}</template>
-      {% endfor %}
-    {% endif %}
-  {% endblock %}
+  {% if widget.supports_check_condition %}
+    {% block widget-error-templates %}
+      {% if not widget.readonly %}
+        {% for error_message in widget.get_error_messages %}
+          <template id="error_{{ widget.get_name_for_id }}_{{ error_message.camel_code }}">{{ error_message.label }}</template>
+        {% endfor %}
+      {% endif %}
+    {% endblock %}
+    <button type="button" onclick="check_condition(this, '{{ widget.get_name_for_id }}')">check condition</button>
+  {% endif %}
 </div>
-- 
2.39.2


From c19aa5f1ad87c393c9fc9b137ae1c94b73b22cac Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Fr=C3=A9d=C3=A9ric=20P=C3=A9ters?= <fpeters@entrouvert.com>
Date: Sat, 1 Apr 2023 17:16:56 +0200
Subject: [PATCH 04/11] include errorCode in json response

---
 wcs/forms/root.py | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/wcs/forms/root.py b/wcs/forms/root.py
index f6a92d071..e0a07af5c 100644
--- a/wcs/forms/root.py
+++ b/wcs/forms/root.py
@@ -1691,7 +1691,13 @@ class FormPage(FormdefDirectoryBase, FormTemplateMixin):
         widget = field.add_to_form(form)
         widget.parse()
         if widget.has_error():
-            return json.dumps({'err': 1, 'msg': str(widget.get_error())})
+            resp = {'err': 1, 'msg': str(widget.get_error())}
+            if hasattr(widget, 'error_code'):
+                from wcs.qommon.form import ErrorMessage
+
+                error_message = ErrorMessage(widget.error_code, '')
+                resp[error_message.camel_code()] = True
+            return json.dumps(resp)
         else:
             return json.dumps({'err': 0})
 
-- 
2.39.2


From 14917e3d1801373b41b66dc0704084f5f0282bdf Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Fr=C3=A9d=C3=A9ric=20P=C3=A9ters?= <fpeters@entrouvert.com>
Date: Sun, 2 Apr 2023 19:34:31 +0200
Subject: [PATCH 05/11] misc: add string validation type to HTML markup
 (#75724)

---
 wcs/qommon/templates/qommon/forms/widget.html | 1 +
 1 file changed, 1 insertion(+)

diff --git a/wcs/qommon/templates/qommon/forms/widget.html b/wcs/qommon/templates/qommon/forms/widget.html
index b5240c89e..f3d1ce265 100644
--- a/wcs/qommon/templates/qommon/forms/widget.html
+++ b/wcs/qommon/templates/qommon/forms/widget.html
@@ -6,6 +6,7 @@
      {% block widget-attrs %}
        {% if widget.is_hidden %}style="display: none"{% endif %}
        {% if widget.field %}data-field-id="{{ widget.field.id }}"{% endif %}
+       {% if not widget.readonly and widget.field.validation.type %}data-validation-type="{{ widget.field.validation.type }}"{% endif %}
        data-widget-name="{{ widget.name }}"
        {% if widget.div_id %}id="{{widget.div_id}}" data-valuecontainerid="form_{{widget.name}}"{% endif %}
        {% if widget.a11y_role %}role="{{ a11y_role }}"{% endif %}
-- 
2.39.2


From 5d78ec98a455528c6ba9ba5f4e054fdeabe796ab Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Fr=C3=A9d=C3=A9ric=20P=C3=A9ters?= <fpeters@entrouvert.com>
Date: Tue, 4 Apr 2023 10:39:51 +0200
Subject: [PATCH 06/11] add custom error message as invalid value message

---
 wcs/qommon/form.py | 18 +++++++++++++-----
 1 file changed, 13 insertions(+), 5 deletions(-)

diff --git a/wcs/qommon/form.py b/wcs/qommon/form.py
index f342ebe53..d4a163212 100644
--- a/wcs/qommon/form.py
+++ b/wcs/qommon/form.py
@@ -1421,7 +1421,6 @@ class WcsExtraStringWidget(StringWidget):
     prefill = False
     prefill_attributes = None
     validation_function = None
-    validation_function_error_message = None
 
     def add_media(self):
         if self.prefill_attributes and 'geolocation' in self.prefill_attributes:
@@ -1433,13 +1432,22 @@ class WcsExtraStringWidget(StringWidget):
             self.inputmode = ValidationWidget.get_html_inputmode(self.field.validation)
         return super().render_content()
 
+    def get_error_message_codes(self):
+        yield from super().get_error_message_codes()
+        yield 'invalid_value'
+
+    def get_invalid_value_message(self):
+        validation_function_error_message = None
+        if self.field and self.field.validation:
+            validation_function_error_message = ValidationWidget.get_validation_error_message(
+                self.field.validation
+            )
+        return validation_function_error_message or _('invalid value')
+
     def _parse(self, request):
         StringWidget._parse(self, request)
         if self.field and self.field.validation and self.value is not None:
             self.validation_function = ValidationWidget.get_validation_function(self.field.validation)
-            self.validation_function_error_message = ValidationWidget.get_validation_error_message(
-                self.field.validation
-            )
 
         normalized_value = self.value
         if self.field and self.value and self.field.validation:
@@ -1447,7 +1455,7 @@ class WcsExtraStringWidget(StringWidget):
             normalized_value = normalize(self.value)
 
         if self.value and self.validation_function and not self.validation_function(normalized_value):
-            self.set_error(self.validation_function_error_message or _('invalid value'))
+            self.set_error(error_code='invalid_value')
 
         if self.field and self.value and not self.error and self.field.validation:
             self.value = normalized_value
-- 
2.39.2


From 6aaa2574f5313fd237749211aecbcd1be1459578 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Fr=C3=A9d=C3=A9ric=20P=C3=A9ters?= <fpeters@entrouvert.com>
Date: Tue, 4 Apr 2023 10:43:22 +0200
Subject: [PATCH 07/11] add form_error_tpl <template>

---
 wcs/forms/root.py | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/wcs/forms/root.py b/wcs/forms/root.py
index e0a07af5c..b58cdd9ff 100644
--- a/wcs/forms/root.py
+++ b/wcs/forms/root.py
@@ -933,6 +933,13 @@ class FormPage(FormdefDirectoryBase, FormTemplateMixin):
         form.attrs['data-check-condition-url'] = (
             self.formdef.get_url(language=get_publisher().current_language) + 'check_condition'
         )
+        form.widgets.append(
+            HtmlWidget(
+                '''<template id="form_error_tpl">
+          <div id="form_error_fieldname" class="error"></div>
+          </template>'''
+            )
+        )
         return form
 
     def create_view_form(self, *args, **kwargs):
-- 
2.39.2


From de1c8d22f94d35c17f1f413d42f987bfff7e29db Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Fr=C3=A9d=C3=A9ric=20P=C3=A9ters?= <fpeters@entrouvert.com>
Date: Tue, 4 Apr 2023 15:25:30 +0200
Subject: [PATCH 08/11] add data-supports-check-condition attribute

---
 wcs/fields.py                                 | 7 ++++++-
 wcs/qommon/templates/qommon/forms/widget.html | 5 ++++-
 2 files changed, 10 insertions(+), 2 deletions(-)

diff --git a/wcs/fields.py b/wcs/fields.py
index b71deaaa1..16898b030 100644
--- a/wcs/fields.py
+++ b/wcs/fields.py
@@ -876,6 +876,7 @@ class WidgetField(Field):
     prefill = {}
 
     widget_class = None
+    widget_supports_check_condition = True
 
     def add_to_form(self, form, value=None):
         kwargs = {'required': self.required, 'render_br': False}
@@ -892,7 +893,7 @@ class WidgetField(Field):
         form.add(self.widget_class, 'f%s' % self.id, title=self.label, hint=hint, **kwargs)
         widget = form.get_widget('f%s' % self.id)
         widget.field = self
-        widget.supports_check_condition = True
+        widget.supports_check_condition = self.widget_supports_check_condition
         if self.extra_css_class:
             if hasattr(widget, 'extra_css_class') and widget.extra_css_class:
                 widget.extra_css_class = '%s %s' % (widget.extra_css_class, self.extra_css_class)
@@ -1642,6 +1643,7 @@ class FileField(WidgetField):
     storage = 'default'
 
     widget_class = FileWithPreviewWidget
+    widget_supports_check_condition = True
     extra_attributes = [
         'file_type',
         'max_file_size',
@@ -3145,6 +3147,7 @@ class TableField(WidgetField):
     columns = None
 
     widget_class = TableWidget
+    widget_supports_check_condition = True
 
     def __init__(self, **kwargs):
         self.rows = []
@@ -3366,6 +3369,7 @@ class TableRowsField(WidgetField):
     columns = None
 
     widget_class = TableListRowsWidget
+    widget_supports_check_condition = True
 
     def __init__(self, **kwargs):
         self.columns = []
@@ -3627,6 +3631,7 @@ class RankedItemsField(WidgetField):
     items = []
     randomize_items = False
     widget_class = RankedItemsWidget
+    widget_supports_check_condition = True
     anonymise = False
 
     def perform_more_widget_changes(self, form, kwargs, edit=True):
diff --git a/wcs/qommon/templates/qommon/forms/widget.html b/wcs/qommon/templates/qommon/forms/widget.html
index f3d1ce265..21d2cd2f9 100644
--- a/wcs/qommon/templates/qommon/forms/widget.html
+++ b/wcs/qommon/templates/qommon/forms/widget.html
@@ -6,7 +6,10 @@
      {% block widget-attrs %}
        {% if widget.is_hidden %}style="display: none"{% endif %}
        {% if widget.field %}data-field-id="{{ widget.field.id }}"{% endif %}
-       {% if not widget.readonly and widget.field.validation.type %}data-validation-type="{{ widget.field.validation.type }}"{% endif %}
+       {% if not widget.readonly %}
+         {% if widget.field.validation.type %}data-validation-type="{{ widget.field.validation.type }}"{% endif %}
+         {% if widget.supports_check_condition %}data-supports-check-condition="true"{% endif %}
+       {% endif %}
        data-widget-name="{{ widget.name }}"
        {% if widget.div_id %}id="{{widget.div_id}}" data-valuecontainerid="form_{{widget.name}}"{% endif %}
        {% if widget.a11y_role %}role="{{ a11y_role }}"{% endif %}
-- 
2.39.2


From e000d645961cd2311f93ce917dc15deeb752a1be Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Fr=C3=A9d=C3=A9ric=20P=C3=A9ters?= <fpeters@entrouvert.com>
Date: Tue, 4 Apr 2023 16:53:06 +0200
Subject: [PATCH 09/11] add html5 required attribute to string inputs

---
 wcs/qommon/form.py | 1 +
 1 file changed, 1 insertion(+)

diff --git a/wcs/qommon/form.py b/wcs/qommon/form.py
index d4a163212..9eed2d32c 100644
--- a/wcs/qommon/form.py
+++ b/wcs/qommon/form.py
@@ -634,6 +634,7 @@ class StringWidget(QuixoteStringWidget):
     def render_content(self):
         attrs = {'id': 'form_' + self.get_name_for_id()}
         if self.required:
+            attrs['required'] = 'required'
             attrs['aria-required'] = 'true'
         if getattr(self, 'prefill_attributes', None) and 'autocomplete' in self.prefill_attributes:
             attrs['autocomplete'] = self.prefill_attributes['autocomplete']
-- 
2.39.2


From 4faff356ed4f9aefd8a48c95303cd18885ee6089 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Fr=C3=A9d=C3=A9ric=20P=C3=A9ters?= <fpeters@entrouvert.com>
Date: Tue, 4 Apr 2023 17:01:12 +0200
Subject: [PATCH 10/11] fix maxlength test

---
 wcs/qommon/form.py | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/wcs/qommon/form.py b/wcs/qommon/form.py
index 9eed2d32c..6114fc50a 100644
--- a/wcs/qommon/form.py
+++ b/wcs/qommon/form.py
@@ -675,6 +675,10 @@ class TextWidget(QuixoteTextWidget):
     def _parse(self, request, use_validation_function=True):
         QuixoteTextWidget._parse(self, request)
         if self.value is not None:
+            try:
+                maxlength = int(self.attrs.get('maxlength', 0))
+            except (TypeError, ValueError):
+                maxlength = 0
             if maxlength:
                 if len(self.value) > maxlength:
                     self.set_error('too_long')
-- 
2.39.2


From 04a3dedd089568d52719f5a1560911a45e2893cf Mon Sep 17 00:00:00 2001
From: Thomas JUND <tjund@entrouvert.com>
Date: Thu, 13 Apr 2023 15:43:44 +0200
Subject: [PATCH 11/11] Js: add live field validation (#75724)

---
 wcs/qommon/static/js/qommon.forms.js | 152 +++++++++++++++++++++++++++
 1 file changed, 152 insertions(+)

diff --git a/wcs/qommon/static/js/qommon.forms.js b/wcs/qommon/static/js/qommon.forms.js
index a4dc20cae..dee328282 100644
--- a/wcs/qommon/static/js/qommon.forms.js
+++ b/wcs/qommon/static/js/qommon.forms.js
@@ -774,3 +774,155 @@ function check_condition(button, widget_id) {
     },
   });
 }
+
+
+
+/*
+ *  Live Field Validation
+ */
+
+const LiveValidation = (function(){
+ 
+  const excludedField = function (field) {
+    if (field.disabled ) return true
+    const excludedType = [ 'button', 'reset', 'submit' ]
+    if (excludedType.includes(field.type)) return true
+    return false
+  }
+
+  /*
+   * Check validy of field by HTML attributs
+   * cf JS constaint validation API
+   * return first error fouded 
+   */
+  const hasAttrError = function (field) {
+    const validityState = field.validity
+    if (validityState.valid) return
+    
+    let errorType
+    for (const key in validityState) {
+      if (validityState[key]) {
+        errorType = key
+        break
+      }
+    }
+    return errorType
+  }
+
+  /*
+   * Check Validy of field by request to server
+   */
+  const hasServerError = function (field, form, url) {
+    return fetch( url+field.name, {
+      method: 'POST',
+      body: new FormData(form)
+    })
+    .then( (response) => response.json() )
+    .then( (json) => {
+      if (json.err === 0) {
+        return
+      } else {
+        let errorType
+        for (const key in json) {
+          if (json[key] === true) {
+            errorType = key
+            break
+          }
+        }
+        return errorType
+      }
+    })
+  }
+
+  class FieldLiveValidation {
+    constructor (widget, formDatas) {
+      this.widget = widget
+      this.name = widget.dataset.widgetName
+      this.errorClass = "widget-with-error"
+      this.errorEl = this.setErrorEl(formDatas.errorTpl.content.children[0])
+      this.checkUrl = formDatas.checkUrl
+      this.hasError = false
+      this.init()
+    }
+
+    setErrorEl = function(errorTpl) {
+      const errorEl = document.importNode(errorTpl)
+      errorEl.id = errorEl.id.replace('fieldname', this.name)
+      return errorEl
+    }
+
+    async toggleStatus(field) {
+        if (excludedField(field)) return
+        const attrError = hasAttrError(field);
+        const serverError = this.widget.dataset.supportsCheckCondition 
+          ? await hasServerError(field, field.form, this.checkUrl)
+          : false
+        const error = attrError ? attrError : serverError
+        if (error) {
+          this.showError(field, error)
+        } else {
+          this.removeError(field, error)
+        }
+    }
+
+    showError(field, error) {
+      if (this.hasError === error) return
+      this.widget.classList.add(this.errorClass)
+      const errorElMessage = document.getElementById(`error_${this.name}_${error}`).innerHTML
+      this.errorEl.innerHTML = errorElMessage
+      this.widget.appendChild(this.errorEl)
+      field.setAttribute("aria-invalid", "true")
+      field.setAttribute("aria-describedby", this.errorEl.id)
+      this.hasError = error
+    }
+
+    removeError(field, error) {
+      if (error) return
+      this.errorEl.remove()
+      field.setAttribute("aria-invalid", "false")
+      field.setAttribute("aria-describedby", this.errorEl.id)
+      this.widget.classList.remove(this.errorClass)
+      this.hasError = false
+    }
+
+    init() {
+      // Check if field is allready on error
+      if (this.widget.classList.contains(this.errorClass)) {
+        this.hasError = true;
+        // Check if error element exist allready
+        const existingErrorEl = document.getElementById(this.errorEl.id)
+        if (existingErrorEl) 
+          this.errorEl = existingErrorEl;
+      }
+
+      // Events
+      this.widget.addEventListener('blur', (event) => {
+        this.toggleStatus(event.target)
+      }, true);
+      // If field has Error, check when it change with debounce
+      let timeout;
+      this.widget.addEventListener('input', (event) => {
+        if (this.hasError) {
+          clearTimeout(timeout)
+          timeout = setTimeout(() => {
+            this.toggleStatus(event.target)
+          }, 500)
+        }
+      }, true);
+    }
+  }
+
+  return FieldLiveValidation
+})()
+
+document.addEventListener('DOMContentLoaded', function(){
+  const form = document.querySelector('form[data-check-condition-url]')
+  const formWidgets = form.querySelectorAll('.widget')
+  let formDatas = {
+    errorTpl: document.getElementById('form_error_tpl'),
+    checkUrl: form.dataset.checkConditionUrl + '?field=',
+  }
+  formWidgets.forEach((widget) => {
+    new LiveValidation(widget, formDatas)
+  })
+})
-- 
2.39.2