def rend(self, context, data):
defaults = context.locate(iformless.IFormDefaults)
value = defaults.getDefault(context.key, context)
context.remember(data.typedValue, iformless.ITyped)
if data.typedValue.getAttribute('immutable'):
inp = tags.span(id=keyToXMLID(context.key))[value]
else:
##value may be a deferred; make sure to wait on it properly before calling self.input
## TODO: If flattening this results in an empty string, return an empty string
inp = tags.invisible(render=lambda c, value: self.input(
context, tags.invisible(), data, data.name, value),
data=value)
if data.typedValue.getAttribute(
'hidden') or data.typedValue.getAttribute('compact'):
return inp
context.fillSlots('label', data.label)
context.fillSlots('name', data.name)
context.fillSlots('input', inp)
context.fillSlots('error', getError(context))
context.fillSlots('description', data.description)
context.fillSlots('id', keyToXMLID(context.key))
context.fillSlots('value', value)
return context.tag
def rend(self, context, data):
defaults = context.locate(iformless.IFormDefaults)
value = defaults.getDefault(context.key, context)
context.remember(data.typedValue, iformless.ITyped)
if data.typedValue.getAttribute('immutable'):
inp = tags.span(id=keyToXMLID(context.key))[value]
else:
##value may be a deferred; make sure to wait on it properly before calling self.input
## TODO: If flattening this results in an empty string, return an empty string
inp = tags.invisible(
render=lambda c, value: self.input( context, tags.invisible(), data, data.name, value ),
data=value)
if data.typedValue.getAttribute('hidden') or data.typedValue.getAttribute('compact'):
return inp
context.fillSlots( 'label', data.label )
context.fillSlots( 'name', data.name )
context.fillSlots( 'input', inp )
context.fillSlots( 'error', getError(context) )
context.fillSlots( 'description', data.description )
context.fillSlots( 'id', keyToXMLID(context.key) )
context.fillSlots( 'value', value )
return context.tag
def gotIPs(self, ips):
self.ips = [x[0] for x in ips]
if not self.ips:
fragment = T.span[
"I cannot find any IP associated to this MAC address"]
elif len(self.ips) == 1:
fragment = T.span[
"This MAC address is associated with IP ",
T.invisible(data=self.ips[0], render=T.directive("ip")), "."]
else:
fragment = T.span[
"This MAC address is associated with the following IPs: ",
T.ul[[
T.li[T.invisible(data=ip, render=T.directive("ip")), " "]
for ip in self.ips
]]]
fragment = FragmentMixIn(self.dbpool,
docFactory=loaders.stan(fragment))
results = [fragment]
results.append(SearchMacInInterfaces(self.dbpool, self.mac))
for ip in self.ips:
results.append(SearchIPInEquipment(self.dbpool, ip))
results.append(SearchIPInSonmp(self.dbpool, ip))
results.append(SearchIPInLldp(self.dbpool, ip))
results.append(SearchIPInCdp(self.dbpool, ip))
results.append(SearchMacInFdb(self.dbpool, self.mac))
return results
class Progressbar(livepage.LivePage):
addSlash = True
progress = {
'bar1': 0,
'bar2': 20,
'bar3': 30,
'bar4': 50,
}
def data_bar1(self, ctx, data):
return {'name': 'bar1'}
def data_bar2(self, ctx, data):
return {'name': 'bar2', 'percent': self.progress['bar2']}
def data_bar3(self, ctx, data):
return {'name': 'bar3', 'percent': self.progress['bar3']}
def data_bar4(self, ctx, data):
return {'name': 'bar4', 'percent': self.progress['bar4']}
def goingLive(self, ctx, client):
self.progress = self.progress.copy()
def handle_click(self, ctx, value):
def send():
if self.progress[value] >= 100:
t.stop()
else:
self.progress[value] += 1
livepage.IClientHandle(ctx).send(component[value].setPercent(
str(self.progress[value])))
t = task.LoopingCall(send)
t.start(1)
docFactory = loaders.stan(t.html[t.head[
t.title["ProgressBar Example"], livepage.glue,
componentGlue.inlineGlue, progressBarGlue.inlineGlue, ], t.body[
t.invisible(data=t.directive('bar1'), render=progressBar),
t.p[t.a(href="",
onclick=
[livepage.server.handle('click', 'bar1'), livepage.
stop])['Start meter']],
t.invisible(data=t.directive('bar2'), render=progressBar),
t.p[t.a(href="",
onclick=
[livepage.server.handle('click', 'bar2'), livepage.
stop])['Start meter']],
t.invisible(data=t.directive('bar3'), render=progressBar),
t.p[t.a(href="",
onclick=
[livepage.server.handle('click', 'bar3'), livepage.
stop])['Start meter']],
t.invisible(data=t.directive('bar4'), render=progressBar),
t.p[t.a(href="",
onclick=
[livepage.server.handle('click', 'bar4'), livepage.
stop])['Start meter']], ]])
class Uploader(formrender.Form):
"""A renderer allowing for updates to individual records using file upload.
This renderer exposes a form with a file widget. It is likely that
the interface will change.
"""
name = "upload"
def render_uploadInfo(self, ctx, data):
if data is None:
return T.invisible()
else:
for key, val in data.original.getPrimaryTable().rows[0].iteritems():
ctx.tag.fillSlots(key, str(val))
return ctx.tag
docFactory = loaders.stan(T.html[
T.head[
T.title["Upload"],
T.invisible(render=T.directive("commonhead")),
],
T.body(render=T.directive("withsidebar"))[
T.h1(render=T.directive("meta"))["title"],
T.p(class_="procMessage", data=T.directive("result"),
render=T.directive("uploadInfo"))[
T.slot(name="nAffected"),
" record(s) modified."
],
T.invisible(render=T.directive("form genForm"))
]
])
class Page(rend.Page):
db = None
def __init__(self, db, *a, **kw):
rend.Page.__init__(self, *a, **kw)
self.db = db
def childFactory(self, ctx, seg):
if seg == "Wizard":
return ConfWiz.Page()
else:
return rend.Page.childFactory(self, ctx, seg)
addSlash = True
child_css = static.File(Settings.BaseDir + '/css/')
child_scripts = static.File(Settings.BaseDir + '/scripts/')
child_images = static.File(Settings.BaseDir + '/images/')
child_php = static.File('/var/www/localhost/htdocs/')
def render_content(self, ctx, data):
if self.db[0] == "FIRSTRUN":
return ctx.tag[tags.table(
height="100%", width="100%"
)[tags.tr(height="100%")[tags.td[tags.div(
id="centerBox", valign="middle"
)[tags.div(id="blockTop")
[""],
tags
.div(id="centerBlock")[tags.h1(
style="color:#fff;font-family:arial;"
)["TUMS Installation Wizard"]],
tags
.div(id="menuBlock")[tags.div(
style=
"margin-top:-5em; text-align:left; font-family:arial; color:#786D38;"
)[tags.h3["Welcome to the TUMS installation wizard."],
"""This wizard will guide you through an initial configuration of the host system.
This should be carried out by a Thusa employee. If your server has arrived unconfigured it
is recommended that you contact Thusa support for this to be carried out.
""", tags.br,
"""Click the NEXT button bellow to continue with the installation""",
tags.br, tags.br,
tags.a(href="Wizard/1/")[tags.img(
src='/images/next.png')]]]]]]]]
return ctx.tag[tags.a(href="/auth/")["Login"]]
def render_head(self, ctx, data):
if self.db[0] == "FIRSTRUN":
return ctx.tag[tags.link(rel="stylesheet",
type="text/css",
href="/css/login.css")]
return ctx.tag[tags.xml(
'<meta http-equiv="refresh" content="0;url=auth/"/>')]
docFactory = loaders.stan(
tags.html[tags.head[tags.title["TUMS"],
tags.invisible(render=tags.directive('head'))],
tags.body[tags.invisible(render=tags.directive('content'))]])
def render(self, data):
return [("%s / Host" % self.discovery_name,
T.invisible(data=data[0][2],
render=T.directive("hostname")), data[0][2]),
("%s / IP" % self.discovery_name,
T.invisible(data=data[0][0],
render=T.directive("ip")), data[0][0]),
("%s / Description" % self.discovery_name, data[0][1], None),
("%s / Port" % self.discovery_name, data[0][3], None)]
def test_basic(self):
top = context.WovenContext()
middle = context.WovenContext(top, tags.invisible())
bottom = context.WovenContext(middle, tags.invisible())
top.remember(0, IStuff)
self.assertEquals(bottom.locate(IStuff), 0)
middle.remember(1, IStuff)
self.assertEquals(bottom.locate(IStuff), 1)
self.assertEquals(bottom.locate(IStuff, depth=2), 0)
def test_basic(self):
top = context.WovenContext()
middle = context.WovenContext(top, tags.invisible())
bottom = context.WovenContext(middle, tags.invisible())
top.remember(0, IStuff)
self.assertEquals(bottom.locate(IStuff), 0)
middle.remember(1, IStuff)
self.assertEquals(bottom.locate(IStuff), 1)
self.assertEquals(bottom.locate(IStuff, depth=2), 0)
def test_deferredRememberInRenderer(self):
class IFoo(compy.Interface):
pass
def rememberIt(ctx, data):
ctx.remember("bar", IFoo)
return defer.succeed(ctx.tag)
def locateIt(ctx, data):
return IFoo(ctx)
tag = tags.invisible(render=rememberIt)[tags.invisible(render=locateIt)]
self.assertEquals(self.render(tag), "bar")
def _render(self, ctx, key, args, errors, value, tag):
def data_facets(ctx, data):
storeSession = util.getStoreSession(ctx)
avatar = util.getAvatar(ctx)
@defer.deferredGenerator
def loadCategories(facets):
d = defer.waitForDeferred(avatar.getCategoryManager(storeSession))
yield d
categories = d.getResult()
rv = []
for f in facets:
facetData = FacetData()
facetData.label = f[2]
facetData.textid = f[1]
rv.append(facetData)
d = defer.waitForDeferred(categories.loadCategories(facetData.textid))
yield d
facetData.tree = d.getResult().children
yield rv
d = avatar.getCategoryManager(storeSession)
d.addCallback(lambda categories: categories.loadFacets())
d.addCallback(loadCategories)
return d
def render_facet(ctx, data):
tag = ctx.tag
tag.fillSlots("facetlabel", data.label)
return tag
def render_node(ctx, data):
tag = ctx.tag
tag.fillSlots("value", data.path)
tag.fillSlots("label", data.label)
if data.path in value:
tag.children[0] = tag.children[0](checked="checked")
else:
tag.children[0](checked=None)
return tag
template = T.div(class_="categorieswidget")[
T.p(class_="opener")["click to open/close"],
T.ul(class_="panel", data=data_facets, render=rend.sequence)[
T.li(pattern="item", render=render_facet)[
T.slot("facetlabel"),
T.div(data=T.directive("tree"), render=tree.render)[
T.invisible(pattern="item", render=render_node)[tag, T.slot("label")]
],
]
],
]
return T.invisible()[template]
def render_macif(self, ctx, data):
if not data:
return ctx.tag["I did not find this MAC on any interface."]
return ctx.tag["This MAC was found on the following interfaces: ",
T.ul [ [ T.li[
T.invisible(data=l[0],
render=T.directive("hostname")),
" (", T.invisible(data=l[1],
render=T.directive("ip")), ") "
"interface ", T.span(_class="data") [ l[2] ] ]
for l in data] ] ]
def test_deferredRememberInRenderer(self):
class IFoo(Interface):
pass
def rememberIt(ctx, data):
ctx.remember("bar", IFoo)
return defer.succeed(ctx.tag)
def locateIt(ctx, data):
return IFoo(ctx)
tag = tags.invisible(render=rememberIt)[tags.invisible(render=locateIt)]
self.render(tag, wantDeferred=True).addCallback(
lambda result: self.assertEquals(result, "bar"))
def render_macif(self, ctx, data):
if not data:
return ctx.tag["I did not find this MAC on any interface."]
return ctx.tag[
"This MAC was found on the following interfaces: ", T.ul[[
T.li[T.invisible(data=l[0], render=T.directive("hostname")),
" (",
T.invisible(data=l[1], render=T.directive("ip")), ") "
"interface ",
T.span(_class="data")[l[2]]] for l in data
]]]
def test_deferredRememberInRenderer(self):
class IFoo(Interface):
pass
def rememberIt(ctx, data):
ctx.remember("bar", IFoo)
return defer.succeed(ctx.tag)
def locateIt(ctx, data):
return IFoo(ctx)
tag = tags.invisible(render=rememberIt)[tags.invisible(render=locateIt)]
self.render(tag, wantDeferred=True).addCallback(
lambda result: self.assertEqual(result, "bar"))
def render_macfdb(self, ctx, data):
if not data:
return ctx.tag["I did not find this MAC on any FDB entry."]
return ctx.tag["This MAC was found in FDB of the following equipments: ",
T.ul [ [ T.li[
T.invisible(data=l[0],
render=T.directive("hostname")),
" (", T.invisible(data=l[1],
render=T.directive("ip")), ") "
"on port ", T.span(_class="data") [ l[2] ],
" (out of %d MAC address%s)" % (l[4], l[4]>1 and "es" or "") ]
for l in data] ] ]
def render(self, data):
return [("%s / Host" % self.discovery_name,
T.invisible(data=data[0][2],
render=T.directive("hostname")),
data[0][2]),
("%s / IP" % self.discovery_name,
T.invisible(data=data[0][0],
render=T.directive("ip")),
data[0][0]),
("%s / Description" % self.discovery_name,
data[0][1], None),
("%s / Port" % self.discovery_name,
data[0][3], None)]
def render_macfdb(self, ctx, data):
if not data:
return ctx.tag["I did not find this MAC on any FDB entry."]
return ctx.tag[
"This MAC was found in FDB of the following equipments: ", T.ul[[
T.li[T.invisible(data=l[0], render=T.directive("hostname")),
" (",
T.invisible(data=l[1], render=T.directive("ip")), ") "
"on port ",
T.span(_class="data")[l[2]],
" (out of %d MAC address%s)" %
(l[4], l[4] > 1 and "es" or "")] for l in data
]]]
class MyPage(rend.Page):
addSlash = True
docFactory = loaders.stan(
tags.html[
tags.head[tags.title["Hi Boy"]],
tags.body[
tags.invisible(render=tags.directive("isLogged"))[
tags.div(pattern="False")[
tags.form(action=guard.LOGIN_AVATAR, method='post')[
tags.table[
tags.tr[
tags.td[ "Username:"******"Password:"******"True")[
tags.h3["Hi bro"],
tags.invisible(render=tags.directive("sessionId")),
tags.br,
tags.a(href=guard.LOGOUT_AVATAR)["Logout"]
]
]
]
])
def __init__(self, avatarId=None):
rend.Page.__init__(self)
self.avatarId=avatarId
def render_isLogged(self, context, data):
q = inevow.IQ(context)
true_pattern = q.onePattern('True')
false_pattern = q.onePattern('False')
if self.avatarId: return true_pattern or context.tag().clear()
else: return false_pattern or context.tag().clear()
def render_sessionId(self, context, data):
sess = inevow.ISession(context)
return context.tag[sess.uid]
def logout(self):
print("Bye")
def test_deferredRememberInRenderer(self):
class IFoo(compy.Interface):
pass
def rememberIt(ctx, data):
ctx.remember("bar", IFoo)
return defer.succeed(ctx.tag)
def locateIt(ctx, data):
return IFoo(ctx)
tag = tags.invisible(render=rememberIt)[tags.invisible(
render=locateIt)]
self.assertEquals(self.render(tag), "bar")
class Page(rend.Page):
db = None
def __init__(self, db, *a, **kw):
rend.Page.__init__(self, *a, **kw)
self.db = db
addSlash = True
child_css = compression.CompressingResourceWrapper(
static.File(Settings.BaseDir + '/css/'))
child_scripts = compression.CompressingResourceWrapper(
static.File(Settings.BaseDir + '/scripts/'))
child_images = compression.CompressingResourceWrapper(
static.File(Settings.BaseDir + '/images/'))
child_sandbox = compression.CompressingResourceWrapper(
static.File(Settings.BaseDir + '/sandbox/'))
child_php = static.File('/var/www/localhost/htdocs/')
child_packs = static.File(Settings.BaseDir + '/packages/')
child_updates = static.File('/var/lib/samba/updates/')
child_chart = chartResource()
child_myvulani = Portal()
child_files = compression.CompressingResourceWrapper(
static.File(Settings.BaseDir + '/files/'))
child_portal = PortalRedirector()
child_topology = PageHelpers.Topology()
def childFactory(self, ctx, seg):
if seg == "favicon.ico":
return static.File(Settings.BaseDir + '/images/favicon.ico')
if seg == "whoami":
return ThebeName(self.db[-1])
if seg == 'snom':
return Snom.Page(self.db)
if seg == 'vRecordings':
if os.path.exists('/var/lib/samba/data/vRecordings'):
return static.File('/var/lib/samba/data/vRecordings/')
return rend.Page.childFactory(self, ctx, seg)
def render_content(self, ctx, data):
return ctx.tag[tags.a(href="/auth/")["Login"]]
def render_head(self, ctx, data):
return ctx.tag[tags.xml(
'<meta http-equiv="refresh" content="0;url=auth/"/>')]
docFactory = loaders.stan(
tags.html[tags.head[tags.title["Vulani"],
tags.invisible(render=tags.directive('head'))],
tags.body[tags.invisible(render=tags.directive('content'))]])
def render_content(self, ctx, data):
return ctx.tag[
PageHelpers.TabSwitcher(
(('Configuration', 'panelConf'), ('Mapping', 'panelMap'),
('Computers', 'panelComp'))),
tags.div(id="panelConf", _class="tabPane")[
tags.h3[tags.img(src="/images/sharefold.png"),
" Domain configuration"],
tags.directive('form configSamba')],
tags.div(id="panelMap", _class="tabPane")[tags.invisible(
render=tags.directive('drives'))],
tags.div(id="panelComp", _class="tabPane")[tags.invisible(
render=tags.directive('computers'))],
PageHelpers.LoadTabSwitcher()]
def render(self, ctx, key, args, errors):
if errors:
value = args.get(key,[None])[0]
else:
if args is not None:
value = iforms.IStringConvertible(self.original).fromType(args.get(key))
def render_node(ctx, data):
tag = ctx.tag
data = self.nodeInterface(data)
tag.fillSlots('value',data.value)
tag.fillSlots('label',data.label)
if str(data.value) == str(value):
tag = tag(checked='checked')
return tag
template = T.div()[
T.input(pattern='item', render=render_node, type='radio', name=key,
value=T.slot('value'))[
T.slot('label')
],
T.input(pattern='itemdisabled', render=render_node,
disabled="disabled", type='radio', name=key,
value=T.slot('value'))[
T.slot('label')
]
]
return T.invisible(data=self.tree, render=tree.render)[template]
class TestSuiteFragment(athena.LiveFragment):
jsClass = u'Nevow.Athena.Test.TestSuite'
docFactory = loaders.stan(tags.invisible(render=tags.directive('tests')))
def __init__(self, suite):
super(TestSuiteFragment, self).__init__()
self.suite = suite
self.testInstances = suite.gatherInstances()
def gatherTests(self, testInstances):
suiteTag = tags.div()
for test in testInstances:
if isinstance(test, list):
suiteTag[self.gatherTests(testInstances)]
else:
test.setFragmentParent(self)
suiteTag[test]
return suiteTag
def gatherHead(self):
head = []
def gather(testInstances):
for test in testInstances:
if isinstance(test, list):
head.extend(gather(test))
else:
head.append(test.head())
gather(self.testInstances)
return filter(None, head)
def render_tests(self, ctx, data):
return ctx.tag[self.gatherTests(self.testInstances)]
def render(self, data):
r = []
i = 0
notpresent = T.td(_class="notpresent")[
T.acronym(title="Unable to get IP from ARP tables")["N/A"]]
for row in data:
mac = T.td[T.span(data=row[0], render=T.directive("mac"))]
if row[1] is not None:
r.append(T.tr(_class=(i%2) and "odd" or "even")
[mac, T.td[T.invisible(data=row[1],
render=T.directive("ip"))]])
else:
r.append(T.tr(_class=(i%2) and "odd" or "even")
[mac, notpresent])
i += 1
if len(r) == 1:
return [('FDB',
[T.span(data=data[0][0], render=T.directive("mac")),
data[0][1] and [", ", T.span(data=data[0][1],
render=T.directive("ip"))] or ""],
1)]
return [('FDB',
[len(r) == 20 and "20+" or len(r),
T.span(render=T.directive("tooltip"),
data=T.table(_class="mac")[
T.thead[T.td["MAC"], T.td["IP"]], r])],
len(r) == 20 and 21 or len(r))]
def _renderTag(self, ctx, key, value, converter, disabled):
def renderOption(ctx, itemKey, itemLabel, num, selected):
cssid = render_cssid(key, num)
tag = T.input(name=key, type='radio', id=cssid, value=itemKey)
if selected:
tag = tag(checked='checked')
if disabled:
tag = tag(disabled='disabled')
return tag, ' ', T.label(for_=cssid)[itemLabel], T.br
def renderOptions(ctx, data):
# A counter to assign unique ids to each input
idCounter = itertools.count()
if self.noneOption is not None:
itemKey = iformal.IKey(self.noneOption).key()
itemLabel = iformal.ILabel(self.noneOption).label()
yield renderOption(ctx, itemKey, itemLabel, idCounter.next(), itemKey==value)
if not data:
return
for item in data:
itemKey = iformal.IKey(item).key()
itemLabel = iformal.ILabel(item).label()
itemKey = converter.fromType(itemKey)
yield renderOption(ctx, itemKey, itemLabel, idCounter.next(), itemKey==value)
return T.invisible(data=self.options)[renderOptions]
def _dataRows(self, items, count):
# Find the patterns
dataRow = self._patterns.patternGenerator('dataRow')
dataCell = self._patterns.patternGenerator('dataCell')
emptyDataRow = self._patterns.patternGenerator('emptyDataRow')
# Return an empty data row if there are no results
if not items:
return emptyDataRow()
# Create a tag to hold the rows
rowsTag = tags.invisible()
for item in items:
item = itabular.IItem(item)
rowTag = dataRow()
rowsTag[rowTag]
for col in self.columns:
cellTag = col.rend(self._patterns, item)
# cellTag = dataCell()
# cellTag.fillSlots('value',
# item.getAttributeValue(col.attribute))
rowTag[cellTag]
return rowsTag
def generateBindings():
for name in bindingNames:
bnd = configurable.getBinding(context, name)
renderer = iformless.IBindingRenderer(bnd, defaultBindingRenderer)
renderer.isGrouped = True
renderer.needsSkin = True
yield tags.invisible(data=bnd, render=renderer, key=name)
def _renderTag(self, ctx, key, value, converter, disabled):
def renderOption(ctx, itemKey, itemLabel, num, selected):
cssid = render_cssid(key, num)
tag = T.input(name=key, type='radio', id=cssid, value=itemKey)
if selected:
tag = tag(checked='checked')
if disabled:
tag = tag(disabled='disabled')
return tag, ' ', T.label(for_=cssid)[itemLabel], T.br
def renderOptions(ctx, data):
# A counter to assign unique ids to each input
idCounter = itertools.count()
if self.noneOption is not None:
itemKey = iformal.IKey(self.noneOption).key()
itemLabel = iformal.ILabel(self.noneOption).label()
yield renderOption(ctx, itemKey, itemLabel, idCounter.next(),
itemKey == value)
if not data:
return
for item in data:
itemKey = iformal.IKey(item).key()
itemLabel = iformal.ILabel(item).label()
itemKey = converter.fromType(itemKey)
yield renderOption(ctx, itemKey, itemLabel, idCounter.next(),
itemKey == value)
return T.invisible(data=self.options)[renderOptions]
class TestFramework(athena.LivePage):
addSlash = True
docFactory = loaders.stan([
tags.xml(DOCTYPE_XHTML),
tags.html[
tags.head(render=tags.directive('liveglue'))[
tags.link(rel='stylesheet', href='livetest.css'),
tags.directive('head')],
tags.body[
tags.invisible(render=tags.directive('runner'))]]])
def __init__(self, testSuite):
super(TestFramework, self).__init__()
self.testSuite = testSuite
self.children = {
'livetest.css': static.File(util.resource_filename('nevow.livetrial', 'livetest.css')),
}
def beforeRender(self, ctx):
self.runner = TestRunner(self.testSuite)
def render_runner(self, ctx, data):
self.runner.setFragmentParent(self)
return self.runner
def render_head(self, ctx, data):
return self.runner.gatherHead()
def rend(self, context, data):
context.remember(data, iformless.IBinding)
context.remember(data.typedValue, iformless.ITyped)
typedRenderer = iformless.ITypedRenderer(data.typedValue,
defaultBindingRenderer)
if typedRenderer.complexType:
return tags.invisible(data=data, render=typedRenderer)
if self.needsSkin or not context.tag.children:
self.calculateDefaultSkin(context)
if self.isGrouped or data.typedValue.getAttribute('immutable'):
subm = ''
else:
subm = tags.input(type="submit", name="change", value="Change")
self.fillForm(context, data)
context.fillSlots('form-label', '')
context.fillSlots('form-description', '')
try:
content_pattern = context.tag.patternGenerator('binding')
except NodeNotFound:
content_pattern = freeformDefaultContentPattern
context.fillSlots(
'form-arguments',
content_pattern(data=data, render=typedRenderer, key=data.name))
context.fillSlots('form-button', subm)
return context.tag
def _getRenderViewScroller(self):
"""
Get a L{hyperbola_view.ShareScrollingElement} by way of
L{hyperbola_view.BlogBlurbViewer.view}.
"""
fragment = hyperbola_view.BlogBlurbViewer(self.publicBlogShare)
return fragment.view(FakeRequest(), tags.invisible())
def _renderTag(self, ctx, tparser, tvalue, namer, readonly):
tag = T.invisible()
if len(self.parsers) > 1:
tp = T.select(name=namer('tparser'),
id=render_cssid(namer('tparser')))
if readonly:
tp(class_='disabled', disabled='disabled')
for k, v in self.parsers:
if k == tparser:
tp[T.option(selected='selected', value=k)[v]]
else:
tp[T.option(value=k)[v]]
else:
tp = T.input(type='hidden',
name=namer('tparser'),
id=render_cssid(namer('tparser')),
value=self.parsers[0][0])
ta = T.textarea(name=namer('tvalue'),
id=render_cssid(namer('tvalue')),
cols=self.cols,
rows=self.rows)[tvalue or '']
if readonly:
ta(class_='readonly', readonly='readonly')
tag[tp, T.br, ta]
return tag
def returnMailLog(mail):
if self.offset > 0:
previousTag = tags.a(
href=url.root.child("Mail").child(self.offset -
20))["Previous 20"]
else:
previousTag = "Previous 20"
return ctx.tag[
#tags.div(id="rightBlockIFrame")[
tags.h3[tags.img(src="/images/maillog.png"),
" Mail Logs"], previousTag,
tags.a(href=url.root.child("Mail").child(self.offset +
20))["Next 20"],
tags.br,
tags.table(cellspacing=0, _class='listing')[tags.thead(
background="/images/gradMB.png")[tags.tr[
tags.th["Date"], tags.th["From"], tags.th["To"],
tags.th["Size"], tags.th["Message ID"]]], tags.tbody[[
tags.tr[tags.td[time.ctime(m[2])], tags.td[m[5]],
tags.td[m[18]],
tags.td["%0.3f KB" %
(float(m[11]) / 1024.0)],
tags.td[m[1]]] for m in mail
]]], tags.br, previousTag,
tags.a(href=url.root.child("Mail").child(self.offset +
20))["Next 20"],
tags.br, tags.h3["Search Logs"],
tags.invisible(render=tags.directive('form searchForm'))]
def _renderTag(self, ctx, tparser, tvalue, namer, readonly):
tag=T.invisible()
if len(self.parsers) > 1:
tp = T.select(name=namer('tparser'),id=render_cssid(namer('tparser')))
if readonly:
tp(class_='disabled', disabled='disabled')
for k,v in self.parsers:
if k == tparser:
tp[T.option(selected='selected',value=k)[ v ]]
else:
tp[T.option(value=k)[ v ]]
else:
tp = T.input(type='hidden',name=namer('tparser'),id=render_cssid(namer('tparser')),value=self.parsers[0][0])
tag[tp]
if self.itemTypes is not None:
tag[ T.input(type='hidden',class_="itemTypes",name=namer('itemTypes'),id=render_cssid(namer('itemTypes')),value=encodeTypes(self.itemTypes)) ]
if self.itemTemplates is not None:
tag[ T.input(type='hidden',class_="itemTemplates",name=namer('itemTemplates'),id=render_cssid(namer('itemTemplates')),value=','.join(self.itemTemplates)) ]
ta=T.textarea(name=namer('tvalue'), id=render_cssid(namer('tvalue')), cols=self.cols, rows=self.rows)[tvalue or '']
if readonly:
ta(class_='readonly', readonly='readonly')
tag[ [T.br,ta ]]
return tag
def render(self, data):
return [("SONMP / IP",
T.invisible(data=data[0][0],
render=T.directive("ip")),
data[0][0]),
("SONMP / Port",
data[0][1], None)]
class Page(rend.Page):
addSlash = True
child_css = static.File('./css/')
child_scripts = static.File('./scripts/')
child_images = static.File('./images/')
docFactory = loaders.stan(
tags.html[tags.head[
tags.title["Tabbed Page Example"],
tags.link(rel="stylesheet",
href="css/folder-tree-static.css",
type="text/css"),
tags.
script(type="text/javascript", src="scripts/folder-tree-static.js"
)['']],
tags.body[tags.invisible(render=tags.directive('tree'))]])
def render_tree(self, c, d):
Tr = Tree.Tree("r", "Domains")
l = Tree.retrieveTree("127.0.0.1", "cn=Manager", "wsthusa",
"o=TRYPTOPHAN")
flatL = Tree.flattenTree(l, 'o=TRYPTOPHAN')
for node in flatL:
Tree.addPath(node, Tr)
return Tree.StanTree(Tr)
def test_dataContextCreation(self):
data = {'foo': 'oof', 'bar': 'rab'}
doc = tags.p(data=data)[tags.slot('foo'), tags.slot('bar')]
doc.fillSlots('foo',
tags.invisible(data=tags.directive('foo'), render=str))
doc.fillSlots('bar', lambda ctx, data: data['bar'])
self.assertEquals(flat.flatten(doc), '<p>oofrab</p>')
def render_content(self, ctx, data):
return ctx.tag[
tags.h3[tags.img(src="/images/networking_section.png"), " Mail Diagnostics"],
tags.div[
tags.invisible(render=tags.directive('thisFragment'))
]
]
def test_deferredFromNestedFunc(self):
def outer(ctx, data):
def inner(ctx, data):
return defer.succeed(tags.p['Hello'])
return inner
self.render(tags.invisible(render=outer), wantDeferred=True).addCallback(
lambda result: self.assertEquals(result, '<p>Hello</p>'))
def _renderTag(self, ctx, key, value, readonly):
tag = T.invisible()
ta = T.textarea(name=key, id=render_cssid(key), cols=self.cols, rows=self.rows)[value or ""]
if readonly:
ta(class_="readonly", readonly="readonly")
tag[ta]
if not readonly:
try:
import docutils
except ImportError:
raise
else:
form = iformal.IForm(ctx)
srcId = render_cssid(key)
previewDiv = render_cssid(key, "preview-div")
frameId = render_cssid(key, "preview-frame")
targetURL = widgetResourceURLFromContext(ctx, form.name).child(key).child(srcId)
tag[T.br()]
onclick = ["return Forms.Util.previewShow('", previewDiv, "', '", frameId, "', '", targetURL, "');"]
tag[T.button(onclick=onclick)["Preview ..."]]
tag[
T.div(id=previewDiv, class_="preview-hidden")[
T.iframe(class_="preview-frame", name=frameId, id=frameId),
T.br(),
T.button(onclick=["return Forms.Util.previewHide('", previewDiv, "');"])["Close"],
]
]
return tag
def _renderReSTTag(self, ctx, content, key, readonly):
namer = self._namer(key)
tag=T.invisible()
ta=T.textarea(name=namer('content'), id=formal_keytocssid(namer('content')), cols=self.cols, rows=self.rows)[content or '']
if readonly:
ta(class_='readonly', readonly='readonly')
tag[ta]
if not readonly:
try:
import docutils
except ImportError:
raise
else:
form = iformal.IForm( ctx )
srcId = formal_keytocssid(namer('content'))
previewDiv = srcId + '-preview-div'
frameId = srcId + '-preview-frame'
targetURL = formal_widgetResourceURLFromContext(ctx, form.name).child(key).child( srcId )
tag[T.br()]
tag[T.button(onClick="return Forms.Util.previewShow('%s', '%s', '%s');"%(previewDiv, frameId, targetURL))['Preview ...']]
if self.withImagePicker:
tag[T.button(onclick=["return Cms.Forms.ImagePicker.popup('",srcId,"','tag')"])['Choose image ...']]
tag[T.div(id=previewDiv, class_="preview-hidden")[
T.iframe(class_="preview-frame", name=frameId, id=frameId),
T.br(),
T.button(onClick=["return Forms.Util.previewHide('",previewDiv,"');"])['Close']
]
]
return tag
class authorizedResource(rend.Page):
def render_root(self, ctx, data):
req = inevow.IRequest(ctx)
host = req.client.host
# Pull out our config - requests to here should be minimised to reduce disk thrash
sysconf = confparse.Config()
authority = sysconf.General.get('infoserv', {}).get('authorized', [])
bsvr = [] # branch server container
for k in sysconf.Mail.get('branches', []):
if isinstance(k, list):
bsvr.append(k[0])
else:
bsvr.append(k)
authority.extend(bsvr)
if host in authority:
return ctx.tag[self.allowed(host)]
else:
return ctx.tag[self.denied(host)]
def allowed(self, host):
return "Not implemented"
def denied(self, host):
return "Access Denied"
docFactory = loaders.stan(tags.invisible(render=tags.directive('root')))
def test_deferredFromNestedFunc(self):
def outer(ctx, data):
def inner(ctx, data):
return defer.succeed(tags.p['Hello'])
return inner
self.render(tags.invisible(render=outer), wantDeferred=True).addCallback(
lambda result: self.assertEqual(result, '<p>Hello</p>'))
def render_content(self, ctx, data):
""" Function is deffered to make less blocking on system calls"""
if not self.avatarId.isAdmin:
return ctx.tag[""]
# Fetch running profile
thisProfile = Utils.currentProfile()
runningProfile = Utils.runningProfile()[0]
if thisProfile[0] != runningProfile:
thisProfile = [
thisProfile[0], " [",
tags.a(href=url.root.child("Profiles").child("switch").child(
thisProfile[1]))["Activate"]
], "]"
else:
thisProfile = thisProfile[0]
return ctx.tag[tags.table(
width="100%",
cellspacing="10")[tags.tr[tags.td(colspan=2)[tags.div(
id="ProfileBlock")[tags.div(_class="roundedBlock")[
tags.h1["Profile"],
tags.div(id="123")["Current profile: ", thisProfile,
tags.br, "Running profile: ",
runningProfile, tags.br,
tags.directive('form selectProfile'),
tags.a(href=url.root.child("Profiles")
)["Manage Profiles"]]], ], ]],
tags.tr[tags.invisible(
render=tags.directive('thisFragment'))]]]
def render_head(self, ctx, data):
"""
Put liveglue content into the header of this page to activate it, but
otherwise delegate to my parent's renderer for <head>.
"""
ctx.tag[tags.invisible(render=tags.directive('liveglue'))]
return _PublicPageMixin.render_head(self, ctx, data)
def render_uploadInfo(self, ctx, data): if data is None: return T.invisible() else: for key, val in data.original.getPrimaryTable().rows[0].iteritems(): ctx.tag.fillSlots(key, str(val)) return ctx.tag
class NewEntry(BaseUI):
implements(IInsert)
docFactory = loaders.stan(
t.html[
t.head[
t.title['Insertion form'],
t.link(rel='stylesheet', type='text/css', href=url.root.child('webform_css')),
],
t.body[
t.h1['Insertion'],
t.invisible(render=t.directive("forms"))
]
])
def render_forms(self, ctx, data):
d = iformless.IFormDefaults(ctx).getAllDefaults('insert')
d['author'] = 'Anonymous'
d['id'] = IBlog(IStore(ctx)).getNextId()
return webform.renderForms()
def insert(self, ctx, id, title, author, category, content):
newPost = Post(store=IStore(ctx),
id=int(id),
author=unicode(author),
title=unicode(title),
category=unicode(category),
content=unicode(content))
IBlog(IStore(ctx)).addNewPost(newPost)
inevow.IRequest(ctx).setComponent(iformless.IRedirectAfterPost, '/thx')
def makeContext(self, *args):
ctx = context.WovenContext()
ctx.remember(convertToData(self.remember, ctx), inevow.IData)
for a in args:
ctx = context.WovenContext(ctx, invisible())
ctx.remember(convertToData(a, ctx), inevow.IData)
return ctx
def render(self, data):
r = []
i = 0
notpresent = T.td(_class="notpresent")[T.acronym(
title="Unable to get IP from ARP tables")["N/A"]]
for row in data:
mac = T.td[T.span(data=row[0], render=T.directive("mac"))]
if row[1] is not None:
r.append(
T.tr(_class=(i % 2) and "odd" or "even")
[mac,
T.td[T.invisible(data=row[1], render=T.directive("ip"))]])
else:
r.append(
T.tr(_class=(i % 2) and "odd" or "even")[mac, notpresent])
i += 1
if len(r) == 1:
return [('FDB', [
T.span(data=data[0][0],
render=T.directive("mac")), data[0][1] and
[", ", T.span(data=data[0][1], render=T.directive("ip"))] or ""
], 1)]
return [('FDB', [
len(r) == 20 and "20+" or len(r),
T.span(render=T.directive("tooltip"),
data=T.table(_class="mac")[T.thead[T.td["MAC"], T.td["IP"]],
r])
], len(r) == 20 and 21 or len(r))]
def makeContext(self, *args):
ctx = context.WovenContext()
ctx.remember(convertToData(self.remember, ctx), inevow.IData)
for a in args:
ctx = context.WovenContext(ctx, invisible())
ctx.remember(convertToData(a, ctx), inevow.IData)
return ctx
def rend(self, context, data):
context.remember(data, iformless.IBinding)
context.remember(data.typedValue, iformless.ITyped)
typedRenderer = iformless.ITypedRenderer(data.typedValue, defaultBindingRenderer)
if typedRenderer.complexType:
return tags.invisible(data=data, render=typedRenderer)
if self.needsSkin or not context.tag.children:
self.calculateDefaultSkin(context)
if self.isGrouped or data.typedValue.getAttribute('immutable'):
subm = ''
else:
subm = tags.input(type="submit", name="change", value="Change")
self.fillForm(context, data)
context.fillSlots( 'form-label', '' )
context.fillSlots( 'form-description', '' )
try:
content_pattern = context.tag.patternGenerator( 'binding' )
except NodeNotFound:
content_pattern = freeformDefaultContentPattern
context.fillSlots(
'form-arguments',
content_pattern(
data=data, render=typedRenderer, key=data.name))
context.fillSlots('form-button', subm)
return context.tag
def render(self, data):
return [("EDP / Host",
T.invisible(data=data[0][0],
render=T.directive("hostname")),
data[0][0]),
("EDP / Port",
"%d/%d" % (data[0][1], data[0][2]),
data[0][1]*1000 + data[0][2])]
def _renderActions(self, ctx, data):
if self.original.actions is None:
yield ''
return
for action in self.original.actions:
yield T.invisible(data=action, render=self._renderAction)
def renderHTTP(self, ctx):
self.setup()
#ensure that we are delivered with the correct content type header
inevow.IRequest(ctx).setHeader("Content-Type",
"application/vnd.mozilla.xul+xml; charset=%s" % (self.charset,))
#Do something a bit magical.. glue css/js stuff into the window before
#any other widgets so they get read first.
if self.css is not None:
self.window.children.insert(0,
htmlns.style(type="text/css")[self.css])
self.css = None
for css in self.cssIncludes:
self.window.children.insert(0,
htmlns.style(type="text/css", src=css))
self.cssIncludes = []
if self.js is not None:
self.window.children.insert(0,
htmlns.script(type="text/javascript")[self.js])
self.js = None
for js in self.jsIncludes:
self.window.children.insert(0,
htmlns.script(type="text/javascript", src=js))
self.jsIncludes = []
#We want to have javascript included in this order:
# preLiveglue.js
# liveglue.js
# postLiveglue.ps
if not self.glueInstalled:
self.window.children.insert(0, htmlns.script(
type="text/javascript", src=url.here.child(
'javascript').child('postLiveglue.js')))
self.window.children.insert(0, T.invisible(
render=T.directive('liveglue')))
self.window.children.insert(0, htmlns.script(
type="text/javascript", src=url.here.child(
'javascript').child('preLiveglue.js')))
self.glueInstalled = True
#.. end magical
#make sure our XUL tree is loaded and our correct doc type is set
self.docFactory = loaders.stan([
T.xml("""<?xml version="1.0"?><?xml-stylesheet href="chrome://global/skin/" type="text/css"?>"""),
self.window])
#return our XUL
return athena.LivePage.renderHTTP(self, ctx)
def test_leaky(self):
def foo(ctx, data):
ctx.tag.fillSlots('bar', tags.invisible(data="two"))
return ctx.tag
result = self.render(
tags.div(render=foo, data="one")[
tags.slot("bar"),
tags.invisible(render=str)])
self.assertEquals(result, '<div>one</div>')
def test_synchronousFlattenError(self):
"""
If the old flattener encounters an exception while flattening an
L{IRenderable}, the exception is raised to the caller of the flattener
API.
"""
element = Element()
element.docFactory = stan(invisible(render=directive('foo')))
self.assertRaises(FlattenerError, synchronousFlatten, element)
def test_slotAttributeEscapingWhenPrecompiled(self):
def render_searchResults(ctx, remoteCursor):
ctx.fillSlots('old-query', '"meow"')
return ctx.tag
tag = tags.invisible(render=render_searchResults)[
tags.input(value=tags.slot('old-query')),
]
precompiled = self.render(tag, precompile=True)
self.assertEquals(self.render(precompiled), '<input value=""meow"" />')
def render(self, data):
return [
('LLDP (remote) / Host',
T.invisible(data=data[0][0],
render=T.directive("hostname")),
data[0][0]),
('LLDP (remote) / Port',
data[0][1], None)
]
def render_skin(ctx, data):
content = inevow.IQ(ctx.tag).onePattern('skincontent')
gather = tags.invisible()
d = deferflatten(content, ctx, gather.__getitem__)
def gotContent(s):
self.content = gather
return skin
d.addCallback(gotContent)
return d
