Skip to content

Z
Zope
Commit 15888ee6 authored by Amos Latteier's avatar Amos Latteier
Browse files
Options

Added DTML Reference.

parent 2fa35322
Show whitespace changes
Inline Side-by-side
Showing with 1265 additions and 1 deletion
lib/python/HelpSys/HelpSys.py
View file @ 15888ee6
......@@ -301,13 +301,18 @@ class ProductHelp(Acquisition.Implicit, ObjectManager, Item, Persistent):
"""
topics=[]
apitopics=[]
dtmltopics=[]
for topic in self.objectValues('Help Topic'):
if hasattr(topic,'isAPIHelpTopic') and topic.isAPIHelpTopic:
apitopics.append(topic)
elif topic.getId()[:5]=='dtml-':
dtmltopics.append(topic)
else:
topics.append(topic)
if dtmltopics:
topics = topics + [TreeCollection(' DTML Reference', dtmltopics)]
if apitopics:
topics = topics + [TreeCollection('API Documentation', apitopics)]
topics = topics + [TreeCollection(' API Reference', apitopics)]
return topics
def all_meta_types(self):
......
lib/python/Products/OFSP/help/dtml-call.stx 0 → 100644
View file @ 15888ee6
call: Call a method
The 'call' tag lets you call a method without inserting the results
into the DTML output.
Syntax
'call' tag syntax::
<dtml-call Variable|expr="Expression">
If the call tag uses a variable, the methods arguments are passed
automatically by DTML just as with the 'var' tag. If the method is
specified in a expression, then you must pass the arguments yourself.
Examples
Calling by variable name::
<dtml-call UpdateInfo>
This calls the 'UpdateInfo' object automatically passing arguments.
Calling by expression::
<dtml-call expr="RESPONSE.setHeader('content-type', 'text/plain')">
See Also
"var tag":dtml-var.stx
lib/python/Products/OFSP/help/dtml-comment.stx 0 → 100644
View file @ 15888ee6
comment: Comments DTML
The comment tag lets you document your DTML with comments. You can
also use it to temporarily disable DTML tags by commenting them
out.
Syntax
'comment' tag syntax::
<dtml-comment>
</dtml-comment>
The 'comment' tag is a block tag. The contents of the block are
not executed, nor are they inserted into the DTML output.
Examples
Documenting DTML::
<dtml-comment>
This content is not executed and does not appear in the
output.
</dtml-comment>
Commenting out DTML::
<dtml-comment>
This DTML is disabled and will not be executed.
<dtml-call someMethod>
</dtml-comment>
lib/python/Products/OFSP/help/dtml-if.stx 0 → 100644
View file @ 15888ee6
if: Tests Conditions
The 'if' tags allows you to test conditions and to take different
actions depending on the conditions. The 'if' tag mirrors Python's
'if/elif/else' condition testing statements.
Syntax
If tag syntax::
<dtml-if ConditionVariable|expr="ConditionExpression">
[<dtml-elif ConditionVariable|expr="ConditionExpression">]
...
[<dtml-else>]
</dtml-if>
The 'if' tag is a block tag. The 'if' tag and optional 'elif' tags
take a condition variable name or a condition expression, but not
both. If the condition name or expression evaluates to true then
the 'if' block is executed. True means not zero, an empty string
or an empty list. If the condition variable is not found then the
condition is considered false.
If the initial condition is false, each 'elif' condition is tested
in turn. If any 'elif' condition is true, its block is
executed. Finally the optional 'else' condition is tested. If it
is true, the 'else' block is executed. Only one block will be
executed.
Examples
Testing for a variable::
<dtml-if snake>
The snake variable is true
</dtml-if>
Testing for expression conditions::
<dtml-if expr="num > 5">
num is greater than five
<dtml-elif expr="num < 5">
num is less than five
<dtml-else>
num must be five
</dtml-if>
See Also
"Python Tutorial: If Statements":http://www.python.org/doc/current/tut/node6.html#SECTION006100000000000000000
lib/python/Products/OFSP/help/dtml-in.stx 0 → 100644
View file @ 15888ee6
in: Loops over sequences
The 'in' tag gives you powerful controls for looping over sequences
and performing batch processing.
Syntax
'in' tag syntax::
<dtml-in SequenceVariable|expr="SequenceExpression">
[<dtml-else>]
</dtml-in>
The 'in' block is repeated once for each item in the sequence
variable or sequence expression. The current item is pushed on to
the DTML namespace during each executing of the 'in' block.
If there are no items in the sequence variable or expression, the
optional 'else' block is executed.
Attributes
mapping -- Iterates over mapping objects rather than
instances. This allows values of the mapping objects to be
accessed as DTML variables.
reverse -- Reverses the sequence.
sort=string -- Sorts the sequence by the given attribute name.
start=int -- Begins the batch with the given index number.
size=int -- The size of the batch.
skip_unauthorized -- Don't raise an exception if an unauthorized
item is encountered.
orphan=int -- The desired minimum batch size.
overlap=int -- The number of items to overlap between batches.
previous -- Iterates once if there is a previous batch. Sets batch
variables for previous sequence.
next -- Iterates once if there is a next batch. Sets batch variables
for the next sequence.
Tag Variables
Current Item Variables
These variables describe the current item.
sequence-item -- The current item.
sequence-key -- The current key. When looping over tuples of the
form '(key,value)', the 'in' tag interprets them as
'(sequence-key, sequence-item)'.
sequence-index -- The index starting with 0 of the current item.
sequence-number -- The index starting with 1 of the current item.
sequence-roman -- The index in lowercase Roman numerals of the
current item.
sequence-Roman -- The index in uppercase Roman numerals of the
current item.
sequence-letter -- The index in lowercase letters of the current
item.
sequence-Letter -- The index in uppercase letters of the current
item.
sequence-start -- True if the current item is the first item.
sequence-end -- True if the current item is the last item.
sequence-even -- True if the index of the current item is even.
sequence-odd -- True if the index of the current item is odd.
sequence-length -- The length of the sequence.
sequence-var-*variable* -- A variable in the current item. For
example, 'sequence-var-title' is the 'title' variable of the
current item. Normally you can access these variables directly
since the current item is pushed on the DTML namespace. However
these variables can be useful when displaying previous and next
batch information.
sequence-index-*variable* -- The index of a variable of the
current item.
Summary Variables
These variable summarize information about numeric item
variables. To use these variable you must loop over objects
(like database query results) that have numeric variables.
total-*variable* -- The total of all occurrences of an item variable.
count-*variable* -- The number of occurrences of an item variable.
min-*variable* -- The minimum value of an item variable.
max-*variable* -- The maximum value of an item variable.
mean-*variable* -- The mean value of an item variable.
variance-*variable* -- The variance of an item variable with
count-1 degrees of freedom.
variance-n-*variable* -- The variance of an item variable with
count degrees of freedom.
standard-deviation-*variable* -- The standard-deviation of an
item variable with count-1 degrees of freedom.
standard-deviation-n-*variable* -- The standard-deviation of
an item variable with count degrees of freedom.
Grouping Variables
These variables allow you to track changes in current item
variables.
first-*variable* -- True if the current item is the first with
a particular value for a variable.
last-*variable* -- True if the current item is the last with a
particular value for a variable.
Batch Variables
sequence-query -- The query string with the 'start' variable
removed. You can use this variable to construct links to next
and previous batches.
sequence-step-size -- The batch size.
previous-sequence -- True if the current batch is not the
first one. Note, this variable is only true the first loop
iteration.
previous-sequence-start-index -- The starting index of the
previous batch.
previous-sequence-end-index -- The ending index of the previous
batch.
previous-sequence-size -- The size of the previous batch.
previous-batches -- A sequence of mapping objects with
information about all previous batches. Each mapping object has
these keys 'batch-start-index', 'batch-end-index', and
'batch-size'.
next-sequence -- True if the current batch is not the last
batch. Note, this variable is only true for the last loop
iteration.
next-sequence-start-index -- The starting index of the next
sequence.
next-sequence-end-index -- The ending index of the next
sequence.
next-sequence-size -- The size of the next index.
next-batches -- A sequence of mapping objects with information
about all following batches. Each mapping object has these keys
'batch-start-index', 'batch-end-index', and 'batch-size'.
Examples
Looping over sub-objects::
<dtml-in objectValues>
title: <dtml-var title><br>
</dtml-in>
Looping over a list of '(key, value)' tuples::
<dtml-in objectItems>
id: <dtml-var sequence-key>, title: <dtml-var title><br>
</dtml-in>
Creating alternate colored table cells::
<table>
<dtml-in objectValues>
<tr <dtml-if sequence-odd>bgcolor="#EEEEEE"
<dtml-else>bgcolor="#FFFFFF"
</dtml-if>
<td><dtml-var title></td>
</tr>
</dtml-in>
</table>
Basic batch processing::
<p>
<dtml-in largeSequence size=10 start=start previous>
<a href="<dtml-var absolute_url>?start=<dtml-var previous-sequence-start-index>">Previous</a>
</dtml-in>
<dtml-in largeSequence size=10 start=start next>
<a href="<dtml-var absolute_url>?start=<dtml-var next-sequence-start-index>">Next</a>
</dtml-in>
</p>
<p>
<dtml-in largeSequence size=10 start=start>
<dtml-var sequence-item>
</dtml-in>
</p>
This example creates *Previous* and *Next* links to navigate
between batches.
lib/python/Products/OFSP/help/dtml-let.stx 0 → 100644
View file @ 15888ee6
let: Defines DTML variables
The 'let' tag defines variables in the DTML namespace.
Syntax
<dtml-let [Name=Variable][Name="Expression"]...>
</dtml-let>
The 'let' tag is a block tag. Variables are defined by tag
arguments. Defined variables are pushed onto the DTML namespace
while the 'let' block is executed. Variables are defined by
attributes. The 'let' tag can have one or more attributes with
arbitrary names. If the attributes are defined with double quotes
they are considered expressions, otherwise they are looked up by
name. Attributes are processed in order, so later attributes can
reference, and/or overwrite earlier ones.
Examples
Basic usage::
<dtml-let name="'Bob'" ids=objectIds>
name: <dtml-var name>
ids: <dtml-var ids>
</dtml-let>
Using the 'let' tag with the 'in' tag::
<dtml-in expr="(1,2,3,4)">
<dtml-let num=sequence-item
index=sequence-index
result="num*index">
<dtml-var num> * <dtml-var index> = <dtml-var result>
</dtml-let>
</dtml-in>
This yields:
1 * 0 = 0
2 * 1 = 2
3 * 2 = 6
4 * 3 = 12
See Also
"with tag":dtml-with.stx
lib/python/Products/OFSP/help/dtml-mime.stx 0 → 100644
View file @ 15888ee6
mime: Formats data with MIME
The 'mime' tag allows you to create MIME encoded data. It is
chiefly used to format email inside the 'sendmail' tag.
Syntax
'mime' tag syntax::
<dtml-mime>
[<dtml-boundry>]
...
</dtml-mime>
The 'mime' tag is a block tag. The block is can be divided by one
or more 'boundry' tags to create a multi-part MIME message. 'mime'
tags may be nested. The 'mime' tag is most often used inside the
'sendmail' tag.
Attributes
Both the 'mime' and 'boundry' tags
have the same attributes.
encode=string -- MIME Content-Transfer-Encoding header, defaults
to 'base64'. Valid encoding options include 'base64',
'quoted-printable', 'uuencode', 'x-uuencode', 'uue', 'x-uue',
and '7bit'. If the 'encode' attribute is set to '7bit' no
encoding is done on the block and the data is assumed to be in a
valid MIME format.
type=string -- MIME Content-Type header.
type_expr=string -- MIME Content-Type header as a variable
expression. You cannot use both 'type' and 'type_expr'.
name=string -- MIME Content-Type header name.
name_expr=string -- MIME Content-Type header name as a variable
expression. You cannot use both 'name' and 'name_expr'.
disposition=string -- MIME Content-Disposition header.
disposition_expr=string -- MIME Content-Disposition header as a
variable expression. You cannot use both 'disposition' and
'disposition_expr'.
filename=string -- MIME Content-Disposition header filename.
filename_expr=string -- MIME Content-Disposition header filename
as a variable expression. You cannot use both 'filename' and
'filename_expr'.
skip_expr=string -- A variable expression that if true, skips
the block. You can use this attribute to selectively include
MIME blocks.
Examples
Sending a file attachment::
<dtml-sendmail>
To: <dtml-recipient>
Subject: Resume
<dtml-mime type="text/plain" encode="7bit">
Hi, please take a look at my resume.
<dtml-boundary type="application/octet-stream" disposition="attachment"
encode="base64" filename_expr="resume_file.getId()"><dtml-var expr="resume_file.read()"></dtml-mime>
</dtml-sendmail>
See Also
"Python Library: mimetools":http://www.python.org/doc/current/lib/module-mimetools.html
lib/python/Products/OFSP/help/dtml-raise.stx 0 → 100644
View file @ 15888ee6
raise: Raises an exception
The 'raise' tag raises an exception, mirroring the Python 'raise'
statement.
Syntax
'raise' tag syntax::
<dtml-raise ExceptionName|ExceptionExpression>
</dtml-raise>
The 'raise' tag is a block tag. It raises an exception. Exceptions
can be an exception class or a string. The contents of the tag are
passed as the error value.
Examples
Raising a KeyError::
<dtml-raise KeyError></dtml-raise>
Raising an HTTP 404 error::
<dtml-raise NotFound>Web Page Not Found</dtml-raise>
See Also
"try tag":dtml-try.stx
"Python Tutorial: Errors and
Exceptions":http://www.python.org/doc/current/tut/node10.html
"Python Bult-in
Exceptions":http://www.python.org/doc/current/lib/module-exceptions.html
lib/python/Products/OFSP/help/dtml-return.stx 0 → 100644
View file @ 15888ee6
return: Returns data
The 'return' tag stops executing DTML and returns data. It mirrors
the Python 'return' statement.
Syntax
'return' tag syntax::
<dtml-return ReturnVariable|expr="ReturnExpression">
Stops execution of DTML and returns a variable or expression. The
DTML output is not returned. Usually a return expression is more
useful than a return variable. Python Methods largely obsolete
this tag.
Examples
Returning a variable::
<dtml-return result>
Returning a Python dictionary::
<dtml-return expr="{'hi':200, 'lo':5}">
lib/python/Products/OFSP/help/dtml-sendmail.stx 0 → 100644
View file @ 15888ee6
sendmail: Sends email with SMTP
The 'sendmail' tag sends an email message using SMTP.
Syntax
'sendmail' tag syntax::
<dtml sendmail>
</dtml-sendmail>
The 'sendmail' tag is a block tag. It either requires a 'mailhost'
or a 'smtphost' argument, but not both. The tag block is sent as
an email message. The beginning of the block describes the email
headers. The headers are separated from the body by a blank
line. Alternately the 'To', 'From' and 'Subject' headers can be
set with tag arguments.
Attributes
mailhost -- The name of a Zope MailHost object
to use to send email. You cannot specify both a mailhost and a smtphost.
smtphost -- The name of a SMTP server used to send email. You
cannot specify both a mailhost and a smtphost.
port -- If the smtphost attribute is used, then the port attribute
is used to specify a port number to connect to. If not specified,
then port 25 will be used.
mailto -- The recipient address or a list of recipient addresses
separated by commas. This can also be specified with the 'To' header.
mailfrom -- The sender address. This can also be specified with
the 'From' header.
subject -- The email subject. This can also be specified with the
'Subject' header.
Examples
Sending an email message using a Mail Host::
<dtml-sendmail mailhost="mailhost">
To: <dtml-var recipient>
From: <dtml-var sender>
Subject: <dtml-var subject>
Dear <dtml-var recipient>,
You order number <dtml-var order_number> is ready.
Please pick it up at your soonest convenience.
</dtml-sendmail>
See Also
"RFC 821 (SMTP Protocol)":http://www.ietf.org/rfc/rfc0821.txt
"mime tag":dtml-mime.stx
lib/python/Products/OFSP/help/dtml-sqlgroup.stx 0 → 100644
View file @ 15888ee6
sqlgroup: Formats complex SQL expressions
The 'sqlgroup' tag formats complex boolean SQL expressions. You
can use it along with the 'sqltest' tag to build dynamic SQL
queries that tailor themselves to the environment. This tag is
used in SQL Methods.
Syntax
'sqlgroup' tag syntax::
<dtml-sqlgroup>
[<dtml-or>]
[<dtml-and>]
...
</dtml-sqlgroup>
The 'sqlgroup' tag is a block tag. It is divided into blocks with
one or more optional 'or' and 'and' tags. 'sqlgroup' tags can be
nested to produce complex logic.
Attributes
required=boolean -- Indicates whether the group is required. If it
is not required and contains nothing, it is excluded from the DTML
output.
where=boolean -- If true, includes the string "where". This is
useful for the outermost 'sqlgroup' tag in a SQL 'select' query.
Examples
Sample usage
select * from employees
<dtml-sqlgroup where>
<dtml-sqltest salary op=gt type=float optional>
<dtml-and>
<dtml-sqltest first op=eq type=string multiple optional>
<dtml-and>
<dtml-sqltest last op=eq type=string multiple optional>
</dtml-sqlgroup>
If 'first' is 'Bob' and 'last' is 'Smith, McDonald' it renders::
select * from employees
where
(first='Bob'
and
last in ('Smith', 'McDonald')
)
If 'salary' is 50000 and 'last' is 'Smith' it renders::
select * from employees
where
(salary > 50000.0
and
last='Smith'
)
Nested 'sqlgroup' tags::
select * from employees
<dtml-sqlgroup where>
<dtml-sqlgroup>
<dtml-sqltest first op=like type=string>
<dtml-and>
<dtml-sqltest last op=like type=string>
<dtml-sqlgroup>
<dtml-or>
<dtml-sqltest salary op=gt type=float>
</dtml-sqlgroup>
Given sample arguments, this template renders to SQL like so::
select * form employees
where
(
(
name like 'A*'
and
last like 'Smith'
)
or
salary > 20000.0
)
See Also
"sqltest tag":dtml-sqltest.stx
lib/python/Products/OFSP/help/dtml-sqltest.stx 0 → 100644
View file @ 15888ee6
sqltest: Formats SQL condition tests
The 'sqltest' tag inserts a condition test into SQL code. It tests
a column against a variable. This tag is used in SQL Methods.
Syntax
'sqltest' tag syntax::
<dtml-sqltest Variable|expr="VariableExpression">
The 'sqltest' tag is a singleton. It inserts a SQL condition test
statement. It is used to build SQL queries. The 'sqltest' tag
correctly escapes the inserted variable. The named variable or
variable expression is tested against a SQL column using the
specified comparison operation.
Attributes
type=string -- The type of the variable. Valid types include:
'string', 'int', 'float' and 'nb'. 'nb' means non-blank
string. The type attribute is required and is used to properly
escape inserted variable.
column=string -- The name of the SQL column to test against. This
attribute defaults to the variable name.
multiple=boolean -- If true, then the variable may be a sequence
of values to test the column against.
optional=boolean -- If true, then the test is optional and will
not be rendered if the variable is empty or non-existent.
op=string -- The comparison operation. Valid comparisons include:
eq -- equal to
gt -- greater than
lt -- less than
ne -- not equal to
ge -- greater than or equal to
le -- less than or equal to
The comparison defaults to equal to. If the comparison is not
recognized it is used anyway. Thus you can use comparisons such
as 'like'.
Examples
Basic usage::
select * from employees
where <dtml-sqltest name type="string">
If the 'name' variable is 'Bob' then this renders::
select * from employees
where name = 'Bob'
Multiple values::
select * from employees
where <dtml-sqltest empid type=int multiple>
If the 'empid' variable is '(12,14,17)' then this renders::
select * from employees
where empid in (12, 14, 17)
See Also
"sqlgroup tag":dtml-sqlgroup.stx
"sqlvar tag":dtml-sqlvar.stx
lib/python/Products/OFSP/help/dtml-sqlvar.stx 0 → 100644
View file @ 15888ee6
sqlvar: Inserts SQL variables
The 'sqlvar' tag safely inserts variables into SQL code. This tag
is used in SQL Methods.
Syntax
'sqlvar' tag syntax::
<dml-sqlvar Variable|expr="VariableExpression">
The 'sqlvar' tag is a singleton. Like the 'var' tag, the 'sqlvar'
tag looks up a variable and inserts it. Unlike the var tag, the
formatting options are tailored for SQL code.
Attributes
type=string -- The type of the variable. Valid types include:
'string', 'int', 'float' and 'nb'. 'nb' means non-blank
string. The type attribute is required and is used to properly
escape inserted variable.
optional=boolean -- If true and the variable is null or
non-existent, then nothing is inserted.
Examples
Basic usage::
select * from employees
where name=<dtml-sqlvar name type="string">
This SQL quotes the 'name' string variable.
See Also
"sqltest tag":dtml-sqltest.stx
lib/python/Products/OFSP/help/dtml-tree.stx 0 → 100644
View file @ 15888ee6
tree: Inserts a tree widget
The 'tree' tag displays a dynamic tree widget by querying Zope
objects.
Syntax
'tree' tag syntax::
<dtml-tree [VariableName|expr="VariableExpression"]>
</dtml-tree>
The 'tree' tag is a block tag. It renders a dynamic tree widget in
HTML. The root of the tree is given by variable name or
expression, if present, otherwise it defaults to the current
object. The 'tree' block is rendered for each tree node, with the
current node pushed onto the DTML namespace.
Tree state is set in HTTP cookies. Thus for trees to work, cookies
must be enabled. Also you can only have one tree per page.
Attributes
branches=string -- Finds tree branches by calling the named
method. The default method is 'tpValues' which most Zope objects
support.
branches_expr=string -- Finds tree branches by evaluating the
expression.
expand -- XXX deprecated? XXX
id=string -- The name of a method or id to determine tree
state. It defaults to 'tpId' which most Zope objects support. This
attribute is for advanced usage only.
url=string -- The name of a method or attribute to determine tree
item URLs. It defaults to 'tpURL' which most Zope objects
support. This attribute is for advanced usage only.
leaves=string -- The name of a DTML Document or Method used to
render nodes that don't have any children.
header=string -- The name of a DTML Document or Method displayed
before expanded nodes. If the header is not found, it is skipped.
footer=string -- The name of a DTML Document or Method displayed
after expanded nodes. If the footer is not found, it is skipped.
nowrap=boolean -- If true then rather than wrap, nodes may be
truncated to fit available space.
sort=string -- Sorts the branches by the named attribute.
reverse -- Reverses the order of the branches.
assume_children=boolean -- Assumes that nodes have children. This
is useful if fetching and querying child nodes is a costly
process. This results in plus boxes being drawn next to all nodes.
single=boolean -- Allows only one branch to be expanded at a
time. When you expand a new branch, any other expanded branches
close.
skip_unauthorized -- Skips nodes that the user is unauthorized to
see, rather than raising an error.
urlparam=string -- A query string which is included in the
expanding and contracting widget links. This attribute is for
advanced usage only.
Tag Variables
tree-item-expanded -- True if the current node is expanded.
tree-item-url -- The URL of the current node.
tree-root-url -- The URL of the root node.
tree-level -- The depth of the current node. Top-level nodes have
a depth of zero.
tree-colspan -- The number of levels deep the tree is being
rendered. This variable along with the 'tree-level' variable can
be used to calculate table rows and colspan settings when
inserting table rows into the tree table.
tree-state -- The tree state expressed as a list of ids and
sub-lists of ids. This variable is for advanced usage only.
Tag Control Variables
You can control the tree tag by setting variables.
expand_all -- If this variable is true then the entire tree is
expanded.
collapse_all -- If this variable is true then the entire tree is
collapsed.
Examples
Display a rooted in the current object::
<dtml-tree>
<dtml-var title_or_id>
</dtml-tree>
Display a tree rooted in another object, using a custom branches
method::
<dtml-tree expr="folder.object" branches="objectValues">
Node id : <dtml-var getId>
</dtml-tree>
lib/python/Products/OFSP/help/dtml-try.stx 0 → 100644
View file @ 15888ee6
try: Handles exceptions
The 'try' tag allows exception handling in DTML, mirroring the
Python 'try/except' and 'try/finally' constructs.
Syntax
The 'try' tag has two different syntaxes, 'try/except/else' and
'try/finally'.
'try/except/else' Syntax::
<dtml-try>
<dtml-except [ExceptionName] [ExceptionName]...>
...
[<dtml-else>]
</dtml-try>
The 'try' tag encloses a block in which exceptions can be caught and
handled. There can be one or more 'except' tags that handles
zero or more exceptions. If a 'except' tag does not specify an
exception, then it handles all exceptions.
When an exception is raised, control jumps to the first 'except'
tag that handles the exception. If there is no 'except' tag to
handled the exception, then the exception is raised normally.
If no exception is raised, and there is an 'else' tag, then the
'else' tag will be executed after the body of the 'try' tag.
The 'except' and 'else' tags are optional.
'try/finally' Syntax::
<dtml-try>
<dtml-finally>
</dtml-try>
The 'finally' tag cannot be used in the same 'try' block as the
'except' and 'else' tags. If there is a 'finally' tag, its block
will be executed whether or not an exception is raised in the
'try' block.
Attributes
except -- Zero or more exception names. If no exceptions are
listed then the except tag will handle all exceptions.
Tag Variables
Inside the 'except' block these variables are defined.
error_type -- The exception type.
error_value -- The exception value.
error_tb -- The traceback.
Examples
Catching a math error::
<dtml-try>
<dtml-var expr="1/0">
<dtml-except ZeroDivisionError>
You tried to divide by zero.
</dtml-try>
Returning information about the handled exception::
<dtml-try>
<dtml-call dangerousMethod>
<dtml-except>
An error occurred.
Error type: <dtml-var error_type>
Error value: <dtml-var error_value>
</dtml-try>
Using finally to make sure to perform clean up regardless
of whether an error is raised or not::
<dtml-call acquireLock>
<dtml-try>
<dtml-call someMethod>
<dtml-finally>
<dtml-call releaseLock>
</dtml-try>
See Also
"raise tag":dtml-raise.stx
"Python Tutorial: Errors and
Exceptions":http://www.python.org/doc/current/tut/node10.html
"Python Bult-in
Exceptions":http://www.python.org/doc/current/lib/module-exceptions.html
lib/python/Products/OFSP/help/dtml-unless.stx 0 → 100644
View file @ 15888ee6
unless: Tests a condition
The 'unless' tag provides a shortcut for testing negative
conditions. For more complete condition testing use the 'if' tag.
Syntax
'unless' tag syntax::
<dtml-unless ConditionVariable|expr="ConditionExpression">
</dtml-unless>
The 'unless' tag is a block tag. If the condition variable or
expression evaluates to false, then the contained block is
executed. Like the 'if' tag, variables that are not present are
considered false.
Examples
Testing a variable::
<dtml-unless testMode>
<dtml-call dangerousOperation>
</dtml-unless>
The block will be executed if 'testMode' does not exist, or exists
but is false.
See Also
"if tag":dtml-if.stx
lib/python/Products/OFSP/help/dtml-var.stx 0 → 100644
View file @ 15888ee6
var: Inserts a variable
The 'var' tags allows you insert variables into DTML output.
Syntax
'var' tag syntax::
<dtml-var Variable|expr="Expression">
The 'var' tag is a singleton tag. The 'var' tag finds a variable
by searching the DTML namespace which usually consists of current
object, the current object's containers, and finally the web
request. If the variable is found, it is inserted into the DTML
output. If not found, Zope raises an error.
'var' tag entity syntax::
&dtml-variableName;
Entity syntax is a short cut which HTML quotes the variable. It is
useful when inserting variables into HTML tags.
Attributes
html_quote -- Convert characters that have special meaning in
HTML to HTML character entities.
missing=string -- Specify a default value in case Zope cannot find
the variable.
fmt=string -- Format a variable. Zope provides a view built-in
formats including C-style format strings. For more information on
C-style format strings see the "Python Library
Reference":http://www.python.org/doc/current/lib/typesseq-strings.html
whole-dollars -- Formats the variable as dollars.
dollars-and-cents -- Formats the variable as dollars and cents.
collection-length -- The length of the variable, assuming it is
a sequence.
structured-text -- Formats the variable as Structured Text. For
more information on Structured Text see "Structured Text
How-To":http://www.zope.org/Members/millejoh/structuredText on
the Zope.org web site.
null=string -- A default value to use if the variable is None.
lower -- Converts upper-case letters to lower case.
upper -- Converts lower-case letters to upper case.
capitalize -- Capitalizes the first character of the inserted
word.
spacify -- Changes underscores in the inserted value to spaces.
thousands_commas -- Inserts commas every three
digits to the left of a decimal point in values containing
numbers for example '12000' becomes '12,000'.
url_quote -- Converts characters that have special meaning in
URLs to HTML character entities.
url_quote_plus -- URL quotes character, like 'url_quote' but also
converts spaces to plus signs.
sql_quote -- Converts single quotes to pairs of single
quotes. This is needed to safely include values in SQL strings.
newline_to_br -- Convert newlines (including carriage returns) to
HTML break tags.
size=arg -- Truncates the variable at the given length
(Note: if a space occurs in the second half of the truncated
string, then the string is further truncated to the right-most space).
etc=arg -- Specifies a string to add to the end of a string
which has been truncated (by setting the 'size' attribute listed
above). By default, this is '...'
Examples
Inserting a simple variable into a document::
<dtml-var standard_html_header>
Truncation. Suppose colors is the string 'red yellow green',
then::
<dtml-var colors size=10 etc=", etc.">
will produce the output::
red yellow, etc.
C-style string formatting::
<dtml-var expr="23432.2323" fmt="%.2f">
renders to::
23432.23
See Also
XXX
lib/python/Products/OFSP/help/dtml-with.stx 0 → 100644
View file @ 15888ee6
with: Controls DTML variable look up
The 'with' tag pushes an object onto the DTML namespace. Variables
will be looked up in the pushed object first.
Syntax
<dtml-with Variable|expr="Expression">
</dtml-with>
The 'with' tag is a block tag. It pushes the named variable or
variable expression onto the DTML namespace for the duration of
the 'with' block. Thus names are looked up in the pushed object
first.
Attributes
only -- Limits the DTML namespace to only include the one defined
in the 'with' tag.
mapping -- Indicates that the variable or expression is a mapping
object. This ensures that variables are looked up correctly in the
mapping object.
Examples
Looking up a variable in the REQUEST::
<dtml-with REQUEST only>
<dtml-if id>
<dtml-var id>
<dtml-else>
'id' was not in the request.
</dtml-if>
</dtml-with>
Pushing the first child on the DTML namespace::
<dtml-with expr="objectValues()[0]">
First child's id: <dtml-var id>
</dtml-with>
See Also
"let tag"dtml-let.stx
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment
GitLab Nexedi Edition | About GitLab | About Nexedi | 沪ICP备2021021310号-2 | 沪ICP备2021021310号-7