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 post(self, request, slug):
published = Form.objects.published(for_user=request.user)
form = get_object_or_404(published, slug=slug)
if not form.is_user_permitted(request.user, 'submit'):
raise Http404
request_context = RequestContext(request)
args = (form, request_context, request.POST or None, request.FILES or None)
form_for_form = FormForForm(*args)
if not form_for_form.is_valid():
form_invalid.send(sender=request, form=form_for_form)
else:
try:
entry = form_for_form.save(user=request.user)
except IntegrityError:
err = "You have already voted for this"
request.session['form_submitted'] = True
request.session['form_error'] = err
return redirect(reverse("form_error", kwargs={"slug": form.slug}))
except:
raise
form_valid.send(sender=request, form=form_for_form, entry=entry)
request.session['form_submitted'] = True;
return redirect(reverse("form_success", kwargs={"slug": form.slug}))
context = self.get_context_data(form=form, can_submit=form.is_user_permitted(request.user, 'submit'))
return self.render_to_response(context)
def __call__(self, 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()
self.email(request, form, form_for_form, entry)
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 form_detail(request, slug, template="forms/form_detail.html", success_url=None):
"""
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 = [e.strip() for e in form.email_copies.split(",")
if e.strip()]
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)
if success_url is None:
success_url = reverse("form_sent", kwargs={"slug": form.slug})
# Check to see if the POST data overrides the view's success_url argument.
success_url = request.POST.get("success_url", success_url)
return redirect(success_url)
context = {"form": form}
return render_to_response(template, context, request_context)
def form_entry_edit(request, form_entry_id, template='forms/form_entry_edit.html'):
form_entry = get_object_or_404(FormEntry, id=form_entry_id)
form_entry_fields = form_entry.fields.all()
the_form = form_entry.form
conversation_form_entry = form_entry.conversationformentry_set.all()[0]
# enforce permissions, must have special right or be staff in current conversation to continue
if not request.user.has_perm('questionnaire.can_revise_questionnaire') and not request.user == conversation_form_entry.conversation.getStaff().user:
return redirect('/admin')
if request.method == 'POST':
args = (the_form, request.POST or None, request.FILES or None)
form_for_form = FormForForm(*args)
if form_for_form.is_valid():
# save new FormEntry, assign to ConversationFormEntry
entry = form_for_form.save()
conversation_form_entry.entry = entry
conversation_form_entry.save()
# delete old FormEntry and FieldEntry
form_entry.fields.all().delete()
form_entry.conversationformentry_set.clear()
form_entry.delete()
# redirect to conversation-detail-page, store conversation id before so it remains known
return redirect('form_entry_edit', form_entry_id=entry.id)
# convert FormEntry to QueryDict to initialize FormForForm (django-forms-builder doesnt support editing instances)
# the reverse part to FormForForm.save(), there doesnt seem to be a general cover all cases approach
data = QueryDict('', mutable=True)
for entry_field in form_entry_fields:
# skip if question to this entry does not exist anymore
try:
the_field = Field.objects.get(pk=entry_field.field_id)
widget = WIDGETS.get(the_field.field_type)
if widget == DoubleDropWidget:
for i, val in enumerate(DoubleDropWidget().decompress(entry_field.value)):
data['field_%s_%s' % (entry_field.field_id, i)] = val
elif widget == CheckboxSelectMultiple:
for val in entry_field.value.split(', '):
data.appendlist('field_%s' % entry_field.field_id, val)
else:
data['field_%s' % entry_field.field_id] = entry_field.value
except Field.DoesNotExist:
pass
args = (the_form, data, request.FILES or None)
form_for_form = FormForForm(*args)
return render_to_response(template, {
'form': the_form,
"form_for_form": form_for_form,
}, RequestContext(request))
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 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_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 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 = self.assemble_attachments(request, form_for_form, form)
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}
return self.render_to_response(context)
def post(self, request, *args, **kwargs):
published = Form.objects.published(for_user=request.user)
form = get_object_or_404(published, slug=kwargs["slug"])
entry_id = request.POST.get('entry_id')
if entry_id:
form_entry = get_object_or_404(FormEntry, pk=entry_id)
form_for_form = FormForForm(form, RequestContext(request),
request.POST or None,
request.FILES or None, instance=form_entry)
else:
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 self.request.is_ajax():
redirect_url = form.redirect_url
if redirect_url:
if '$' in redirect_url:
try:
import re
person__groupdict = re.match(r'^.+/\$(?P<tag_name>\w+)/?$',
redirect_url).groupdict()
tag_name = person__groupdict['tag_name']
field = entry.form.fields.get(label=tag_name)
field_entry, _ = entry.fields.get_or_create(field_id=field.id)
redirect_url = redirect_url.replace(tag_name, field_entry.value)
redirect_url = redirect_url.replace('$', '')
return redirect(redirect_url)
except:
return redirect(redirect_url)
return redirect(redirect_url or reverse("form_sent", kwargs={"slug": form.slug}))
else:
return redirect(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)
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 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):
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 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()))
entry = form_for_form.save()
form_valid.send(sender=request, form=form_for_form, entry=entry)
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 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)
current_form = Form.objects.get(slug=kwargs["slug"])
entries_form = EntriesForm(current_form, self.request)
form_struct = self.make_form_struct(entries_form, form)
query_dict = dict(request.POST.iterlists())
form_warnings = self.get_warning_messages(form_struct)
reserve = False
for question in form_warnings:
question_decoded = unidecode(question).lower()
if question_decoded in query_dict:
for answer in query_dict[question_decoded]:
for answer_stats in form_warnings[question]:
if answer in answer_stats:
reserve = True
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(reserved=reserve)
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}
return self.render_to_response(context)
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 process_form(request, form, context={}, is_cms_plugin=False):
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_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)
if is_cms_plugin:
context['form_sent'] = True
else:
return redirect(reverse("form_sent", kwargs={"slug": form.slug}))
context.update({"form": form, "form_for_form": form_for_form})
return context
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=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 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 process(self, request, **kwargs):
request_context = RequestContext(request)
form = self.form
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()
# send e-mail message to user
email_to = form_for_form.email_to()
if email_to and form.send_email:
send_email_message(form_for_form, email_to, entry)
# send email to email_copies
send_email_form(request, form_for_form, entry)
form_valid.send(sender=request, form=form_for_form, entry=entry)
if form.response.startswith('/') or form.response.startswith('http'):
return redirect(form.response)
context = Context({
'form': form_for_form,
})
template = Template(form.response)
self.rendered_output = template.render(context)
return
context = {
"form": form_for_form,
}
self.rendered_output = render_to_string(self.template, context,
request_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 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 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 render(self, context, instance, placeholder):
request = context['request']
form = instance.form
context.update({'form': form, 'published' : True, 'valid': False})
if form.login_required and not request.user.is_authenticated():
return context
published = Form.objects.published(for_user=request.user)
if USE_SITES:
published = published.filter(sites=Site.objects.get_current())
if form not in published:
context.update({'published': False})
return context
form_for_form = FormForForm(form, context)
form_for_form.fields['cms_form_id'] = forms.CharField(initial=form.id, widget=forms.HiddenInput)
try:
if request.method == 'POST' and int(request.POST.get('cms_form_id',0)) == form.id:
form_for_form = FormForForm(form, context, request.POST, request.FILES)
if form_for_form.is_valid():
context.update({'valid': True})
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()
return context
except ValueError:
pass
context.update({'form_for_form': form_for_form})
return 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 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 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 get_form(self):
c = Context()
return FormForForm(self.get_builder_form_object(), c)
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 = [
e.strip() for e in form.email_copies.split(",") if e.strip()
]
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 form_detail(request, slug, template="questionnaire/form_detail.html", extra_object_id=None):
"""
Display a built form and handle its submission.
object_id is the primary key of an object like Conversation or BuddyChatProfile that will be linked to this FormEntry
via ConversationFormEntry or QuestionnaireFormEntry.
"""
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":
has_extra_permission = False
# if the id of an extra object is given, make sure user has permissions and preconditions are met
if extra_object_id > 0:
if form.questionnaire.position == 'SC':
conv = get_object_or_404(Conversation, pk=extra_object_id)
# only staff member assigned to Conversation may take SC-Questionnaire
has_permission = (conv.getStaff().user == request.user)
# the SC-Questionnaire can be taken only once
doesnt_exist = (form.questionnaire.conversationformentry_set.filter(conversation__id=extra_object_id).count() == 0)
has_extra_permission = has_permission and doesnt_exist
elif form.questionnaire.position == 'CR':
profile = get_object_or_404(BuddyChatProfile, pk=extra_object_id)
has_permission = (profile.user == request.user)
doesnt_exist = (profile.questionnaires.filter(position='CR').count() == 0)
has_extra_permission = has_permission and doesnt_exist
elif form.questionnaire.position == 'CX':
profile = get_object_or_404(BuddyChatProfile, pk=extra_object_id)
has_extra_permission = (profile.user == request.user)
elif form.questionnaire.position == 'SX':
profile = get_object_or_404(BuddyChatProfile, pk=extra_object_id)
# only careworker assigned to BuddyProfile may take SX-Questionnaire
has_extra_permission = (profile.careworker == request.user)
if not form_for_form.is_valid() or (extra_object_id > 0 and not has_extra_permission):
form_invalid.send(sender=request, form=form_for_form)
else:
entry = form_for_form.save()
# send email
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()
# send signals
form_valid.send(sender=request, form=form_for_form, entry=entry)
questionnaire_saved.send(sender=request, questionnaire=form.questionnaire, entry=entry, extra_object_id=extra_object_id)
return redirect(reverse("form_sent", kwargs={"slug": form.slug, "entry": entry.pk}))
context = {
"form": form,
"form_for_form": form_for_form,
}
return render_to_response(template, context, RequestContext(request))
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 not has_view_perm(request.user,'forms.view_form',form):
raise Http403
form_for_form = FormForForm(form, request.user, request.POST or None, request.FILES or None)
for field in form_for_form.fields:
form_for_form.fields[field].initial = request.GET.get(field, '')
if request.method == "POST":
if form_for_form.is_valid():
entry = form_for_form.save()
entry.entry_path = request.POST.get("entry_path", "")
entry.save()
email_headers = {} # content type specified below
if form.email_from:
email_headers.update({'Reply-To':form.email_from})
subject = generate_email_subject(form, entry)
# fields aren't included in submitter body to prevent spam
admin_body = generate_admin_email_body(entry)
submitter_body = generate_submitter_email_body(entry)
email_from = form.email_from or settings.DEFAULT_FROM_EMAIL
sender = get_setting('site', 'global', 'siteemailnoreplyaddress')
email_to = form_for_form.email_to()
if email_to and form.send_email and form.email_text:
# Send message to the person who submitted the form.
msg = EmailMessage(subject, submitter_body, sender, [email_to], headers=email_headers)
msg.content_subtype = 'html'
msg.send()
email_from = email_to or email_from # Send from the email entered.
email_headers.update({'Reply-To':email_from})
email_copies = [e.strip() for e in form.email_copies.split(",")
if e.strip()]
if email_copies:
# Send message to the email addresses listed in the copies.
msg = EmailMessage(subject, admin_body, sender, email_copies, headers=email_headers)
msg.content_subtype = 'html'
for f in form_for_form.files.values():
f.seek(0)
msg.attach(f.name, f.read())
msg.send()
# payment redirect
if form.custom_payment:
# create the invoice
invoice = make_invoice_for_entry(entry, custom_price=form_for_form.cleaned_data.get('custom_price'))
# log an event for invoice add
log_defaults = {
'event_id' : 311000,
'event_data': '%s (%d) added by %s' % (invoice._meta.object_name, invoice.pk, request.user),
'description': '%s added' % invoice._meta.object_name,
'user': request.user,
'request': request,
'instance': invoice,
}
EventLog.objects.log(**log_defaults)
# redirect to billing form
return redirect('form_entry_payment', invoice.id, invoice.guid)
# default redirect
if form.completion_url:
return redirect(form.completion_url)
return redirect("form_sent", form.slug)
context = {"form": form, "form_for_form": form_for_form}
return render_to_response(template, context, RequestContext(request))
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)
