def test_layout_chain_same_layer_id_on_different_levels(self):
class View(view.View):
def render(self):
return "View: test"
class Layout1(view.Layout):
def render(self, content):
return "<div>%s</div>" % content
class Layout2(view.Layout):
def render(self, content):
return "<html>%s</html>" % content
view.register_layout("", klass=Layout1, context=Context, parent=".")
view.register_layout("", klass=Layout2, context=Root, parent=None)
self._init_ptah()
root = Root()
context1 = Context2(root)
context2 = Context(context1)
renderer = SimpleRenderer()
res = renderer(context2, self.request, viewMapper(View, "render"))
self.assertTrue("<html><div>View: test</div></html>" in res.body)
def test_layout_simple_chain_multi_level(self):
class LayoutTest(view.Layout):
def render(self, content):
return '<div>%s</div>'%content
class LayoutPage(view.Layout):
def render(self, content):
return '<html>%s</html>'%content
view.register_layout('', klass=LayoutPage, context=Root, parent=None)
view.register_layout('test', klass=LayoutTest, parent='.')
self._init_ptah()
root = Root()
context = Context(root)
renderer = LayoutRenderer('test')
res = renderer(context, self.request, 'View: test')
self.assertTrue('<html><div>View: test</div></html>' in res)
layout = query_layout(context, self.request, 'test')
self.assertTrue(isinstance(layout, LayoutTest))
rootlayout = query_layout(context, self.request, '')
self.assertTrue(isinstance(rootlayout, LayoutPage))
rootlayout = query_layout(root, self.request, '')
self.assertTrue(isinstance(rootlayout, LayoutPage))
def test_layout_simple_chain_multi_level(self):
class View(view.View):
def render(self):
return "View: test"
class LayoutTest(view.Layout):
def render(self, content):
return "<div>%s</div>" % content
class LayoutPage(view.Layout):
def render(self, content):
return "<html>%s</html>" % content
view.register_layout("", klass=LayoutPage, context=Root, parent=None)
view.register_layout("test", klass=LayoutTest, parent=".")
self._init_ptah()
root = Root()
context = Context(root)
v = View(context, self.request)
renderer = SimpleRenderer("test")
res = renderer(context, self.request, viewMapper(View, "render"))
self.assertTrue("<html><div>View: test</div></html>" in res.body)
layout = query_layout(self.request, v.context, "test")
self.assertTrue(isinstance(layout, LayoutTest))
rootlayout = query_layout(self.request, context, "")
self.assertTrue(isinstance(rootlayout, LayoutPage))
rootlayout = query_layout(self.request, root, "")
self.assertTrue(isinstance(rootlayout, LayoutPage))
def test_layout_register_custom_class(self):
class MyLayout(view.Layout):
pass
view.register_layout("test", klass=MyLayout)
self._init_ptah()
layout = config.registry.getMultiAdapter((object(), self.request), view.ILayout, "test")
self.assertTrue(isinstance(layout, MyLayout))
def test_layout_register_simple(self):
view.register_layout("test")
self._init_ptah()
layout = config.registry.getMultiAdapter((object(), self.request), view.ILayout, "test")
self.assertEqual(layout.name, "test")
self.assertEqual(layout.__name__, "test")
self.assertTrue(isinstance(layout, Layout))
self.assertTrue(issubclass(layout.__class__, Layout))
self.assertTrue(layout.__class__ is not Layout)
def test_layout_for_route(self):
view.register_route("test-route", "/test/", use_global_views=True)
view.register_layout("test", route="test-route")
self._init_ptah()
layout = query_layout(self.request, Context(), "test")
self.assertIsNone(layout)
request_iface = config.registry.getUtility(IRouteRequest, name="test-route")
interface.directlyProvides(self.request, request_iface)
layout = query_layout(self.request, Context(), "test")
self.assertIsNotNone(layout)
def test_layout_simple_view_without_template(self):
class View(view.View):
def render(self):
return 'test'
view.register_layout('test')
self._init_ptah()
v = View(Context(), self.request)
layout = query_layout(v.context, self.request, 'test')
layout.update()
self.assertTrue('test' == layout.render(v.render()))
def test_layout_for_route(self):
view.register_route('test-route', '/test/', use_global_views=True)
view.register_layout('test', route = 'test-route')
self._init_ptah()
layout = query_layout(Context(), self.request, 'test')
self.assertIsNone(layout)
request_iface = config.registry.getUtility(
IRouteRequest, name='test-route')
interface.directlyProvides(self.request, request_iface)
layout = query_layout(Context(), self.request, 'test')
self.assertIsNotNone(layout)
def test_layout_simple_view_with_template(self):
fn = os.path.join(self.dir, 'test.pt')
tmpl = open(fn, 'wb')
tmpl.write('<html>${content}</html>')
tmpl.close()
view.register_layout('test', template = view.template(fn))
self._init_ptah()
renderer = LayoutRenderer('test')
context = Context()
res = renderer(context, self.request, 'View: test')
self.assertTrue('<html>View: test</html>' in res)
def test_layout_chain_parent_notfound(self):
class Layout(view.Layout):
def render(self, content):
return '<div>%s</div>'%content
view.register_layout('', klass=Layout, context=Context, parent='page')
self._init_ptah()
root = Root()
context = Context(root)
renderer = LayoutRenderer('')
res = renderer(context, self.request, 'View: test')
self.assertTrue('<div>View: test</div>' in res)
def test_view_register_view_layout(self):
class MyLayout(view.Layout):
def render(self, rendered):
return '<html>%s</html>'%rendered
class MyView(view.View):
def render(self):
return 'test'
view.register_view('index.html', MyView, Context)
view.register_layout('', Context, klass=MyLayout)
self._init_ptah()
context = Context()
res = view.render_view('index.html', context, self.request)
self.assertTrue('<html>test</html>' in res.body)
def test_layout_simple_chain_one_level(self):
class LayoutTest(view.Layout):
def render(self,content):
return '<div>%s</div>'%content
class LayoutPage(view.Layout):
def render(self, content):
return '<html>%s</html>'%content
view.register_layout('', klass=LayoutPage, parent=None)
view.register_layout('test', klass=LayoutTest, parent='.')
self._init_ptah()
context = Context()
renderer = LayoutRenderer('test')
res = renderer(context, self.request, 'View: test')
self.assertTrue('<html><div>View: test</div></html>' in res)
def test_layout_chain_parent_notfound(self):
class View(view.View):
def __call__(self):
return "View: test"
class Layout(view.Layout):
def render(self, content):
return "<div>%s</div>" % content
view.register_layout("", klass=Layout, context=Context, parent="page")
self._init_ptah()
root = Root()
context = Context(root)
renderer = SimpleRenderer(layout="")
res = renderer(context, self.request, viewMapper(View))
self.assertTrue("<div>View: test</div>" in res.body)
def test_layout_simple_view_with_template(self):
class View(view.View):
def __call__(self):
return "View: test"
fn = os.path.join(self.dir, "test.pt")
tmpl = open(fn, "wb")
tmpl.write("<html>${content}</html>")
tmpl.close()
view.register_layout("test", template=view.template(fn))
self._init_ptah()
renderer = SimpleRenderer(layout="test")
context = Context()
res = renderer(context, self.request, viewMapper(View))
self.assertTrue("<html>View: test</html>" in res.body)
def test_layout_simple_multilevel(self):
class Layout(view.Layout):
def render(self, content):
return '<html>%s</html>'%content
view.register_layout('', klass=Layout, context=Root)
self._init_ptah()
root = Root()
context = Context(root)
# find layout for view
layout = query_layout(context, self.request, '')
self.assertTrue(isinstance(layout, Layout))
renderer = LayoutRenderer('')
res = renderer(context, self.request, 'View: test')
self.assertTrue('<html>View: test</html>' in res)
def test_renderer_simple_with_layout(self):
class Layout(view.Layout):
def render(self, content):
return '<html>%s</html>'%content
view.register_layout('test', klass=Layout)
self._init_ptah()
def viewFactory(context, request):
return None, 'test'
# renderer layout is different
r = SimpleRenderer('')
res = r(Context(), self.request, viewFactory)
self.assertEqual(res.body, 'test')
# layout is 'test'
r = SimpleRenderer('test')
res = r(Context(), self.request, viewFactory)
self.assertEqual(res.body, '<html>test</html>')
def test_layout_simple_view(self):
class View(view.View):
def __call__(self):
return 'View: test'
class Layout(view.Layout):
def render(self, rendered):
return '<html>%s</html>'%rendered
view.register_layout('test', klass=Layout)
self._init_ptah()
v = View(Context(), self.request)
# find layout for view
layout = query_layout(v.context, self.request, 'test')
self.assertTrue(isinstance(layout, Layout))
layout.update()
self.assertEqual(layout.render(v()),
'<html>View: test</html>')
def test_view_register_view_disable_layout1(self):
class MyLayout(view.Layout):
def render(self, rendered):
return '<html>%s</html>'%rendered
class MyView(view.View):
def render(self):
return 'test'
view.register_view('index.html', MyView, Context, layout=None)
view.register_layout('', Context, klass=MyLayout)
self._init_ptah()
context = Context()
res = view.render_view('index.html', context, self.request)
self.assertEqual(res.body, 'test')
v = MyView(None, self.request)
self.assertEqual(MyLayout(v, self.request).render(
v.render()), '<html>test</html>')
def test_layout_chain_same_layer_id_on_different_levels(self):
class Layout1(view.Layout):
def render(self, content):
return '<div>%s</div>'%content
class Layout2(view.Layout):
def render(self, content):
return '<html>%s</html>'%content
view.register_layout('', klass=Layout1, context=Context, parent='.')
view.register_layout('', klass=Layout2, context=Root, parent=None)
self._init_ptah()
root = Root()
context1 = Context2(root)
context2 = Context(context1)
renderer = LayoutRenderer('')
res = renderer(context2, self.request, 'View: test')
self.assertTrue('<html><div>View: test</div></html>' in res)
def test_renderer_tmpl_with_layout(self):
class Layout(view.Layout):
def render(self, content):
return '<html>%s</html>'%content
view.register_layout('test', klass=Layout)
self._init_ptah()
def viewFactory(context, request):
return None, {}
# renderer layout is different
r = Renderer(view.template('templates/test.pt'), '')
res = r(Context(), self.request, viewFactory)
self.assertEqual(res.body.strip(), '<div>My snippet</div>')
# layout is 'test'
config.cleanup_system()
r = Renderer(view.template('templates/test.pt'), 'test')
res = r(Context(), self.request, viewFactory)
self.assertEqual(''.join(res.body.split()), '<html><div>Mysnippet</div></html>')
def test_layout_simple_context(self):
class View(view.View):
layout = "test"
def render(self):
return "View: test"
class Layout(view.Layout):
def render(self, content):
return "<html>%s</html>" % content
view.register_layout("test", klass=Layout, context=Context)
self._init_ptah()
v = View(Context(), self.request)
# find layout for view
layout = query_layout(self.request, v.context, "test")
self.assertTrue(isinstance(layout, Layout))
layout.update()
self.assertEqual(layout.render(v.render()), "<html>View: test</html>")
def test_layout_simple_chain_one_level(self):
class View(view.View):
def render(self):
return "View: test"
class LayoutTest(view.Layout):
def render(self, content):
return "<div>%s</div>" % content
class LayoutPage(view.Layout):
def render(self, content):
return "<html>%s</html>" % content
view.register_layout("", klass=LayoutPage, parent=None)
view.register_layout("test", klass=LayoutTest, parent=".")
self._init_ptah()
context = Context()
renderer = SimpleRenderer("test")
res = renderer(context, self.request, viewMapper(View, "render"))
self.assertTrue("<html><div>View: test</div></html>" in res.body)
def test_layout_simple_multilevel(self):
class View(view.View):
def __call__(self):
return "View: test"
class Layout(view.Layout):
def render(self, content):
return "<html>%s</html>" % content
view.register_layout("", klass=Layout, context=Root)
self._init_ptah()
root = Root()
context = Context(root)
v = View(context, self.request)
# find layout for view
layout = query_layout(self.request, context, "")
self.assertTrue(isinstance(layout, Layout))
renderer = SimpleRenderer(layout="")
res = renderer(context, self.request, viewMapper(View))
self.assertTrue("<html>View: test</html>" in res.body)
def test_layout_chain_multi_level(self):
class Layout1(view.Layout):
""" """
class Layout2(view.Layout):
""" """
class Layout3(view.Layout):
""" """
class Context1(object):
""" """
class Context2(object):
""" """
class Context3(object):
""" """
view.register_layout('l1', klass=Layout1, context=Context1)
view.register_layout('l1', klass=Layout2, context=Context2, parent='l1')
view.register_layout('l3', klass=Layout3, context=Context3, parent='l1')
self._init_ptah()
root = Root()
context1 = Context1()
context2 = Context2()
context3 = Context3()
context1.__parent__ = root
context2.__parent__ = context1
context3.__parent__ = context2
chain = query_layout_chain(context1, self.request, 'l1')
self.assertEqual(len(chain), 1)
self.assertIsInstance(chain[0], Layout1)
chain = query_layout_chain(context2, self.request, 'l1')
self.assertEqual(len(chain), 2)
self.assertIsInstance(chain[0], Layout2)
self.assertIsInstance(chain[1], Layout1)
chain = query_layout_chain(context3, self.request, 'l3')
self.assertEqual(len(chain), 3)
self.assertIsInstance(chain[0], Layout3)
self.assertIsInstance(chain[1], Layout2)
self.assertIsInstance(chain[2], Layout1)
view.register_route(
'ptah-manage-view','/ptah-manage',
PtahManageRoute, use_global_views=True)
view.register_route(
'ptah-manage','/ptah-manage/*traverse',
PtahManageRoute, use_global_views=True)
view.snippettype('ptah-module-actions', PtahModule)
view.register_snippet(
'ptah-module-actions', PtahModule,
template = view.template('ptah.manage:templates/moduleactions.pt'))
view.register_layout(
'', PtahManageRoute, parent='ptah-manage',
template=view.template("ptah.manage:templates/ptah-layout.pt"))
class LayoutManage(view.Layout):
view.layout('ptah-manage', PtahManageRoute,
template=view.template("ptah.manage:templates/ptah-manage.pt"))
def update(self):
self.user = authService.get_current_principal()
mod = self.request.context
while not isinstance(mod, PtahModule):
mod = getattr(mod, '__parent__', None)
if mod is None: # pragma: no cover
break
import ptah
from ptah import view, cms, manage, authService
from myapp301.app import ApplicationRoot
ptah.cms.uiaction(cms.Content, 'layout-preview', 'Layout preview',
description='view parameter is any registered view name for object',
action='layout-preview.html?view=')
view.register_layout(
'ptah-page', ApplicationRoot, parent='workspace', layer='myapp301',
template = view.template("myapp301:templates/layout-ptahpage.pt"))
class PageLayout(view.Layout):
view.layout('page', ApplicationRoot, layer='myapp301',
template = view.template('templates/layout-page.pt'))
""" override 'page' layout
layer - identifier, import order does matter, last imported wins
"""
def render(self, content, **kwargs):
""" default implementation, just example. in most cases
default implementation is ok. """
if self.template is None:
return content
kwargs.update({'view': self,
'content': content,
'context': self.context,
from ptah import view
from pyramid.httpexceptions import HTTPFound
from pyramid.security import forget, authenticated_userid
import ptah
import ptah.cms
from ploud.utils.policy import POLICIES
from ploud.frontend.config import PLOUD, LAYER
from ploud.frontend.root import PloudApplicationRoot
import config
from models import User
view.register_layout(
'workspace', context=PloudApplicationRoot, parent='page',
template=view.template('ploud.frontend:newui/layout-workspace.pt'))
view.register_layout(
'', ptah.cms.IContent, parent="workspace", layer=LAYER,
template=view.template("ploud.frontend:newui/layout-content.pt"))
class Fake(view.Layout):
view.layout('', PloudApplicationRoot, parent='page', layer=LAYER)
def render(self, content):
return content
class MainLayout(view.Layout):
from zope import interface
from ptah import view, form, config
from pyramid.httpexceptions import HTTPFound, HTTPNotFound
import ptah
from ptah import authService, manage
from ptah import cms
from ptah.cms import tinfo, interfaces, events
from forms import AddForm
from uiactions import list_uiactions
view.register_layout(
'page', cms.ApplicationRoot,
template = view.template("ptah.cmsapp:templates/layoutpage.pt"))
view.register_layout(
'ptah-page', cms.ApplicationRoot, parent='workspace', layer='ptah.cmsapp',
template = view.template("ptah.cmsapp:templates/layout-ptahsecurity.pt"))
class LayoutWorkspace(view.Layout):
view.layout('workspace', cms.ApplicationRoot, parent="page",
template=view.template("ptah.cmsapp:templates/layoutworkspace.pt"))
def update(self):
self.root = getattr(self.request, 'root', None)
self.user = authService.get_current_principal()
self.isAnon = self.user is None
self.ptahManager = manage.get_access_manager()(authService.get_userid())
