Navigation

25. Appendix A: DTML Reference

DTML is the Document Template Markup Language, a handy presentation and templating language that comes with Zope. This Appendix is a reference to all of DTMLs markup tags and how they work.

25.1. call: Call a method

The ‘call’ tag lets you call a method without inserting the results into the DTML output.

25.1.1. 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.

25.1.2. 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')">

25.1.3. See Also

  • var tag

25.2. 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.

25.2.1. 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.

25.2.2. 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>

Zope still validates the DTML inside the comment block and will not save any comments that are not valid DTML. It is also not possible to comment in a way that breaks code flow, for example you cannot inproperly nest a comment and a dtml-in.

25.3. functions: DTML Functions

DTML utility functions provide some Python built-in functions and some DTML-specific functions.

25.3.1. Functions

abs(number)
Return the absolute value of a number. The argument may be a plain or long integer or a floating point number. If the argument is a complex number, its magnitude is returned.
chr(integer)
Return a string of one character whose ASCII code is the integer, e.g., ‘chr(97)’ returns the string ‘a’. This is the inverse of ord(). The argument must be in the range 0 to 255, inclusive; ‘ValueError’ will be raised if the integer is outside that range.
DateTime()
Returns a Zope ‘DateTime’ object given constructor arguments. See the DateTime API reference for more information on constructor arguments.
divmod(number, number)
Take two numbers as arguments and return a pair of numbers consisting of their quotient and remainder when using long division. With mixed operand types, the rules for binary arithmetic operators apply. For plain and long integers, the result is the same as ‘(a / b, a % b)’. For floating point numbers the result is ‘(q, a % b)’, where q is usually ‘math.floor(a / b)’ but may be 1 less than that. In any case ‘q * b + a % b’ is very close to a, if ‘a % b’ is non-zero it has the same sign as b, and ‘0 <= abs(a % b) < abs(b)’.
float(number)
Convert a string or a number to floating point. If the argument is a string, it must contain a possibly signed decimal or floating point number, possibly embedded in whitespace; this behaves identical to ‘string.atof(number)’. Otherwise, the argument may be a plain or long integer or a floating point number, and a floating point number with the same value (within Python’s floating point precision) is returned.
getattr(object, string)
Return the value of the named attributed of object. name must be a string. If the string is the name of one of the object’s attributes, the result is the value of that attribute. For example, ‘getattr(x, “foobar”)’ is equivalent to ‘x.foobar’. If the named attribute does not exist, default is returned if provided, otherwise ‘AttributeError’ is raised.
getitem(variable, render=0)
Returns the value of a DTML variable. If ‘render’ is true, the variable is rendered. See the ‘render’ function.
hasattr(object, string)
The arguments are an object and a string. The result is 1 if the string is the name of one of the object’s attributes, 0 if not. (This is implemented by calling getattr(object, name) and seeing whether it raises an exception or not.)
hash(object)
Return the hash value of the object (if it has one). Hash values are integers. They are used to quickly compare dictionary keys during a dictionary lookup. Numeric values that compare equal have the same hash value (even if they are of different types, e.g. 1 and 1.0).
has_key(variable)
Returns true if the DTML namespace contains the named variable.
hex(integer)
Convert an integer number (of any size) to a hexadecimal string. The result is a valid Python expression. Note: this always yields an unsigned literal, e.g. on a 32-bit machine, ‘hex(-1)’ yields ‘0xffffffff’. When evaluated on a machine with the same word size, this literal is evaluated as -1; at a different word size, it may turn up as a large positive number or raise an ‘OverflowError’ exception.
int(number)
Convert a string or number to a plain integer. If the argument is a string, it must contain a possibly signed decimal number representable as a Python integer, possibly embedded in whitespace; this behaves identical to ‘string.atoi(number[, radix]’). The ‘radix’ parameter gives the base for the conversion and may be any integer in the range 2 to 36. If ‘radix’ is specified and the number is not a string, ‘TypeError’ is raised. Otherwise, the argument may be a plain or long integer or a floating point number. Conversion of floating point numbers to integers is defined by the C semantics; normally the conversion truncates towards zero.
len(sequence)
Return the length (the number of items) of an object. The argument may be a sequence (string, tuple or list) or a mapping (dictionary).
max(s)
With a single argument s, return the largest item of a non-empty sequence (e.g., a string, tuple or list). With more than one argument, return the largest of the arguments.
min(s)
With a single argument s, return the smallest item of a non-empty sequence (e.g., a string, tuple or list). With more than one argument, return the smallest of the arguments.
namespace([name=value]...)
Returns a new DTML namespace object. Keyword argument ‘name=value’ pairs are pushed into the new namespace.
oct(integer)
Convert an integer number (of any size) to an octal string. The result is a valid Python expression. Note: this always yields an unsigned literal, e.g. on a 32-bit machine, ‘oct(-1)’ yields ‘037777777777’. When evaluated on a machine with the same word size, this literal is evaluated as -1; at a different word size, it may turn up as a large positive number or raise an OverflowError exception.
ord(character)
Return the ASCII value of a string of one character. E.g., ‘ord(“a”)’ returns the integer 97. This is the inverse of ‘chr()’.
pow(x, y [,z])
Return x to the power y; if z is present, return x to the power y, modulo z (computed more efficiently than ‘pow(x, y) % z’). The arguments must have numeric types. With mixed operand types, the rules for binary arithmetic operators apply. The effective operand type is also the type of the result; if the result is not expressible in this type, the function raises an exception; e.g., ‘pow(2, -1)’ or ‘pow(2, 35000)’ is not allowed.
range([start,] stop [,step])
This is a versatile function to create lists containing arithmetic progressions. The arguments must be plain integers. If the step argument is omitted, it defaults to 1. If the start argument is omitted, it defaults to 0. The full form returns a list of plain integers ‘[start, start + step, start + 2 * step, ...]’. If step is positive, the last element is the largest ‘start + i * step’ less than stop; if step is negative, the last element is the largest ‘start + i * step’ greater than stop. step must not be zero (or else ‘ValueError’ is raised).
round(x [,n])
Return the floating point value x rounded to n digits after the decimal point. If n is omitted, it defaults to zero. The result is a floating point number. Values are rounded to the closest multiple of 10 to the power minus n; if two multiples are equally close, rounding is done away from 0 (so e.g. round(0.5) is 1.0 and round(-0.5) is -1.0).
render(object)
Render ‘object’. For DTML objects this evaluates the DTML code with the current namespace. For other objects, this is equivalent to ‘str(object)’.
reorder(s [,with] [,without])
Reorder the items in s according to the order given in ‘with’ and without the items mentioned in ‘without’. Items from s not mentioned in with are removed. s, with, and without are all either sequences of strings or sequences of key-value tuples, with ordering done on the keys. This function is useful for constructing ordered select lists.
SecurityCalledByExecutable()
Return a true if the current object (e.g. DTML document or method) is being called by an executable (e.g. another DTML document or method, a script or a SQL method).
SecurityCheckPermission(permission, object)
Check whether the security context allows the given permission on the given object. For example, ‘SecurityCheckPermission(“Add Documents, Images, and Files”, this())’ would return true if the current user was authorized to create documents, images, and files in the current location.
SecurityGetUser()
Return the current user object. This is normally the same as the ‘REQUEST.AUTHENTICATED_USER’ object. However, the ‘AUTHENTICATED_USER’ object is insecure since it can be replaced.
SecurityValidate([object] [,parent] [,name] [,value])
Return true if the value is accessible to the current user. ‘object’ is the object the value was accessed in, ‘parent’ is the container of the value, and ‘name’ is the named used to access the value (for example, if it was obtained via ‘getattr’). You may omit some of the arguments, however it is best to provide all available arguments.
SecurityValidateValue(object)
Return true if the object is accessible to the current user. This function is the same as calling ‘SecurityValidate(None, None, None, object)’.
str(object)
Return a string containing a nicely printable representation of an object. For strings, this returns the string itself.
test(condition, result [,condition, result]... [,default])
Takes one or more condition, result pairs and returns the result of the first true condition. Only one result is returned, even if more than one condition is true. If no condition is true and a default is given, the default is returned. If no condition is true and there is no default, None is returned.
unichr(number)
Return a unicode string representing the value of number as a unicode character. This is the inverse of ord() for unicode characters.
unicode(string[, encoding[, errors ] ])
Decodes string using the codec for encoding. Error handling is done according to errors. The default behavior is to decode UTF-8 in strict mode, meaning that encoding errors raise ValueError.

25.3.2. Attributes

None
The ‘None’ object is equivalent to the Python built-in object ‘None’. This is usually used to represent a Null or false value.

25.4. 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.

25.4.1. 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’ block is executed if none of the ‘if’ and ‘elif’ conditions were true. Only one block will be executed.

25.4.2. 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>

25.5. in: Loops over sequences

The ‘in’ tag gives you powerful controls for looping over sequences and performing batch processing.

25.5.1. Syntax

‘in’ tag syntax:

<dtml-in SequenceVariable|expr="SequenceExpression">
[<dtml-else>]
</dtml-in>

a commenting identifier at the end tag is allowed and will be ignored like:

</dtml-in my_short_sequ_name>

same for ‘</dtml-if>’ and ‘</dtml-let>’

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.

25.5.2. 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
The number of the first item to be shown, where items are numbered from 1.
end=int
The number of the last item to be shown, where items are numbered from 1.
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. This controls how sequences are split into batches. If a batch smaller than the orphan size would occur, then no split is performed, and a batch larger than the batch size results.

For example, if the sequence size is 12, the batch size is 10 the orphan size is 3, then the result is one batch with all 12 items since splitting the items into two batches would result in a batch smaller than the orphan size.

The default value is 0.

overlap=int
The number of items to overlap between batches. The default is no overlap.
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.
prefix=string
Provide versions of the tag variables that start with this prefix instead of “sequence”, and that use underscores (_) instead of hyphens (-). The prefix must start with a letter and contain only alphanumeric characters and underscores (_).
sort_expr=expression
Sorts the sequence by an attribute named by the value of the expression. This allows you to sort on different attributes.
reverse_expr=expression
Reverses the sequence if the expression evaluates to true. This allows you to selectively reverse the sequence.

25.5.3. Tag Variables

25.5.3.1. 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.

25.5.3.2. 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 n 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 n degrees of freedom.

25.5.3.3. 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.

25.5.3.4. 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 for the first loop iteration.
previous-sequence-start-index
The starting index of the previous batch.
previous-sequence-start-number
The starting number of the previous batch. Note, this is the same as ‘previous-sequence-start-index’ + 1.
previous-sequence-end-index
The ending index of the previous batch.
previous-sequence-end-number
The ending number of the previous batch. Note, this is the same as ‘previous-sequence-end-index’ + 1.
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-start-number
The starting number of the next sequence. Note, this is the same as ‘next-sequence-start-index’ + 1.
next-sequence-end-index
The ending index of the next sequence.
next-sequence-end-number
The ending number of the next sequence. Note, this is the same as ‘next-sequence-end-index’ + 1.
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’.

25.5.4. Examples

Looping over sub-objects:

<dtml-in objectValues>
  title: <dtml-var title><br>
</dtml-in>

Looping over two sets of objects, using prefixes:

<dtml-let rows="(1,2,3)" cols="(4,5,6)">
  <dtml-in rows prefix="row">
    <dtml-in cols prefix="col">
      <dtml-var expr="row_item * col_item"><br>
      <dtml-if col_end>
        <dtml-var expr="col_total_item * row_mean_item">
      </dtml-if>
    </dtml-in>
  </dtml-in>
</dtml-let>

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 rows:

<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>
    <dtml-var sequence-query>start=<dtml-var previous-sequence-start-number>">
    Previous
  </a>
</dtml-in>

<dtml-in largeSequence size=10 start=start next>
  <a href="<dtml-var absolute_url>
    <dtml-var sequence-query>start=<dtml-var next-sequence-start-number>">
    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. Note, by using ‘sequence-query’, you do not lose any GET variables as you navigate between batches.

25.6. let: Defines DTML variables

The ‘let’ tag defines variables in the DTML namespace.

25.6.1. Syntax

‘let’ tag 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.

25.6.2. 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

25.6.3. See Also

  • with tag

25.7. 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.

25.7.1. 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.

25.7.2. 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.

25.7.3. Examples

Sending a file attachment:

<dtml-sendmail>
To: <dtml-var 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>

25.7.4. See Also

25.8. raise: Raises an exception

The ‘raise’ tag raises an exception, mirroring the Python ‘raise’ statement.

25.8.1. 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.

25.8.2. Examples

Raising a KeyError:

<dtml-raise KeyError></dtml-raise>

Raising an HTTP 404 error:

<dtml-raise NotFound>Web Page Not Found</dtml-raise>

25.9. return: Returns data

The ‘return’ tag stops executing DTML and returns data. It mirrors the Python ‘return’ statement.

25.9.1. 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. Scripts largely obsolete this tag.

Examples

Returning a variable:

<dtml-return result>

Returning a Python dictionary:

<dtml-return expr="{'hi':200, 'lo':5}">

25.10. sendmail: Sends email with SMTP

The ‘sendmail’ tag sends an email message using SMTP.

25.10.1. 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.

25.10.2. 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.

25.10.3. 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>

25.10.4. See Also

25.11. 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.

25.11.1. 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.

25.11.2. 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.

25.11.3. Examples

Sample usage:

select * from employees
<dtml-sqlgroup where>
  <dtml-sqltest salary op="gt" type="float" optional>
<dtml-and>
  <dtml-sqltest first type="nb" multiple optional>
<dtml-and>
  <dtml-sqltest last type="nb" 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="nb">
  <dtml-and>
     <dtml-sqltest last op="like" type="nb">
  </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
)

25.11.4. See Also

  • sqltest tag

25.12. 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.

25.12.1. 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.

25.12.2. Attributes

type=string
The type of the variable. Valid types include: ‘string’, ‘int’, ‘float’ and ‘nb’. ‘nb’ means non-blank string, and should be used instead of ‘string’ unless you want to test for blank values. 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’.

25.12.3. Examples

Basic usage:

select * from employees
  where <dtml-sqltest name type="nb">

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)

25.12.4. See Also

  • sqlgroup tag
  • sqlvar tag

25.13. sqlvar: Inserts SQL variables

The ‘sqlvar’ tag safely inserts variables into SQL code. This tag is used in SQL Methods.

25.13.1. Syntax

‘sqlvar’ tag syntax:

<dtml-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.

25.13.2. Attributes

type=string
The type of the variable. Valid types include: ‘string’, ‘int’, ‘float’ and ‘nb’. ‘nb’ means non-blank string and should be used in place of ‘string’ unless you want to use blank strings. 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.

25.13.3. Examples

Basic usage:

select * from employees
  where name=<dtml-sqlvar name type="nb">

This SQL quotes the ‘name’ string variable.

25.13.4. See Also

  • sqltest tag

25.14. tree: Inserts a tree widget

The ‘tree’ tag displays a dynamic tree widget by querying Zope objects.

25.14.1. 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.

25.14.2. 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.
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. Note: this document should begin with ‘<dtml-var standard_html_header>’ and end with ‘<dtml-var standard_html_footer>’ in order to ensure proper display in the tree.
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.
prefix=string
Provide versions of the tag variables that start with this prefix instead of “tree”, and that use underscores (_) instead of hyphens (-). The prefix must start with a letter and contain only alphanumeric characters and underscores (_).

25.14.3. 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.

25.14.4. Tag Control Variables

You can control the tree tag by setting these 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.

25.14.5. Examples

Display a tree 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>

25.15. try: Handles exceptions

The ‘try’ tag allows exception handling in DTML, mirroring the Python ‘try/except’ and ‘try/finally’ constructs.

25.15.1. 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 an ‘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 handle 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.

25.15.2. Attributes

except
Zero or more exception names. If no exceptions are listed then the except tag will handle all exceptions.

25.15.3. Tag Variables

Inside the ‘except’ block these variables are defined.

error_type
The exception type.
error_value
The exception value.
error_tb
The traceback.

25.15.4. 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>

25.16. unless: Tests a condition

The ‘unless’ tag provides a shortcut for testing negative conditions. For more complete condition testing use the ‘if’ tag.

25.16.1. 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.

25.16.2. 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.

25.16.3. See Also

  • if tag

25.17. var: Inserts a variable

The ‘var’ tags allows you insert variables into DTML output.

25.17.1. 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 inserts and HTML quotes the variable. It is useful when inserting variables into HTML tags.

‘var’ tag entity syntax with attributes:

&dtml.attribute1[.attribute2]...-variableName;

To a limited degree you may specify attributes with the entity syntax. You may include zero or more attributes delimited by periods. You cannot provide arguments for attributes using the entity syntax. If you provide zero or more attributes, then the variable is not automatically HTML quoted. Thus you can avoid HTML quoting with this syntax, ‘&dtml.-variableName;’.

25.17.2. 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 few built-in formats including C-style format strings. For more information on C-style format strings see the Python Library Reference. If the format string is not a built-in format, then it is assumed to be a method of the object, and it called.

collection-length
The length of the variable, assuming it is a sequence.
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
Inserts the URL of the object, by calling its ‘absolute_url’ method.
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 ‘...’

25.17.3. Examples

Inserting a simple variable into a document:

<dtml-var standard_html_header>

Truncation:

<dtml-var colors size=10 etc=", etc.">

will produce the following output if colors is the string ‘red yellow green’:

red yellow, etc.

C-style string formatting:

<dtml-var expr="23432.2323" fmt="%.2f">

renders to:

23432.23

Inserting a variable, link, inside an HTML ‘A’ tag with the entity syntax:

<a href="&dtml-link;">Link</a>

Inserting a link to a document ‘doc’, using entity syntax with attributes:

<a href="&dtml.url-doc;"><dtml-var doc fmt="title_or_id"></a>

This creates an HTML link to an object using its URL and title. This example calls the object’s ‘absolute_url’ method for the URL (using the ‘url’ attribute) and its ‘title_or_id’ method for the title.

25.18. 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.

25.18.1. Syntax

‘with’ tag 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.

25.18.2. 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.

25.18.3. 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>

25.18.4. See Also

  • let tag

Table Of Contents

Previous topic

24. Maintaining Zope

Next topic

26. Appendix B: API Reference

This Page

Navigation

© Copyright 2009-2010, Zope Developers Community. Created using Sphinx 1.0.4.