def test_mezzanine_form(self):
page = Form.objects.create(slug='my-form')
page.save()
field = Field.objects.create(
form=page,
field_type=3,
required=False)
field.save()
page_middleware = PageMiddleware()
request = test.RequestFactory().post(
'/my-form', data={'field_1': '*****@*****.**'})
request.user = User.objects.get_or_create(pk=1)[0]
SessionMiddleware().process_request(request)
request.session.save()
self.assertEqual(len(mail.outbox), 0,)
page_middleware.process_view(request, mezzanine_page_view, {}, {})
self.assertEqual(len(mail.outbox), 1)
self.assertNotIn('access your downloads', mail.outbox[0].body)
download = Download.objects.create()
download.forms.add(page)
download.save()
page_middleware.process_view(request, mezzanine_page_view, {}, {})
self.assertEqual(len(mail.outbox), 2)
self.assertIn('access your downloads', mail.outbox[1].body)
def page(request, template=u"pages/versionpage.html", extra_context=None):
"""
Select a template for a page and render it. The request
object should have a ``page`` attribute that's added via
``mezzanine.pages.middleware.PageMiddleware``. The page is loaded
earlier via middleware to perform various other functions.
The urlpattern that maps to this view is a catch-all pattern, in
which case the page attribute won't exist, so raise a 404 then.
For template selection, a list of possible templates is built up
based on the current page. This list is order from most granular
match, starting with a custom template for the exact page, then
adding templates based on the page's parent page, that could be
used for sections of a site (eg all children of the parent).
Finally at the broadest level, a template for the page's content
type (it's model class) is checked for, and then if none of these
templates match, the default pages/page.html is used.
"""
from mezzanine.pages.middleware import PageMiddleware
if not PageMiddleware.installed():
raise ImproperlyConfigured("mezzanine.pages.middleware.PageMiddleware "
"(or a subclass of it) is missing from " +
"settings.MIDDLEWARE_CLASSES or " +
"settings.MIDDLEWARE")
return TemplateResponse(request, [template], extra_context or {})
def page(request, slug, template=u"pages/page.html", extra_context=None):
"""
Select a template for a page and render it. The request
object should have a ``page`` attribute that's added via
``mezzanine.pages.middleware.PageMiddleware``. The page is loaded
earlier via middleware to perform various other functions.
The urlpattern that maps to this view is a catch-all pattern, in
which case the page attribute won't exist, so raise a 404 then.
For template selection, a list of possible templates is built up
based on the current page. This list is order from most granular
match, starting with a custom template for the exact page, then
adding templates based on the page's parent page, that could be
used for sections of a site (eg all children of the parent).
Finally at the broadest level, a template for the page's content
type (it's model class) is checked for, and then if none of these
templates match, the default pages/page.html is used.
"""
from mezzanine.pages.middleware import PageMiddleware
if not PageMiddleware.installed():
raise ImproperlyConfigured("mezzanine.pages.middleware.PageMiddleware "
"(or a subclass of it) is missing from " +
"settings.MIDDLEWARE_CLASSES or " +
"settings.MIDDLEWARE")
if not hasattr(request, "page") or request.page.slug != slug:
raise Http404
# Check for a template name matching the page's slug. If the homepage
# is configured as a page instance, the template "pages/index.html" is
# used, since the slug "/" won't match a template name.
template_name = str(slug) if slug != home_slug() else "index"
templates = [u"pages/%s.html" % template_name]
method_template = request.page.get_content_model().get_template_name()
if method_template:
templates.insert(0, method_template)
if request.page.content_model is not None:
templates.append(u"pages/%s/%s.html" %
(template_name, request.page.content_model))
for parent in request.page.get_ascendants(for_user=request.user):
parent_template_name = str(parent.slug)
# Check for a template matching the page's content model.
if request.page.content_model is not None:
templates.append(
u"pages/%s/%s.html" %
(parent_template_name, request.page.content_model))
# Check for a template matching the page's content model.
if request.page.content_model is not None:
templates.append(u"pages/%s.html" % request.page.content_model)
templates.append(template)
if request.is_ajax() or (template != "pages/unifypage.html"
and template != "pages/page.html"):
templates = template
return TemplateResponse(request, templates, extra_context or {})
def page(request, slug, template=u"pages/page.html", extra_context=None):
"""
Select a template for a page and render it. The ``extra_context``
arg will include a ``page`` object that's added via
``mezzanine.pages.middleware.PageMiddleware``. The page is loaded
via the middleware so that other apps with urlpatterns that match
the current page can include a page in their template context.
The urlpattern that maps to this view is a catch-all pattern, in
which case the page instance will be None, so raise a 404 then.
For template selection, a list of possible templates is built up
based on the current page. This list is order from most granular
match, starting with a custom template for the exact page, then
adding templates based on the page's parent page, that could be
used for sections of a site (eg all children of the parent).
Finally at the broadest level, a template for the page's content
type (it's model class) is checked for, and then if none of these
templates match, the default pages/page.html is used.
"""
from mezzanine.pages.middleware import PageMiddleware
if not PageMiddleware.installed():
raise ImproperlyConfigured("mezzanine.pages.middleware.PageMiddleware "
"(or a subclass of it) is missing from " +
"settings.MIDDLEWARE_CLASSES")
extra_context = extra_context or {}
try:
page = extra_context["page"]
except KeyError:
raise Http404
# Check for a template name matching the page's slug. If the homepage
# is configured as a page instance, the template "pages/index.html" is
# used, since the slug "/" won't match a template name.
template_name = str(slug) if slug != home_slug() else "index"
templates = [u"pages/%s.html" % template_name]
method_template = page.get_content_model().get_template_name()
if method_template:
templates.insert(0, method_template)
if page.content_model is not None:
templates.append(u"pages/%s/%s.html" % (template_name,
page.content_model))
for parent in page.get_ascendants(for_user=request.user):
parent_template_name = str(parent.slug)
# Check for a template matching the page's content model.
if page.content_model is not None:
templates.append(u"pages/%s/%s.html" % (parent_template_name,
page.content_model))
# Check for a template matching the page's content model.
if page.content_model is not None:
templates.append(u"pages/%s.html" % page.content_model)
templates.append(template)
return render(request, templates, extra_context)
def test_mezzanine_form(self):
page = Form.objects.create(slug='my-form')
page.save()
field = Field.objects.create(form=page, field_type=3, required=False)
field.save()
page_middleware = PageMiddleware()
request = test.RequestFactory().post(
'/my-form', data={'field_1': '*****@*****.**'})
request.user = User.objects.get_or_create(pk=1)[0]
SessionMiddleware().process_request(request)
request.session.save()
self.assertEqual(
len(mail.outbox),
0,
)
page_middleware.process_view(request, mezzanine_page_view, {}, {})
self.assertEqual(len(mail.outbox), 1)
self.assertNotIn('access your downloads', mail.outbox[0].body)
download = Download.objects.create()
download.forms.add(page)
download.save()
page_middleware.process_view(request, mezzanine_page_view, {}, {})
self.assertEqual(len(mail.outbox), 2)
self.assertIn('access your downloads', mail.outbox[1].body)
def test_exact_page_processor_for(self):
"""
Test that passing exact_page=True works with the PageMiddleware
"""
from mezzanine.pages.middleware import PageMiddleware
from mezzanine.pages.page_processors import processor_for
from mezzanine.pages.views import page as page_view
@processor_for('foo/bar', exact_page=True)
def test_page_processor(request, page):
return HttpResponse("bar")
foo, _ = RichTextPage.objects.get_or_create(title="foo")
bar, _ = RichTextPage.objects.get_or_create(title="bar", parent=foo)
request = self._request_factory.get('/foo/bar/')
request.user = self._user
response = PageMiddleware().process_view(request, page_view, [], {})
self.assertTrue(isinstance(response, HttpResponse))
self.assertContains(response, "bar")
def page(request, slug, template="pages/page.html", extra_context=None):
"""
Select a template for a page and render it. The request
object should have a ``page`` attribute that's added via
``mezzanine.pages.middleware.PageMiddleware``. The page is loaded
earlier via middleware to perform various other functions.
The urlpattern that maps to this view is a catch-all pattern, in
which case the page attribute won't exist, so raise a 404 then.
For template selection, a list of possible templates is built up
based on the current page. This list is order from most granular
match, starting with a custom template for the exact page, then
adding templates based on the page's parent page, that could be
used for sections of a site (eg all children of the parent).
Finally at the broadest level, a template for the page's content
type (it's model class) is checked for, and then if none of these
templates match, the default pages/page.html is used.
"""
from mezzanine.pages.middleware import PageMiddleware
if not PageMiddleware.installed():
raise ImproperlyConfigured(
"mezzanine.pages.middleware.PageMiddleware "
"(or a subclass of it) is missing from " + "settings.MIDDLEWARE_CLASSES"
)
if not hasattr(request, "page") or request.page.slug != slug:
raise Http404
# Check for a template name matching the page's slug. If the homepage
# is configured as a page instance, the template "pages/index.html" is
# used, since the slug "/" won't match a template name.
template_name = str(slug) if slug != home_slug() else "index"
templates = ["pages/%s.html" % template_name]
method_template = request.page.get_content_model().get_template_name()
if method_template:
templates.insert(0, method_template)
if request.page.content_model is not None:
templates.append("pages/%s/%s.html" % (template_name, request.page.content_model))
for parent in request.page.get_ascendants(for_user=request.user):
parent_template_name = str(parent.slug)
# Check for a template matching the page's content model.
if request.page.content_model is not None:
templates.append("pages/%s/%s.html" % (parent_template_name, request.page.content_model))
# Check for a template matching the page's content model.
if request.page.content_model is not None:
templates.append("pages/%s.html" % request.page.content_model)
templates.append(template)
# added by RobinWang
ss = slug.split("/")
if len(ss) == 1:
categorys = BlogCategory.objects.all()
categoryslug = ""
for c in categorys:
if c.slug == ss[0]:
categoryslug = ss[0]
break
if categoryslug != "":
blogs = getposts(request, category=categoryslug)
extra_context["blog_posts"] = blogs
return render(request, templates, extra_context or {})
def page(request, slug, template=u"pages/page.html", extra_context=None):
"""
Select a template for a page and render it. The request
object should have a ``page`` attribute that's added via
``mezzanine.pages.middleware.PageMiddleware``. The page is loaded
earlier via middleware to perform various other functions.
The urlpattern that maps to this view is a catch-all pattern, in
which case the page attribute won't exist, so raise a 404 then.
For template selection, a list of possible templates is built up
based on the current page. This list is order from most granular
match, starting with a custom template for the exact page, then
adding templates based on the page's parent page, that could be
used for sections of a site (eg all children of the parent).
Finally at the broadest level, a template for the page's content
type (it's model class) is checked for, and then if none of these
templates match, the default pages/page.html is used.
"""
from mezzanine.pages.middleware import PageMiddleware
if not PageMiddleware.installed():
raise ImproperlyConfigured("mezzanine.pages.middleware.PageMiddleware "
"(or a subclass of it) is missing from " +
"settings.MIDDLEWARE_CLASSES")
obj=None
if not hasattr(request, "page") or request.page.slug != slug:
split=slug.split('/')
article=split.pop(-1)
obj=get_object_or_404(Article,slug=article)
if obj:
slug="/".join(split)+"/detail"
# Check for a template name matching the page's slug. If the homepage
# is configured as a page instance, the template "pages/index.html" is
# used, since the slug "/" won't match a template name.
template_name = str(slug) if slug != home_slug() else "index"
templates = [u"pages/%s.html" % template_name]
if obj:
templates.append("pages/detail.html")
obj.prepare_content(request)
return TemplateResponse(request, templates, {'article':obj})
method_template = request.page.get_content_model().get_template_name()
if method_template:
templates.insert(0, method_template)
if request.page.content_model is not None:
templates.append(u"pages/%s/%s.html" % (template_name,
request.page.content_model))
for parent in request.page.get_ascendants(for_user=request.user):
parent_template_name = str(parent.slug)
# Check for a template matching the page's content model.
if request.page.content_model is not None:
templates.append(u"pages/%s/%s.html" % (parent_template_name,
request.page.content_model))
# Check for a template matching the page's content model.
if request.page.content_model is not None:
templates.append(u"pages/%s.html" % request.page.content_model)
templates.append(template)
return TemplateResponse(request, templates, extra_context or {})
