def diff_view(self, request, **kwargs):
# view that shows a revision on the left and one on the right
# if the right revision has value zero: the current page is used!
# -> page id is only necessary in the utter case
# if the comparison_pk is zero: the latest version is used
# comparison_pk and base_pk are primary keys for *pages*!
# also called left_pk
left_pk = kwargs.pop('left_pk')
# also called right_pk
right_pk = kwargs.pop('right_pk')
page_pk = kwargs.pop('page_pk')
right_page_is_active_page = True
language = request.GET.get('language')
left = 'page'
right = 'page'
# get the draft we are talking about
page_draft = get_object_or_404(Page, pk=page_pk).get_draft_object()
# check if the current user may view the revision
# -> if the user may see the page
user = get_current_user()
if not user_can_view_page(user, page_draft):
messages.error(request, _('Missing permission to view this page.'))
prev = request.META.get('HTTP_REFERER')
if prev:
return redirect(prev)
else:
raise Http404
# the right panel has id=0
# -> use the draft of the page
# -> else: fetch the page
if int(right_pk) == 0:
right_page = page_draft
right_page_is_active_page = True
else:
right = 'pageVersion'
right_page = PageVersion.objects.get(pk=right_pk)
right_page_is_active_page = False
# the left panel has id=0
# -> use the latest PageVersion draft of the page
# -> else: fetch the page
if int(left_pk) == 0:
page_draft_versions = PageVersion.objects.filter(draft=page_draft, active=True, language=language)\
.order_by('-hidden_page__changed_date')[:1]
if page_draft_versions.count() > 0:
left_page = page_draft_versions.first()
left = 'pageVersion'
else:
messages.info(request,
_(u'There are no snapshots for this page'))
return self.render_close_frame()
else:
left = 'pageVersion'
left_page = PageVersion.objects.get(pk=left_pk)
# list of page's revisions to show as the left sidebar
revision_list = PageVersion.objects.filter(draft=page_draft,
language=language)
# group the revisions by date
grouped_revisions = {}
for rev in revision_list.iterator():
key = rev.hidden_page.changed_date.strftime("%Y-%m-%d")
if key not in grouped_revisions.keys():
grouped_revisions[key] = []
grouped_revisions[key].insert(0, rev)
sorted_grouped_revisions = sorted(grouped_revisions.items(),
key=lambda i: i[0],
reverse=True)
# differences between the placeholders
if left == 'pageVersion':
l_page = left_page.hidden_page
else:
l_page = left_page
if right == 'pageVersion':
r_page = right_page.hidden_page
else:
r_page = right_page
diffs = create_placeholder_contents(l_page, r_page, request, language)
left_page_absolute_url = left_page.hidden_page.get_draft_url(
language=language)
context = SekizaiContext({
'left':
left,
'right':
right,
'left_page':
left_page,
'right_page':
right_page,
'is_popup':
True,
'page':
page_draft.pk,
'active_left_page_version_pk':
left_page.pk,
'request':
request,
'sorted_grouped_revisions':
sorted_grouped_revisions,
'active_language':
language,
'all_languages':
page_draft.languages.split(','),
'diffs':
diffs,
'left_page_absolute_url':
left_page_absolute_url,
'right_page_is_active_page':
right_page_is_active_page
})
return render(request,
self.diff_view_template,
context=context.flatten())
def render_page_row(page):
page.title_cache = {
trans.language: trans
for trans in page.filtered_translations
}
for _language in languages:
# EmptyTitle is used to prevent the cms from trying
# to find a translation in the database
page.title_cache.setdefault(_language,
EmptyTitle(language=_language))
has_move_page_permission = self.has_move_page_permission(request,
obj=page)
if permissions_on and not has_move_page_permission:
# TODO: check if this is really needed
metadata = '{"valid_children": False, "draggable": False}'
else:
metadata = ''
# Get Bin/Version Context
# ----------
page_query = page.get_root().title_set.filter(
title__in=[BIN_ROOT_TITLE, VERSION_ROOT_TITLE])
is_in_bin = page_query.filter(title=BIN_ROOT_TITLE).exists()
is_version = page_query.filter(title=VERSION_ROOT_TITLE).exists()
if is_in_bin or is_version:
# Get the page version associated with the hidden page
page_version = PageVersion.objects.filter(
hidden_page=page.get_draft_object(), language=lang)
# Need this as .~VERSIONS comes up as a 'version' but doesn't have a page_version
if page_version.exists():
page_version = page_version.first()
# Use Sekizai context so we can render the page
context = SekizaiContext({
'admin':
self,
'opts':
self.opts,
'site':
site,
'page':
page,
'node':
page.node,
'ancestors':
[node.item for node in page.node.get_cached_ancestors()],
'descendants':
[node.item for node in page.node.get_cached_descendants()],
'request':
request,
'lang':
language,
'metadata':
metadata,
'page_languages':
page.get_languages(),
'preview_language':
language,
'follow_descendants':
follow_descendants,
'site_languages':
languages,
'is_popup':
is_popup,
# -------- bin/version settings --------
'has_add_page_permission':
False,
'has_change_permission':
False,
'has_change_advanced_settings_permission':
False,
'has_copy_page_permission':
False,
'has_publish_permission':
False,
'has_move_page_permission':
False,
'is_bin':
is_in_bin,
'is_version':
is_version,
'page_version':
page_version,
})
return bin_template.render(context.flatten())
else:
# For 'normal' pages return default context
context = {
'admin':
self,
'opts':
self.opts,
'site':
site,
'page':
page,
'node':
page.node,
'ancestors':
[node.item for node in page.node.get_cached_ancestors()],
'descendants':
[node.item for node in page.node.get_cached_descendants()],
'request':
request,
'lang':
language,
'metadata':
metadata,
'page_languages':
page.get_languages(),
'preview_language':
language,
'follow_descendants':
follow_descendants,
'site_languages':
languages,
'is_popup':
is_popup,
'has_add_page_permission':
user_can_add(user, target=page),
'has_change_permission':
self.has_change_permission(request, obj=page),
'has_publish_permission':
self.has_publish_permission(request, obj=page),
'has_change_advanced_settings_permission':
self.has_change_advanced_settings_permission(request,
obj=page),
'has_move_page_permission':
has_move_page_permission,
}
return template.render(context)
