def logic(self, context):
form = context['_return']
path = "/moya.forms/styles/%s/actions.html" % form.style
form.content.add_template(self._tag_name, path, {})
with form.content.node():
yield logic.DeferNodeContents(self)
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('column', app.resolve_template(params.template), td):
yield logic.DeferNodeContents(self)
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)
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)
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)
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)
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)
def logic(self, context):
params = self.get_parameters(context)
content = context['.content']
table = {
"class": params['class'],
"id": params.id,
"caption": params.caption
}
app = self.get_app(context)
css_path = self.archive.get_media_url(context, app, 'media', 'css/tables.css')
content.include_css(css_path)
with content.template_node("table", app.resolve_template(params.template), {'table': table}):
yield logic.DeferNodeContents(self)
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)
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)
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)
def logic(self, context):
form, dst = self.get_parameters(context, 'src', 'dst')
form_data = form.data
dst_obj = context[dst]
if not hasattr(dst_obj, 'items'):
self.throw(
'moya.forms.bad-dst',
"Object referenced by 'dst' must be dict or other mapping type (not {})"
.format(to_expression(context, dst_obj)))
if dst:
field_names = self.fields(context)
if field_names is None:
fields = list(form.fields)
else:
fields = [form.fields[name] for name in field_names]
for field in fields:
applyers = form.field_applyers[field.name]
if applyers:
for apply_field in applyers:
with self.closure_call(
context,
form.app,
apply_field.data,
form=form,
object=dst_obj,
values=form.data,
value=form.data[field.name]) as call:
yield logic.DeferNodeContents(apply_field.element)
else:
with context.frame(dst):
field_dst = field.dst
if dst:
value = form_data.get(field.name, None)
try:
context[field_dst] = value
except Exception as e:
diagnosis_msg = "Check you are setting this field to an appropriate value."
self.throw(
'moya.forms.apply-fail',
"unable to set for field '{}' to {}".
format(dst, context.to_expr(value)),
diagnosis=diagnosis_msg,
info={
'field': field.name,
'error': text_type(e)
})
def logic(self, context):
params = self.get_parameters(context)
content = context[".content"]
table = {
"class": params["class"],
"id": params.id,
"caption": params.caption,
"_cols": [],
}
app = self.get_app(context)
css_path = self.archive.get_media_url(context, app, "media",
"css/tables.css")
content.include_css(css_path)
with context.data_scope():
context["_moyatable"] = table
with content.template_node("table",
app.resolve_template(params.template),
{"table": table}):
yield logic.DeferNodeContents(self)
def logic(self, context):
form = context['_return']
params = self.get_field_parameters(context)
template = params.pop('template', None)
style = params.pop('style')
field = form.add_field(params,
enctype=self.enctype,
default=self.get_default(),
style=style,
process_value=self.process(context),
template=template,
adapt_value=self.adapt(context),
data=self.get_let_map(context))
content = context['.content']
context['field'] = field
if field is not None:
content.add_renderable(self._tag_name, field)
with content.node():
yield logic.DeferNodeContents(self)
def logic(self, context):
form = self.src(context)
if not form.bound:
return
extends = [form.element]
el = form.element
while 1:
extend = el.extends(context)
if not extend:
break
app, el = el.get_element(extend)
extends.append(el)
values = {
name: field.value
for name, field in iteritems(form.fields_map)
}
app = self.get_app(context)
new_values = {}
for field in form.fields:
new_values[field.name] = field.value
if field.required and field.value in ('', None):
form.add_fail(field.name, "This field is required")
else:
for validate_field in form.get_field_validators(field.name):
with self.closure_call(context,
app,
validate_field.data,
_field=field,
form=form,
value=values[field.name],
values=values,
field=field.value):
yield logic.DeferNodeContents(validate_field.element)
if not form.errors:
for field in form.fields:
if field.adapt_value is not None:
value = new_values[field.name]
new_value = field.adapt_value(context, value=value)
new_values[field.name] = new_value
for field in form.fields:
for adapt_field in form.get_field_adapters(field.name):
value = new_values[field.name]
with self.closure_call(context,
app,
adapt_field.data,
form=form,
values=values,
value=value) as call:
yield logic.DeferNodeContents(adapt_field.element)
if call.has_return:
new_values[field.name] = call.return_value
for field in form.fields:
form.set_field_data(field.name, new_values[field.name])
form.validated = True
if form.ok:
yield logic.DeferNodeContents(self)
yield logic.SkipNext((namespaces.default, "else"))
def logic(self, context):
(bind, form, src, dst, style, template, action, withscope,
blank) = self.get_parameters(context, 'bind', 'form', 'src', 'dst',
'style', 'template', 'action',
'withscope', 'blank')
if withscope:
scope = context['.call']
call = self.push_funccall(context)
try:
yield logic.DeferNodeContents(self)
call.update(self.get_let_map(context))
args, kwargs = call.get_call_params()
if withscope:
new_kwargs = scope
new_kwargs.update(kwargs)
kwargs = new_kwargs
finally:
self.pop_funccall(context)
app = self.get_app(context)
form_app, form_element = self.get_element(form, app)
app = form_app or app
template = app.resolve_template(template)
with self.call(context, app, **kwargs) as call:
(form_style, form_template, form_action, _class,
enctype) = form_element.get_parameters(context, 'style',
'template', 'action',
'class', 'enctype')
style = form_style or style
template = form_template or template
action = form_action or action
if action is None:
action = context['.request.path']
context['_return'] = form = Form(form_element,
context,
app,
style=style,
template=template,
action=action,
enctype=enctype,
_class=_class)
context['_content'] = form
extends = [form_element]
el = form_element
visited = {}
while 1:
extend = el.extends(context)
if not extend:
break
parent_el = el
app, el = el.get_element(extend)
if (app, el) in visited:
raise errors.ElementError(
"Recursive form extends, element {} has already been extended"
.format(el),
element=self,
diagnosis=
"This form has circular references. i.e. the extend attribute references a form that has already been extended."
)
visited[(app, el)] = parent_el
if not style:
style = el.style(context)
if not template:
template = el.template(context)
if not action:
action = el.action(context)
extends.append(el)
form.style = style or "simple"
form.template = template
form.action = action or ""
with push_content(context, form.content):
with form.content.section('fields'):
for el in reversed(extends):
yield logic.DeferNodeContents(el)
if call.has_return:
form = call.return_value
bindings = []
initial_binding = form.get_initial_binding(context)
if initial_binding:
bindings.append(initial_binding)
if src and context[src]:
bindings.append(form.get_src_binding(context, src))
if bind and not blank:
binding = form.get_binding(context, bind)
bindings.append(binding)
if bindings:
form.bind(context, *bindings)
else:
form = None
context[dst] = form
def run(self, context):
yield logic.DeferNodeContents(self)
