def post(self, request, *args, **kwargs):
published = Form.objects.published(for_user=request.user)
form = get_object_or_404(published, slug=kwargs["slug"])
form_for_form = FormForForm(form, RequestContext(request), request.POST
or None, request.FILES or None)
if not form_for_form.is_valid():
form_invalid.send(sender=request, form=form_for_form)
else:
# Attachments read must occur before model save,
# or seek() will fail on large uploads.
attachments = []
for f in form_for_form.files.values():
f.seek(0)
attachments.append((f.name, f.read(), f.content_type))
entry = form_for_form.save()
form_valid.send(sender=request, form=form_for_form, entry=entry)
self.send_emails(request, form_for_form, form, entry, attachments)
# XXX: is_ajax() is deprecated since Django 3.1, removed in Django 4.0
# https://docs.djangoproject.com/en/3.1/releases/3.1/#id2
if not self.request.is_ajax():
return redirect(
form.redirect_url
or reverse("form_sent", kwargs={"slug": form.slug}))
context = {"form": form, "form_for_form": form_for_form}
return self.render_to_response(context)
def form_detail(request, slug, template="forms/form_detail.html"):
"""
Display a built form and handle submission.
"""
published = Form.objects.published(for_user=request.user)
form = get_object_or_404(published, slug=slug)
if form.login_required and not request.user.is_authenticated():
return redirect("%s?%s=%s" % (settings.LOGIN_URL, REDIRECT_FIELD_NAME,
urlquote(request.get_full_path())))
request_context = RequestContext(request)
args = (form, request_context, request.POST or None, request.FILES or None)
form_for_form = FormForForm(*args)
if request.method == "POST":
if not form_for_form.is_valid():
form_invalid.send(sender=request, form=form_for_form)
else:
entry = form_for_form.save()
subject = form.email_subject
if not subject:
subject = "%s - %s" % (form.title, entry.entry_time)
fields = []
for (k, v) in form_for_form.fields.items():
value = form_for_form.cleaned_data[k]
if isinstance(value, list):
value = ", ".join([i.strip() for i in value])
fields.append((v.label, value))
context = {
"fields": fields,
"message": form.email_message,
"request": request,
}
email_from = form.email_from or settings.DEFAULT_FROM_EMAIL
email_to = form_for_form.email_to()
if email_to and form.send_email:
send_mail_template(subject,
"form_response",
email_from,
email_to,
context=context,
fail_silently=settings.DEBUG)
email_copies = split_choices(form.email_copies)
if email_copies:
if email_to and SEND_FROM_SUBMITTER:
# Send from the email entered.
email_from = email_to
attachments = []
for f in form_for_form.files.values():
f.seek(0)
attachments.append((f.name, f.read()))
send_mail_template(subject,
"form_response",
email_from,
email_copies,
context=context,
attachments=attachments,
fail_silently=settings.DEBUG)
form_valid.send(sender=request, form=form_for_form, entry=entry)
return redirect(reverse("form_sent", kwargs={"slug": form.slug}))
context = {"form": form}
return render_to_response(template, context, request_context)
def post(self, request, *args, **kwargs):
published = Form.objects.published(for_user=request.user)
form = get_object_or_404(published, slug=kwargs["slug"])
form_for_form = FormForForm(
form,
RequestContext(request),
request.POST or None,
request.FILES or None,
user=request.user or None,
track=Track.objects.get(id=request.GET.get("track_id")) or None)
form_contains_errors = None
if not form_for_form.is_valid():
form_contains_errors = True
form_invalid.send(sender=request, form=form_for_form)
else:
# Attachments read must occur before model save,
# or seek() will fail on large uploads.
attachments = []
for f in form_for_form.files.values():
f.seek(0)
attachments.append((f.name, f.read()))
entry = form_for_form.save()
form_valid.send(sender=request, form=form_for_form, entry=entry)
self.send_emails(request, form_for_form, form, entry, attachments)
if not self.request.is_ajax():
return redirect("form_sent", slug=form.slug)
context = {
"form": form,
"form_for_form": form_for_form,
"form_contains_errors": form_contains_errors
}
return self.render_to_response(context)
def render(self, context):
request = context["request"]
user = getattr(request, "user", None)
post = getattr(request, "POST", None)
files = getattr(request, "FILES", None)
track = Track.objects.get(id=request.GET.get('track_id'))
if self.name != "form":
lookup = {
str(self.name): template.Variable(self.value).resolve(context)
}
try:
form = Form.objects.published(for_user=user).get(**lookup)
except Form.DoesNotExist:
form = None
else:
form = template.Variable(self.value).resolve(context)
if not isinstance(form, Form) or (form.login_required
and not user.is_authenticated()):
return ""
t = get_template("forms/includes/built_form.html")
context["form"] = form
form_args = (form, context, post or None, files or None)
context["form_for_form"] = FormForForm(*form_args,
user=user,
track=track)
return t.render(context)
def test_input_dropdown_required_with_default(self):
form = Form.objects.create(title="Test")
form.fields.create(label="Foo", field_type=SELECT, choices="one, two, three", default="two")
form_for_form = FormForForm(form, Context())
self.assertContains(HttpResponse(form_for_form), """
<select name="foo" required class="choicefield required" id="id_foo">
<option value="one">one</option>
<option value="two" selected>two</option>
<option value="three">three</option>
</select>""", html=True)
def test_input_dropdown_not_required_with_placeholder(self):
form = Form.objects.create(title="Test")
form.fields.create(label="Foo", placeholder_text="choose item", field_type=SELECT,
required=False, choices="one, two, three")
form_for_form = FormForForm(form, Context())
self.assertContains(HttpResponse(form_for_form), """
<select name="foo" class="choicefield" id="id_foo">
<option value="" selected>choose item</option>
<option value="one">one</option>
<option value="two">two</option>
<option value="three">three</option>
</select>""", html=True)
def post(self, request, *args, **kwargs):
# throw an error if this user is not authorized
# TODO: find a way to do this with carteblanche
if (self.request.user.is_staff != True) and (self.noun.members.filter(
id=self.request.user.id).count() == 0):
raise Exception(
"You tried to create a record with a location you're not assigned to. You must be an Admin or a member of "
+ self.noun.title + " to create a new record.")
indicator = get_object_or_404(cm.Indicator, id=kwargs["pk"])
builder_form_object = indicator.get_builder_form_object()
form = FormForForm(builder_form_object, RequestContext(request),
request.POST or None, request.FILES or None)
if not form.is_valid():
form_invalid.send(sender=request, form=self.form_for_form)
else:
# Attachments read must occur before model save,
# or seek() will fail on large uploads.
attachments = []
for f in form.files.values():
f.seek(0)
attachments.append((f.name, f.read()))
indicator = get_object_or_404(cm.Indicator, id=kwargs["pk"])
location = get_object_or_404(cm.Location, id=kwargs["location_pk"])
form.cleaned_data["user"] = request.user.get_full_name()
form.cleaned_data["location"] = location.__str__()
entry = form.save()
form_valid.send(sender=request, form=form, entry=entry)
form = self.prep_form(form)
score = indicator.score_entry(entry)
context = self.get_context_data(**kwargs)
if score >= indicator.passing_percentage:
messages.success(request, 'Passing score of ' + str(score))
action.send(self.request.user,
verb='entered passing record',
action_object=context.get("indicator"),
target=self.noun)
else:
messages.error(request, 'Not passing score of ' + str(score))
action.send(self.request.user,
verb='entered failing record',
action_object=context.get("indicator"),
target=self.noun)
return HttpResponseRedirect(
reverse(viewname='indicator_record_create',
args=(
kwargs['location_pk'],
kwargs['pk'],
),
current_app='core'))
context = {"builder_form_object": builder_form_object, "form": form}
return self.render_to_response(context)
def test_optional_filefield(self):
form = Form.objects.create(title="Test", status=STATUS_PUBLISHED)
if USE_SITES:
form.sites.add(self._site)
form.save()
form.fields.create(label="file field",
field_type=FILE,
required=False,
visible=True)
fields = form.fields.visible()
data = {'field_%s' % fields[0].id: ''}
context = Context({})
form_for_form = FormForForm(form, context, data=data)
#should not raise IntegrityError: forms_fieldentry.value may not be NULL
form_for_form.save()
def form_detail(request, slug, template="forms/form_detail.html"):
"""
Display a built form and handle submission.
"""
published = Form.objects.published(for_user=request.user)
if USE_SITES:
published = published.filter(sites=Site.objects.get_current())
form = get_object_or_404(published, slug=slug)
if form.login_required and not request.user.is_authenticated():
return redirect("%s?%s=%s" % (settings.LOGIN_URL, REDIRECT_FIELD_NAME,
urlquote(request.get_full_path())))
args = (form, request.POST or None, request.FILES or None)
form_for_form = FormForForm(*args)
if request.method == "POST":
if not form_for_form.is_valid():
form_invalid.send(sender=request, form=form_for_form)
else:
entry = form_for_form.save()
fields = [
"%s: %s" % (v.label, form_for_form.cleaned_data[k])
for (k, v) in form_for_form.fields.items()
]
subject = form.email_subject
if not subject:
subject = "%s - %s" % (form.title, entry.entry_time)
body = "\n".join(fields)
if form.email_message:
body = "%s\n\n%s" % (form.email_message, body)
email_from = form.email_from or settings.DEFAULT_FROM_EMAIL
email_to = form_for_form.email_to()
if email_to and form.send_email:
msg = EmailMessage(subject, body, email_from, [email_to])
msg.send()
email_from = email_to or email_from # Send from the email entered.
email_copies = [
e.strip() for e in form.email_copies.split(",") if e.strip()
]
if email_copies:
msg = EmailMessage(subject, body, email_from, email_copies)
for f in form_for_form.files.values():
f.seek(0)
msg.attach(f.name, f.read())
msg.send()
form_valid.send(sender=request, form=form_for_form, entry=entry)
return redirect(reverse("form_sent", kwargs={"slug": form.slug}))
context = {"form": form, "form_for_form": form_for_form}
return render_to_response(template, context, RequestContext(request))
def render(self, context):
request = context["request"]
post = getattr(request, "POST", None)
form = template.Variable(self.value).resolve(context)
t = get_template("forms/includes/built_form.html")
context["form"] = form
form_args = (form, context, post or None)
form_for_form = FormForForm(*form_args)
# kind of a hack
# add the 'data-verify' attribute if the field is marked
# as a verifiable field
for field in filter(lambda f: f.verify, form_for_form.form_fields):
form_for_form.fields[field.slug].widget.attrs['data-verify'] = True
context["form_for_form"] = form_for_form
return t.render(context)
def render(self, context):
request = context["request"]
user = getattr(request, "user", None)
post = getattr(request, "POST", None)
files = getattr(request, "FILES", None)
if self.name != "form":
lookup_value = template.Variable(self.value).resolve(context)
try:
form = Form.objects.get(**{str(self.name): lookup_value})
except Form.DoesNotExist:
form = None
else:
form = template.Variable(self.value).resolve(context)
if not isinstance(form, Form) or not form.published(for_user=user):
return ""
t = get_template("forms_builder/includes/built_form.html")
context["form"] = form
form_args = (form, context, post or None, files or None)
context["form_for_form"] = FormForForm(*form_args)
return t.render(context)
def post(self, request, *args, **kwargs):
published = Form.objects.published(for_user=request.user)
form = get_object_or_404(published, slug=kwargs["slug"])
form_for_form = FormForForm(request.user.username or "default",form, RequestContext(request), request.POST or None, request.FILES or None)
if not form_for_form.is_valid():
form_invalid.send(sender=request, form=form_for_form)
else:
# Attachments read must occur before model save,
# or seek() will fail on large uploads.
attachments = []
for f in form_for_form.files.values():
f.seek(0)
attachments.append((f.name, f.read()))
entry = form_for_form.save()
form_valid.send(sender=request, form=form_for_form, entry=entry)
self.send_emails(request, form_for_form, form, entry, attachments)
if not self.request.is_ajax():
return redirect(form.redirect_url or
reverse("forms:form_sent", kwargs={"slug": form.slug}))
context = {"form": form, "form_for_form": form_for_form}
return self.render_to_response(context)
def render(self, context):
request = context["request"]
user = getattr(request, "user", None)
post = getattr(request, "POST", None)
files = getattr(request, "FILES", None)
if self.name != "form":
lookup_value = template.Variable(self.value).resolve(context)
try:
form = Form.objects.get(**{str(self.name): lookup_value})
except Form.DoesNotExist:
form = None
else:
form = template.Variable(self.value).resolve(context)
if (not issubclass(form.__class__, AbstractForm)
or not form.published(for_user=user)):
return ""
t = get_template("forms/includes/built_form.html")
context["form"] = form
form_args = (form, context, post or None, files or None)
context["form_for_form"] = FormForForm(*form_args)
# django 1.11 migration - dict required instead of Context
return t.render(context.flatten())
def form_post(self, request, slug):
published = Form.objects.published(for_user=request.user)
form = get_object_or_404(published, slug=slug)
form_for_form = FormForForm(form, RequestContext(request),
request.POST or None,
request.FILES or None)
if not form_for_form.is_valid():
form_invalid.send(sender=request, form=form_for_form)
else:
# Attachments read must occur before model save,
# or seek() will fail on large uploads.
attachments = []
for f in form_for_form.files.values():
f.seek(0)
attachments.append((f.name, f.read()))
entry = form_for_form.save()
form_valid.send(sender=request, form=form_for_form, entry=entry)
self.send_emails(request, form_for_form, form, entry, attachments)
if not request.is_ajax():
return False, form, {}
context = {"form": form, "form_for_form": form_for_form}
return True, form, context
def render(self, context):
request = context["request"]
post = getattr(request, "POST", None)
form = template.Variable(self.value).resolve(context)
t = get_template("forms/includes/built_form.html")
context["form"] = form
form_args = (form, context, post or None)
form_for_form = FormForForm(*form_args)
# kind of a hack
# add the 'data-verify' attribute if the field is marked
# as a verifiable field
for i, field in enumerate(form_for_form.form_fields):
if field.verify:
form_for_form.fields[field.slug].widget.attrs['data-verify'] = True
# We give to all the form fields a common class so we can reference
# them in the frontend
fieldAttrs = form_for_form.fields[field.slug].widget.attrs
fieldAttrs['class'] = fieldAttrs['class'] + ' form-field'
context["form_for_form"] = form_for_form
return t.render(context)
def render(self, context):
request = context["request"]
post = getattr(request, "POST", None)
form = template.Variable(self.value).resolve(
context
) # TODO catch VariableDoesNotExist Error: Admin: Define form in given DOcumentSet (users shouldn;t be allowed to enter site if this is not set)
t = get_template("forms/includes/built_form.html")
context["form"] = form
form_args = (form, context, post or None)
form_for_form = FormForForm(*form_args)
# kind of a hack
# add the 'data-verify' attribute if the field is marked
# as a verifiable field
for field in filter(lambda f: f.verify, form_for_form.form_fields):
form_for_form.fields[field.slug].widget.attrs['data-verify'] = True
for field_ in form_for_form.form_fields:
form_for_form.fields[
field_.slug].widget.attrs['group'] = field_.group
form_for_form.fields[field_.slug].group = field_.group
context["form_for_form"] = form_for_form
return t.render(context)
def post(self, request, *args, **kwargs):
context = self.get_context_data(**kwargs)
form_for_form = FormForForm(self.form, RequestContext(request),
request.POST or None,
request.FILES or None)
if not form_for_form.is_valid():
form_invalid.send(sender=request, form=form_for_form)
else:
# Attachments read must occur before model save,
# or seek() will fail on large uploads.
attachments = []
for f in form_for_form.files.values():
f.seek(0)
attachments.append((f.name, f.read()))
entry = form_for_form.save()
form_valid.send(sender=request, form=form_for_form, entry=entry)
self.send_emails(request, form_for_form, self.form, entry, attachments)
if not self.request.is_ajax():
return redirect(
self.form.redirect_url or reverse(
"form_sent", kwargs={"slug": self.form.slug}))
context.update({"form_for_form": form_for_form})
return self.render_to_response(context)
def get_form(self):
c = Context()
return FormForForm(self.get_builder_form_object(), c)
def serialize_BuilderForm(builder_form):
c = Context()
z = FormForForm(builder_form, c)
remote_form = RemoteForm(z)
remote_form_dict = remote_form.as_dict()
return remote_form_dict
def post(self,
request,
content_type=None,
object_id=None,
form_detail_template="forms/form_detail.html",
*args,
**kwargs):
self.object = get_object_or_404(
content_type.model_class(),
id=object_id) if content_type is not None else None
published = Form.objects.published(
for_user=request.user,
for_object=self.object,
editor_check=kwargs.get("edit_perm_check"))
kw = {
"slug": kwargs["slug"]
} if wrapper_settings.USE_SLUGS else {
"id": kwargs["form_id"]
}
form = get_object_or_404(published,
content_type=content_type,
object_id=object_id,
**kw)
form_for_form = FormForForm(
form,
RequestContext(request),
request.POST or None,
request.FILES or None,
instance=FormEntry(submitter=request.user if request.user.
is_authenticated() else None))
if not form_for_form.is_valid():
form_invalid.send(sender=request, form=form_for_form)
else:
# Attachments read must occur before model save,
# or seek() will fail on large uploads.
attachments = []
for f in form_for_form.files.values():
f.seek(0)
attachments.append((f.name, f.read()))
entry = form_for_form.save()
form_valid.send(sender=request, form=form_for_form, entry=entry)
self.send_emails(request, form_for_form, form, entry, attachments)
if not self.request.is_ajax():
key = "slug" if wrapper_settings.USE_SLUGS else "form_id"
return redirect(
form.redirect_url
or reverse("forms:form_sent",
current_app=request.resolver_match.namespace,
kwargs={
key: form.get_url_attr(),
"object_id": object_id
}))
context = {
"form": form,
"form_for_form": form_for_form,
"object_id": object_id
}
context[kwargs.pop("object_context_name", "object")] = self.object
context.update(kwargs.pop("custom_context", {}))
self.template_name = form_detail_template
return self.render_to_response(context)
