def delete(request, site, page_id):
delete_children = request.GET.get('delete_children', False)
active_site = Site.objects.get(id=site)
if not delete_children:
page = Page.on(active_site).get(id=page_id)
new_parent = page.parent
page.reparent_children(new_parent)
# Yes, have to get the page again, or things will get messy
page = Page.on(active_site).get(id=page_id)
page.delete()
return redirect('admin.sites.pages.page.list', active_site.id)
def page(request, slug):
try:
page = Page.on(request.site).get(slug=slug, published=True)
except Page.DoesNotExist:
# This is (as of this writing) the only point of entry to the 404 template.
raise Http404
matched_variant = match_user(request, page)
requested_variant = request.GET.get(variant_key)
if requested_variant is None:
if matched_variant is None:
# No variant requested, and no variant matched. The default, simple view for a page.
default_variant = Variant.objects.get(page=page, segment__isnull=True)
version = Version.objects.get(variant=default_variant, active=True)
return parse_content(request, version)
else:
# No variant requested, but the page has variants and a special one matched.
return redirect("%s?%s=%s" %
(reverse('page.views.page', args=[slug]), variant_key, matched_variant.id))
else:
# A specific variant was requested. Show it regardless of which variant matches the user,
# but do log what actually matched.
requested_variant = Variant.objects.get(id=requested_variant)
version = Version.objects.get(variant=requested_variant, active=True)
# In case the user happens to requests a variant without actually matching any
if matched_variant is None:
matched_segment = None
else:
matched_segment = matched_variant.segment
return parse_content(request, version)
def list(request, site):
active_site = Site.objects.get(id=site)
pages = Page.objects.filter(site=active_site)
root_page = Page.on(active_site).get(level=0)
context = {
'active_site': active_site,
'nodes': pages,
'root_node': root_page,
}
return render(request, 'common/admin/sites/pages/list.html', context)
def url_picker_context(active_site):
article_versions = Version.objects.select_related('variant', 'variant__article').filter(
variant__article__isnull=False,
variant__segment__isnull=True,
variant__article__published=True,
active=True,
variant__article__pub_date__lt=datetime.now(),
variant__article__site=active_site,
).order_by('-variant__article__pub_date')
return {'url_picker': {
'pages': Page.on(active_site).order_by('title'),
'article_versions': article_versions,
'foreninger': Forening.get_all_sorted(),
}}
def edit(request, site, version):
active_site = Site.objects.get(id=site)
root_page = Page.on(active_site).get(level=0)
pages = Page.objects.filter(site=active_site)
version = Version.objects.get(id=version)
is_editing_root_page = root_page.id == version.variant.page.id
context = {
'active_site': active_site,
'version': version,
'widget_data': admin_context(active_site),
'pages': pages,
'root_page': root_page,
'is_editing_root_page': is_editing_root_page,
'image_search_length': settings.IMAGE_SEARCH_LENGTH,
}
context.update(url_picker_context(active_site))
# Fake request.site to the edited site; this will make context processors behave accordingly
request.site = active_site
return render(request, 'common/admin/sites/pages/edit.html', context)
def has_published_front_page(self):
return Page.on(self).filter(
slug='',
published=True,
).exists()
def has_front_page(self):
return Page.on(self).filter(slug='').exists()
def get_page_count(self):
return Page.on(self).filter(
published=True,
).count()
def search(request):
# Very simple search for now
if 'q' not in request.GET:
return render(request, 'common/page/search.html')
search_query = request.GET['q'].strip()
if len(search_query) < SEARCH_CHAR_LIMIT:
context = {
'search_query': search_query,
'query_too_short': True,
'search_char_limit': SEARCH_CHAR_LIMIT,
}
return render(request, 'common/page/search.html', context)
# Record the search
search = Search(query=search_query, site=request.site)
search.save()
pages = Page.on(request.site).filter(
# Match page title or content
Q(variant__version__rows__columns__contents__content__icontains=search_query) |
Q(title__icontains=search_query),
# Default segment, active version, published page
variant__segment=None,
variant__version__active=True,
published=True,
).distinct()
article_versions = Version.objects.filter(
# Match content
variant__version__rows__columns__contents__content__icontains=search_query,
# Active version, default segment, published article
active=True,
variant__segment=None,
variant__article__published=True,
variant__article__pub_date__lt=datetime.now(),
variant__article__site=request.site,
).distinct().order_by('-variant__article__pub_date')
aktivitet_filter = {'search': search_query}
if request.site.forening.id != Forening.DNT_CENTRAL_ID:
aktivitet_filter['organizers'] = '%s:%s' % ('forening', request.site.forening.id)
_, aktivitet_dates = filter_aktivitet_dates(aktivitet_filter)
aktivitet_date_count = aktivitet_dates.count()
if request.site.id == Site.DNT_CENTRAL_ID:
old_articles = OldArticle.objects.filter(
Q(title__icontains=search_query) |
Q(lede__icontains=search_query) |
Q(content__icontains=search_query)
).distinct().order_by('-date')
else:
old_articles = []
context = {
'search_query': search_query,
'article_versions': article_versions,
'pages': pages,
'old_articles': old_articles,
'article_count': len(article_versions) + len(old_articles),
'aktivitet_date_count': aktivitet_date_count,
}
return render(request, 'common/page/search.html', context)
def check_slug(request, site):
active_site = Site.objects.get(id=site)
urls_valid = slug_is_unique(request.POST['slug'])
page_valid = not Page.on(active_site).filter(slug=request.POST['slug']).exists()
return HttpResponse(json.dumps({'valid': urls_valid and page_valid}))
