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)