wagtailstreamforms 0.0.0__py3-none-any.whl

wagtailstreamforms/templatetags/streamforms_tags.py

@@ -0,0 +1,43 @@
+from urllib.parse import urlencode
+
+from django.template import Library
+from django.utils.safestring import mark_safe
+
+from wagtailstreamforms.blocks import WagtailFormBlock
+from wagtailstreamforms.models import Form
+
+register = Library()
+
+
+@register.simple_tag(takes_context=True)
+def url_replace(context, **kwargs):
+    """will append kwargs to the existing url replacing any passed in"""
+
+    query = context["request"].GET.dict()
+    query.update(kwargs)
+    return urlencode(query)
+
+
+@register.simple_tag(takes_context=True)
+def streamforms_form(context, slug, reference, action=".", **kwargs):
+    """
+    Renders a form on the page.
+
+    {% load streamforms_tags %}
+    {% streamforms_form "the-form-slug" "some-unique-reference" "." %}
+    """
+
+    try:
+        form = Form.objects.get(slug=slug)
+
+        block = WagtailFormBlock()
+
+        # the context is a RequestContext, we need to turn it into a dict or
+        # the blocks in wagtail will start to fail with dict(context)
+        return block.render(
+            block.to_python({"form": form.pk, "form_action": action, "form_reference": reference}),
+            context.flatten(),
+        )
+
+    except Form.DoesNotExist:
+        return mark_safe("")

wagtailstreamforms/urls.py

@@ -0,0 +1,31 @@
+from django.urls import path
+
+from wagtailstreamforms import views
+from wagtailstreamforms.utils.loading import get_advanced_settings_model
+
+SettingsModel = get_advanced_settings_model()
+
+
+urlpatterns = [
+    path("<int:pk>/copy/", views.CopyFormView.as_view(), name="streamforms_copy"),
+    path(
+        "<int:pk>/submissions/",
+        views.SubmissionListView.as_view(),
+        name="streamforms_submissions",
+    ),
+    path(
+        "<int:pk>/submissions/delete/",
+        views.SubmissionDeleteView.as_view(),
+        name="streamforms_delete_submissions",
+    ),
+]
+
+
+if SettingsModel:  # pragma: no cover
+    urlpatterns += [
+        path(
+            "<int:pk>/advanced/",
+            views.AdvancedSettingsView.as_view(),
+            name="streamforms_advanced",
+        )
+    ]

wagtailstreamforms/utils/apps.py

@@ -0,0 +1,25 @@
+from importlib import import_module
+
+from django.apps import apps
+from django.utils.module_loading import module_has_submodule
+
+
+def get_app_modules():
+    """
+    Generator function that yields a module object for each installed app
+    yields tuples of (app_name, module)
+    """
+
+    for app in apps.get_app_configs():
+        yield app.name, app.module
+
+
+def get_app_submodules(submodule_name):
+    """
+    Searches each app module for the specified submodule
+    yields tuples of (app_name, module)
+    """
+
+    for name, module in get_app_modules():
+        if module_has_submodule(module, submodule_name):
+            yield name, import_module("%s.%s" % (name, submodule_name))

wagtailstreamforms/utils/general.py

@@ -0,0 +1,6 @@
+from django.utils.text import slugify
+from unidecode import unidecode
+
+
+def get_slug_from_string(label):
+    return str(slugify(str(unidecode(label))))

wagtailstreamforms/utils/loading.py

@@ -0,0 +1,30 @@
+from django.apps import apps
+from django.core.exceptions import ImproperlyConfigured
+
+from wagtailstreamforms.conf import get_setting
+from wagtailstreamforms.models import AbstractFormSetting
+
+
+def get_advanced_settings_model():
+    """
+    Returns the advanced form settings model if one is defined
+    """
+
+    model = get_setting("ADVANCED_SETTINGS_MODEL")
+
+    if not model:
+        return
+
+    def raise_error(msg):
+        setting = "WAGTAILSTREAMFORMS_ADVANCED_SETTINGS_MODEL"
+        raise ImproperlyConfigured("%s %s" % (setting, msg))
+
+    try:
+        model_class = apps.get_model(model, require_ready=False)
+        if issubclass(model_class, AbstractFormSetting):
+            return model_class
+        raise_error("must inherit from 'wagtailstreamforms.models.AbstractFormSetting'")
+    except ValueError:
+        raise_error("must be of the form 'app_label.model_name'")
+    except LookupError:
+        raise_error("refers to model '%s' that has not been installed" % model)

wagtailstreamforms/utils/requests.py

@@ -0,0 +1,13 @@
+from wagtailstreamforms.models import Form
+
+
+def get_form_instance_from_request(request):
+    """Get the form class from the request."""
+
+    form_id = request.POST.get("form_id")
+    if form_id and form_id.isdigit():
+        try:
+            return Form.objects.get(pk=int(form_id))
+        except Form.DoesNotExist:
+            pass
+    return None

wagtailstreamforms/views/__init__.py

@@ -0,0 +1,4 @@
+from .advanced_settings import AdvancedSettingsView  # noqa
+from .copy import CopyFormView  # noqa
+from .submission_delete import SubmissionDeleteView  # noqa
+from .submission_list import SubmissionListView  # noqa

wagtailstreamforms/views/advanced_settings.py

@@ -0,0 +1,51 @@
+from django import forms
+from django.contrib import messages
+from django.shortcuts import get_object_or_404
+from django.utils.translation import gettext as _
+from django.views.generic import UpdateView
+
+from wagtailstreamforms.models import Form
+from wagtailstreamforms.utils.loading import get_advanced_settings_model
+from wagtailstreamforms.wagtail_hooks import FormURLHelper
+
+SettingsModel = get_advanced_settings_model()
+
+
+class AdvancedSettingsForm(forms.ModelForm):
+    class Meta:
+        exclude = ("form",)
+        model = SettingsModel
+
+
+class AdvancedSettingsView(UpdateView):
+    form_class = AdvancedSettingsForm
+    model = SettingsModel
+    template_name = "streamforms/advanced_settings.html"
+    success_message = _("Form '%s' advanced settings updated.")
+
+    @property
+    def url_helper(self):
+        return FormURLHelper(model=Form)
+
+    def get_object(self, queryset=None):
+        form_pk = self.kwargs.get("pk")
+        form = get_object_or_404(Form, pk=form_pk)
+
+        try:
+            obj = self.model.objects.get(form=form)
+        except self.model.DoesNotExist:
+            obj = self.model(form=form)
+
+        return obj
+
+    def form_valid(self, form):
+        response = super().form_valid(form)
+        self.create_success_message()
+        return response
+
+    def create_success_message(self):
+        success_message = self.success_message % self.object.form
+        messages.success(self.request, success_message)
+
+    def get_success_url(self):
+        return self.url_helper.index_url

wagtailstreamforms/views/copy.py

@@ -0,0 +1,83 @@
+from django import forms
+from django.contrib import messages
+from django.core.exceptions import PermissionDenied
+from django.http import HttpResponseRedirect
+from django.utils.translation import gettext_lazy as _
+from django.views.generic.detail import (
+    BaseDetailView,
+    SingleObjectTemplateResponseMixin,
+)
+from wagtail_modeladmin.helpers import PermissionHelper
+
+from wagtailstreamforms.models import Form
+from wagtailstreamforms.wagtail_hooks import FormURLHelper
+
+
+class CopyForm(forms.Form):
+    title = forms.CharField(label=_("New title"))
+    slug = forms.SlugField(label=_("New slug"))
+
+    def clean_slug(self):
+        slug = self.cleaned_data["slug"]
+        if Form.objects.filter(slug=slug).exists():
+            raise forms.ValidationError("This slug is already in use")
+        return slug
+
+
+class CopyFormView(SingleObjectTemplateResponseMixin, BaseDetailView):
+    model = Form
+    template_name = "streamforms/confirm_copy.html"
+    success_message = _("Form '%s' copied to '%s'.")
+
+    @property
+    def permission_helper(self):
+        return PermissionHelper(model=self.model)
+
+    @property
+    def url_helper(self):
+        return FormURLHelper(model=self.model)
+
+    def dispatch(self, request, *args, **kwargs):
+        self.object = self.get_object()
+        if not self.permission_helper.user_can_create(self.request.user):
+            raise PermissionDenied
+        return super().dispatch(request, *args, **kwargs)
+
+    def get_object(self, queryset=None):
+        obj = super().get_object(queryset)
+        return obj
+
+    def copy(self, request, *args, **kwargs):
+        form = CopyForm(request.POST)
+
+        if form.is_valid():
+            copied = self.object.copy()
+            copied.title = form.cleaned_data["title"]
+            copied.slug = form.cleaned_data["slug"]
+
+            copied.save()
+
+            self.create_success_message(copied)
+
+            return HttpResponseRedirect(self.get_success_url())
+
+        context = self.get_context_data(object=self.object)
+        context["form"] = form
+
+        return self.render_to_response(context)
+
+    def get(self, request, *args, **kwargs):
+        context = self.get_context_data(object=self.object)
+        context["form"] = CopyForm(initial={"title": self.object.title, "slug": self.object.slug})
+
+        return self.render_to_response(context)
+
+    def post(self, request, *args, **kwargs):
+        return self.copy(request, *args, **kwargs)
+
+    def create_success_message(self, copied):
+        success_message = self.success_message % (self.object, copied)
+        messages.success(self.request, success_message)
+
+    def get_success_url(self):
+        return self.url_helper.index_url

wagtailstreamforms/views/submission_delete.py

@@ -0,0 +1,73 @@
+from django.contrib import messages
+from django.core.exceptions import PermissionDenied
+from django.http import HttpResponseRedirect
+from django.urls import reverse
+from django.utils.translation import ngettext
+from django.views.generic import DeleteView
+from wagtail_modeladmin.helpers import PermissionHelper
+
+from wagtailstreamforms.models import Form
+
+
+class SubmissionDeleteView(DeleteView):
+    model = Form
+    template_name = "streamforms/confirm_delete.html"
+
+    @property
+    def permission_helper(self):
+        return PermissionHelper(model=self.model)
+
+    def dispatch(self, request, *args, **kwargs):
+        self.object = self.get_object()
+        if not self.permission_helper.user_can_delete_obj(self.request.user, self.object):
+            raise PermissionDenied
+        return super().dispatch(request, *args, **kwargs)
+
+    def get_object(self, queryset=None):
+        obj = super().get_object(queryset)
+        return obj
+
+    def get_submissions(self):
+        submission_ids = self.request.GET.getlist("selected-submissions")
+        submission_class = self.object.get_submission_class()
+        return submission_class._default_manager.filter(id__in=submission_ids)
+
+    def get_context_data(self, **kwargs):
+        context = super().get_context_data(**kwargs)
+        context["submissions"] = self.get_submissions()
+        return context
+
+    def delete(self, request, *args, **kwargs):
+        """
+        Django 4.0 uses FormMixin, so this logic has been moved to form_valid.
+
+        This can be removed once Django 3.2 is no longer supported.
+        """
+        success_url = self.get_success_url()
+        submissions = self.get_submissions()
+        count = submissions.count()
+        submissions.delete()
+        self.create_success_message(count)
+        return HttpResponseRedirect(success_url)
+
+    def form_valid(self, request, *args, **kwargs):
+        success_url = self.get_success_url()
+        submissions = self.get_submissions()
+        count = submissions.count()
+        submissions.delete()
+        self.create_success_message(count)
+        return HttpResponseRedirect(success_url)
+
+    def create_success_message(self, count):
+        messages.success(
+            self.request,
+            ngettext(
+                "One submission has been deleted.",
+                "%(count)d submissions have been deleted.",
+                count,
+            )
+            % {"count": count},
+        )
+
+    def get_success_url(self):
+        return reverse("wagtailstreamforms:streamforms_submissions", kwargs={"pk": self.object.pk})

wagtailstreamforms/views/submission_list.py

@@ -0,0 +1,112 @@
+import csv
+import datetime
+
+from django.core.exceptions import PermissionDenied
+from django.http import Http404, HttpResponse
+from django.utils.encoding import smart_str
+from django.utils.translation import gettext as _
+from django.views.generic import ListView
+from django.views.generic.detail import SingleObjectMixin
+from wagtail_modeladmin.helpers import PermissionHelper
+
+from wagtailstreamforms import hooks
+from wagtailstreamforms.forms import SelectDateForm
+from wagtailstreamforms.models import Form
+
+
+class SubmissionListView(SingleObjectMixin, ListView):
+    paginate_by = 25
+    page_kwarg = "p"
+    template_name = "streamforms/index_submissions.html"
+    filter_form = None
+    model = Form
+
+    @property
+    def permission_helper(self):
+        return PermissionHelper(model=self.model)
+
+    def dispatch(self, request, *args, **kwargs):
+        self.object = self.get_object()
+        if not self.permission_helper.user_can_list(self.request.user):
+            raise PermissionDenied
+        return super().dispatch(request, *args, **kwargs)
+
+    def get_object(self, queryset=None):
+        pk = self.kwargs.get(self.pk_url_kwarg)
+        try:
+            qs = self.model.objects.all()
+            for fn in hooks.get_hooks("construct_form_queryset"):
+                qs = fn(qs, self.request)
+            return qs.get(pk=pk)
+        except self.model.DoesNotExist:
+            raise Http404(_("No Form found matching the query"))
+
+    def get(self, request, *args, **kwargs):
+        self.filter_form = SelectDateForm(request.GET)
+
+        if request.GET.get("action") == "CSV":
+            return self.csv()
+
+        return super().get(request, *args, **kwargs)
+
+    def csv(self):
+        queryset = self.get_queryset()
+        data_fields = self.object.get_data_fields()
+        data_headings = [smart_str(label) for name, label in data_fields]
+
+        response = HttpResponse(content_type="text/csv; charset=utf-8")
+        response["Content-Disposition"] = "attachment;filename=export.csv"
+
+        writer = csv.writer(response)
+        writer.writerow(data_headings)
+        for s in queryset:
+            data_row = []
+            form_data = s.get_data()
+            for name, label in data_fields:
+                data_row.append(smart_str(form_data.get(name)))
+            writer.writerow(data_row)
+
+        return response
+
+    def get_queryset(self):
+        submission_class = self.object.get_submission_class()
+        self.queryset = submission_class._default_manager.filter(form=self.object)
+
+        # filter the queryset by the required dates
+        if self.filter_form.is_valid():
+            date_from = self.filter_form.cleaned_data.get("date_from")
+            date_to = self.filter_form.cleaned_data.get("date_to")
+            if date_from:
+                self.queryset = self.queryset.filter(submit_time__gte=date_from)
+            if date_to:
+                date_to += datetime.timedelta(days=1)
+                self.queryset = self.queryset.filter(submit_time__lte=date_to)
+
+        return self.queryset.prefetch_related("files")
+
+    def get_context_data(self, **kwargs):
+        context = super().get_context_data(**kwargs)
+
+        data_fields = self.object.get_data_fields()
+        data_headings = [label for name, label in data_fields]
+
+        # populate data rows from paginator
+        data_rows = []
+        for s in context["page_obj"]:
+            form_data = s.get_data()
+            form_files = s.files.all()
+            data_row = [form_data.get(name) for name, label in data_fields]
+            data_rows.append({"model_id": s.id, "fields": data_row, "files": form_files})
+
+        context.update(
+            {
+                "filter_form": self.filter_form,
+                "data_rows": data_rows,
+                "data_headings": data_headings,
+                "has_delete_permission": self.permission_helper.user_can_delete_obj(
+                    self.request.user, self.object
+                ),
+            }
+        )
+
+        return context