wagtailstreamforms 0.0.0__py3-none-any.whl

wagtailstreamforms/__init__.py

@@ -0,0 +1 @@
+__version__ = "4.1.0"

wagtailstreamforms/blocks.py

@@ -0,0 +1,93 @@
+import uuid
+
+from django.utils.functional import cached_property
+from django.utils.safestring import SafeText, mark_safe
+from django.utils.translation import gettext_lazy as _
+from wagtail import blocks
+
+
+class InfoBlock(blocks.CharBlock):
+    def render_form(self, value, prefix="", errors=None) -> SafeText:
+        field = self.field
+        shown_value = value if value else field.help_text
+        return mark_safe('<div style="margin-top:5px;padding:0.9em 1.2em;">%s</div>' % shown_value)
+
+
+class FormChooserBlock(blocks.ChooserBlock):
+    @cached_property
+    def target_model(self):
+        from .models import Form
+
+        return Form
+
+    @cached_property
+    def widget(self):
+        from .wagtail_hooks import WagtailStreamFormsChooser
+
+        return WagtailStreamFormsChooser()
+
+    def get_form_state(self, value: dict):
+        return self.widget.get_value_data(value)
+
+
+class WagtailFormBlock(blocks.StructBlock):
+    form = FormChooserBlock()
+    form_action = blocks.CharBlock(
+        required=False,
+        help_text=_('The form post action. "" or "." for the current page or a url'),
+    )
+    form_reference = InfoBlock(
+        required=False,
+        help_text=_("This form will be given a unique reference once saved"),
+    )
+
+    class Meta:
+        icon = "form"
+        template = None
+
+    def render(self, value: dict, context: dict | None = None) -> str | SafeText:
+        form = value.get("form")
+
+        # check if we have a form, as they can be deleted, and we dont want to break the site with
+        # a none template value
+        if form:
+            self.meta.template = form.template_name
+        else:
+            self.meta.template = "streamforms/non_existent_form.html"
+
+        return super().render(value, context)
+
+    def get_context(self, value: dict, parent_context: dict | None = None) -> dict:
+        context = super().get_context(value, parent_context)
+
+        form = value.get("form")
+        form_reference = value.get("form_reference")
+
+        if form:
+            # check the context for an invalid form submitted to the page.
+            # Use that instead if it has the same unique form_reference number
+            invalid_form_reference = context.get("invalid_stream_form_reference")
+            invalid_form = context.get("invalid_stream_form")
+
+            if (
+                invalid_form_reference
+                and invalid_form
+                and invalid_form_reference == form_reference
+            ):
+                context["form"] = invalid_form
+            else:
+                context["form"] = form.get_form(
+                    initial={"form_id": form.id, "form_reference": form_reference}
+                )
+
+        return context
+
+    def clean(self, value: dict) -> dict:
+        result = super().clean(value)
+
+        # set to a new uuid so we can ensure we can identify this form
+        # against other forms of the same type in the page
+        if not result.get("form_reference"):
+            result["form_reference"] = uuid.uuid4()
+
+        return result

wagtailstreamforms/conf.py

@@ -0,0 +1,35 @@
+from django.conf import settings
+from django.utils.translation import gettext_lazy as _
+
+SETTINGS_PREFIX = "WAGTAILSTREAMFORMS"
+SETTINGS_DEFAULTS = {
+    "ADMIN_MENU_LABEL": _("Streamforms"),
+    "ADMIN_MENU_ORDER": None,
+    "ADVANCED_SETTINGS_MODEL": None,
+    "ENABLE_FORM_PROCESSING": True,
+    "ENABLE_BUILTIN_HOOKS": True,
+    "ENABLED_FIELDS": (
+        "singleline",
+        "multiline",
+        "date",
+        "datetime",
+        "email",
+        "url",
+        "number",
+        "dropdown",
+        "radio",
+        "checkboxes",
+        "checkbox",
+        "hidden",
+        "singlefile",
+        "multifile",
+    ),
+    "FORM_TEMPLATES": [
+        ("streamforms/form_block.html", "Default Form Template"),
+    ],
+}
+
+
+def get_setting(name):
+    setting_key = "{}_{}".format(SETTINGS_PREFIX, name)
+    return getattr(settings, setting_key, SETTINGS_DEFAULTS[name])

wagtailstreamforms/fields.py

@@ -0,0 +1,218 @@
+from django import forms
+from django.core import exceptions
+from django.db import models
+from django.utils.text import capfirst
+from wagtail import blocks
+
+from wagtailstreamforms import hooks
+from wagtailstreamforms.utils.apps import get_app_submodules
+from wagtailstreamforms.utils.general import get_slug_from_string
+
+_fields = {}
+_searched_for_fields = False
+
+
+def register(field_name, cls=None):
+    """
+    Register field for ``field_name``. Can be used as a decorator::
+        @register('singleline')
+        class SingleLineTextField(BaseField):
+            field_class = django.forms.CharField
+    or as a function call::
+        class SingleLineTextField(BaseField):
+            field_class = django.forms.CharField
+        register('singleline', SingleLineTextField)
+    """
+
+    if cls is None:
+
+        def decorator(cls):
+            register(field_name, cls)
+            return cls
+
+        return decorator
+
+    _fields[field_name] = cls
+
+
+def search_for_fields():
+    global _searched_for_fields
+    if not _searched_for_fields:
+        list(get_app_submodules("wagtailstreamforms_fields"))
+        _searched_for_fields = True
+
+
+def get_fields():
+    """Return the registered field classes."""
+
+    search_for_fields()
+    return _fields
+
+
+class BaseField:
+    """A base form field class, all form fields must inherit this class.
+
+    Usage::
+
+        @register('multiline')
+        class MultiLineTextField(BaseField):
+            field_class = forms.CharField
+            widget = forms.widgets.Textarea
+            icon = 'placeholder'
+            label = 'Text (multi line)'
+
+    """
+
+    field_class = None
+    widget = None
+    icon = "placeholder"
+    label = None
+
+    @classmethod
+    def get_formfield_name(cls, block_value):
+        """
+        Return a value to use as the 'name' for the Django form field.
+        """
+        return block_value.get("name") or get_slug_from_string(
+            cls.get_formfield_label(block_value)
+        )
+
+    @classmethod
+    def get_formfield_label(cls, block_value):
+        """
+        Return a value to use as the 'label' for the Django form field.
+        """
+        try:
+            return block_value["label"]
+        except KeyError:
+            raise AttributeError(
+                f"No label value can be determined for an instance of {cls.__name__}. "
+                "Add a 'label' CharBlock() in your field's get_form_block() method to "
+                "allow this to be specified by form editors. Or, override "
+                "get_formfield_label() to return a different value."
+            )
+
+    @classmethod
+    def get_formfield_help_text(cls, block_value):
+        """
+        Return a value to use as the 'help_text' for the Django form field.
+        """
+        return block_value.get("help_text")
+
+    @classmethod
+    def get_formfield_initial(cls, block_value):
+        """
+        Return a 'initial' value to use for the Django form field.
+        """
+        return block_value.get("default_value")
+
+    @classmethod
+    def get_formfield_required(cls, block_value):
+        """
+        Return a boolean indicating whether the Django form field should be required.
+        """
+        return block_value.get("required", True)
+
+    def get_formfield(self, block_value):
+        """
+        Get the form field. Its unlikely you will need to override this.
+
+        :param block_value: The StreamValue for this field from the StreamField
+        :return: An instance of a form field class, ie ``django.forms.CharField(**options)``
+        """
+
+        if not self.field_class:
+            raise NotImplementedError("must provide a cls.field_class")
+
+        options = self.get_options(block_value)
+
+        if self.widget:
+            return self.field_class(widget=self.widget, **options)
+
+        return self.field_class(**options)
+
+    def get_options(self, block_value):
+        """The field options.
+
+        Override this to provide additional options such as ``choices`` for a dropdown.
+
+        :param block_value: The StreamValue for this field from the StreamField
+        :return: The options to be passed into the field, ie ``django.forms.CharField(**options)``
+        """
+
+        return {
+            "label": self.get_formfield_label(block_value),
+            "help_text": self.get_formfield_help_text(block_value),
+            "required": self.get_formfield_required(block_value),
+            "initial": self.get_formfield_initial(block_value),
+        }
+
+    def get_form_block(self):
+        """The StreamField StructBlock.
+
+        Override this to provide additional fields in the StreamField.
+
+        :return: The ``wagtail.core.blocks.StructBlock`` to be used in the StreamField
+        """
+        return blocks.StructBlock(
+            [
+                ("label", blocks.CharBlock()),
+                ("help_text", blocks.CharBlock(required=False)),
+                ("required", blocks.BooleanBlock(required=False)),
+                ("default_value", blocks.CharBlock(required=False)),
+            ],
+            icon=self.icon,
+            label=self.label,
+        )
+
+
+class HookMultiSelectFormField(forms.MultipleChoiceField):
+    widget = forms.CheckboxSelectMultiple
+
+
+class HookSelectField(models.Field):
+    def get_choices_default(self):
+        return [
+            (fn.__name__, capfirst(fn.__name__.replace("_", " ")))
+            for fn in hooks.get_hooks("process_form_submission")
+        ]
+
+    def get_db_prep_value(self, value, connection=None, prepared=False):
+        if isinstance(value, str):
+            return value
+        elif isinstance(value, list):
+            return ",".join(value)
+
+    def get_internal_type(self):
+        return "TextField"
+
+    def formfield(self, **kwargs):
+        defaults = {
+            "form_class": HookMultiSelectFormField,
+            "choices": self.get_choices_default(),
+        }
+        defaults.update(kwargs)
+        return super().formfield(**defaults)
+
+    def from_db_value(self, value, expression, connection, context=None, *args, **kwargs):
+        if value is None or value == "":
+            return []
+        return value.split(",")
+
+    def to_python(self, value):
+        if not value or value == "":
+            return []
+        if isinstance(value, list):
+            return value
+        return value.split(",")
+
+    def value_to_string(self, obj):
+        value = self.value_from_object(obj)
+        return ",".join(value)
+
+    def validate(self, value, model_instance):
+        arr_choices = [v for v, s in self.get_choices_default()]
+        for opt in value:
+            if opt not in arr_choices:
+                raise exceptions.ValidationError("%s is not a valid choice" % opt)
+        return

wagtailstreamforms/forms.py

@@ -0,0 +1,61 @@
+from collections import OrderedDict
+
+from django import forms
+from django.utils.translation import gettext_lazy as _
+
+from wagtailstreamforms.fields import get_fields
+
+
+class BaseForm(forms.Form):
+    def __init__(self, *args, **kwargs):
+        kwargs.setdefault("label_suffix", "")
+
+        self.user = kwargs.pop("user", None)
+        self.page = kwargs.pop("page", None)
+
+        super().__init__(*args, **kwargs)
+
+
+class FormBuilder:
+    def __init__(self, fields):
+        self.fields = fields
+
+    @property
+    def formfields(self):
+        """Return a list of form fields from the registered fields."""
+
+        formfields = OrderedDict()
+
+        registered_fields = get_fields()
+
+        for field in self.fields:
+            field_type = field.get("type")
+            field_value = field.get("value")
+
+            # check we have the field
+            if field_type not in registered_fields:
+                raise AttributeError("Could not find a registered field of type %s" % field_type)
+
+            # get the field
+            registered_cls = registered_fields[field_type]()
+            field_name = registered_cls.get_formfield_name(field_value)
+            field_cls = registered_cls.get_formfield(field_value)
+            formfields[field_name] = field_cls
+
+        # add fields to uniquely identify the form
+        formfields["form_id"] = forms.CharField(widget=forms.HiddenInput)
+        formfields["form_reference"] = forms.CharField(widget=forms.HiddenInput)
+
+        return formfields
+
+    def get_form_class(self):
+        return type(str("StreamformsForm"), (BaseForm,), self.formfields)
+
+
+class SelectDateForm(forms.Form):
+    date_from = forms.DateTimeField(
+        required=False, widget=forms.DateInput(attrs={"placeholder": _("Date from")})
+    )
+    date_to = forms.DateTimeField(
+        required=False, widget=forms.DateInput(attrs={"placeholder": _("Date to")})
+    )

wagtailstreamforms/hooks.py

@@ -0,0 +1,62 @@
+from operator import itemgetter
+
+from wagtailstreamforms.conf import get_setting
+from wagtailstreamforms.utils.apps import get_app_submodules
+
+_hooks = {}
+
+
+def register(hook_name, fn=None, order=0):
+    """
+    Register hook for ``hook_name``. Can be used as a decorator::
+        @register('hook_name')
+        def my_hook(...):
+            pass
+    or as a function call::
+        def my_hook(...):
+            pass
+        register('hook_name', my_hook)
+    """
+
+    # Pretend to be a decorator if fn is not supplied
+    if fn is None:
+
+        def decorator(fn):
+            register(hook_name, fn, order=order)
+            return fn
+
+        return decorator
+
+    if hook_name not in _hooks:
+        _hooks[hook_name] = []
+    _hooks[hook_name].append((fn, order))
+
+
+_searched_for_hooks = False
+
+
+def search_for_hooks():
+    global _searched_for_hooks
+    if not _searched_for_hooks:
+        list(get_app_submodules("wagtailstreamforms_hooks"))
+        _searched_for_hooks = True
+
+
+def get_hooks(hook_name):
+    """Return the hooks function sorted by their order."""
+
+    search_for_hooks()
+    hooks = _hooks.get(hook_name, [])
+    hooks = sorted(hooks, key=itemgetter(1))
+    fncs = []
+    builtin_hook_modules = ["wagtailstreamforms.wagtailstreamforms_hooks"]
+    builtin_enabled = get_setting("ENABLE_BUILTIN_HOOKS")
+
+    for fn, _ in hooks:
+        # dont add the hooks if they have been disabled via the setting
+        # this is so that they can be overridden
+        if fn.__module__ in builtin_hook_modules and not builtin_enabled:
+            continue
+        fncs.append(fn)
+
+    return fncs