class Checkbox(FieldElement):
"""
Add a checkbox to a form.
"""
class Help:
synopsis = "add a checkbox to a form"
fieldname = Attribute("Field name", required=False, default="check-box")
on = Attribute("Value when checked", required=False, default="on")
text = Attribute("Text associated with checkbox",
required=False,
default='')
adapt = Attribute("Function to adapt field before applying",
type="function",
default="value=='on'",
evaldefault=True)
process = Attribute("Function to process src in to a string",
type="function",
default="value ? 'on' : ''",
evaldefault=True)
def get_default(self):
return ''
class Row(LogicElement):
"""
Define a row in a [tag tables]table[/tag].
"""
class Help:
synopsis = "define a row in a table"
xmlns = namespaces.tables
template = Attribute("Template", required=False, default="row.html")
_class = Attribute("Extra class", required=False, map_to="class", default=None)
style = Attribute("Option CSS style", required=False)
_id = Attribute("Table ID", required=False, default=None)
_from = Attribute("Application", type="application", required=False, default='moya.tables')
class Meta:
text_nodes = "text"
def logic(self, context):
app = self.get_app(context)
params = self.get_parameters(context)
content = context['.content']
td = {"class": params["class"]}
with content.template_node('row', app.resolve_template(params.template), td):
yield logic.DeferNodeContents(self)
class CheckSelect(FieldElement):
"""
Add a [i]check select[/i] to a form.
A check select is an alternative to a multiple select ([tag forms]select[/tag]) which uses checkboxes rather than an input.
"""
fieldname = Attribute("Field name", required=False, default="check-select")
_class = Attribute("Extra class for select",
required=False,
default="input-medium")
choices = Attribute("Possible choices",
type="expression",
required=False,
default=None)
class Help:
synopsis = "add a check select control to a form"
def logic(self, context):
form = context['_return']
params = self.get_field_parameters(context)
params['multiple'] = True
template = params.pop('template', None)
select = context['_select'] = form.add_field(params, template=template)
select_choices = self.choices(context)
if select_choices:
Select.add_choices(select, select_choices)
yield logic.DeferNodeContents(self)
del context['_select']
context['.content'].add_renderable(self._tag_name, select)
class Error(LogicElement):
"""
Set an error message on either a field or the entire form.
"""
xmlns = namespaces.forms
src = Attribute("Form",
default="form",
evaldefault=True,
type="expression")
field = Attribute("Field name", required=False, default=None)
class Meta:
translate = True
class Help:
synopsis = "add an error message to a form"
example = """
<forms:error src="form" if=".user">
You must be logged in to do that!
</forms:error>
"""
def logic(self, context):
field = self.field(context)
form = self.src(context)
text = context.sub(self.text)
if field is None:
form.error = text
else:
form.errors[field] = text
class SortHeader(LogicElement):
"""
Define a sortable header column in a [tag tables]table[/tag].
"""
class Help:
synopsis = "define a sortable header column in a table"
xmlns = namespaces.tables
template = Attribute("Template", required=False, default="sortheader.html")
_class = Attribute("Extra class", required=False, map_to="class", default=None)
name = Attribute("Name to be set in query string", required=True)
_from = Attribute("Application", type="application", required=False, default='moya.tables')
class Meta:
text_nodes = "text"
def logic(self, context):
app = self.get_app(context)
params = self.get_parameters(context)
content = context['.content']
td = {'class': params['class'],
'name': params.name}
with content.template_node('column', app.resolve_template(params.template), td):
yield logic.DeferNodeContents(self)
class Error(LogicElement):
"""Return an rpc error response."""
xmlns = namespaces.jsonrpc
class Help:
synopsis = "return an rpc error"
code = Attribute("Error code", default="0", map_to="error_code")
data = Attribute(
"Optional data regarding the error",
type="expression",
default=None,
required=False,
)
def logic(self, context):
code, data = self.get_parameters(context, "error_code", "data")
error_message = context.sub(self.text.strip())
self.throw(
"jsonrpc.error",
"JSON RPC error",
code=code,
message=error_message,
data=data,
)
class Columns(LogicElement):
"""
Defines the columns in a [tag tables]table[/tag].
"""
class Help:
synopsis = "define the columns in a table"
xmlns = namespaces.tables
template = Attribute("Template", required=False, default="columns.html")
headers = Attribute("Headers",
required=False,
type="commalist",
default=None)
_from = Attribute("Application",
type="application",
required=False,
default="moya.tables")
def logic(self, context):
app = self.get_app(context)
params = self.get_parameters(context)
content = context[".content"]
with content.template_node(
"columns",
app.resolve_template(params.template),
{"headers": params.headers},
):
yield logic.DeferNodeContents(self)
class HiddenInput(FieldElement):
"""
Add a hidden input to a form.
"""
class Help:
synopsis = "add a hidden input value to a form"
fieldname = Attribute("Field name", required=False, default="hidden")
visible = Attribute("Visible",
type="boolean",
required=False,
default=False)
class Password(FieldElement):
"""
Add a password input to a form
"""
class Help:
synopsis = "add a password field to a form"
fieldname = Attribute("Field name", required=False, default="password")
placeholder = Attribute("Placeholder text", required=False, default=None)
_class = Attribute("Extra class for input",
required=False,
default="input-medium")
class TextArea(FieldElement):
"""
Add a textarea (multi-line text input) to a form.
"""
class Help:
synopsis = "add a textarea to a form"
fieldname = Attribute("Field name", required=False, default="text-area")
rows = Attribute("Number of rows",
required=False,
default=8,
type="integer")
_class = Attribute("Extra class for input",
required=False,
default="input-block-level")
class RadioGroup(FieldElement):
"""
Add a radio group (container for radio buttons) to a form.
"""
fieldname = Attribute("Field name", required=False, default="radio-group")
class Help:
synopsis = "add a radio group to a form"
example = """
<radio-group name="option" label="Radio Group" required="yes">
<radio text="Option 1" on="1"/>
<radio text="Option 2" on="2"/>
<radio text="Option 3" on="3"/>
</radio-group>
"""
def logic(self, context):
form = context['_return']
params = self.get_field_parameters(context)
template = params.pop('template', None)
renderable = context['_radiogroup'] = form.add_field(params,
template=template)
yield logic.DeferNodeContents(self)
del context['_radiogroup']
context['.content'].add_renderable(self._tag_name, renderable)
class Input(FieldElement):
"""
Add an input to a form.
"""
class Help:
synopsis = "add an input to a form"
example = """
<input name="username" maxlength="30" />
"""
fieldname = Attribute("Field name", required=False, default="text")
type = Attribute("Input type", required=False, default="text")
placeholder = Attribute("Placeholder text", required=False, default=None)
_class = Attribute("Extra class for input",
required=False,
default="input-medium")
class SubmitButton(FieldElement):
"""
Add a submit button to a form.
"""
class Help:
synopsis = "add a submit button in a form"
fieldname = Attribute("Field name",
required=False,
default="submit-button")
name = Attribute("Field name", required=False)
_class = Attribute("Extra class(es)", required=False, default=None)
text = Attribute("Text on button", required=False, default="Submit")
clicked = Attribute("Value when button is clicked",
default=None,
required=False)
class Header(LogicElement):
"""
Defines a single column header in a [tag tables]table[/tag].
"""
class Help:
synopsis = "define a column header in a table"
xmlns = namespaces.tables
template = Attribute("Template", required=False, default="header.html")
_class = Attribute("Extra class",
required=False,
map_to="class",
default=None)
_from = Attribute("Application",
type="application",
required=False,
default="moya.tables")
hide = Attribute("Hide this column?",
type="boolean",
required=False,
default=False)
align = Attribute(
"Alignment of column",
required=False,
choices=["left", "center", "right"],
default="left",
)
class Meta:
text_nodes = "text"
def logic(self, context):
app = self.get_app(context)
params = self.get_parameters(context)
content = context[".content"]
td = {"class": params["class"], "align": params.align}
context["_moyatable._cols"].append({
"hide": params.hide,
"align": params.align
})
if not params.hide:
with content.template_node("column",
app.resolve_template(params.template),
td):
yield logic.DeferNodeContents(self)
class Select(FieldElement):
"""
Add a select input to a form.
"""
class Help:
synopsis = "add a select box to a form"
fieldname = Attribute("Field name", required=False, default="select")
_class = Attribute("Extra class for select",
required=False,
default="input-medium")
multiple = Attribute("Multiple select?", required=False, default=False)
choices = Attribute("Possible choices",
type="expression",
required=False,
default=None)
@classmethod
def add_choices(cls, select, select_choices):
for group, choices in select_choices:
if isinstance(choices, text_type):
select.add_option(group, choices)
else:
if group:
for choice, choice_label in choices:
select.add_option(choice, choice_label, group=group)
else:
for choice, choice_label in choices:
select.add_option(choice, choice_label, group=group)
def logic(self, context):
form = context['_return']
params = self.get_field_parameters(context)
template = params.pop('template', None)
select = context['_select'] = form.add_field(params, template=template)
select_choices = self.choices(context)
if select_choices:
self.add_choices(select, select_choices)
yield logic.DeferNodeContents(self)
del context['_select']
context['.content'].add_renderable(self._tag_name, select)
class FormElement(LogicElement):
"""
Defines a form.
"""
xmlns = namespaces.forms
class Help:
synopsis = "begin a form definition"
example = """
<form libname="form.login" legend="Please login" xmlns="http://moyaproject.com/forms">
<input name="username" label="Username" type="text" maxlength="30" required="yes"/>
<password name="password" label="Password" maxlength="30" required="yes"/>
<submit-button text="Login" />
</form>
"""
legend = Attribute("legend text shown above form")
style = Attribute("Form style", default=None)
template = Attribute("Form template", default=None)
action = Attribute("Form action", default=None)
enctype = Attribute("Form encoding type", default=None)
extends = Attribute("Extend another form", default=None)
_class = Attribute("Additional CSS class", required=False, default=None)
class Meta:
tag_name = "form"
class Option(LogicElement):
"""
Define an option in a select input.
"""
xmlns = namespaces.forms
value = Attribute("Value", default=None, required=False)
group = Attribute("Group", required=False, default=None)
selected = Attribute("Selected",
type="expression",
required=False,
default=False)
help = Attribute("Help text", required=False, default=None)
renderable = Attribute("Renderable object",
type="expression",
required=False,
default=None)
class Help:
synopsis = "an option in a select control"
example = """
<select name="fruit">
<option value="apples">Apples</option>
<option value="oranges">Oranges</option>
<option value="pears">Pears</option>
</select>
"""
def logic(self, context):
if '_select' not in context:
# TODO: Throw an error?
return
text = context.sub(self.text.strip())
if self.has_parameter('value'):
value = self.value(context)
else:
value = text
params = self.get_parameters(context)
context['_select'].add_option(value,
text,
group=params.group,
help=params.help,
renderable=params.renderable)
class ParameterTag(ElementBase):
"""Defines a parameter in an RPC call."""
xmlns = namespaces.jsonrpc
_element_class = "data"
_param_types = ["number", "string", "bool", "list", "object", "anything"]
class Help:
synopsis = "define an rpc parameter"
example = """
<rpc:error code="100" if="format not in ['short', 'medium', 'long', 'full']">
Format parameter is not correct
</rpc:error>
"""
class Meta:
tag_name = "parameter"
logic_skip = True
name = Attribute("Name of the parameter", required=True)
type = Attribute(
"Parameter type (number, string, bool, list, object, anything)",
required=False,
default="anything",
)
null = Attribute("Also permit a null value? (None in Moya)",
required=False,
default=False)
default = Attribute("Default value", type="expression", required=False)
required = Attribute("Required?",
type="boolean",
required=False,
default=True)
def finalize(self, context):
type = self.type(context)
if type not in self._param_types:
raise errors.ElementError(
"attribute '{}' must be {} (not '{}') ".format(
"type", textual_list(self._param_types), type),
element=self,
)
class AdaptField(LogicElement):
xmlns = namespaces.forms
field = Attribute("Field name", required=True, default=None)
class Help:
synopsis = "adapt a field in a form"
def logic(self, context):
form = context['_return']
form.add_field_adapter(self.field(context), self.get_closure(context))
class Bind(ContextElementBase):
"""
Bind a form to data
"""
xmlns = namespaces.forms
class Help:
synopsis = "Add data to a form"
bind = Attribute("Object to bind to", type="expression", required=False)
src = Attribute("Source object to fill in fields",
type="expression",
default=None)
def logic(self, context):
bind, src = self.get_parameters(context, 'bind', 'src')
if bind is None:
bind = {}
bind.update(self.get_let_map(context))
form = src
form.bind(context, bind)
class Upload(FieldElement):
"""
Add a file upload input to a form.
"""
class Help:
synopsis = "add a file upload to a form"
enctype = "multipart/form-data"
fieldname = Attribute("Field name", required=False, default="upload")
type = Attribute("Input type", required=False, default="file")
placeholder = Attribute("Placeholder text", required=False, default=None)
_class = Attribute("Extra class for input", required=False, default="")
def adapt(self, context):
def process_field_storage(context, value=None):
if not isinstance(value, FieldStorage):
return value
return UploadFileProxy(value)
return process_field_storage
class Radio(FieldElement):
"""
Add a radio button to a form.
The user will be able to select just one radio button with the same [c]name[/c] attribute.
"""
class Help:
synopsis = "add a radio button to a field"
fieldname = Attribute("Field name", required=False, default="radio")
text = Attribute("Text associated with checkbox",
required=False,
default='')
on = Attribute("Value when selected", required=True)
def logic(self, context):
if '_radiogroup' not in context:
return super(Radio, self).logic(context)
radiogroup = context['_radiogroup']
on = self.on(context)
text = self.text(context)
radiogroup.add_option(on or text, text)
class Cell(LogicElement):
"""
A container for a single cell in a [tag tables]table[/tag].
"""
class Help:
synopsis = "a cell in a table"
xmlns = namespaces.tables
template = Attribute("Template", required=False, default="cell.html")
_class = Attribute("Extra class", required=False, map_to="class", default=None)
_from = Attribute("Application", type="application", required=False, default='moya.tables')
class Meta:
text_nodes = "text"
def logic(self, context):
app = self.get_app(context)
params = self.get_parameters(context)
content = context['.content']
td = {'class': params['class']}
with content.template_node('cell', app.resolve_template(params.template), td):
yield logic.DeferNodeContents(self)
class Cell(LogicElement):
"""
A container for a single cell in a [tag tables]table[/tag].
"""
class Help:
synopsis = "a cell in a table"
xmlns = namespaces.tables
template = Attribute("Template", required=False, default="cell.html")
_class = Attribute("Extra class",
required=False,
map_to="class",
default=None)
_from = Attribute("Application",
type="application",
required=False,
default="moya.tables")
hide = Attribute("Hide this cell?",
type="boolean",
required=False,
default=False)
class Meta:
text_nodes = "text"
def logic(self, context):
app = self.get_app(context)
params = self.get_parameters(context)
content = context[".content"]
td = {"class": params["class"], "align": context["align"]}
with content.template_node("cell",
app.resolve_template(params.template), td):
if not params.hide:
yield logic.DeferNodeContents(self)
class Rows(LogicElement):
"""
Defines a collection of rows in a [tag tables]table[/tag].
A [tag tables]rows[/tag] tag may contain either [tag tables]row[/tag] tags [i]or[/i] -- if the [c]src[/c] attribute is set -- [tag tables]cell[/tag] tags.
When the [c]src[/c] attribute is set, it should be a sequence of values to be iterated over (like [tag]for[/tag]). Each item in the sequence will generate a row containing the enclosed [tag tables]cell[/tag] tags.
"""
class Help:
synopsis = "a collection of rows in a table"
xmlns = namespaces.tables
template = Attribute("Template", required=False, default="rows.html")
row_template = Attribute("Template", required=False, default="row.html")
row_class = Attribute("Extra class for rows", required=False, default=None)
style = Attribute("Optional CSS style", required=False)
src = Attribute("Sequence of row data", required=False, type="expression")
dst = Attribute("Destination", required=False, type="reference")
_id = Attribute("Table ID", required=False, default=None)
_from = Attribute("Application", type="application", required=False, default='moya.tables')
def logic(self, context):
params = self.get_parameters(context)
content = context['.content']
app = self.get_app(context)
if self.has_parameter('src'):
objects, dst = self.get_parameters(context, 'src', 'dst')
with content.template_node('rows', app.resolve_template(params.template)):
for obj in objects:
if dst:
context[dst] = obj
td = {'id': self.id(context),
'class': self.row_class(context),
'style': self.style(context)}
with content.template_node("row", app.resolve_template(params.row_template), td):
yield logic.DeferNodeContents(self)
else:
with content.template_node('rows', app.resolve_template(params.template)):
yield logic.DeferNodeContents(self)
class ApplyField(LogicElement):
"""
Apply a form field.
Invoked by [tag forms]apply[/tag].
"""
xmlns = namespaces.forms
class Help:
synopsis = "apply a form field"
field = Attribute("Field name", required=True)
def logic(self, context):
form = context['_return']
form.add_field_applyer(self.field(context), self.get_closure(context))
class Reset(ContextElementBase):
"""
Resets a form to a blank state.
"""
xmlns = namespaces.forms
class Help:
synopsis = "reset a form"
src = Attribute("Form source",
type="index",
default="form",
evaldefault=True,
map_to="src")
def logic(self, context):
form = self.src(context)
form.reset()
class _Field(FieldElement):
"""
This tag adds a field to the form object, but defers the rendering to enclosed content.
"""
fieldname = Attribute("Field name", required=False, default="field")
class Meta:
synopsis = "add a custom field to a form"
tag_name = "field"
example = """
<field name="example">
<moya:node template="custom_field.html" />
</field>
"""
class Help:
synopsis = "add a custom field to a form"
class SortHeader(LogicElement):
"""
Define a sortable header column in a [tag tables]table[/tag].
"""
class Help:
synopsis = "define a sortable header column in a table"
xmlns = namespaces.tables
template = Attribute("Template", required=False, default="sortheader.html")
_class = Attribute("Extra class",
required=False,
map_to="class",
default=None)
name = Attribute("Name to be set in query string", required=True)
_from = Attribute("Application",
type="application",
required=False,
default='moya.tables')
hide = Attribute("Hide this column?",
type="boolean",
required=False,
default=False)
align = Attribute("Alignment of column",
required=False,
choices=['left', 'center', 'right'],
default="left")
class Meta:
text_nodes = "text"
def logic(self, context):
app = self.get_app(context)
params = self.get_parameters(context)
content = context['.content']
td = {
'class': params['class'],
'align': params.align,
'name': params.name
}
context['_moyatable._cols'].append({
'hide': params.hide,
'align': params.align
})
if not params.hide:
with content.template_node('column',
app.resolve_template(params.template),
td):
yield logic.DeferNodeContents(self)
class OptGroup(LogicElement):
"""
Add an optgroup (heading for options) to a select.
"""
xmlns = namespaces.forms
label = Attribute("Label", required=True)
class Help:
synopsis = "add an optgroup to a select"
def logic(self, context):
if '_select' not in context:
# TODO: Throw an error?
return
context['_select'].set_group(self.label(context))
yield logic.DeferNodeContents(self)
context['_select'].set_group(None)