def new_document(request):
"""Create a new wiki document."""
if request.method == 'GET':
doc_form = DocumentForm(
can_create_tags=request.user.has_perm('taggit.add_tag'))
rev_form = RevisionForm(initial={'review_tags': [t[0] for t in REVIEW_FLAG_TAGS]})
return jingo.render(request, 'wiki/new_document.html',
{'document_form': doc_form,
'revision_form': rev_form})
post_data = request.POST.copy()
post_data.update({'locale': request.locale})
doc_form = DocumentForm(post_data,
can_create_tags=request.user.has_perm('taggit.add_tag'))
rev_form = RevisionForm(post_data)
if doc_form.is_valid() and rev_form.is_valid():
doc = doc_form.save(None)
_save_rev_and_notify(rev_form, request.user, doc)
if doc.current_revision.is_approved:
view = 'wiki.document'
else:
view = 'wiki.document_revisions'
return HttpResponseRedirect(reverse(view,
args=[doc.slug]))
return jingo.render(request, 'wiki/new_document.html',
{'document_form': doc_form,
'revision_form': rev_form})
def new_document(request):
"""Create a new wiki document."""
if request.method == 'GET':
doc_form = DocumentForm(
can_create_tags=request.user.has_perm('taggit.add_tag'))
rev_form = RevisionForm(
initial={'review_tags': [t[0] for t in REVIEW_FLAG_TAGS]})
return jingo.render(request, 'wiki/new_document.html', {
'document_form': doc_form,
'revision_form': rev_form
})
post_data = request.POST.copy()
post_data.update({'locale': request.locale})
doc_form = DocumentForm(
post_data, can_create_tags=request.user.has_perm('taggit.add_tag'))
rev_form = RevisionForm(post_data)
if doc_form.is_valid() and rev_form.is_valid():
doc = doc_form.save(None)
_save_rev_and_notify(rev_form, request.user, doc)
if doc.current_revision.is_approved:
view = 'wiki.document'
else:
view = 'wiki.document_revisions'
return HttpResponseRedirect(reverse(view, args=[doc.slug]))
return jingo.render(request, 'wiki/new_document.html', {
'document_form': doc_form,
'revision_form': rev_form
})
def new_document(request):
"""Create a new wiki document."""
if request.method == 'GET':
doc_form = DocumentForm(initial_title=request.GET.get('title'))
rev_form = RevisionForm()
return jingo.render(request, 'wiki/new_document.html', {
'document_form': doc_form,
'revision_form': rev_form
})
post_data = request.POST.copy()
post_data.update({'locale': request.locale})
doc_form = DocumentForm(post_data)
rev_form = RevisionForm(post_data)
if doc_form.is_valid() and rev_form.is_valid():
doc = doc_form.save(None)
_save_rev_and_notify(rev_form, request.user, doc)
return HttpResponseRedirect(
reverse('wiki.document_revisions', args=[doc.slug]))
return jingo.render(request, 'wiki/new_document.html', {
'document_form': doc_form,
'revision_form': rev_form
})
def new_document(request):
"""Create a new wiki document."""
if request.method == 'GET':
doc_form = DocumentForm(
can_create_tags=request.user.has_perm('taggit.add_tag'))
rev_form = RevisionForm()
return jingo.render(request, 'wiki/new_document.html',
{'document_form': doc_form,
'revision_form': rev_form})
post_data = request.POST.copy()
post_data.update({'locale': request.locale})
doc_form = DocumentForm(post_data,
can_create_tags=request.user.has_perm('taggit.add_tag'))
rev_form = RevisionForm(post_data)
if doc_form.is_valid() and rev_form.is_valid():
doc = doc_form.save(None)
_save_rev_and_notify(rev_form, request.user, doc)
return HttpResponseRedirect(reverse('wiki.document_revisions',
args=[doc.slug]))
return jingo.render(request, 'wiki/new_document.html',
{'document_form': doc_form,
'revision_form': rev_form})
def test_form_save_section(self):
d, r = doc_rev("""
<h1 id="s1">s1</h1>
<p>test</p>
<p>test</p>
<h1 id="s2">s2</h1>
<p>test</p>
<p>test</p>
<h1 id="s3">s3</h1>
<p>test</p>
<p>test</p>
""")
replace_content = """
<h1 id="s2">New stuff</h1>
<p>new stuff</p>
"""
expected = """
<h1 id="s1">s1</h1>
<p>test</p>
<p>test</p>
<h1 id="s2">New stuff</h1>
<p>new stuff</p>
<h1 id="s3">s3</h1>
<p>test</p>
<p>test</p>
"""
rev_form = RevisionForm({"content": replace_content},
instance=r,
section_id="s2")
new_rev = rev_form.save(r.creator, d)
eq_(normalize_html(expected), normalize_html(new_rev.content))
def test_form_save_section(self):
d, r = doc_rev(
"""
<h1 id="s1">s1</h1>
<p>test</p>
<p>test</p>
<h1 id="s2">s2</h1>
<p>test</p>
<p>test</p>
<h1 id="s3">s3</h1>
<p>test</p>
<p>test</p>
"""
)
replace_content = """
<h1 id="s2">New stuff</h1>
<p>new stuff</p>
"""
expected = """
<h1 id="s1">s1</h1>
<p>test</p>
<p>test</p>
<h1 id="s2">New stuff</h1>
<p>new stuff</p>
<h1 id="s3">s3</h1>
<p>test</p>
<p>test</p>
"""
rev_form = RevisionForm({"content": replace_content}, instance=r, section_id="s2")
new_rev = rev_form.save(r.creator, d)
eq_(normalize_html(expected), normalize_html(new_rev.content))
def page_edit(request, page_slug):
try:
page = Page.objects.get_by_write(page_slug, request)
except PermissionDenied:
return redirect('wiki-page', page_slug=page_slug)
except Page.DoesNotExist:
page = None
form_page = None
if request.POST:
form = RevisionForm(request.POST)
if form.is_valid():
# adding new page
if page is None:
form_page = PageAddForm(request.POST, user=request.user)
if form_page.is_valid():
page = form_page.save()
if Page.objects.count() == 1:
# first wiki page created
configuration = Configuration.objects.current()
configuration.wiki_homepage = page
configuration.save()
messages.info(request, _(u'Diese Wiki-Seite wurde nun als Startseite des Wikis eingerichtet. '
u'Du kannst das in der Konfiguration ändern.'))
if page:
revision = form.save(commit=False)
revision.user = request.user.actor
revision.page = page
revision.save()
message_object_updated(request, page)
return redirect(page)
else:
form_page = PageAddForm(request.POST, user=request.user, initial={'title': page_slug.capitalize})
else:
if page is None:
form = RevisionForm()
form_page = PageAddForm(user=request.user, initial={'title': page_slug.capitalize})
else:
revision = page.get_current()
revision.summary = ''
form = RevisionForm(instance=revision)
if page is not None:
is_owner = page.is_owner(request.user.actor)
else:
is_owner = None
return render(request, 'wiki/page-edit.html', get_context_wiki(request, 'wiki-page-edit',
{'form': form, 'page': page,
'form_page': form_page,
'tpl__is_owner': is_owner}))
def edit(request, slug, binder, *args, **kwargs):
wiki = binder.lookup(*args, **kwargs)
try:
if wiki:
page = wiki.pages.get(slug=slug)
else:
page = Page.objects.get(slug=slug)
except Page.DoesNotExist:
return HttpResponseRedirect(reverse("wiki_add") + "?slug=" + slug)
else:
if not hookset.can_edit_page(page, request.user):
messages.add_message(
request, messages.ERROR,
"You do not have permission to edit this page.")
return HttpResponseRedirect(reverse("wiki_all"))
rev = page.revisions.latest()
form = RevisionForm(
request.POST if "edit" in request.POST else None,
revision=rev,
)
if form.is_valid():
revision = form.save(commit=False)
revision.page = page
revision.created_by = request.user
revision.created_ip = request.META.get(
settings.WIKI_IP_ADDRESS_META_FIELD,
request.META.get("REMOTE_ADDR"))
revision.parse()
revision.save()
return HttpResponseRedirect(binder.page_url(wiki, slug))
form.fields["content"].help_text = ""
can_delete = hookset.can_delete_page(page, request.user) and page.pk
if can_delete and "delete" in request.POST:
page.delete()
return HttpResponseRedirect(reverse("wiki_all"))
page_name = "Edit {0}".format(page.slug)
return render_to_response("wiki/edit.html", {
"page_name": page_name,
"form": form,
"page": page,
"can_delete": can_delete,
},
context_instance=RequestContext(request))
def add_page_view(request, binder, *args, **kwargs):
wiki = binder.lookup(*args, **kwargs)
slug = request.GET.get("slug", "")
if not slug:
slug = "Page Name"
try:
if wiki:
page = wiki.pages.get(slug=slug)
else:
page = Page.objects.get(slug=slug)
except Page.DoesNotExist:
pass
else:
return HttpResponseRedirect(page.get_edit_url())
if not hookset.can_create_page(wiki, request.user, slug=slug):
messages.add_message(
request, messages.ERROR,
"You do not have permission to create this page.")
return HttpResponseRedirect(reverse("wiki_all"))
form = RevisionForm(
request.POST if "edit" in request.POST else None,
revision=None,
)
if form.is_valid():
page = Page.objects.create(wiki=wiki, slug=slug)
revision = form.save(commit=False)
revision.page = page
revision.created_by = request.user
revision.created_ip = request.META.get(
settings.WIKI_IP_ADDRESS_META_FIELD,
request.META.get("REMOTE_ADDR"))
revision.parse()
revision.save()
return HttpResponseRedirect(binder.page_url(wiki, slug))
form.fields["content"].help_text = ""
page_name = "Add {0}".format(slug)
return render_to_response("wiki/edit.html", {
"page_name": page_name,
"form": form,
"can_delete": False,
},
context_instance=RequestContext(request))
def test_form_onload_attr_filter(self):
"""RevisionForm should strip out any harmful onload attributes from
input markup"""
d, r = doc_rev("""
<svg><circle onload=confirm(3)>
""")
rev_form = RevisionForm(instance=r)
ok_('onload' not in rev_form.initial['content'])
def edit(request, slug, binder, *args, **kwargs):
wiki = binder.lookup(*args, **kwargs)
try:
if wiki:
page = wiki.pages.get(slug=slug)
else:
page = Page.objects.get(slug=slug)
rev = page.revisions.latest()
if not hookset.can_edit_page(page, request.user):
return HttpResponseForbidden()
except Page.DoesNotExist:
return HttpResponseRedirect(reverse("wiki_add") + "?slug=" + slug)
form = RevisionForm(
request.POST if "edit" in request.POST else None,
revision=rev,
)
if form.is_valid():
revision = form.save(commit=False)
revision.page = page
revision.created_by = request.user
revision.created_ip = request.META.get(settings.WIKI_IP_ADDRESS_META_FIELD,
request.META.get("REMOTE_ADDR"))
revision.parse()
revision.save()
return HttpResponseRedirect(binder.page_url(wiki, slug))
form.fields["content"].help_text = ""
can_delete = hookset.can_delete_page(page, request.user) and page.pk
if can_delete and "delete" in request.POST:
page.delete()
return HttpResponseRedirect(reverse("wiki_all"))
page_name = "Edit {0}".format(page.slug)
return render_to_response("wiki/edit.html", {
"page_name": page_name,
"form": form,
"page": page,
"can_delete": can_delete,
}, context_instance=RequestContext(request))
def add_page_view(request, binder, *args, **kwargs):
wiki = binder.lookup(*args, **kwargs)
slug = request.GET.get("slug", "")
if not slug:
slug = "Page Name"
try:
if wiki:
page = wiki.pages.get(slug=slug)
else:
page = Page.objects.get(slug=slug)
except Page.DoesNotExist:
pass
else:
return HttpResponseRedirect(page.get_edit_url())
if not hookset.can_create_page(wiki, request.user):
raise Http404()
form = RevisionForm(
request.POST if "edit" in request.POST else None,
revision=None,
)
if form.is_valid():
page = Page.objects.create(wiki=wiki, slug=slug)
revision = form.save(commit=False)
revision.page = page
revision.created_by = request.user
revision.created_ip = request.META.get(settings.WIKI_IP_ADDRESS_META_FIELD,
request.META.get("REMOTE_ADDR"))
revision.parse()
revision.save()
return HttpResponseRedirect(binder.page_url(wiki, slug))
form.fields["content"].help_text = ""
page_name = "Add {0}".format(slug)
return render_to_response("wiki/edit.html", {
"page_name": page_name,
"form": form,
"can_delete": False,
}, context_instance=RequestContext(request))
def new_document(request):
"""Create a new wiki document."""
if request.method == 'GET':
doc_form = DocumentForm(initial_title=request.GET.get('title'))
rev_form = RevisionForm()
return render(request, 'wiki/new_document.html', {
'document_form': doc_form,
'revision_form': rev_form})
post_data = request.POST.copy()
post_data.update({'locale': request.LANGUAGE_CODE})
doc_form = DocumentForm(post_data)
rev_form = RevisionForm(post_data)
if doc_form.is_valid() and rev_form.is_valid():
doc = doc_form.save(None)
_save_rev_and_notify(rev_form, request.user, doc)
return HttpResponseRedirect(reverse('wiki.document_revisions',
args=[doc.slug]))
return render(request, 'wiki/new_document.html', {
'document_form': doc_form,
'revision_form': rev_form})
def test_form_loaded_with_section(self):
"""RevisionForm given section_id should load initial content for only
one section"""
d, r = doc_rev("""
<h1 id="s1">s1</h1>
<p>test</p>
<p>test</p>
<h1 id="s2">s2</h1>
<p>test</p>
<p>test</p>
<h1 id="s3">s3</h1>
<p>test</p>
<p>test</p>
""")
expected = """
<h1 id="s2">s2</h1>
<p>test</p>
<p>test</p>
"""
rev_form = RevisionForm(instance=r, section_id="s2")
eq_(normalize_html(expected),
normalize_html(rev_form.initial['content']))
def translate(request, document_slug, revision_id=None):
"""Create a new translation of a wiki document.
* document_slug is for the default locale
* translation is to the request locale
"""
# TODO: Refactor this view into two views? (new, edit)
# That might help reduce the headache-inducing branchiness.
parent_doc = get_object_or_404(
Document, locale=settings.WIKI_DEFAULT_LANGUAGE, slug=document_slug)
user = request.user
if settings.WIKI_DEFAULT_LANGUAGE == request.locale:
# Don't translate to the default language.
return HttpResponseRedirect(reverse(
'wiki.edit_document', locale=settings.WIKI_DEFAULT_LANGUAGE,
args=[parent_doc.slug]))
if not parent_doc.is_localizable:
message = _lazy(u'You cannot translate this document.')
return jingo.render(request, 'handlers/400.html',
{'message': message}, status=400)
based_on_rev = parent_doc.localizable_or_latest_revision(
include_rejected=True)
disclose_description = bool(request.GET.get('opendescription'))
try:
doc = parent_doc.translations.get(locale=request.locale)
except Document.DoesNotExist:
doc = None
disclose_description = True
user_has_doc_perm = ((not doc) or (doc and doc.allows_editing_by(user)))
user_has_rev_perm = ((not doc) or (doc and doc.allows_revision_by(user)))
if not user_has_doc_perm and not user_has_rev_perm:
# User has no perms, bye.
raise PermissionDenied
doc_form = rev_form = None
base_rev = None
if user_has_doc_perm:
doc_initial = _document_form_initial(doc) if doc else None
doc_form = DocumentForm(initial=doc_initial,
can_create_tags=user.has_perm('taggit.add_tag'))
if user_has_rev_perm:
initial = {'based_on': based_on_rev.id, 'comment': ''}
if revision_id:
base_rev = Revision.objects.get(pk=revision_id)
initial.update(content=base_rev.content,
summary=base_rev.summary,
keywords=base_rev.keywords)
elif not doc:
initial.update(content=based_on_rev.content,
summary=based_on_rev.summary,
keywords=based_on_rev.keywords)
# Get a revision of the translation to plonk into the page as a
# starting point. Since translations are never "ready for
# localization", this will first try to find an approved revision, then
# an unrejected one, then give up.
instance = doc and doc.localizable_or_latest_revision()
rev_form = RevisionForm(instance=instance, initial=initial)
base_rev = base_rev or instance
if request.method == 'POST':
which_form = request.POST.get('form', 'both')
doc_form_invalid = False
if user_has_doc_perm and which_form in ['doc', 'both']:
disclose_description = True
post_data = request.POST.copy()
post_data.update({'locale': request.locale})
doc_form = DocumentForm(post_data, instance=doc,
can_create_tags=user.has_perm('taggit.add_tag'))
doc_form.instance.locale = request.locale
doc_form.instance.parent = parent_doc
if which_form == 'both':
rev_form = RevisionForm(request.POST)
# If we are submitting the whole form, we need to check that
# the Revision is valid before saving the Document.
if doc_form.is_valid() and (which_form == 'doc' or
rev_form.is_valid()):
doc = doc_form.save(parent_doc)
# Possibly schedule a rebuild.
_maybe_schedule_rebuild(doc_form)
if which_form == 'doc':
url = urlparams(reverse('wiki.edit_document',
args=[doc.slug]),
opendescription=1)
return HttpResponseRedirect(url)
doc_slug = doc_form.cleaned_data['slug']
else:
doc_form_invalid = True
else:
doc_slug = doc.slug
if doc and user_has_rev_perm and which_form in ['rev', 'both']:
rev_form = RevisionForm(request.POST)
rev_form.instance.document = doc # for rev_form.clean()
if rev_form.is_valid() and not doc_form_invalid:
_save_rev_and_notify(rev_form, request.user, doc)
url = reverse('wiki.document_revisions',
args=[doc_slug])
return HttpResponseRedirect(url)
show_revision_warning = _show_revision_warning(doc, base_rev)
return jingo.render(request, 'wiki/translate.html',
{'parent': parent_doc, 'document': doc,
'document_form': doc_form, 'revision_form': rev_form,
'locale': request.locale, 'based_on': based_on_rev,
'disclose_description': disclose_description,
'show_revision_warning': show_revision_warning})
def edit_document(request, document_slug, revision_id=None):
"""Create a new revision of a wiki document, or edit document metadata."""
doc = get_object_or_404(
Document, locale=request.locale, slug=document_slug)
user = request.user
# If this document has a parent, then the edit is handled by the
# translate view. Pass it on.
if doc.parent:
return translate(request, doc.parent.slug, revision_id)
if revision_id:
rev = get_object_or_404(Revision, pk=revision_id, document=doc)
else:
rev = doc.current_revision or doc.revisions.order_by('-created',
'-id')[0]
disclose_description = bool(request.GET.get('opendescription'))
doc_form = rev_form = None
if doc.allows_revision_by(user):
rev_form = RevisionForm(
instance=rev,
initial={'based_on': rev.id, 'comment': ''})
if doc.allows_editing_by(user):
doc_form = DocumentForm(
initial=_document_form_initial(doc),
can_create_tags=user.has_perm('taggit.add_tag'),
can_archive=user.has_perm('wiki.archive_document'))
if request.method == 'GET':
if not (rev_form or doc_form):
# You can't do anything on this page, so get lost.
raise PermissionDenied
else: # POST
# Comparing against localized names for the Save button bothers me, so
# I embedded a hidden input:
which_form = request.POST.get('form')
if which_form == 'doc':
if doc.allows_editing_by(user):
post_data = request.POST.copy()
post_data.update({'locale': request.locale})
doc_form = DocumentForm(
post_data,
instance=doc,
can_create_tags=user.has_perm('taggit.add_tag'),
can_archive=user.has_perm('wiki.archive_document'))
if doc_form.is_valid():
# Get the possibly new slug for the imminent redirection:
doc = doc_form.save(None)
# Do we need to rebuild the KB?
_maybe_schedule_rebuild(doc_form)
return HttpResponseRedirect(
urlparams(reverse('wiki.edit_document',
args=[doc.slug]),
opendescription=1))
disclose_description = True
else:
raise PermissionDenied
elif which_form == 'rev':
if doc.allows_revision_by(user):
rev_form = RevisionForm(request.POST)
rev_form.instance.document = doc # for rev_form.clean()
if rev_form.is_valid():
_save_rev_and_notify(rev_form, user, doc)
if 'notify-future-changes' in request.POST:
EditDocumentEvent.notify(request.user, doc)
return HttpResponseRedirect(
reverse('wiki.document_revisions',
args=[document_slug]))
else:
raise PermissionDenied
show_revision_warning = _show_revision_warning(doc, rev)
return jingo.render(request, 'wiki/edit_document.html',
{'revision_form': rev_form,
'document_form': doc_form,
'disclose_description': disclose_description,
'document': doc,
'show_revision_warning': show_revision_warning})
def edit_document(request, document_slug, revision_id=None):
"""Create a new revision of a wiki document, or edit document metadata."""
doc = get_object_or_404(Document,
locale=request.locale,
slug=document_slug)
user = request.user
# If this document has a parent, then the edit is handled by the
# translate view. Pass it on.
if doc.parent:
return translate(request, doc.parent.slug, revision_id)
if revision_id:
rev = get_object_or_404(Revision, pk=revision_id, document=doc)
else:
rev = doc.current_revision or doc.revisions.order_by(
'-created', '-id')[0]
section_id = request.GET.get('section', None)
disclose_description = bool(request.GET.get('opendescription'))
doc_form = rev_form = None
if doc.allows_revision_by(user):
rev_form = RevisionForm(instance=rev,
initial={
'based_on': rev.id,
'current_rev': rev.id,
'comment': ''
},
section_id=section_id)
if doc.allows_editing_by(user):
doc_form = DocumentForm(
initial=_document_form_initial(doc),
can_create_tags=user.has_perm('taggit.add_tag'))
if request.method == 'GET':
if not (rev_form or doc_form):
# You can't do anything on this page, so get lost.
raise PermissionDenied
else: # POST
is_iframe_target = request.GET.get('iframe', False)
is_raw = request.GET.get('raw', False)
need_edit_links = request.GET.get('edit_links', False)
# Comparing against localized names for the Save button bothers me, so
# I embedded a hidden input:
which_form = request.POST.get('form')
if which_form == 'doc':
if doc.allows_editing_by(user):
post_data = request.POST.copy()
post_data.update({'locale': request.locale})
doc_form = DocumentForm(
post_data,
instance=doc,
can_create_tags=user.has_perm('taggit.add_tag'))
if doc_form.is_valid():
# Get the possibly new slug for the imminent redirection:
doc = doc_form.save(None)
# Do we need to rebuild the KB?
_maybe_schedule_rebuild(doc_form)
if is_iframe_target:
# TODO: Does this really need to be a template? Just
# shoehorning data into a single HTML element.
response = HttpResponse("""
<span id="iframe-response"
data-status="OK"
data-current-revision="%s">OK</span>
""" % doc.current_revision.id)
response['x-frame-options'] = 'SAMEORIGIN'
return response
return HttpResponseRedirect(
urlparams(reverse('wiki.edit_document',
args=[doc.slug]),
opendescription=1))
disclose_description = True
else:
raise PermissionDenied
elif which_form == 'rev':
if not doc.allows_revision_by(user):
raise PermissionDenied
else:
rev_form = RevisionForm(request.POST,
is_iframe_target=is_iframe_target,
section_id=section_id)
rev_form.instance.document = doc # for rev_form.clean()
# Come up with the original revision to which these changes
# would be applied.
orig_rev_id = request.POST.get('current_rev', False)
if False == orig_rev_id:
orig_rev = None
else:
orig_rev = Revision.objects.get(pk=orig_rev_id)
# Get the document's actual current revision.
curr_rev = doc.current_revision
if not rev_form.is_valid():
# Was there a mid-air collision?
if 'current_rev' in rev_form._errors:
# Jump out to a function to escape indentation hell
return _edit_document_collision(
request, orig_rev, curr_rev, is_iframe_target,
is_raw, rev_form, doc_form, section_id, rev, doc)
else:
_save_rev_and_notify(rev_form, user, doc)
if is_iframe_target:
# TODO: Does this really need to be a template? Just
# shoehorning data into a single HTML element.
response = HttpResponse("""
<span id="iframe-response"
data-status="OK"
data-current-revision="%s">OK</span>
""" % doc.current_revision.id)
response['x-frame-options'] = 'SAMEORIGIN'
return response
if (is_raw and orig_rev is not None
and curr_rev.id != orig_rev.id):
# If this is the raw view, and there was an original
# revision, but the original revision differed from the
# current revision at start of editing, we should tell
# the client to refresh the page.
response = HttpResponse('RESET')
response.status_code = 205
response['x-frame-options'] = 'SAMEORIGIN'
return response
if rev_form.instance.is_approved:
view = 'wiki.document'
else:
view = 'wiki.document_revisions'
# Construct the redirect URL, adding any needed parameters
url = reverse(view, args=[doc.slug], locale=doc.locale)
params = {}
if is_raw:
params['raw'] = 'true'
if need_edit_links:
# Only need to carry over ?edit_links with ?raw,
# because they're on by default in the normal UI
params['edit_links'] = 'true'
if section_id:
# If a section was edited, and we're using the raw
# content API, constrain to that section.
params['section'] = section_id
if params:
url = '%s?%s' % (url, urlencode(params))
if not is_raw and section_id:
# If a section was edited, jump to the section anchor
# if we're not getting raw content.
url = '%s#%s' % (url, section_id)
return HttpResponseRedirect(url)
return jingo.render(
request, 'wiki/edit_document.html', {
'revision_form': rev_form,
'document_form': doc_form,
'section_id': section_id,
'disclose_description': disclose_description,
'revision': rev,
'document': doc
})
def translate(request, document_slug, revision_id=None):
"""Create a new translation of a wiki document.
* document_slug is for the default locale
* translation is to the request locale
"""
# TODO: Refactor this view into two views? (new, edit)
# That might help reduce the headache-inducing branchiness.
parent_doc = get_object_or_404(Document,
locale=settings.WIKI_DEFAULT_LANGUAGE,
slug=document_slug)
user = request.user
if settings.WIKI_DEFAULT_LANGUAGE == request.locale:
# Don't translate to the default language.
return HttpResponseRedirect(
reverse('wiki.edit_document',
locale=settings.WIKI_DEFAULT_LANGUAGE,
args=[parent_doc.slug]))
if not parent_doc.is_localizable:
message = _lazy(u'You cannot translate this document.')
return jingo.render(request,
'handlers/400.html', {'message': message},
status=400)
based_on_rev = parent_doc.localizable_or_latest_revision(
include_rejected=True)
disclose_description = bool(request.GET.get('opendescription'))
try:
doc = parent_doc.translations.get(locale=request.locale)
except Document.DoesNotExist:
doc = None
disclose_description = True
user_has_doc_perm = ((not doc) or (doc and doc.allows_editing_by(user)))
user_has_rev_perm = ((not doc) or (doc and doc.allows_revision_by(user)))
if not user_has_doc_perm and not user_has_rev_perm:
# User has no perms, bye.
raise PermissionDenied
doc_form = rev_form = None
base_rev = None
if user_has_doc_perm:
doc_initial = _document_form_initial(doc) if doc else None
doc_form = DocumentForm(initial=doc_initial)
if user_has_rev_perm:
initial = {'based_on': based_on_rev.id, 'comment': ''}
if revision_id:
base_rev = Revision.objects.get(pk=revision_id)
initial.update(content=base_rev.content,
summary=base_rev.summary,
keywords=base_rev.keywords)
elif not doc:
initial.update(content=based_on_rev.content,
summary=based_on_rev.summary,
keywords=based_on_rev.keywords)
# Get a revision of the translation to plonk into the page as a
# starting point. Since translations are never "ready for
# localization", this will first try to find an approved revision, then
# an unrejected one, then give up.
instance = doc and doc.localizable_or_latest_revision()
rev_form = RevisionForm(instance=instance, initial=initial)
base_rev = base_rev or instance
if request.method == 'POST':
which_form = request.POST.get('form', 'both')
doc_form_invalid = False
if user_has_doc_perm and which_form in ['doc', 'both']:
disclose_description = True
post_data = request.POST.copy()
post_data.update({'locale': request.locale})
doc_form = DocumentForm(post_data, instance=doc)
doc_form.instance.locale = request.locale
doc_form.instance.parent = parent_doc
if which_form == 'both':
rev_form = RevisionForm(request.POST)
# If we are submitting the whole form, we need to check that
# the Revision is valid before saving the Document.
if doc_form.is_valid() and (which_form == 'doc'
or rev_form.is_valid()):
doc = doc_form.save(parent_doc)
# Possibly schedule a rebuild.
_maybe_schedule_rebuild(doc_form)
if which_form == 'doc':
url = urlparams(reverse('wiki.edit_document',
args=[doc.slug]),
opendescription=1)
return HttpResponseRedirect(url)
doc_slug = doc_form.cleaned_data['slug']
else:
doc_form_invalid = True
else:
doc_slug = doc.slug
if doc and user_has_rev_perm and which_form in ['rev', 'both']:
rev_form = RevisionForm(request.POST)
rev_form.instance.document = doc # for rev_form.clean()
if rev_form.is_valid() and not doc_form_invalid:
_save_rev_and_notify(rev_form, request.user, doc)
url = reverse('wiki.document_revisions', args=[doc_slug])
return HttpResponseRedirect(url)
show_revision_warning = _show_revision_warning(doc, base_rev)
return jingo.render(
request, 'wiki/translate.html', {
'parent': parent_doc,
'document': doc,
'document_form': doc_form,
'revision_form': rev_form,
'locale': request.locale,
'based_on': based_on_rev,
'disclose_description': disclose_description,
'show_revision_warning': show_revision_warning
})
def edit_document(request, document_slug, revision_id=None):
"""Create a new revision of a wiki document, or edit document metadata."""
doc = get_object_or_404(Document,
locale=request.locale,
slug=document_slug)
user = request.user
# If this document has a parent, then the edit is handled by the
# translate view. Pass it on.
if doc.parent:
return translate(request, doc.parent.slug, revision_id)
if revision_id:
rev = get_object_or_404(Revision, pk=revision_id, document=doc)
else:
rev = doc.current_revision or doc.revisions.order_by(
'-created', '-id')[0]
disclose_description = bool(request.GET.get('opendescription'))
doc_form = rev_form = None
if doc.allows_revision_by(user):
rev_form = RevisionForm(instance=rev,
initial={
'based_on': rev.id,
'comment': ''
})
if doc.allows_editing_by(user):
doc_form = DocumentForm(
initial=_document_form_initial(doc),
can_archive=user.has_perm('wiki.archive_document'))
if request.method == 'GET':
if not (rev_form or doc_form):
# You can't do anything on this page, so get lost.
raise PermissionDenied
else: # POST
# Comparing against localized names for the Save button bothers me, so
# I embedded a hidden input:
which_form = request.POST.get('form')
if which_form == 'doc':
if doc.allows_editing_by(user):
post_data = request.POST.copy()
post_data.update({'locale': request.locale})
doc_form = DocumentForm(
post_data,
instance=doc,
can_archive=user.has_perm('wiki.archive_document'))
if doc_form.is_valid():
# Get the possibly new slug for the imminent redirection:
doc = doc_form.save(None)
# Do we need to rebuild the KB?
_maybe_schedule_rebuild(doc_form)
return HttpResponseRedirect(
urlparams(reverse('wiki.edit_document',
args=[doc.slug]),
opendescription=1))
disclose_description = True
else:
raise PermissionDenied
elif which_form == 'rev':
if doc.allows_revision_by(user):
rev_form = RevisionForm(request.POST)
rev_form.instance.document = doc # for rev_form.clean()
if rev_form.is_valid():
_save_rev_and_notify(rev_form, user, doc)
if 'notify-future-changes' in request.POST:
EditDocumentEvent.notify(request.user, doc)
return HttpResponseRedirect(
reverse('wiki.document_revisions',
args=[document_slug]))
else:
raise PermissionDenied
show_revision_warning = _show_revision_warning(doc, rev)
return jingo.render(
request, 'wiki/edit.html', {
'revision_form': rev_form,
'document_form': doc_form,
'disclose_description': disclose_description,
'document': doc,
'show_revision_warning': show_revision_warning
})
def edit_document(request, document_slug, revision_id=None):
"""Create a new revision of a wiki document, or edit document metadata."""
doc = get_object_or_404(
Document, locale=request.locale, slug=document_slug)
user = request.user
# If this document has a parent, then the edit is handled by the
# translate view. Pass it on.
if doc.parent:
return translate(request, doc.parent.slug, revision_id)
if revision_id:
rev = get_object_or_404(Revision, pk=revision_id, document=doc)
else:
rev = doc.current_revision or doc.revisions.order_by('-created',
'-id')[0]
section_id = request.GET.get('section', None)
disclose_description = bool(request.GET.get('opendescription'))
doc_form = rev_form = None
if doc.allows_revision_by(user):
rev_form = RevisionForm(instance=rev,
initial={'based_on': rev.id,
'current_rev': rev.id,
'comment': ''},
section_id=section_id)
if doc.allows_editing_by(user):
doc_form = DocumentForm(initial=_document_form_initial(doc),
can_create_tags=user.has_perm('taggit.add_tag'))
if request.method == 'GET':
if not (rev_form or doc_form):
# You can't do anything on this page, so get lost.
raise PermissionDenied
else: # POST
is_iframe_target = request.GET.get('iframe', False)
is_raw = request.GET.get('raw', False)
need_edit_links = request.GET.get('edit_links', False)
# Comparing against localized names for the Save button bothers me, so
# I embedded a hidden input:
which_form = request.POST.get('form')
if which_form == 'doc':
if doc.allows_editing_by(user):
post_data = request.POST.copy()
post_data.update({'locale': request.locale})
doc_form = DocumentForm(post_data, instance=doc,
can_create_tags=user.has_perm('taggit.add_tag'))
if doc_form.is_valid():
# Get the possibly new slug for the imminent redirection:
doc = doc_form.save(None)
# Do we need to rebuild the KB?
_maybe_schedule_rebuild(doc_form)
if is_iframe_target:
# TODO: Does this really need to be a template? Just
# shoehorning data into a single HTML element.
response = HttpResponse("""
<span id="iframe-response"
data-status="OK"
data-current-revision="%s">OK</span>
""" % doc.current_revision.id)
response['x-frame-options'] = 'SAMEORIGIN'
return response
return HttpResponseRedirect(
urlparams(reverse('wiki.edit_document',
args=[doc.slug]),
opendescription=1))
disclose_description = True
else:
raise PermissionDenied
elif which_form == 'rev':
if not doc.allows_revision_by(user):
raise PermissionDenied
else:
rev_form = RevisionForm(request.POST,
is_iframe_target=is_iframe_target,
section_id=section_id)
rev_form.instance.document = doc # for rev_form.clean()
# Come up with the original revision to which these changes
# would be applied.
orig_rev_id = request.POST.get('current_rev', False)
if False == orig_rev_id:
orig_rev = None
else:
orig_rev = Revision.objects.get(pk=orig_rev_id)
# Get the document's actual current revision.
curr_rev = doc.current_revision
if not rev_form.is_valid():
# Was there a mid-air collision?
if 'current_rev' in rev_form._errors:
# Jump out to a function to escape indentation hell
return _edit_document_collision(request,
orig_rev, curr_rev,
is_iframe_target,
is_raw,
rev_form, doc_form,
section_id,
rev, doc)
else:
_save_rev_and_notify(rev_form, user, doc)
if is_iframe_target:
# TODO: Does this really need to be a template? Just
# shoehorning data into a single HTML element.
response = HttpResponse("""
<span id="iframe-response"
data-status="OK"
data-current-revision="%s">OK</span>
""" % doc.current_revision.id)
response['x-frame-options'] = 'SAMEORIGIN'
return response
if (is_raw and orig_rev is not None and
curr_rev.id != orig_rev.id):
# If this is the raw view, and there was an original
# revision, but the original revision differed from the
# current revision at start of editing, we should tell
# the client to refresh the page.
response = HttpResponse('RESET')
response.status_code = 205
response['x-frame-options'] = 'SAMEORIGIN'
return response
if rev_form.instance.is_approved:
view = 'wiki.document'
else:
view = 'wiki.document_revisions'
# Construct the redirect URL, adding any needed parameters
url = reverse(view, args=[doc.slug], locale=doc.locale)
params = {}
if is_raw:
params['raw'] = 'true'
if need_edit_links:
# Only need to carry over ?edit_links with ?raw,
# because they're on by default in the normal UI
params['edit_links'] = 'true'
if section_id:
# If a section was edited, and we're using the raw
# content API, constrain to that section.
params['section'] = section_id
if params:
url = '%s?%s' % (url, urlencode(params))
if not is_raw and section_id:
# If a section was edited, jump to the section anchor
# if we're not getting raw content.
url = '%s#%s' % (url, section_id)
return HttpResponseRedirect(url)
return jingo.render(request, 'wiki/edit_document.html',
{'revision_form': rev_form,
'document_form': doc_form,
'section_id': section_id,
'disclose_description': disclose_description,
'revision': rev,
'document': doc})
