def test_form_validation_fail(self, client, root):
""" Only registered templates are allowed """
template_registry.register(self.type, "foo/bar", "foo bar", default=False)
form = self.type.form(parent=root,
data=self.valid_data(template="bar/foo", language="en"))
assert not form.is_valid()
assert 'template' in form.errors
def test_form_validation_language(self, client, root):
""" language is required """
template_registry.register(self.type, "foo/bar", "foo bar", default=False)
data = self.valid_data(template="foo/bar")
form = self.type.form(parent=root, data=data)
assert not form.is_valid()
assert 'language' in form.errors
def test_slug_generate(self, client):
""" test slug generation """
template_registry.register(self.type, "foo/bar", "foo bar", default=False)
p = Node.root()
data = self.valid_data(title="Hello World", template="foo/bar", language="en")
form = self.type.form(parent=p, data=data, files=self.valid_files())
assert form.is_valid()
def test_single(self, client, root):
""" An single template registered """
template_registry.register(self.type, "foo/bar", "foo bar", default=False)
form = self.type.form(parent=root)
assert 'template' in form.fields
assert form.fields['template'].choices == [('foo/bar', 'foo bar')]
model = self.create_instance()
model.save()
assert self.type(model).view_template() == 'foo/bar'
def test_slug_generate_stopwords(self, client):
""" test slug generation """
template_registry.register(self.type, "foo/bar", "foo bar", default=False)
p = Node.root()
data = self.valid_data(title='a world the are', template='foo/bar',
language='en') ## use english stopwords
form = self.type.form(parent=p, data=data, files=self.valid_files())
assert form.is_valid()
assert form.cleaned_data['slug'] == "world"
def test_slug_generate_stopwords_empty_dashes(self, client):
""" test slug generation - only stopwords """
template_registry.register(self.type, "foo/bar", "foo bar", default=False)
p = Node.root()
## use english stopwords
data = self.valid_data(title="are - a - they", template="foo/bar", language="en")
form = self.type.form(parent=p, data=data, files=self.valid_files())
assert form.is_valid()
assert form.cleaned_data['slug']
def test_context(self, client):
""" a context method can be stored in the registry """
def ctx(ins):
return dict(a="1")
template_registry.register(self.type, "foo/bar", "foo bar",
default=False, context=ctx)
context_method = template_registry.context.get((self.type, "foo/bar"))
assert context_method
assert context_method(None) == dict(a="1")
def test_slug_generate_dashes(self, client):
""" test slug generation """
template_registry.register(self.type, "foo/bar", "foo bar", default=False)
p = Node.root()
data = self.valid_data(title='foo -- bar - cccc', template='foo/bar',
language="en")
form = self.type.form(parent=p, data=data, files=self.valid_files())
assert form.is_valid()
assert form.cleaned_data['slug'] == "foo-bar-cccc"
def test_slug_generate_conflict(self, client):
""" slug generation should not create duplicate slugs """
template_registry.register(self.type, "foo/bar", "foo bar", default=False)
p = Node.root()
p.add('foo')
data = self.valid_data(slug="", title="foo", template="foo/bar",
language="en")
form = self.type.form(parent=p, data=data, files=self.valid_files())
assert form.is_valid()
assert form.cleaned_data['slug'] == 'foo1'
def test_slug_exists(self, client):
""" a slug has been chosen that's already in use """
template_registry.register(self.type, "foo/bar", "foo bar", default=False)
p = Node.root()
p.add('foo')
data = self.valid_data(slug="foo", title="t", template="foo/bar", language="en")
form = self.type.form(parent=p, data=data, files=self.valid_files())
assert not form.is_valid()
assert 'slug' in form.errors
assert form.errors['slug'].pop() == 'Name in use' ## fragile
def test_slug_generate_complex(self, client):
""" test slug generation """
template_registry.register(self.type, "foo/bar", "foo bar", default=False)
p = Node.root()
data = self.valid_data(title='Hello World, What\'s up?',
slug='',
template='foo/bar',
language='en')
form = self.type.form(parent=p, data=data, files=self.valid_files())
assert form.is_valid()
assert form.cleaned_data['slug'] == 'hello-world-what-s-up'
def test_slug_generate_reserved(self, client):
""" slug generation should not create reserved names """
template_registry.register(self.type, "foo/bar", "foo bar", default=False)
p = Node.root()
data = self.valid_data(slug='',
title='foo',
template='foo/bar',
language='en')
form = self.type.form(parent=p, data=data, files=self.valid_files(),
reserved=["foo"])
assert form.is_valid()
assert form.cleaned_data['slug'] == 'foo1'
def test_explicit(self, client):
""" unless there's an explicit other selection """
template_registry.register(self.type, "foo/bar", "foo bar", default=False)
template_registry.register(self.type, "foo/bar2", "foo bar", default=True)
template_registry.register(self.type, "foo/bar3", "foo bar", default=False)
model = self.create_instance(template="foo/bar3")
model.save()
assert self.type(model).view_template() == "foo/bar3"
def test_default(self, client):
""" If there's a default, it should be used """
model = self.create_instance()
model.save()
template_registry.register(self.type, "foo/bar", "foo bar", default=False)
template_registry.register(self.type, "foo/bar2", "foo bar", default=True)
template_registry.register(self.type, "foo/bar3", "foo bar", default=False)
assert self.type(model).view_template() == "foo/bar2"
def test_form_validation_success(self, client):
""" In the end it should succeed """
template_registry.register(self.type, "foo/bar", "foo bar", default=False)
template_registry.register(self.type, "foo/bar2", "foo bar", default=True)
template_registry.register(self.type, "foo/bar3", "foo bar", default=False)
p = Node.root()
data = self.valid_data(slug="s", title="t", template="foo/bar3", language="en")
form = self.type.form(parent=p, data=data, files=self.valid_files())
assert form.is_valid()
assert form.cleaned_data['template'] == "foo/bar3"
## have test settings with TESTING=True
captcha = CaptchaField(label=_('Captcha'))
class CommentType(Spoke):
implicit_add = False # can't create through frontend directly
add_to_index = False # do not index in search
discussable = False # well...
model = Comment
form = formfactory(Comment)
title = "A comment"
# type_icon = icon = ..
template_registry.register(CommentType, "wheelcms_comments/comment_view.html", _("Comment View"), default=True)
type_registry.register(CommentType)
class Configuration(models.Model):
main = models.ForeignKey(BaseConfiguration, related_name="comments")
enabled = models.BooleanField(default=True)
notify_address = models.EmailField(blank=True)
class ConfigurationForm(forms.ModelForm):
class Meta:
model = Configuration
exclude = ['main']
configuration_registry.register("comments", "Comments", Configuration, ConfigurationForm)
def frontpage_context(handler, request, node):
## limit to images, visible
language = handler.active_language()
datanode = node.child('data', language=language)
if datanode is None:
return dict(carousel=[])
images = []
pages = []
for n in datanode.children():
content = n.content()
if isinstance(
content,
ImageContent) and content.spoke().workflow().is_visible():
images.append(n)
if isinstance(content,
Page) and content.spoke().workflow().is_visible():
pages.append(n)
return dict(carousel=images, slots=pages)
template_registry.register(PageType,
"wheelcms_carousel/page_carousel_view.html",
"Carousel view",
context=frontpage_context)
from wheelcms_axle.templates import template_registry
from wheelcms_spokes.page import Page, PageType
from wheelcms_axle.content import ImageContent
def frontpage_context(handler, request, node):
## limit to images, visible
language = handler.active_language()
datanode = node.child('data', language=language)
if datanode is None:
return dict(carousel=[])
images = []
pages = []
for n in datanode.children():
content = n.content()
if isinstance(content, ImageContent) and content.spoke().workflow().is_visible():
images.append(n)
if isinstance(content, Page) and content.spoke().workflow().is_visible():
pages.append(n)
return dict(carousel=images, slots=pages)
template_registry.register(PageType, "wheelcms_carousel/page_carousel_view.html",
"Carousel view", context=frontpage_context)
from wheelcms_axle.models import type_registry
from wheelcms_axle.templates import template_registry
from wheelcms_axle.content import FileContent
from wheelcms_axle.spoke import FileSpoke
class File(FileContent):
""" Holds a file """
## cannot be named file - that's used for the content base relation
storage = models.FileField(upload_to="files", blank=False)
## hide filename from form - extract it from uploaded file.
##
## provide list of mimetypes for mimetype, provide detection option
class FileType(FileSpoke):
model = File
title = "A file"
children = ()
type_icon = icon = "file.png"
def detail_template(self):
""" A small detail template, used in browse modal """
return "wheelcms_spokes/file_detail.html"
template_registry.register(FileType, "wheelcms_spokes/file_view.html", "Basic File view", default=True)
type_registry.register(FileType)
from wheelcms_axle.templates import template_registry
from wheelcms_spokes.page import Page, PageType
from wheelcms_axle.content import ImageContent
def frontpage_context(handler, request, node):
## limit to images, visible
datanode = node.child('data')
if datanode is None:
return dict(carousel=[])
return dict(carousel=[n for n in node.child('data').children()
if isinstance(n.content(), ImageContent)
and n.content().spoke().workflow().is_visible()
],
slots=[s for s in node.child('data').children()
if isinstance(s.content(), Page)
and s.content().spoke().workflow().is_visible()
],
)
template_registry.register(PageType, "wheelsite_site/page_frontpage_view.html",
"Frontpage view", context=frontpage_context)
from django.db import models
from wheelcms_axle.content import type_registry, ImageContent
from wheelcms_axle.templates import template_registry
from wheelcms_axle.spoke import FileSpoke
class Image(ImageContent):
""" Holds an image. """
## cannot be named image - that's used for the content base relation
storage = models.ImageField(upload_to="images", blank=False)
class ImageType(FileSpoke):
model = Image
title = "An image"
children = ()
default_language = "any" # images are usually not language specific
type_icon = icon = "image.png"
def detail_template(self):
""" A small detail template, used in browse modal """
return "wheelcms_spokes/image_detail.html"
template_registry.register(ImageType, "wheelcms_spokes/image_view.html", "Basic Image view", default=True)
type_registry.register(ImageType)
class PageIndex(indexfactory(cls)):
description = SpokeCharField(spoke=cls,
stored=True, indexed=False,
model_attr="index_description")
return PageIndex
def context(self, handler, request, node):
ctx = super(PageType, self).context(handler, request, node)
wpm = 180 # avg adult for monitor
# XXX NOTTESTED
ctx['reading_minutes'] = (len(strip_tags(self.instance.body).split())/wpm) + 1
return ctx
def contentlisting_context(handler, request, node):
language = get_active_language()
q = node_proxy_factory(Node, language).objects.children(node).filter(contentbase__language=language).order_by("position")
if not access.has_access(request.user, node):
q = q.public()
return dict(contents=q)
type_registry.register(PageType)
template_registry.register(PageType, "wheelcms_spokes/page_view.html",
"Basic Page view", default=True)
template_registry.register(PageType, "wheelcms_spokes/page_contents.html",
"Contents Listing", default=False,
context=contentlisting_context)
class News(NewsBase):
pass
class NewsForm(formfactory(News)):
body = forms.CharField(widget=TinyMCE(), required=False)
class NewsType(Spoke):
model = News
form = NewsForm
title = "A simple News item"
type_icon = icon = "news.png"
def index_description(self):
""" truncate body text if no explicit description available """
return self.description()
def description(self):
""" truncate body text if no explicit description available """
if self.instance.intro:
return self.instance.intro
if self.instance.description:
return self.instance.description
return Truncator(strip_tags(self.instance.body)).words(50,
truncate=" ...")
template_registry.register(NewsType, "wheelcms_spokes/news_view.html", "Basic News view", default=True)
type_registry.register(NewsType)
ctx = super(ValveBlogType, self).context(handler, request, node)
ctx.update(blog_context(handler, request, node))
return ctx
def feed(self):
## XXX Use content object manager once available
return ValveEntry.objects.filter(
node__tree_path__startswith=self.instance.node.tree_path,
state="published",
language=self.instance.language).order_by("-created")
def global_blog_context(handler, request, node):
ctx = blog_context(handler, request, node)
ctx['all_blogs'] = ValveBlog.objects.filter(state="published")
ctx['global_context'] = True
return ctx
type_registry.register(ValveBlogType)
template_registry.register(ValveBlogType, "wheelcms_valve/valveblog_view.html",
"Blog view", default=True)
type_registry.register(ValveEntryType)
template_registry.register(ValveEntryType, "wheelcms_valve/valveentry_view.html",
"Blog entry view", default=True)
template_registry.register(PageType, "wheelcms_valve/valveblog_view.html",
"Blog view", default=False,
context=global_blog_context)
