def add_fields(self):
super(InputBasics, self).add_fields()
self.fields[u'delivered_date'] = forms.DateField(
label=_(u'inforequests:obligee_action:InputBasics:delivered_date:label'),
localize=True,
widget=forms.DateInput(attrs={
u'placeholder':
_('inforequests:obligee_action:InputBasics:delivered_date:placeholder'),
u'class': u'pln-datepicker',
}),
)
self.fields[u'attachments'] = AttachmentsField(
label=_(u'inforequests:obligee_action:InputBasics:attachments:label'),
help_text=_(u'inforequests:obligee_action:InputBasics:attachments:help_text'),
upload_url_func=(
lambda: reverse(u'inforequests:upload_attachment')),
download_url_func=(
lambda a: reverse(u'inforequests:download_attachment', args=[a.pk])),
attached_to=(
self.wizard.draft,
Session.objects.get(session_key=self.wizard.request.session.session_key),
),
)
def add_fields(self):
super(Main, self).add_fields()
self.fields[u'content'] = CompositeTextField(
label=_(u'inforequests:clarification_response:Main:content:label'),
template=u'inforequests/clarification_response/forms/content.txt',
context=self.context(),
fields=[
forms.CharField(widget=forms.Textarea(attrs={
u'placeholder':
_(u'inforequests:clarification_response:Main:content:placeholder'),
u'class': u'pln-autosize',
u'cols': u'', u'rows': u'',
})),
],
composite_attrs={
},
)
self.fields[u'attachments'] = AttachmentsField(
label=_(u'inforequests:clarification_response:Main:attachments:label'),
required=False,
attached_to=(
self.wizard.draft,
Session.objects.get(session_key=self.wizard.request.session.session_key),
),
upload_url_func=(
lambda: reverse(u'inforequests:upload_attachment')),
download_url_func=(
lambda a: reverse(u'inforequests:download_attachment', args=[a.pk])),
)
def add_fields(self):
super(InputBasics, self).add_fields()
self.fields[u'delivered_date'] = forms.DateField(
label=_(
u'inforequests:obligee_action:InputBasics:delivered_date:label'
),
localize=True,
widget=forms.DateInput(
attrs={
u'placeholder':
_('inforequests:obligee_action:InputBasics:delivered_date:placeholder'
),
u'class':
u'pln-datepicker',
}),
)
self.fields[u'attachments'] = AttachmentsField(
label=_(
u'inforequests:obligee_action:InputBasics:attachments:label'),
help_text=_(
u'inforequests:obligee_action:InputBasics:attachments:help_text'
),
upload_url_func=(
lambda: reverse(u'inforequests:upload_attachment')),
download_url_func=(lambda a: reverse(
u'inforequests:download_attachment', args=[a.pk])),
attached_to=(
self.wizard.draft,
Session.objects.get(
session_key=self.wizard.request.session.session_key),
),
)
def index(request):
if request.method == u'POST':
button = clean_button(request.POST, [u'jump', u'reset'])
if button == u'jump':
form = forms.WarpForm(request.POST)
if form.is_valid():
jumpto = form.cleaned_data[u'jumpto']
speedup = form.cleaned_data[u'speedup']
if jumpto is not None or speedup is not None:
timewarp.jump(jumpto, speedup)
return HttpResponseRedirect(reverse(u'admin:timewarp'))
elif button == u'reset':
timewarp.reset()
return HttpResponseRedirect(reverse(u'admin:timewarp'))
else: # invalid button
form = forms.WarpForm()
else:
form = forms.WarpForm()
return render(request, u'timewarp/timewarp.html', {
u'timewarp': timewarp,
u'form': form,
u'title': u'Timewarp',
})
def obligee_action_dispatcher(request):
inforequests = (Inforequest.objects
.not_closed()
.owned_by(request.user)
.order_by_submission_date()
.select_undecided_emails_count()
.prefetch_related(
Inforequest.prefetch_main_branch(None,
Branch.objects.select_related(u'historicalobligee')))
)
# If the user has an inforequest with a new email, continue with it. If there is no new email
# and the user has only one pending inforequest, continue with it. If the user has no pending
# inforequests, return to inforequest index. Finally, if the user has at least two pending
# inforequests, let him choose with which to continue.
for inforequest in inforequests:
if inforequest.has_undecided_emails:
return HttpResponseRedirect(
reverse(u'inforequests:obligee_action', kwargs=dict(inforequest=inforequest)))
if len(inforequests) == 1:
return HttpResponseRedirect(
reverse(u'inforequests:obligee_action', kwargs=dict(inforequest=inforequests[0])))
if len(inforequests) == 0:
return HttpResponseRedirect(reverse(u'inforequests:index'))
return render(request, u'inforequests/obligee_action_dispatcher/dispatcher.html', {
u'inforequests': inforequests,
})
def index(request):
if request.method == u'POST':
button = clean_button(request.POST, [u'jump', u'reset'])
if button == u'jump':
form = forms.WarpForm(request.POST)
if form.is_valid():
jumpto = form.cleaned_data[u'jumpto']
speedup = form.cleaned_data[u'speedup']
if jumpto is not None or speedup is not None:
timewarp.jump(jumpto, speedup)
return HttpResponseRedirect(reverse(u'admin:timewarp'))
elif button == u'reset':
timewarp.reset()
return HttpResponseRedirect(reverse(u'admin:timewarp'))
else: # invalid button
form = forms.WarpForm()
else:
form = forms.WarpForm()
return render(request, u'timewarp/timewarp.html', {
u'timewarp': timewarp,
u'form': form,
u'title': u'Timewarp',
})
def file_create_or_edit(request, lang, path, name, create):
u"""
If ``create`` is False, then ``name`` should point to the page file we want to edit. If
``create`` is True, then ``name`` is ignored.
"""
try:
page = Page(path, lang)
except InvalidPageError:
raise Http404()
if page.lpath != path:
raise Http404()
try:
file = File(page, name) if not create else None
except InvalidFileError:
raise Http404()
if request.method == u'POST':
button = clean_button(request.POST, [u'save', u'save-and-continue'])
if button in [u'save', u'save-and-continue']:
form = forms.FileEditForm(page, file, create, request.POST,
request.FILES)
if form.is_valid():
try:
new_file = form.save()
except forms.FormSaveError:
pass
else:
if button == u'save':
return HttpResponseRedirect(
reverse(u'admin:pages_edit',
args=[lang, page.lpath]))
else: # save-and-continue
return HttpResponseRedirect(
reverse(u'admin:pages_file_edit',
args=[lang, page.lpath, new_file.name]))
else: # Invalid button
raise SuspiciousOperation()
else: # GET
form = forms.FileEditForm(page, file, create)
return render(
request, u'pages/admin/file_edit.html', {
u'title':
u'Add Page Attachment' if create else u'Edit Page Attachment',
u'create': create,
u'lang': lang,
u'page': page,
u'file': file,
u'form': form,
})
def page(context, *args):
u"""
Get page url. The page may be given with an absolute path or with a relative path
with respect to the current page. If there is no current page, only absolute path
may be given. The returned page is always is the same language as the current page.
If you want to speficy different page paths for different languages, use multiple
arguments prefixed with particular language code.
Example: (Assuming the current page is '/sk/test/')
Absolute path:
{% page "/moo/foo/" %} -> /sk/moo/foo/
{% page "/" %} -> /sk/
Ralative path:
{% page "foo/goo/" %} -> /sk/test/foo/goo/
{% page "../" %} -> /sk/
{% page "../foo/goo/" %} -> /sk/foo/goo/
{% page "../../../../foo/goo/" %} -> /sk/foo/goo/
Path with no trailing slash:
{% page "/moo/foo" %} -> /sk/foo/goo/
{% page "foo/goo" %} -> /sk/test/foo/goo/
File path:
{% page "moo.jpg" %} -> /sk/test/moo.jpg
{% page "/moo/foo/moo.jpg" %} -> /sk/moo/foo/moo.jpg
{% page "foo/goo/moo.jpg" %} -> /sk/test/foo/goo/moo.jpg
Language alternatives:
{% page "en:moo/enfoo" "sk:moo/skfoo" %} -> /sk/test/moo/skfoo/
{% page "en:moo/enfoo" "moo/xxfoo" %} -> /sk/test/moo/xxfoo/
{% page "en:moo/enfoo" %} -> /sk/test/
"""
try:
page = context[u'page']
lang = page.lang
path = page.path
except (KeyError, AttributeError):
lang = get_language()
path = u'/'
for arg in args:
if u':' in arg:
prefix, arg = arg.split(u':', 1)
if prefix != lang:
continue
path = os.path.normpath(os.path.join(path, arg))
break
ppath, name = path.rsplit(u'/', 1)
if u'.' in name:
if not ppath.endswith(u'/'):
ppath += u'/'
return reverse(u'pages:file', args=[ppath.lstrip(u'/'), name])
else:
if not path.endswith(u'/'):
path += u'/'
return reverse(u'pages:view', args=[path.lstrip(u'/')])
def file_create_or_edit(request, lang, path, name, create):
u"""
If ``create`` is False, then ``name`` should point to the page file we want to edit. If
``create`` is True, then ``name`` is ignored.
"""
try:
page = Page(path, lang)
except InvalidPageError:
raise Http404()
if page.lpath != path:
raise Http404()
try:
file = File(page, name) if not create else None
except InvalidFileError:
raise Http404()
if request.method == u'POST':
button = clean_button(request.POST, [u'save', u'save-and-continue'])
if button in [u'save', u'save-and-continue']:
form = forms.FileEditForm(page, file, create, request.POST, request.FILES)
if form.is_valid():
try:
new_file = form.save()
except forms.FormSaveError:
pass
else:
if button == u'save':
return HttpResponseRedirect(reverse(u'admin:pages_edit',
args=[lang, page.lpath]))
else: # save-and-continue
return HttpResponseRedirect(reverse(u'admin:pages_file_edit',
args=[lang, page.lpath, new_file.name]))
else: # Invalid button
raise SuspiciousOperation()
else: # GET
form = forms.FileEditForm(page, file, create)
return render(request, u'pages/admin/file_edit.html', {
u'title': u'Add Page Attachment' if create else u'Edit Page Attachment',
u'create': create,
u'lang': lang,
u'page': page,
u'file': file,
u'form': form,
})
def alternatives(request, lang, path):
try:
page = Page(path, lang)
except InvalidPageError:
raise Http404()
if page.lpath != path:
logger = logging.getLogger(u'poleno.pages')
logger.warning(u'Redirected request: /{}/{} -> /{}{}; Referer: {}'.format(
lang, path, page.lang, page.path, request.META.get(u'HTTP_REFERER', u'--')))
if page.is_disabled:
raise Http404()
if page.lpath != path:
return HttpResponseRedirect(reverse(u'pages:alternatives', args=[lang, page.lpath]))
alts = []
current_lang = get_language()
for alt_lang, alt_name in settings.LANGUAGES:
alt_page = page.translation(alt_lang)
if not alt_page:
continue
if alt_lang == current_lang:
# And yet the translation is available
return HttpResponseRedirect(alt_page.url)
alts.append(dict(lang=alt_lang, name=alt_name, page=alt_page))
return render(request, u'pages/alternatives.html', {
u'alternatives': alts,
})
def invite(request):
if not request.user.invitationsupply.can_use_invitations:
raise Http404()
if request.method == u'POST':
form = forms.InviteForm(request.POST)
if form.is_valid():
try:
email = form.cleaned_data[u'email']
request.user.invitationsupply.invite(email)
except UserMayNotInvite:
render_message(request, messages.ERROR,
u'invitations/messages/depleted.txt')
else:
render_message(request, messages.SUCCESS,
u'invitations/messages/invited.txt', {
u'email': email,
})
return HttpResponseRedirect(reverse(u'invitations:invite'))
else:
form = forms.InviteForm()
return render(request, u'invitations/invite.html', {
u'form': form,
})
def delete(request, lang, path):
try:
page = Page(path, lang, keep_last=True)
except InvalidPageError:
raise Http404()
if page.lpath != path:
raise Http404()
if page.is_root:
raise Http404()
if request.method == u'POST':
button = clean_button(request.POST, [u'delete'])
if button == u'delete':
page.delete()
return HttpResponseRedirect(reverse(u'admin:pages_index', args=[lang]))
else: # Invalid button
raise SuspiciousOperation()
return render(request, u'pages/admin/delete.html', {
u'title': u'Delete Page',
u'lang': lang,
u'page': page,
})
def file_delete(request, lang, path, name):
try:
page = Page(path, lang)
except InvalidPageError:
raise Http404()
if page.lpath != path:
raise Http404()
try:
file = File(page, name)
except InvalidFileError:
raise Http404()
if request.method == u'POST':
button = clean_button(request.POST, [u'delete'])
if button == u'delete':
file.delete()
return HttpResponseRedirect(reverse(u'admin:pages_edit', args=[lang, page.lpath]))
else: # Invalid button
raise SuspiciousOperation()
return render(request, u'pages/admin/file_delete.html', {
u'title': u'Delete Page Attachment',
u'lang': lang,
u'page': page,
u'file': file,
})
def snooze(request, inforequest_slug, inforequest_pk, branch_pk, action_pk):
inforequest = (Inforequest.objects
.not_closed().owned_by(request.user).get_or_404(pk=inforequest_pk))
branch = inforequest.branch_set.get_or_404(pk=branch_pk)
action = branch.last_action
if action.pk != Action._meta.pk.to_python(action_pk):
raise Http404()
if not action.can_applicant_snooze:
raise Http404()
if inforequest.has_undecided_emails:
raise Http404()
if inforequest_slug != inforequest.slug:
return HttpResponseRedirect(reverse(u'inforequests:snooze', kwargs=dict(action=action)))
if request.method != u'POST':
form = SnoozeForm(prefix=action.pk)
return render_form(request, form, inforequest=inforequest, branch=branch, action=action)
form = SnoozeForm(request.POST, prefix=action.pk)
if not form.is_valid():
return json_form(request, form, inforequest=inforequest, branch=branch, action=action)
form.save(action)
action.save(update_fields=[u'snooze'])
# The inforequest was changed, we need to refetch it
inforequest = Inforequest.objects.prefetch_detail().get(pk=inforequest.pk)
return json_success(request, inforequest)
def alternatives(request, lang, path):
try:
page = Page(path, lang)
except InvalidPageError:
raise Http404()
if page.lpath != path:
logger = logging.getLogger(u'poleno.pages')
logger.warning(
u'Redirected request: /{}/{} -> /{}{}; Referer: {}'.format(
lang, path, page.lang, page.path,
request.META.get(u'HTTP_REFERER', u'--')))
if page.is_disabled:
raise Http404()
if page.lpath != path:
return HttpResponseRedirect(
reverse(u'pages:alternatives', args=[lang, page.lpath]))
alts = []
current_lang = get_language()
for alt_lang, alt_name in settings.LANGUAGES:
alt_page = page.translation(alt_lang)
if not alt_page:
continue
if alt_lang == current_lang:
# And yet the translation is available
return HttpResponseRedirect(alt_page.url)
alts.append(dict(lang=alt_lang, name=alt_name, page=alt_page))
return render(request, u'pages/alternatives.html', {
u'alternatives': alts,
})
def devtools_delete(request, inforequest_pk):
assert settings.DEBUG
inforequest = Inforequest.objects.owned_by(request.user).get_or_404(pk=inforequest_pk)
inforequest.delete()
return HttpResponseRedirect(reverse(u'inforequests:index'))
def delete(request, lang, path):
try:
page = Page(path, lang, keep_last=True)
except InvalidPageError:
raise Http404()
if page.lpath != path:
raise Http404()
if page.is_root:
raise Http404()
if request.method == u'POST':
button = clean_button(request.POST, [u'delete'])
if button == u'delete':
page.delete()
return HttpResponseRedirect(
reverse(u'admin:pages_index', args=[lang]))
else: # Invalid button
raise SuspiciousOperation()
return render(request, u'pages/admin/delete.html', {
u'title': u'Delete Page',
u'lang': lang,
u'page': page,
})
def adminurl(obj, view=u'change'):
try:
view_name = u'admin:{}_{}_{}'.format(obj._meta.app_label,
obj._meta.model_name, view)
return reverse(view_name, args=[obj.pk])
except:
return u''
def file(request, path, name):
try:
page = Page(path)
except InvalidPageError:
raise Http404()
if page.lpath != path:
logger = logging.getLogger(u'poleno.pages')
logger.warning(
u'Redirected request: /{}/{} -> /{}{}; Referer: {}'.format(
page.lang, path, page.lang, page.path,
request.META.get(u'HTTP_REFERER', u'--')))
try:
file = File(page, name)
except InvalidFileError:
raise Http404()
if page.lpath != path:
return HttpResponseRedirect(
reverse(u'pages:file', args=[page.lpath, name]))
return send_file_response(request,
file.filepath,
file.name,
file.content_type,
attachment=False)
def file_delete(request, lang, path, name):
try:
page = Page(path, lang)
except InvalidPageError:
raise Http404()
if page.lpath != path:
raise Http404()
try:
file = File(page, name)
except InvalidFileError:
raise Http404()
if request.method == u'POST':
button = clean_button(request.POST, [u'delete'])
if button == u'delete':
file.delete()
return HttpResponseRedirect(
reverse(u'admin:pages_edit', args=[lang, page.lpath]))
else: # Invalid button
raise SuspiciousOperation()
return render(
request, u'pages/admin/file_delete.html', {
u'title': u'Delete Page Attachment',
u'lang': lang,
u'page': page,
u'file': file,
})
def create_or_edit(request, lang, path, create):
u"""
If ``create`` is False, then ``path`` should point to the page we want to edit. If ``create``
is True, then ``path`` should point to the page that will be the parent of the new page.
"""
try:
page = Page(path, lang, keep_last=True)
except InvalidPageError:
raise Http404()
if page.lpath != path:
raise Http404()
if create and page.is_redirect:
raise Http404()
if request.method == u'POST':
button = clean_button(request.POST, [u'save', u'save-and-continue'])
if button in [u'save', u'save-and-continue']:
form = forms.PageEditForm(page, create, request.POST)
if form.is_valid():
try:
new_page = form.save()
except forms.FormSaveError:
pass
else:
if button == u'save':
return HttpResponseRedirect(
reverse(u'admin:pages_index', args=[lang]))
else: # save-and-continue
return HttpResponseRedirect(
reverse(u'admin:pages_edit',
args=[lang, new_page.lpath]))
else: # Invalid button
raise SuspiciousOperation()
else: # GET
form = forms.PageEditForm(page, create)
return render(
request, u'pages/admin/edit.html', {
u'title': u'Add Page' if create else u'Edit Page',
u'create': create,
u'lang': lang,
u'page': page,
u'form': form,
})
def devtools_delete(request, inforequest_pk):
assert settings.DEBUG
inforequest = Inforequest.objects.owned_by(
request.user).get_or_404(pk=inforequest_pk)
inforequest.delete()
return HttpResponseRedirect(reverse(u'inforequests:index'))
def __init__(self, lang, field):
super(LivePath, self).__init__(u' • Details', format_html(
u'<span class="live-path" data-field="{field}" data-value="{value}" data-url="{url}">'+
u'{content}</span>',
field=field.auto_id,
url=reverse(u'admin:pages_live_path', args=[lang]),
value=field.value(),
content=self.render(lang, field.value()),
))
def add_fields(self):
super(Main, self).add_fields()
self.fields[u'content'] = CompositeTextField(
label=_(u'inforequests:clarification_response:Main:content:label'),
template=u'inforequests/clarification_response/forms/content.txt',
context=self.context(),
fields=[
forms.CharField(widget=forms.Textarea(
attrs={
u'placeholder':
_(u'inforequests:clarification_response:Main:content:placeholder'
),
u'class':
u'pln-autosize',
u'cols':
u'',
u'rows':
u'',
})),
],
composite_attrs={},
)
self.fields[u'attachments'] = AttachmentsField(
label=_(
u'inforequests:clarification_response:Main:attachments:label'),
help_text=
_(u'inforequests:clarification_response:Main:attachments:help_text'
),
required=False,
max_count=20,
max_size=parsefilesize(u'15 MB'),
max_total_size=parsefilesize(u'15 MB'),
attached_to=(
self.wizard.draft,
Session.objects.get(
session_key=self.wizard.request.session.session_key),
),
upload_url_func=(
lambda: reverse(u'inforequests:upload_attachment')),
download_url_func=(lambda a: reverse(
u'inforequests:download_attachment', args=[a.pk])),
)
def create_or_edit(request, lang, path, create):
u"""
If ``create`` is False, then ``path`` should point to the page we want to edit. If ``create``
is True, then ``path`` should point to the page that will be the parent of the new page.
"""
try:
page = Page(path, lang, keep_last=True)
except InvalidPageError:
raise Http404()
if page.lpath != path:
raise Http404()
if create and page.is_redirect:
raise Http404()
if request.method == u'POST':
button = clean_button(request.POST, [u'save', u'save-and-continue'])
if button in [u'save', u'save-and-continue']:
form = forms.PageEditForm(page, create, request.POST)
if form.is_valid():
try:
new_page = form.save()
except forms.FormSaveError:
pass
else:
if button == u'save':
return HttpResponseRedirect(reverse(u'admin:pages_index', args=[lang]))
else: # save-and-continue
return HttpResponseRedirect(
reverse(u'admin:pages_edit', args=[lang, new_page.lpath]))
else: # Invalid button
raise SuspiciousOperation()
else: # GET
form = forms.PageEditForm(page, create)
return render(request, u'pages/admin/edit.html', {
u'title': u'Add Page' if create else u'Edit Page',
u'create': create,
u'lang': lang,
u'page': page,
u'form': form,
})
def inforequest_detail(request, inforequest_slug, inforequest_pk):
inforequest = Inforequest.objects.owned_by(request.user).prefetch_detail().get_or_404(pk=inforequest_pk)
if inforequest_slug != inforequest.slug:
return HttpResponseRedirect(reverse(u"inforequests:detail", kwargs=dict(inforequest=inforequest)))
return render(
request,
u"inforequests/detail/detail.html",
{u"inforequest": inforequest, u"devtools": u"inforequests/detail/devtools.html"},
)
def __init__(self, lang, field):
super(LivePath, self).__init__(
u' • Details',
format_html(
u'<span class="live-path" data-field="{field}" data-value="{value}" data-url="{url}">'
+ u'{content}</span>',
field=field.auto_id,
url=reverse(u'admin:pages_live_path', args=[lang]),
value=field.value(),
content=self.render(lang, field.value()),
))
def appeal(request, inforequest_slug, inforequest_pk, branch_pk, step_idx=None):
inforequest = (Inforequest.objects
.not_closed().owned_by(request.user).get_or_404(pk=inforequest_pk))
branch = inforequest.branch_set.get_or_404(pk=branch_pk)
if not branch.can_add_appeal:
raise Http404()
if inforequest_slug != inforequest.slug:
return HttpResponseRedirect(reverse(u'inforequests:appeal',
kwargs=dict(branch=branch, step_idx=step_idx)))
return wizard_view(AppealWizard, request, step_idx, branch)
def obligee_action(request, inforequest_slug, inforequest_pk, step_idx=None):
inforequest = (Inforequest.objects
.not_closed().owned_by(request.user).get_or_404(pk=inforequest_pk))
inforequestemail = inforequest.inforequestemail_set.undecided().oldest().get_or_none()
email = inforequestemail.email if inforequestemail is not None else None
if inforequest_slug != inforequest.slug:
return HttpResponseRedirect(reverse(u'inforequests:obligee_action',
kwargs=dict(inforequest=inforequest, step_idx=step_idx)))
return wizard_view(ObligeeActionWizard, request, step_idx,
inforequest, inforequestemail, email)
def inforequest_detail(request, inforequest_slug, inforequest_pk):
inforequest = (Inforequest.objects.owned_by(request.user).prefetch_detail()
.get_or_404(pk=inforequest_pk))
if inforequest_slug != inforequest.slug:
return HttpResponseRedirect(
reverse(u'inforequests:detail', kwargs=dict(inforequest=inforequest)))
return render(request, u'inforequests/detail/detail.html', {
u'inforequest': inforequest,
u'devtools': u'inforequests/detail/devtools.html',
})
def admin_obj_format(obj, format=u'{tag}', *args, **kwargs):
link = kwargs.pop(u'link', u'change')
if obj is None:
return u'--'
tag = u'<{}: {}>'.format(obj.__class__.__name__, obj.pk)
res = format.format(obj=obj, tag=tag, *args, **kwargs)
if link:
try:
info = obj._meta.app_label, obj._meta.model_name, link
url = reverse(u'admin:{}_{}_{}'.format(*info), args=[obj.pk])
res = format_html(u'<a href="{0}">{1}</a>', url, res)
except NoReverseMatch:
pass
return res
def obligee_action(request, inforequest_slug, inforequest_pk, step_idx=None):
inforequest = (Inforequest.objects.not_closed().owned_by(
request.user).get_or_404(pk=inforequest_pk))
inforequestemail = inforequest.inforequestemail_set.undecided().oldest(
).get_or_none()
email = inforequestemail.email if inforequestemail is not None else None
if inforequest_slug != inforequest.slug:
return HttpResponseRedirect(
reverse(u'inforequests:obligee_action',
kwargs=dict(inforequest=inforequest, step_idx=step_idx)))
return wizard_view(ObligeeActionWizard, request, step_idx, inforequest,
inforequestemail, email)
def admin_obj_format(obj, format=u'{tag}', *args, **kwargs):
link = kwargs.pop(u'link', u'change')
if obj is None:
return u'--'
tag = u'<{}: {}>'.format(obj.__class__.__name__, obj.pk)
res = format.format(obj=obj, tag=tag, *args, **kwargs)
if link:
try:
info = obj._meta.app_label, obj._meta.model_name, link
url = reverse(u'admin:{}_{}_{}'.format(*info), args=[obj.pk])
res = format_html(u'<a href="{0}">{1}</a>', url, res)
except NoReverseMatch:
pass
return res
def appeal(request,
inforequest_slug,
inforequest_pk,
branch_pk,
step_idx=None):
inforequest = (Inforequest.objects.not_closed().owned_by(
request.user).get_or_404(pk=inforequest_pk))
branch = inforequest.branch_set.get_or_404(pk=branch_pk)
if not branch.can_add_appeal:
raise Http404()
if inforequest_slug != inforequest.slug:
return HttpResponseRedirect(
reverse(u'inforequests:appeal',
kwargs=dict(branch=branch, step_idx=step_idx)))
return wizard_view(AppealWizard, request, step_idx, branch)
def view(request, path):
try:
page = Page(path)
except InvalidPageError:
raise Http404()
if page.lpath != path:
logger = logging.getLogger(u'poleno.pages')
logger.warning(u'Redirected request: /{}/{} -> /{}{}; Referer: {}'.format(
page.lang, path, page.lang, page.path, request.META.get(u'HTTP_REFERER', u'--')))
if page.is_disabled:
raise Http404()
if page.lpath != path:
return HttpResponseRedirect(reverse(u'pages:view', args=[page.lpath]))
return render(request, u'pages/view.html', {
u'page': page,
})
def file(request, path, name):
try:
page = Page(path)
except InvalidPageError:
raise Http404()
if page.lpath != path:
logger = logging.getLogger(u'poleno.pages')
logger.warning(u'Redirected request: /{}/{} -> /{}{}; Referer: {}'.format(
page.lang, path, page.lang, page.path, request.META.get(u'HTTP_REFERER', u'--')))
try:
file = File(page, name)
except InvalidFileError:
raise Http404()
if page.lpath != path:
return HttpResponseRedirect(reverse(u'pages:file', args=[page.lpath, name]))
return send_file_response(request, file.filepath, file.name,
file.content_type, attachment=False)
def view(request, path):
try:
page = Page(path)
except InvalidPageError:
raise Http404()
if page.lpath != path:
logger = logging.getLogger(u'poleno.pages')
logger.warning(
u'Redirected request: /{}/{} -> /{}{}; Referer: {}'.format(
page.lang, path, page.lang, page.path,
request.META.get(u'HTTP_REFERER', u'--')))
if page.is_disabled:
raise Http404()
if page.lpath != path:
return HttpResponseRedirect(reverse(u'pages:view', args=[page.lpath]))
return render(request, u'pages/view.html', {
u'page': page,
})
def change_lang(context, lang=None):
u"""
Get active page's url with laguage changed to the specified language.
Example:
{% change_lang 'en' %}
Source: https://djangosnippets.org/snippets/2875/
"""
path = context[u'request'].path
url_parts = resolve(path)
view_name = url_parts.view_name
kwargs = url_parts.kwargs
# Ask the view what to show after changing language.
if hasattr(url_parts.func, u'change_lang'):
view_name, kwargs = url_parts.func.change_lang(lang, **kwargs)
with translation(lang):
url = reverse(view_name, kwargs=kwargs)
return format(url)
def change_lang(context, lang=None):
u"""
Get active page's url with laguage changed to the specified language.
Example:
{% change_lang 'en' %}
Source: https://djangosnippets.org/snippets/2875/
"""
path = context[u'request'].path
url_parts = resolve(path)
view_name = url_parts.view_name
kwargs = url_parts.kwargs
# Ask the view what to show after changing language.
if hasattr(url_parts.func, u'change_lang'):
view_name, kwargs = url_parts.func.change_lang(lang, **kwargs)
with translation(lang):
url = reverse(view_name, kwargs=kwargs)
return format(url)
def snooze(request, inforequest_slug, inforequest_pk, branch_pk, action_pk):
inforequest = (Inforequest.objects.not_closed().owned_by(
request.user).get_or_404(pk=inforequest_pk))
branch = inforequest.branch_set.get_or_404(pk=branch_pk)
action = branch.last_action
if action.pk != Action._meta.pk.to_python(action_pk):
raise Http404()
if not action.can_applicant_snooze:
raise Http404()
if inforequest.has_undecided_emails:
raise Http404()
if inforequest_slug != inforequest.slug:
return HttpResponseRedirect(
reverse(u'inforequests:snooze', kwargs=dict(action=action)))
if request.method != u'POST':
form = SnoozeForm(prefix=action.pk)
return render_form(request,
form,
inforequest=inforequest,
branch=branch,
action=action)
form = SnoozeForm(request.POST, prefix=action.pk)
if not form.is_valid():
return json_form(request,
form,
inforequest=inforequest,
branch=branch,
action=action)
form.save(action)
action.save(update_fields=[u'snooze'])
# The inforequest was changed, we need to refetch it
inforequest = Inforequest.objects.prefetch_detail().get(pk=inforequest.pk)
return json_success(request, inforequest)
def inforequest_create(request, draft_pk=None):
template = u'inforequests/create/create.html'
draft = (InforequestDraft.objects.owned_by(request.user)
.get_or_404(pk=draft_pk) if draft_pk else None)
session = Session.objects.get(session_key=request.session.session_key)
attached_to = (session, draft) if draft else (session,)
if request.method != u'POST':
form = InforequestForm(attached_to=attached_to, user=request.user)
if draft:
form.load_from_draft(draft)
return render(request, template, dict(form=form))
button = clean_button(request.POST, [u'submit', u'draft'])
if button == u'draft':
form = InforequestForm(request.POST, draft=True, attached_to=attached_to, user=request.user)
if not form.is_valid():
return render(request, template, dict(form=form))
if not draft:
draft = InforequestDraft(applicant=request.user)
form.save_to_draft(draft)
draft.save()
return HttpResponseRedirect(reverse(u'inforequests:index'))
if button == u'submit':
form = InforequestForm(request.POST, attached_to=attached_to, user=request.user)
if not form.is_valid():
return render(request, template, dict(form=form))
inforequest = form.save()
inforequest.save()
inforequest.main_branch.last_action.send_by_email()
if draft:
draft.delete()
return HttpResponseRedirect(inforequest.get_absolute_url())
raise SuspiciousOperation()
def invite(request):
if not request.user.invitationsupply.can_use_invitations:
raise Http404()
if request.method == u'POST':
form = forms.InviteForm(request.POST)
if form.is_valid():
try:
email = form.cleaned_data[u'email']
request.user.invitationsupply.invite(email)
except UserMayNotInvite:
render_message(request, messages.ERROR, u'invitations/messages/depleted.txt')
else:
render_message(request, messages.SUCCESS, u'invitations/messages/invited.txt', {
u'email': email,
})
return HttpResponseRedirect(reverse(u'invitations:invite'))
else:
form = forms.InviteForm()
return render(request, u'invitations/invite.html', {
u'form': form,
})
def get_absolute_url(self, anchor=u''):
return reverse(u'inforequests:detail',
kwargs=dict(inforequest=self)) + anchor
def adminurl(obj, view=u'change'):
try:
view_name = u'admin:{}_{}_{}'.format(obj._meta.app_label, obj._meta.model_name, view)
return reverse(view_name, args=[obj.pk])
except:
return u''
def inforequest_delete_draft(request, draft_pk):
draft = InforequestDraft.objects.owned_by(request.user).get_or_404(pk=draft_pk)
draft.delete()
return HttpResponseRedirect(reverse(u"inforequests:index"))
def attachment_upload(request):
session = Session.objects.get(session_key=request.session.session_key)
download_url_func = (
lambda a: reverse(u'inforequests:download_attachment', args=[a.pk]))
return attachments_views.upload(request, session, download_url_func)
def url(self):
with translation(self._lang):
return reverse(u'pages:view', args=[self.lpath])
def get_absolute_url(self, anchor=u''):
return reverse(u'inforequests:detail', kwargs=dict(inforequest=self)) + anchor
def url(viewname, *args, **kwargs):
return reverse(viewname, args=args, kwargs=kwargs)
def get_step_url(self, step, anchor=u''):
return reverse(u'inforequests:obligee_action',
kwargs=dict(inforequest=self.inforequest, step=step)) + anchor
def get_step_url(self, step, anchor=u''):
return reverse(u'inforequests:appeal',
kwargs=dict(branch=self.branch, step=step)) + anchor
def get_step_url(self, step, anchor=u''):
return reverse(u'inforequests:clarification_response',
kwargs=dict(branch=self.branch, step=step)) + anchor
class InforequestForm(PrefixedForm):
obligee = ObligeeField(
label=_(u'inforequests:InforequestForm:obligee:label'),
help_text=_(u'inforequests:InforequestForm:obligee:help_text'),
widget=ObligeeWidget(
input_attrs={
u'placeholder':
_(u'inforequests:InforequestForm:obligee:placeholder'),
}),
)
subject = CompositeTextField(
label=_(u'inforequests:InforequestForm:subject:label'),
help_text=_(u'inforequests:InforequestForm:subject:help_text'),
template=u'inforequests/create/forms/subject.txt',
fields=[
forms.CharField(
max_length=50,
widget=forms.TextInput(
attrs={
u'placeholder':
_(u'inforequests:InforequestForm:subject:placeholder'),
})),
],
)
content = CompositeTextField(
label=_(u'inforequests:InforequestForm:content:label'),
template=u'inforequests/create/forms/content.txt',
fields=[
forms.CharField(widget=forms.Textarea(
attrs={
u'placeholder':
_(u'inforequests:InforequestForm:content:placeholder'),
u'class':
u'pln-autosize',
u'cols':
u'',
u'rows':
u'',
})),
],
composite_attrs={},
)
attachments = AttachmentsField(
label=_(u'inforequests:InforequestForm:attachments:label'),
help_text=_(u'inforequests:InforequestForm:attachments:help_text'),
required=False,
max_count=20,
max_size=parsefilesize(u'15 MB'),
max_total_size=parsefilesize(u'15 MB'),
upload_url_func=(lambda: reverse(u'inforequests:upload_attachment')),
download_url_func=(lambda a: reverse(
u'inforequests:download_attachment', args=[a.pk])),
)
def __init__(self, *args, **kwargs):
self.draft = kwargs.pop(u'draft', False)
self.attached_to = kwargs.pop(u'attached_to')
self.user = kwargs.pop(u'user')
super(InforequestForm, self).__init__(*args, **kwargs)
unique_email = settings.INFOREQUEST_UNIQUE_EMAIL.format(token=u'xxxx')
unique_email = mark_safe(
render_to_string(
u'inforequests/create/snippets/content_unique_email.html',
dict(unique_email=unique_email)).strip())
self.fields[u'content'].widget.context[u'user'] = self.user
self.fields[u'content'].widget.context[u'unique_email'] = unique_email
self.fields[u'attachments'].attached_to = self.attached_to
if self.draft:
self.fields[u'obligee'].required = False
self.fields[u'obligee'].email_required = False
self.fields[u'subject'].required = False
self.fields[u'content'].required = False
self.fields[u'attachments'].max_count = None
self.fields[u'attachments'].max_size = None
self.fields[u'attachments'].max_total_size = None
def save(self):
assert self.is_valid()
subject_finalize = lambda inforequest: self.fields[
u'subject'].finalize(self.cleaned_data[u'subject'])
content_finalize = lambda inforequest: self.fields[
u'content'].finalize(
self.cleaned_data[u'content'],
dict(
unique_email=inforequest.unique_email,
obligee=self.cleaned_data[u'obligee'],
))
inforequest = Inforequest.create(
applicant=self.user,
subject=self.cleaned_data[u'subject'][0],
content=self.cleaned_data[u'content'][0],
obligee=self.cleaned_data[u'obligee'],
subject_finalize=subject_finalize,
content_finalize=content_finalize,
attachments=self.cleaned_data[u'attachments'],
)
return inforequest
def save_to_draft(self, draft):
assert self.is_valid()
draft.obligee = self.cleaned_data[u'obligee']
draft.subject = self.cleaned_data[u'subject']
draft.content = self.cleaned_data[u'content']
@after_saved(draft)
def deferred(draft):
# The new list of attachments may not be directly assigned to ``draft.attachment_set``
# because the assignment would clear ``draft.attachment_set`` before adding the new
# attachments. Any attachment that is in both the old and the new list would be deleted
# and then saved again emitting ``*_delete`` signals and deleting its cascaded
# relations.
old_attachments = set(draft.attachment_set.all())
new_attachments = []
for attachment in self.cleaned_data[u'attachments']:
if attachment in old_attachments:
old_attachments.remove(attachment)
else:
new_attachments.append(attachment)
draft.attachment_set.remove(*old_attachments)
draft.attachment_set.add(*new_attachments)
def load_from_draft(self, draft):
self.initial[u'obligee'] = draft.obligee
self.initial[u'subject'] = draft.subject
self.initial[u'content'] = draft.content
self.initial[u'attachments'] = draft.attachments
def get_step_url(self, step, anchor=u''):
return reverse(u'inforequests:obligee_action',
kwargs=dict(inforequest=self.inforequest,
step=step)) + anchor
def url(viewname, *args, **kwargs):
return reverse(viewname, args=args, kwargs=kwargs)
def __init__(self, page, create, *args, **kwargs):
super(PageEditForm, self).__init__(*args, **kwargs)
self.page = page
self.create = create
edit_root = not create and page.is_root
edit_redirect = not create and page.is_redirect
edit_regular = not create and not page.is_root and not page.is_redirect
assert bool(create) + bool(edit_root) + bool(edit_redirect) + bool(
edit_regular) == 1
self.fieldsets = [
Bunch(label=None, collapse=False, fields=[]),
Bunch(label=u'Raw Config', collapse=True, fields=[]),
Bunch(label=u'Page Content', collapse=False, fields=[]),
]
if edit_regular:
self.fields[u'parent'] = forms.CharField(
label=u'URL Path',
validators=[
RegexValidator(
pages.path_regex,
squeeze(u"""
Enter a valid path. It must be an absolute path with respect to the root
page starting and ending with a slash.
""")),
],
widget=forms.TextInput(
attrs={
u'class':
u'popup-path',
u'style':
u'width: 50em;',
u'data-popup-url':
reverse(u'admin:pages_index', args=[page.lang]),
u'data-icon':
staticfiles_storage.url(
u'admin/img/selector-search.gif'),
}),
)
self.initial[u'parent'] = page.ppath
self.fieldsets[0].fields.append(self[u'parent'])
self.fieldsets[0].fields.append(
LivePath(page.lang, self[u'parent']))
else:
self.fieldsets[0].fields.append(FakeField(u'URL Path', page.path))
if create or edit_regular:
self.fields[u'name'] = forms.CharField(
label=u'URL Name',
validators=[
RegexValidator(
pages.slug_regex,
u'Enter a valid slug. Only letters, numbers and dashes are allowed.'
),
],
)
if not create:
self.initial[u'name'] = page.name
self.fieldsets[0].fields.append(self[u'name'])
if create or edit_root or edit_regular:
self.fields[u'title'] = forms.CharField(
label=u'Page Title',
required=False,
widget=forms.TextInput(attrs={
u'style': u'width: 50em;',
}),
)
if not create:
self.initial[u'title'] = page._config.get(u'title')
self.fieldsets[0].fields.append(self[u'title'])
if create or edit_root or edit_regular:
self.fields[u'label'] = forms.CharField(
label=u'Menu Label',
required=False,
)
if not create:
self.initial[u'label'] = page._config.get(u'label')
self.fieldsets[0].fields.append(self[u'label'])
if create or edit_regular:
self.fields[u'order'] = forms.CharField(
label=u'Sort Key',
required=False,
)
if not create:
self.initial[u'order'] = page._config.get(u'order')
self.fieldsets[0].fields.append(self[u'order'])
if create or edit_regular:
for lang, _ in settings.LANGUAGES:
if lang != page.lang:
key = u'lang_{}'.format(lang)
self.fields[key] = forms.CharField(
label=u'Translation {}'.format(lang.upper()),
required=False,
validators=[
RegexValidator(
pages.path_regex,
squeeze(u"""
Enter a valid path. It must be an absolute path with respect to the
root page starting and ending with a slash.
""")),
],
widget=forms.TextInput(
attrs={
u'class':
u'popup-path',
u'style':
u'width: 50em;',
u'data-popup-url':
reverse(u'admin:pages_index', args=[lang]),
u'data-icon':
staticfiles_storage.url(
u'admin/img/selector-search.gif'),
}),
)
if not create:
self.initial[key] = page._config.get(key)
self.fieldsets[0].fields.append(self[key])
self.fieldsets[0].fields.append(LivePath(lang, self[key]))
if edit_redirect:
self.fields[u'redirect'] = forms.CharField(
label=u'Redirect',
validators=[
RegexValidator(
pages.path_regex,
squeeze(u"""
Enter a valid path. It must be an absolute path with respect to the root
page starting and ending with a slash.
""")),
],
widget=forms.TextInput(
attrs={
u'class':
u'popup-path',
u'style':
u'width: 50em;',
u'data-popup-url':
reverse(u'admin:pages_index', args=[page.lang]),
u'data-icon':
staticfiles_storage.url(
u'admin/img/selector-search.gif'),
}),
)
self.initial[u'redirect'] = page.redirect_path
self.fieldsets[0].fields.append(self[u'redirect'])
self.fieldsets[0].fields.append(
LivePath(page.lang, self[u'redirect']))
if create or edit_root or edit_regular:
self.fields[u'disabled'] = forms.BooleanField(
label=u'Disabled',
required=False,
)
if not create:
self.initial[u'disabled'] = bool(page._config.get(u'disabled'))
self.fieldsets[0].fields.append(self[u'disabled'])
if create or edit_root or edit_regular:
self.fields[u'raw'] = forms.CharField(
label=u'',
required=False,
widget=forms.Textarea(attrs={
u'style': u'width: 100%; height: 10em;',
}),
)
if not create:
self.initial[u'raw'] = page.raw_config
self.fieldsets[1].fields.append(self[u'raw'])
if create or edit_root or edit_regular:
with translation(page.lang):
url = reverse(u'admin:pages_preview')
self.fields[u'template'] = forms.CharField(
label=u'',
required=False,
widget=forms.Textarea(attrs={
u'class': u'template-widget',
u'data-url': url,
}),
)
if not create:
self.initial[u'template'] = page.template
self.fieldsets[2].fields.append(self[u'template'])
