def documents(request, category=None, tag=None):
"""
List wiki documents depending on the optionally given category or tag.
"""
category_id = None
if category:
try:
category_id = int(category)
category = unicode(dict(Document.CATEGORIES)[category_id])
except (KeyError, ValueError):
raise Http404
# Taggit offers a slug - but use name here, because the slugification
# stinks and is hard to customize.
tag_obj = None
if tag:
matching_tags = get_list_or_404(DocumentTag, name__iexact=tag)
for matching_tag in matching_tags:
if matching_tag.name.lower() == tag.lower():
tag_obj = matching_tag
break
docs = Document.objects.filter_for_list(locale=request.locale,
category=category_id,
tag=tag_obj)
paginated_docs = paginate(request, docs, per_page=DOCUMENTS_PER_PAGE)
context = {
'documents': paginated_docs,
'count': docs.count(),
'category': category,
'tag': tag,
}
return render(request, 'wiki/list/documents.html', context)
def documents(request, category=None, tag=None):
"""
List wiki documents depending on the optionally given category or tag.
"""
category_id = None
if category:
try:
category_id = int(category)
category = unicode(dict(Document.CATEGORIES)[category_id])
except (KeyError, ValueError):
raise Http404
# Taggit offers a slug - but use name here, because the slugification
# stinks and is hard to customize.
tag_obj = None
if tag:
matching_tags = get_list_or_404(DocumentTag, name__iexact=tag)
for matching_tag in matching_tags:
if matching_tag.name.lower() == tag.lower():
tag_obj = matching_tag
break
docs = Document.objects.filter_for_list(locale=request.LANGUAGE_CODE,
category=category_id,
tag=tag_obj)
paginated_docs = paginate(request, docs, per_page=DOCUMENTS_PER_PAGE)
context = {
'documents': paginated_docs,
'count': docs.count(),
'category': category,
'tag': tag,
}
return render(request, 'wiki/list/documents.html', context)
def tags(request):
"""
Returns listing of all tags
"""
tags = DocumentTag.objects.order_by('name')
tags = paginate(request, tags, per_page=DOCUMENTS_PER_PAGE)
return render(request, 'wiki/list/tags.html', {'tags': tags})
def tags(request):
"""
Returns listing of all tags
"""
tags = DocumentTag.objects.order_by('name')
tags = paginate(request, tags, per_page=DOCUMENTS_PER_PAGE)
return render(request, 'wiki/list/tags.html', {'tags': tags})
def revisions(request):
"""Dashboard for reviewing revisions"""
filter_form = RevisionDashboardForm(request.GET)
page = request.GET.get('page', 1)
revisions = (Revision.objects.select_related('creator').order_by(
'-created').defer('content'))
query_kwargs = False
# We can validate right away because no field is required
if filter_form.is_valid():
query_kwargs = {}
query_kwargs_map = {
'user': '******',
'locale': 'document__locale',
'topic': 'slug__icontains',
}
# Build up a dict of the filter conditions, if any, then apply
# them all in one go.
for fieldname, kwarg in query_kwargs_map.items():
filter_arg = filter_form.cleaned_data[fieldname]
if filter_arg:
query_kwargs[kwarg] = filter_arg
start_date = filter_form.cleaned_data['start_date']
if start_date:
end_date = (filter_form.cleaned_data['end_date']
or datetime.datetime.now())
query_kwargs['created__range'] = [start_date, end_date]
if query_kwargs:
revisions = revisions.filter(**query_kwargs)
total = revisions.count()
else:
# If no filters, just do a straight count(). It's the same
# result, but much faster to compute.
total = Revision.objects.count()
# Only bother with this if we're actually going to get
# some revisions from it. Otherwise it's a pointless but
# potentially complex query.
revisions = paginate(request, revisions, per_page=PAGE_SIZE)
context = {'revisions': revisions, 'page': page, 'total': total}
# Serve the response HTML conditionally upon reques type
if request.is_ajax():
template = 'dashboards/includes/revision_dashboard_body.html'
else:
template = 'dashboards/revisions.html'
context['form'] = filter_form
return render(request, template, context)
def top_level(request):
"""Lists documents directly under /docs/"""
docs = Document.objects.filter_for_list(locale=request.LANGUAGE_CODE,
toplevel=True)
paginated_docs = paginate(request, docs, per_page=DOCUMENTS_PER_PAGE)
context = {
'documents': paginated_docs,
'toplevel': True,
}
return render(request, 'wiki/list/documents.html', context)
def without_parent(request):
"""Lists wiki documents without parent (no English source document)"""
docs = Document.objects.filter_for_list(locale=request.LANGUAGE_CODE,
noparent=True)
paginated_docs = paginate(request, docs, per_page=DOCUMENTS_PER_PAGE)
context = {
'documents': paginated_docs,
'noparent': True,
}
return render(request, 'wiki/list/documents.html', context)
def without_parent(request):
"""Lists wiki documents without parent (no English source document)"""
docs = Document.objects.filter_for_list(locale=request.LANGUAGE_CODE,
noparent=True)
paginated_docs = paginate(request, docs, per_page=DOCUMENTS_PER_PAGE)
context = {
'documents': paginated_docs,
'noparent': True,
}
return render(request, 'wiki/list/documents.html', context)
def top_level(request):
"""Lists documents directly under /docs/"""
docs = Document.objects.filter_for_list(locale=request.LANGUAGE_CODE,
toplevel=True)
paginated_docs = paginate(request, docs, per_page=DOCUMENTS_PER_PAGE)
context = {
'documents': paginated_docs,
'toplevel': True,
}
return render(request, 'wiki/list/documents.html', context)
def history(request, pk):
key = get_object_or_404(Key, pk=pk)
if key.user != request.user:
raise PermissionDenied
items = key.history.all().order_by("-pk")
items = paginate(request, items, per_page=ITEMS_PER_PAGE)
context = {
"key": key,
"items": items,
}
return render(request, "authkeys/history.html", context)
def history(request, pk):
key = get_object_or_404(Key, pk=pk)
if key.user != request.user:
raise PermissionDenied
items = key.history.all().order_by('-pk')
items = paginate(request, items, per_page=ITEMS_PER_PAGE)
context = {
'key': key,
'items': items,
}
return render(request, 'authkeys/history.html', context)
def history(request, pk):
key = get_object_or_404(Key, pk=pk)
if key.user != request.user:
raise PermissionDenied
items = key.history.all().order_by('-pk')
items = paginate(request, items, per_page=ITEMS_PER_PAGE)
context = {
'key': key,
'items': items,
}
return render(request, 'authkeys/history.html', context)
def templates(request):
"""
Returns listing of all templates
"""
docs = Document.objects.filter(is_template=True).order_by('title')
paginated_docs = paginate(request, docs, per_page=DOCUMENTS_PER_PAGE)
context = {
'documents': paginated_docs,
'count': docs.count(),
'is_templates': True,
}
return render(request, 'wiki/list/documents.html', context)
def with_errors(request):
"""
Lists wiki documents with (KumaScript) errors
"""
docs = Document.objects.filter_for_list(locale=request.locale, errors=True)
paginated_docs = paginate(request, docs, per_page=DOCUMENTS_PER_PAGE)
context = {
'documents': paginated_docs,
'count': docs.count(),
'errors': True,
}
return render(request, 'wiki/list/documents.html', context)
def with_errors(request):
"""
Lists wiki documents with (KumaScript) errors
"""
docs = Document.objects.filter_for_list(locale=request.LANGUAGE_CODE,
errors=True)
paginated_docs = paginate(request, docs, per_page=DOCUMENTS_PER_PAGE)
context = {
"documents": paginated_docs,
"errors": True,
}
return render(request, "wiki/list/documents.html", context)
def with_errors(request):
"""
Lists wiki documents with (KumaScript) errors
"""
docs = Document.objects.filter_for_list(locale=request.locale, errors=True)
paginated_docs = paginate(request, docs, per_page=DOCUMENTS_PER_PAGE)
context = {
'documents': paginated_docs,
'count': docs.count(),
'errors': True,
}
return render(request, 'wiki/list/documents.html', context)
def templates(request):
"""
Returns listing of all templates
"""
docs = Document.objects.filter(is_template=True).order_by('title')
paginated_docs = paginate(request, docs, per_page=DOCUMENTS_PER_PAGE)
context = {
'documents': paginated_docs,
'count': docs.count(),
'is_templates': True,
}
return render(request, 'wiki/list/documents.html', context)
def needs_review(request, tag=None):
"""
Lists wiki documents with revisions flagged for review
"""
tag_obj = tag and get_object_or_404(ReviewTag, name=tag) or None
docs = Document.objects.filter_for_review(locale=request.locale,
tag=tag_obj)
paginated_docs = paginate(request, docs, per_page=DOCUMENTS_PER_PAGE)
context = {
'documents': paginated_docs,
'count': docs.count(),
'tag': tag_obj,
'tag_name': tag,
}
return render(request, 'wiki/list/needs_review.html', context)
def with_localization_tag(request, tag=None):
"""
Lists wiki documents with localization tag
"""
tag_obj = tag and get_object_or_404(LocalizationTag, name=tag) or None
docs = Document.objects.filter_with_localization_tag(locale=request.locale,
tag=tag_obj)
paginated_docs = paginate(request, docs, per_page=DOCUMENTS_PER_PAGE)
context = {
'documents': paginated_docs,
'count': docs.count(),
'tag': tag_obj,
'tag_name': tag,
}
return render(request, 'wiki/list/with_localization_tags.html', context)
def with_localization_tag(request, tag=None):
"""
Lists wiki documents with localization tag
"""
tag_obj = tag and get_object_or_404(LocalizationTag, name=tag) or None
docs = Document.objects.filter_with_localization_tag(
locale=request.LANGUAGE_CODE, tag=tag_obj)
paginated_docs = paginate(request, docs, per_page=DOCUMENTS_PER_PAGE)
context = {
"documents": paginated_docs,
"count": docs.count(),
"tag": tag_obj,
"tag_name": tag,
}
return render(request, "wiki/list/with_localization_tags.html", context)
def with_localization_tag(request, tag=None):
"""
Lists wiki documents with localization tag
"""
tag_obj = tag and get_object_or_404(LocalizationTag, name=tag) or None
docs = Document.objects.filter_with_localization_tag(
locale=request.LANGUAGE_CODE, tag=tag_obj)
paginated_docs = paginate(request, docs, per_page=DOCUMENTS_PER_PAGE)
context = {
'documents': paginated_docs,
'count': docs.count(),
'tag': tag_obj,
'tag_name': tag,
}
return render(request, 'wiki/list/with_localization_tags.html', context)
def needs_review(request, tag=None):
"""
Lists wiki documents with revisions flagged for review
"""
tag_obj = tag and get_object_or_404(ReviewTag, name=tag) or None
docs = Document.objects.filter_for_review(locale=request.LANGUAGE_CODE,
tag=tag_obj)
paginated_docs = paginate(request, docs, per_page=DOCUMENTS_PER_PAGE)
context = {
'documents': paginated_docs,
'count': docs.count(),
'tag': tag_obj,
'tag_name': tag,
}
return render(request, 'wiki/list/needs_review.html', context)
def needs_review(request, tag=None):
"""
Lists wiki documents with revisions flagged for review
"""
tag_obj = tag and get_object_or_404(ReviewTag, name=tag) or None
docs = Document.objects.filter_for_review(locale=request.LANGUAGE_CODE,
tag=tag_obj)
paginated_docs = paginate(request, docs, per_page=DOCUMENTS_PER_PAGE)
context = {
"documents": paginated_docs,
"count": docs.count(),
"tag": tag_obj,
"tag_name": tag,
}
return render(request, "wiki/list/needs_review.html", context)
def documents(request, tag=None):
"""
List wiki documents depending on the optionally given tag.
"""
# Taggit offers a slug - but use name here, because the slugification
# stinks and is hard to customize.
tag_obj = None
if tag:
matching_tags = get_list_or_404(DocumentTag, name__iexact=tag)
for matching_tag in matching_tags:
if matching_tag.name.lower() == tag.lower():
tag_obj = matching_tag
break
docs = Document.objects.filter_for_list(locale=request.LANGUAGE_CODE,
tag=tag_obj)
paginated_docs = paginate(request, docs, per_page=DOCUMENTS_PER_PAGE)
context = {
'documents': paginated_docs,
'tag': tag,
}
return render(request, 'wiki/list/documents.html', context)
def documents(request, tag=None):
"""
List wiki documents depending on the optionally given tag.
"""
# Taggit offers a slug - but use name here, because the slugification
# stinks and is hard to customize.
tag_obj = None
if tag:
matching_tags = get_list_or_404(DocumentTag, name__iexact=tag)
for matching_tag in matching_tags:
if matching_tag.name.lower() == tag.lower():
tag_obj = matching_tag
break
docs = Document.objects.filter_for_list(locale=request.LANGUAGE_CODE,
tag=tag_obj)
paginated_docs = paginate(request, docs, per_page=DOCUMENTS_PER_PAGE)
context = {
'documents': paginated_docs,
'tag': tag,
}
return render(request, 'wiki/list/documents.html', context)
def revisions(request, document_slug, document_locale):
"""
List all the revisions of a given document.
"""
locale = request.GET.get('locale', document_locale)
document = get_object_or_404(
Document.objects.select_related('current_revision'),
locale=locale,
slug=document_slug)
if document.current_revision is None:
raise Http404
def get_previous(revisions):
for current_revision in revisions:
for previous_revision in revisions:
# we filter out all revisions that are not approved
# as that's the way the get_previous method does it as well
# also let's skip comparing the same revisions
if (not previous_revision.is_approved
or current_revision.pk == previous_revision.pk):
continue
# we stick to the first revision that we find
if previous_revision.created < current_revision.created:
current_revision.previous_revision = previous_revision
break
return revisions
per_page = request.GET.get('limit', 10)
if not request.user.is_authenticated() and per_page == 'all':
return render(request,
'403.html', {'reason': 'revisions_login_required'},
status=403)
# Grab revisions, but defer summary and content because they can lead to
# attempts to cache more than memcached allows.
revisions = MultiQuerySet(
(Revision.objects.filter(
pk=document.current_revision.pk).prefetch_related(
'creator', 'document').transform(get_previous)),
(Revision.objects.filter(document=document).order_by(
'-created',
'-id').exclude(pk=document.current_revision.pk).prefetch_related(
'creator', 'document').transform(get_previous)))
if not revisions.exists():
raise Http404
if per_page == 'all':
page = None
else:
try:
per_page = int(per_page)
except ValueError:
per_page = DOCUMENTS_PER_PAGE
page = paginate(request, revisions, per_page)
revisions = page.object_list
context = {
'revisions': revisions,
'document': document,
'page': page,
}
return render(request, 'wiki/list/revisions.html', context)
def revisions(request):
"""Dashboard for reviewing revisions"""
filter_form = RevisionDashboardForm(request.GET)
page = request.GET.get('page', 1)
revisions = Revision.objects.order_by('-id').defer('content')
query_kwargs = False
exclude_kwargs = False
# We can validate right away because no field is required
if filter_form.is_valid():
query_kwargs = {}
exclude_kwargs = {}
query_kwargs_map = {
'user': '******',
'locale': 'document__locale',
'topic': 'slug__icontains',
}
# Build up a dict of the filter conditions, if any, then apply
# them all in one go.
for fieldname, kwarg in query_kwargs_map.items():
filter_arg = filter_form.cleaned_data[fieldname]
if filter_arg:
query_kwargs[kwarg] = filter_arg
start_date = filter_form.cleaned_data['start_date']
if start_date:
end_date = (filter_form.cleaned_data['end_date'] or
datetime.datetime.now())
query_kwargs['created__range'] = [start_date, end_date]
preceding_period = filter_form.cleaned_data['preceding_period']
if preceding_period:
# these are messy but work with timedelta's seconds format,
# and keep the form and url arguments human readable
if preceding_period == 'month':
seconds = 30 * 24 * 60 * 60
if preceding_period == 'week':
seconds = 7 * 24 * 60 * 60
if preceding_period == 'day':
seconds = 24 * 60 * 60
if preceding_period == 'hour':
seconds = 60 * 60
# use the form date if present, otherwise, offset from now
end_date = (filter_form.cleaned_data['end_date'] or
timezone.now())
start_date = end_date - datetime.timedelta(seconds=seconds)
query_kwargs['created__range'] = [start_date, end_date]
authors_filter = filter_form.cleaned_data['authors']
if ((not filter_form.cleaned_data['user']) and
authors_filter not in ['', str(RevisionDashboardForm.ALL_AUTHORS)]):
# Get the 'Known Authors' group.
try:
group = Group.objects.get(name="Known Authors")
except Group.DoesNotExist:
pass
else:
# If the filter is 'Known Authors', then query for the
# 'Known Authors' group, otherwise the filter is
# 'Unknown Authors', so exclude the 'Known Authors' group.
if authors_filter == str(RevisionDashboardForm.KNOWN_AUTHORS):
query_kwargs['creator__groups__pk'] = group.pk
else:
exclude_kwargs['creator__groups__pk'] = group.pk
if query_kwargs or exclude_kwargs:
revisions = revisions.filter(**query_kwargs).exclude(**exclude_kwargs)
# prefetch_related needs to come after all filters have been applied to qs
revisions = revisions.prefetch_related('creator__bans').prefetch_related(
Prefetch('document', queryset=Document.admin_objects.only(
'deleted', 'locale', 'slug')))
show_spam_submission = (
request.user.is_authenticated() and
request.user.has_perm('wiki.add_revisionakismetsubmission'))
if show_spam_submission:
revisions = revisions.prefetch_related('akismet_submissions')
revisions = paginate(request, revisions, per_page=PAGE_SIZE)
context = {
'revisions': revisions,
'page': page,
'show_ips': (
waffle.switch_is_active('store_revision_ips') and
request.user.is_superuser
),
'show_spam_submission': show_spam_submission,
}
# Serve the response HTML conditionally upon request type
if request.is_ajax():
template = 'dashboards/includes/revision_dashboard_body.html'
else:
template = 'dashboards/revisions.html'
context['form'] = filter_form
return render(request, template, context)
def revisions(request, document_slug, document_locale):
"""
List all the revisions of a given document.
"""
locale = request.GET.get('locale', document_locale)
# Load document with only fields for history display
doc_query = (Document.objects
.only('id', 'locale', 'slug', 'title',
'current_revision_id',
'parent__slug', 'parent__locale')
.select_related('parent__slug', 'parent__locale')
.exclude(current_revision__isnull=True)
.filter(locale=locale, slug=document_slug))
document = get_object_or_404(doc_query)
# Process the requested page size
per_page = request.GET.get('limit', 10)
if not request.user.is_authenticated() and per_page == 'all':
return render(request, '403.html',
{'reason': 'revisions_login_required'}, status=403)
# Get ordered revision IDs
revision_ids = list(document.revisions
.order_by('-created', '-id')
.values_list('id', flat=True))
# Create pairs (this revision, previous revision)
revision_pairs = zip(revision_ids, revision_ids[1:] + [None])
# Paginate the revision pairs, or use all of them
if per_page == 'all':
page = None
selected_revision_pairs = revision_pairs
else:
try:
per_page = int(per_page)
except ValueError:
per_page = DOCUMENTS_PER_PAGE
page = paginate(request, revision_pairs, per_page)
selected_revision_pairs = list(page.object_list)
# Include original English revision of the first translation
earliest_id, earliest_prev_id = selected_revision_pairs[-1]
if earliest_prev_id is None and document.parent:
earliest = Revision.objects.only('based_on').get(id=earliest_id)
if earliest.based_on is not None:
selected_revision_pairs[-1] = (earliest_id, earliest.based_on_id)
selected_revision_pairs.append((earliest.based_on_id, None))
# Gather revisions on this history page, restricted to display fields
selected_revision_ids = [rev_id for rev_id, _ in selected_revision_pairs]
previous_id = selected_revision_pairs[-1][1]
if previous_id is not None:
selected_revision_ids.append(previous_id)
selected_revisions = (Revision.objects
.only('id', 'slug', 'created', 'comment',
'document__slug', 'document__locale',
'creator__username', 'creator__is_active')
.select_related('document__slug',
'document__locale',
'creator__is_active',
'creator__username')
.filter(id__in=selected_revision_ids))
revisions = {rev.id: rev for rev in selected_revisions}
context = {
'selected_revision_pairs': selected_revision_pairs,
'revisions': revisions,
'document': document,
'page': page,
}
return render(request, 'wiki/list/revisions.html', context)
def list_files(request):
"""Returns listing of all files"""
files = paginate(request,
Attachment.objects.order_by('title'),
per_page=DOCUMENTS_PER_PAGE)
return render(request, 'attachments/list_files.html', {'files': files})
def revisions(request):
"""Dashboard for reviewing revisions"""
filter_form = RevisionDashboardForm(request.GET)
page = request.GET.get('page', 1)
revisions = (Revision.objects.select_related('creator')
.order_by('-created')
.defer('content'))
query_kwargs = False
# We can validate right away because no field is required
if filter_form.is_valid():
query_kwargs = {}
query_kwargs_map = {
'user': '******',
'locale': 'document__locale',
'topic': 'slug__icontains',
}
# Build up a dict of the filter conditions, if any, then apply
# them all in one go.
for fieldname, kwarg in query_kwargs_map.items():
filter_arg = filter_form.cleaned_data[fieldname]
if filter_arg:
query_kwargs[kwarg] = filter_arg
start_date = filter_form.cleaned_data['start_date']
if start_date:
end_date = (filter_form.cleaned_data['end_date'] or
datetime.datetime.now())
query_kwargs['created__range'] = [start_date, end_date]
preceding_period = filter_form.cleaned_data['preceding_period']
if preceding_period:
# these are messy but work with timedelta's seconds format,
# and keep the form and url arguments human readable
if preceding_period == 'month':
seconds = 30 * 24 * 60 * 60
if preceding_period == 'week':
seconds = 7 * 24 * 60 * 60
if preceding_period == 'day':
seconds = 24 * 60 * 60
if preceding_period == 'hour':
seconds = 60 * 60
# use the form date if present, otherwise, offset from now
end_date = (filter_form.cleaned_data['end_date'] or
timezone.now())
start_date = end_date - datetime.timedelta(seconds=seconds)
query_kwargs['created__range'] = [start_date, end_date]
if query_kwargs:
revisions = revisions.filter(**query_kwargs)
total = revisions.count()
else:
# If no filters, just do a straight count(). It's the same
# result, but much faster to compute.
total = Revision.objects.count()
# Only bother with this if we're actually going to get
# some revisions from it. Otherwise it's a pointless but
# potentially complex query.
revisions = paginate(request, revisions, per_page=PAGE_SIZE)
context = {'revisions': revisions, 'page': page, 'total': total}
# Serve the response HTML conditionally upon reques type
if request.is_ajax():
template = 'dashboards/includes/revision_dashboard_body.html'
else:
template = 'dashboards/revisions.html'
context['form'] = filter_form
return render(request, template, context)
def revisions(request, document_slug, document_locale):
"""
List all the revisions of a given document.
"""
locale = request.GET.get("locale", document_locale)
# Load document with only fields for history display
doc_query = (Document.objects.only(
"id",
"locale",
"slug",
"title",
"current_revision_id",
"parent__slug",
"parent__locale",
).select_related("parent").exclude(current_revision__isnull=True).filter(
locale=locale, slug=document_slug))
document = get_object_or_404(doc_query)
# Process the requested page size
per_page = request.GET.get("limit", 10)
if not request.user.is_authenticated and per_page == "all":
return render(request,
"403.html", {"reason": "revisions_login_required"},
status=403)
# Get ordered revision IDs
revision_ids = list(
document.revisions.order_by("-created", "-id").values_list("id",
flat=True))
# Create pairs (this revision, previous revision)
revision_pairs = list(zip(revision_ids, revision_ids[1:] + [None]))
# Paginate the revision pairs, or use all of them
if per_page == "all":
page = None
selected_revision_pairs = revision_pairs
else:
try:
per_page = int(per_page)
except ValueError:
per_page = DOCUMENTS_PER_PAGE
page = paginate(request, revision_pairs, per_page)
selected_revision_pairs = list(page.object_list)
# Include original English revision of the first translation
earliest_id, earliest_prev_id = selected_revision_pairs[-1]
if earliest_prev_id is None and document.parent:
earliest = Revision.objects.only("based_on").get(id=earliest_id)
if earliest.based_on is not None:
selected_revision_pairs[-1] = (earliest_id, earliest.based_on_id)
selected_revision_pairs.append((earliest.based_on_id, None))
# Gather revisions on this history page, restricted to display fields
selected_revision_ids = [rev_id for rev_id, _ in selected_revision_pairs]
previous_id = selected_revision_pairs[-1][1]
if previous_id is not None:
selected_revision_ids.append(previous_id)
selected_revisions = (Revision.objects.only(
"id",
"slug",
"created",
"comment",
"document__slug",
"document__locale",
"creator__username",
"creator__is_active",
).select_related("document",
"creator").filter(id__in=selected_revision_ids))
revisions = {rev.id: rev for rev in selected_revisions}
context = {
"selected_revision_pairs": selected_revision_pairs,
"revisions": revisions,
"document": document,
"page": page,
}
return render(request, "wiki/list/revisions.html", context)
def revisions(request):
"""Dashboard for reviewing revisions"""
filter_form = RevisionDashboardForm(request.GET)
page = request.GET.get('page', 1)
revisions = (Revision.objects.prefetch_related(
'creator__bans', 'document',
'akismet_submissions').order_by('-created').defer('content'))
query_kwargs = False
# We can validate right away because no field is required
if filter_form.is_valid():
query_kwargs = {}
query_kwargs_map = {
'user': '******',
'locale': 'document__locale',
'topic': 'slug__icontains',
}
# Build up a dict of the filter conditions, if any, then apply
# them all in one go.
for fieldname, kwarg in query_kwargs_map.items():
filter_arg = filter_form.cleaned_data[fieldname]
if filter_arg:
query_kwargs[kwarg] = filter_arg
start_date = filter_form.cleaned_data['start_date']
if start_date:
end_date = (filter_form.cleaned_data['end_date']
or datetime.datetime.now())
query_kwargs['created__range'] = [start_date, end_date]
preceding_period = filter_form.cleaned_data['preceding_period']
if preceding_period:
# these are messy but work with timedelta's seconds format,
# and keep the form and url arguments human readable
if preceding_period == 'month':
seconds = 30 * 24 * 60 * 60
if preceding_period == 'week':
seconds = 7 * 24 * 60 * 60
if preceding_period == 'day':
seconds = 24 * 60 * 60
if preceding_period == 'hour':
seconds = 60 * 60
# use the form date if present, otherwise, offset from now
end_date = (filter_form.cleaned_data['end_date'] or timezone.now())
start_date = end_date - datetime.timedelta(seconds=seconds)
query_kwargs['created__range'] = [start_date, end_date]
if query_kwargs:
revisions = revisions.filter(**query_kwargs)
revisions = paginate(request, revisions, per_page=PAGE_SIZE)
context = {
'revisions':
revisions,
'page':
page,
'show_ips': (waffle.switch_is_active('store_revision_ips')
and request.user.is_superuser),
'show_spam_submission':
(waffle.flag_is_active(request, SPAM_SUBMISSIONS_FLAG)
and request.user.is_superuser),
}
# Serve the response HTML conditionally upon reques type
if request.is_ajax():
template = 'dashboards/includes/revision_dashboard_body.html'
else:
template = 'dashboards/revisions.html'
context['form'] = filter_form
return render(request, template, context)
def revisions(request, document_slug, document_locale):
"""
List all the revisions of a given document.
"""
locale = request.GET.get('locale', document_locale)
document = get_object_or_404(Document.objects
.select_related('current_revision'),
locale=locale,
slug=document_slug)
if document.current_revision is None:
raise Http404
def get_previous(revisions):
for current_revision in revisions:
for previous_revision in revisions:
# we filter out all revisions that are not approved
# as that's the way the get_previous method does it as well
# also let's skip comparing the same revisions
if (not previous_revision.is_approved or
current_revision.pk == previous_revision.pk):
continue
# we stick to the first revision that we find
if previous_revision.created < current_revision.created:
current_revision.previous_revision = previous_revision
break
return revisions
per_page = request.GET.get('limit', 10)
if not request.user.is_authenticated() and per_page == 'all':
return render(request, '403.html',
{'reason': 'revisions_login_required'}, status=403)
# Grab revisions, but defer summary and content because they can lead to
# attempts to cache more than memcached allows.
revisions = MultiQuerySet(
(Revision.objects.filter(pk=document.current_revision.pk)
.prefetch_related('creator', 'document')
.transform(get_previous)),
(Revision.objects.filter(document=document)
.order_by('-created', '-id')
.exclude(pk=document.current_revision.pk)
.prefetch_related('creator', 'document')
.transform(get_previous))
)
if not revisions.exists():
raise Http404
if per_page == 'all':
page = None
else:
try:
per_page = int(per_page)
except ValueError:
per_page = DOCUMENTS_PER_PAGE
page = paginate(request, revisions, per_page)
revisions = page.object_list
context = {
'revisions': revisions,
'document': document,
'page': page,
}
return render(request, 'wiki/list/revisions.html', context)
def revisions(request, document_slug, document_locale):
"""
List all the revisions of a given document.
"""
locale = request.GET.get('locale', document_locale)
document = get_object_or_404(Document.objects
.select_related('current_revision'),
locale=locale,
slug=document_slug)
if document.current_revision is None:
raise Http404
def get_previous(revisions):
for current_revision in revisions:
for previous_revision in revisions:
# we filter out all revisions that are not approved
# as that's the way the get_previous method does it as well
# also let's skip comparing the same revisions
if (not previous_revision.is_approved or
current_revision.pk == previous_revision.pk):
continue
# we stick to the first revision that we find
if previous_revision.created < current_revision.created:
current_revision.previous_revision = previous_revision
break
return revisions
per_page = request.GET.get('limit', 10)
if not request.user.is_authenticated() and per_page == 'all':
return render(request, '403.html',
{'reason': 'revisions_login_required'}, status=403)
# Grab revisions, but defer summary and content because they can lead to
# attempts to cache more than memcached allows.
all_revisions = (document.revisions.defer('summary', 'content').order_by('created', 'id')
.select_related('creator').reverse().transform(get_previous))
if not all_revisions.exists():
raise Http404
if per_page == 'all':
page = None
all_revisions = list(all_revisions)
else:
try:
per_page = int(per_page)
except ValueError:
per_page = DOCUMENTS_PER_PAGE
page = paginate(request, all_revisions, per_page)
all_revisions = list(page.object_list)
# In order to compare the first revision of a translation, need to insert its parent revision to the list
# The parent revision should stay at last page in order to compare. So insert only if there are no next page or
# all revisions are showing
if (not page or not page.has_next()) and document.parent:
# *all_revisions are in descending order. so call last() in order to get first revision
first_rev_based_on = all_revisions[-1].based_on
# Translation can be orphan so that first revision does not have any english based on. So handle the situation.
if first_rev_based_on:
all_revisions.append(first_rev_based_on)
context = {
'revisions': all_revisions,
'document': document,
'page': page,
}
return render(request, 'wiki/list/revisions.html', context)
def revisions(request):
"""Dashboard for reviewing revisions"""
filter_form = RevisionDashboardForm(request.GET)
page = request.GET.get("page", 1)
revisions = Revision.objects.order_by("-id").defer("content")
query_kwargs = False
exclude_kwargs = False
# We can validate right away because no field is required
if filter_form.is_valid():
query_kwargs = {}
exclude_kwargs = {}
query_kwargs_map = {
"user": "******",
"locale": "document__locale",
"topic": "slug__icontains",
}
# Build up a dict of the filter conditions, if any, then apply
# them all in one go.
for fieldname, kwarg in query_kwargs_map.items():
filter_arg = filter_form.cleaned_data[fieldname]
if filter_arg:
query_kwargs[kwarg] = filter_arg
start_date = filter_form.cleaned_data["start_date"]
if start_date:
end_date = filter_form.cleaned_data[
"end_date"] or datetime.datetime.now()
query_kwargs["created__range"] = [start_date, end_date]
preceding_period = filter_form.cleaned_data["preceding_period"]
if preceding_period:
# these are messy but work with timedelta's seconds format,
# and keep the form and url arguments human readable
if preceding_period == "month":
seconds = 30 * 24 * 60 * 60
if preceding_period == "week":
seconds = 7 * 24 * 60 * 60
if preceding_period == "day":
seconds = 24 * 60 * 60
if preceding_period == "hour":
seconds = 60 * 60
# use the form date if present, otherwise, offset from now
end_date = filter_form.cleaned_data["end_date"] or timezone.now()
start_date = end_date - datetime.timedelta(seconds=seconds)
query_kwargs["created__range"] = [start_date, end_date]
authors_filter = filter_form.cleaned_data["authors"]
if (not filter_form.cleaned_data["user"]) and authors_filter not in [
"",
str(RevisionDashboardForm.ALL_AUTHORS),
]:
# Get the 'Known Authors' group.
try:
group = Group.objects.get(name="Known Authors")
except Group.DoesNotExist:
pass
else:
# If the filter is 'Known Authors', then query for the
# 'Known Authors' group, otherwise the filter is
# 'Unknown Authors', so exclude the 'Known Authors' group.
if authors_filter == str(RevisionDashboardForm.KNOWN_AUTHORS):
query_kwargs["creator__groups__pk"] = group.pk
else:
exclude_kwargs["creator__groups__pk"] = group.pk
if query_kwargs or exclude_kwargs:
revisions = revisions.filter(**query_kwargs).exclude(**exclude_kwargs)
# prefetch_related needs to come after all filters have been applied to qs
revisions = revisions.prefetch_related("creator__bans").prefetch_related(
Prefetch(
"document",
queryset=Document.admin_objects.only("deleted", "locale", "slug"),
))
show_spam_submission = request.user.is_authenticated and request.user.has_perm(
"wiki.add_revisionakismetsubmission")
if show_spam_submission:
revisions = revisions.prefetch_related("akismet_submissions")
revisions = paginate(request, revisions, per_page=PAGE_SIZE)
context = {
"revisions":
revisions,
"page":
page,
"show_ips": (waffle.switch_is_active("store_revision_ips")
and request.user.is_superuser),
"show_spam_submission":
show_spam_submission,
}
# Serve the response HTML conditionally upon request type
if request.is_ajax():
template = "dashboards/includes/revision_dashboard_body.html"
else:
template = "dashboards/revisions.html"
context["form"] = filter_form
return render(request, template, context)
def revisions(request, document_slug, document_locale):
"""
List all the revisions of a given document.
"""
locale = request.GET.get('locale', document_locale)
# Load document with only fields for history display
doc_query = (Document.objects
.only('id', 'locale', 'slug', 'title',
'current_revision_id',
'parent__slug', 'parent__locale')
.select_related('parent__slug', 'parent__locale')
.exclude(current_revision__isnull=True)
.filter(locale=locale, slug=document_slug))
document = get_object_or_404(doc_query)
# Process the requested page size
per_page = request.GET.get('limit', 10)
if not request.user.is_authenticated() and per_page == 'all':
return render(request, '403.html',
{'reason': 'revisions_login_required'}, status=403)
# Get ordered revision IDs
revision_ids = list(document.revisions
.order_by('-created', '-id')
.values_list('id', flat=True))
# Create pairs (this revision, previous revision)
revision_pairs = zip(revision_ids, revision_ids[1:] + [None])
# Paginate the revision pairs, or use all of them
if per_page == 'all':
page = None
selected_revision_pairs = revision_pairs
else:
try:
per_page = int(per_page)
except ValueError:
per_page = DOCUMENTS_PER_PAGE
page = paginate(request, revision_pairs, per_page)
selected_revision_pairs = list(page.object_list)
# Include original English revision of the first translation
earliest_id, earliest_prev_id = selected_revision_pairs[-1]
if earliest_prev_id is None and document.parent:
earliest = Revision.objects.only('based_on').get(id=earliest_id)
if earliest.based_on is not None:
selected_revision_pairs[-1] = (earliest_id, earliest.based_on_id)
selected_revision_pairs.append((earliest.based_on_id, None))
# Gather revisions on this history page, restricted to display fields
selected_revision_ids = [rev_id for rev_id, _ in selected_revision_pairs]
previous_id = selected_revision_pairs[-1][1]
if previous_id is not None:
selected_revision_ids.append(previous_id)
selected_revisions = (Revision.objects
.only('id', 'slug', 'created', 'comment',
'document__slug', 'document__locale',
'creator__username', 'creator__is_active')
.select_related('document__slug',
'document__locale',
'creator__is_active',
'creator__username')
.filter(id__in=selected_revision_ids))
revisions = {rev.id: rev for rev in selected_revisions}
context = {
'selected_revision_pairs': selected_revision_pairs,
'revisions': revisions,
'document': document,
'page': page,
}
return render(request, 'wiki/list/revisions.html', context)
def revisions(request):
"""Dashboard for reviewing revisions"""
filter_form = RevisionDashboardForm(request.GET)
page = request.GET.get('page', 1)
revisions = (Revision.objects.prefetch_related('creator__bans',
'document',
'akismet_submissions')
.order_by('-id')
.defer('content'))
query_kwargs = False
exclude_kwargs = False
# We can validate right away because no field is required
if filter_form.is_valid():
query_kwargs = {}
exclude_kwargs = {}
query_kwargs_map = {
'user': '******',
'locale': 'document__locale',
'topic': 'slug__icontains',
}
# Build up a dict of the filter conditions, if any, then apply
# them all in one go.
for fieldname, kwarg in query_kwargs_map.items():
filter_arg = filter_form.cleaned_data[fieldname]
if filter_arg:
query_kwargs[kwarg] = filter_arg
start_date = filter_form.cleaned_data['start_date']
if start_date:
end_date = (filter_form.cleaned_data['end_date'] or
datetime.datetime.now())
query_kwargs['created__range'] = [start_date, end_date]
preceding_period = filter_form.cleaned_data['preceding_period']
if preceding_period:
# these are messy but work with timedelta's seconds format,
# and keep the form and url arguments human readable
if preceding_period == 'month':
seconds = 30 * 24 * 60 * 60
if preceding_period == 'week':
seconds = 7 * 24 * 60 * 60
if preceding_period == 'day':
seconds = 24 * 60 * 60
if preceding_period == 'hour':
seconds = 60 * 60
# use the form date if present, otherwise, offset from now
end_date = (filter_form.cleaned_data['end_date'] or
timezone.now())
start_date = end_date - datetime.timedelta(seconds=seconds)
query_kwargs['created__range'] = [start_date, end_date]
authors_filter = filter_form.cleaned_data['authors']
if (not filter_form.cleaned_data['user'] != '' and
authors_filter not in ['', str(RevisionDashboardForm.ALL_AUTHORS)]):
# The 'Known Authors' group
group, created = Group.objects.get_or_create(name="Known Authors")
# If the filter is 'Known Authors', then query for the
# 'Known Authors' group
if authors_filter == str(RevisionDashboardForm.KNOWN_AUTHORS):
query_kwargs['creator__groups__pk'] = group.pk
# Else query must be 'Unknown Authors', so exclude the
# 'Known Authors' group
else:
exclude_kwargs['creator__groups__pk'] = group.pk
if query_kwargs or exclude_kwargs:
revisions = revisions.filter(**query_kwargs).exclude(**exclude_kwargs)
revisions = paginate(request, revisions, per_page=PAGE_SIZE)
context = {
'revisions': revisions,
'page': page,
'show_ips': (
waffle.switch_is_active('store_revision_ips') and
request.user.is_superuser
),
'show_spam_submission': (
request.user.is_authenticated() and
request.user.has_perm('wiki.add_revisionakismetsubmission')
),
}
# Serve the response HTML conditionally upon request type
if request.is_ajax():
template = 'dashboards/includes/revision_dashboard_body.html'
else:
template = 'dashboards/revisions.html'
context['form'] = filter_form
return render(request, template, context)
def revisions(request):
"""Dashboard for reviewing revisions"""
filter_form = RevisionDashboardForm(request.GET)
page = request.GET.get('page', 1)
revisions = (Revision.objects.prefetch_related('creator__bans',
'document',
'akismet_submissions')
.order_by('-created')
.defer('content'))
query_kwargs = False
# We can validate right away because no field is required
if filter_form.is_valid():
query_kwargs = {}
query_kwargs_map = {
'user': '******',
'locale': 'document__locale',
'topic': 'slug__icontains',
}
# Build up a dict of the filter conditions, if any, then apply
# them all in one go.
for fieldname, kwarg in query_kwargs_map.items():
filter_arg = filter_form.cleaned_data[fieldname]
if filter_arg:
query_kwargs[kwarg] = filter_arg
start_date = filter_form.cleaned_data['start_date']
if start_date:
end_date = (filter_form.cleaned_data['end_date'] or
datetime.datetime.now())
query_kwargs['created__range'] = [start_date, end_date]
preceding_period = filter_form.cleaned_data['preceding_period']
if preceding_period:
# these are messy but work with timedelta's seconds format,
# and keep the form and url arguments human readable
if preceding_period == 'month':
seconds = 30 * 24 * 60 * 60
if preceding_period == 'week':
seconds = 7 * 24 * 60 * 60
if preceding_period == 'day':
seconds = 24 * 60 * 60
if preceding_period == 'hour':
seconds = 60 * 60
# use the form date if present, otherwise, offset from now
end_date = (filter_form.cleaned_data['end_date'] or
timezone.now())
start_date = end_date - datetime.timedelta(seconds=seconds)
query_kwargs['created__range'] = [start_date, end_date]
if query_kwargs:
revisions = revisions.filter(**query_kwargs)
revisions = paginate(request, revisions, per_page=PAGE_SIZE)
context = {
'revisions': revisions,
'page': page,
'show_ips': (
waffle.switch_is_active('store_revision_ips') and
request.user.is_superuser
),
'show_spam_submission': (
waffle.flag_is_active(request, SPAM_SUBMISSIONS_FLAG) and
request.user.is_superuser
),
}
# Serve the response HTML conditionally upon reques type
if request.is_ajax():
template = 'dashboards/includes/revision_dashboard_body.html'
else:
template = 'dashboards/revisions.html'
context['form'] = filter_form
return render(request, template, context)
def list_files(request):
"""Returns listing of all files"""
files = paginate(request,
Attachment.objects.order_by('title'),
per_page=DOCUMENTS_PER_PAGE)
return render(request, 'attachments/list_files.html', {'files': files})
def revisions(request, document_slug, document_locale):
"""
List all the revisions of a given document.
"""
locale = request.GET.get('locale', document_locale)
document = get_object_or_404(Document.objects
.select_related('current_revision'),
locale=locale,
slug=document_slug)
if document.current_revision is None:
raise Http404
def get_previous(revisions):
for current_revision in revisions:
for previous_revision in revisions:
# we filter out all revisions that are not approved
# as that's the way the get_previous method does it as well
# also let's skip comparing the same revisions
if (not previous_revision.is_approved or
current_revision.pk == previous_revision.pk):
continue
# we stick to the first revision that we find
if previous_revision.created < current_revision.created:
current_revision.previous_revision = previous_revision
break
return revisions
per_page = request.GET.get('limit', 10)
if not request.user.is_authenticated() and per_page == 'all':
return render(request, '403.html',
{'reason': 'revisions_login_required'}, status=403)
# Grab revisions, but defer summary and content because they can lead to
# attempts to cache more than memcached allows.
all_revisions = (document.revisions.defer('summary', 'content').order_by('created', 'id')
.select_related('creator').reverse().transform(get_previous))
if not all_revisions.exists():
raise Http404
if per_page == 'all':
page = None
all_revisions = list(all_revisions)
else:
try:
per_page = int(per_page)
except ValueError:
per_page = DOCUMENTS_PER_PAGE
page = paginate(request, all_revisions, per_page)
all_revisions = list(page.object_list)
# In order to compare the first revision of a translation, need to insert its parent revision to the list
# The parent revision should stay at last page in order to compare. So insert only if there are no next page or
# all revisions are showing
if (not page or not page.has_next()) and document.parent:
# *all_revisions are in descending order. so call last() in order to get first revision
first_rev_based_on = all_revisions[-1].based_on
# Translation can be orphan so that first revision does not have any english based on. So handle the situation.
if first_rev_based_on:
all_revisions.append(first_rev_based_on)
context = {
'revisions': all_revisions,
'document': document,
'page': page,
}
return render(request, 'wiki/list/revisions.html', context)
