class TagFormSchema(validators.Schema):
id = validators.Int()
tag = validators.UnicodeString(not_empty=True, max=20, strip=True)
default = validators.StringBool(if_empty=False)
expire_in_days = validators.Int()
needs_product = validators.StringBool(if_empty=False)
chained_validators = [UniqueRetentionTag('id', 'tag')]
class LabInfoForm(HorizontalForm):
fields = [
HiddenField(name="id"),
HiddenField(name="labinfo"),
TextField(name='orig_cost', label=_(u'Original Cost'),
validator=validators.Money()),
TextField(name='curr_cost', label=_(u'Current Cost'),
validator=validators.Money()),
TextField(name='dimensions', label=_(u'Dimensions')),
TextField(name='weight', label=_(u'Weight'),
validator=validators.Int()),
TextField(name='wattage', label=_(u'Wattage'),
validator=validators.Int()),
TextField(name='cooling', label=_(u'Cooling'),
validator=validators.Int()),
]
submit_text = _(u'Save Lab Info Changes')
def update_params(self, d):
super(LabInfoForm, self).update_params(d)
if 'labinfo' in d['value']:
if d['value']['labinfo']:
labinfo = d['value']['labinfo']
d['value']['orig_cost'] = labinfo.orig_cost
d['value']['curr_cost'] = labinfo.curr_cost
d['value']['dimensions'] = labinfo.dimensions
d['value']['weight'] = labinfo.weight
d['value']['wattage'] = labinfo.wattage
d['value']['cooling'] = labinfo.cooling
class Root(RootController):
@expose(template='videostore.templates.index')
@identity.require(identity.not_anonymous())
def index(self):
return dict(movies=Movie.query.all())
@expose(template='videostore.templates.movie')
@identity.require(identity.not_anonymous())
@validate(validators=dict(movieID=validators.Int()))
def movie(self, movieID):
return dict(movie=Movie.get(movieID))
@expose(template='videostore.templates.actor')
@identity.require(identity.not_anonymous())
@validate(validators=dict(actorID=validators.Int()))
def actor(self, actorID):
return dict(actor=Actor.get(actorID))
@expose(template='videostore.templates.director')
@identity.require(identity.not_anonymous())
@validate(validators=dict(directorID=validators.Int()))
def director(self, directorID):
return dict(director=Director.get(directorID))
@expose(template='videostore.templates.login')
def login(self, forward_url=None, previous_url=None, *args, **kw):
if not identity.current.anonymous and \
identity.was_login_attempted() and not \
identity.get_identity_errors():
raise redirect(forward_url)
forward_url = None
previous_url = request.path
if identity.was_login_attempted():
msg = 'The credentials you supplied were not correct.'
elif identity.get_identity_errors():
msg = 'You must provide your credentials.'
else:
msg = 'Please log in.'
forward_url = request.headers.get('Referer', '/')
response.status = 403
return dict(message=msg,
previous_url=previous_url,
logging_in=True,
original_parameters=request.params,
forward_url=forward_url)
@expose()
def logout(self):
identity.current.logout()
raise redirect("/")
class NestedController(Controller):
def nest(self, bar=""):
return dict(title="Nested")
nest = error_handler()(nest)
nest = validate(validators={"bar": validators.Int(not_empty=True)})(nest)
nest = expose()(nest)
class FieldsSchema(validators.Schema):
chained_validators = [validators.FieldsMatch('passwd', 'passwd2')]
name = validators.UnicodeString()
age = validators.Int()
passwd = validators.NotEmpty()
passwd2 = validators.UnicodeString()
class MyFormFields(widgets.WidgetsList):
#XXX: Since allow_extra_fields should be removed from validators.Schema,
# we need a validator for every input-expecting widget
name = widgets.TextField(validator=validators.String())
age = widgets.TextField(validator=validators.Int(), default=0)
date = widgets.CalendarDatePicker(validator=validators.DateConverter(
if_empty=datetime.now()))
def test_validation():
"""Values can be converted to/from Python values"""
textfield = widgets.TextField("age", validator=validators.Int())
output = textfield.render(2, format="xhtml")
assert 'value="2"' in output
value = "2"
value = textfield.validator.to_python(value)
assert value == 2
class UserFormSchema(validators.Schema):
user_id = validators.Int()
user_name = validators.UnicodeString(not_empty=True, strip=True)
display_name = validators.UnicodeString(not_empty=True, strip=True)
disabled = validators.StringBool(if_empty=False)
email_address = validators.Email(not_empty=True, strip=True)
chained_validators = [beaker_validators.UniqueUserName('user_id',
'user_name')]
def test_disabled_widget():
form = widgets.TableForm(fields=[
widgets.TextField("name"),
widgets.TextField("age", validator=validators.Int())
],
submit_text="Submit")
output = form.render(disabled_fields=["age"])
assert "age" not in output
class InputFieldsSchema(validators.Schema):
# Regex validator ensures only certain characters are input, essentially alphanumeric with new lines and spaces
peptide = validators.All(
accesionOrSeq(), validators.String(min=3),
validators.Regex(
r'^[^\x00-\x09\x0B-\x0C\x0E-\x1F\x21-\x2F\x3A-\x3C\x3F-\x40\x5B-\x5E\x60\x7B\x7D-\x7F]*$'
))
enzyme = validators.OneOf([
"Chymotrypsin", "Chymotrypsin Low Specificity", "Trypsin",
"Pepsin (ph = 1.3)", "Pepsin (ph >= 2.0)"
])
misses = validators.Int(if_empty=0, min=0, max=50)
minlen = validators.Int(if_empty=0, min=0)
maxlen = validators.Int(if_empty=1000000000, min=0)
minweight = validators.Int(if_empty=500, min=0)
maxweight = validators.Int(if_empty=1000000000, min=0)
def test_input_errors():
"""Data is stored in the request object if there are errors"""
form = widgets.TableForm(fields=[
widgets.TextField("name"),
widgets.TextField("age", validator=validators.Int())
])
values = dict(name="ed", age="ed")
values, errors = catch_validation_errors(form, values)
assert "enter an integer" in str(errors["age"])
def _guess_validator(self):
"""Inspect sample option value to guess validator (crude)."""
sample_option = self._get_sample_option()
if isinstance(sample_option, int):
return validators.Int()
elif isinstance(sample_option, basestring):
return validators.String()
else:
raise TypeError("Unknown option type in SelectionField: %r" %
(sample_option, ))
def test_callable_options_for_selection_field():
cc = CallableCounter()
w = widgets.CheckBoxList('collections', label='Collections', options=cc)
assert cc.counter == 1 # called once to guess validator
cc = CallableCounter()
w = widgets.CheckBoxList('collections',
label='Collections',
validator=validators.Int(),
options=cc)
assert cc.counter == 0 # cc shouldn't be called if validator is provided
def test_input_conversion():
"""Input for the whole form can be validated and converted"""
form = widgets.TableForm(fields=[
widgets.TextField("name"),
widgets.TextField("age", validator=validators.Int())
],
submit_text="Submit")
values = dict(name="ed", age="15")
values = form.validate(values)
assert values["name"] == "ed"
assert values["age"] == 15
assert not values.has_key("submit")
class TaskSearchForm(RemoteForm):
template = "bkr.server.templates.task_search_form"
params = ['options','hidden']
fields = [HiddenField(name='system_id', validator=validators.Int()),
HiddenField(name='distro_id', validator=validators.Int()),
HiddenField(name='distro_tree_id', validator=validators.Int()),
HiddenField(name='task_id', validator=validators.Int()),
TextField(name='task', label=_(u'Task')),
TextField(name='version', label=_(u'Version')),
TextField(name='system', label=_(u'System')),
SingleSelectField(name='arch_id', label=_(u'Arch'),validator=validators.Int(),
options=model.Arch.get_all),
TextField(name='distro', label=_(u'Distro')),
TextField(name='whiteboard', label=_(u'Recipe Whiteboard')),
SingleSelectField(name='osmajor_id', label=_(u'Family'),validator=validators.Int(),
options=lambda: [(0, 'All')] + [(m.id, m.osmajor) for m
in model.OSMajor.ordered_by_osmajor(model.OSMajor.used_by_any_recipe())]),
SingleSelectField(name='status', label=_(u'Status'), validator=ValidEnumValue(model.TaskStatus),
options=lambda: [(None, 'All')] + [(status, status.value) for status in model.TaskStatus]),
SingleSelectField(name='result', label=_(u'Result'), validator=ValidEnumValue(model.TaskResult),
options=lambda: [(None, 'All')] + [(result, result.value) for result in model.TaskResult]),
]
before = 'task_search_before()'
on_complete = 'task_search_complete()'
submit_text = _(u'Submit Query')
def __init__(self, *args, **kw):
super(TaskSearchForm,self).__init__(*args,**kw)
self.javascript.extend([LocalJSLink('bkr', '/static/javascript/loader_v2.js')])
def update_params(self, d):
super(TaskSearchForm, self).update_params(d)
if 'arch_id' in d['options']:
d['arch_id'] = d['options']['arch_id']
def test_passing_instance():
"""You can pass an instance to a form for the value"""
form = widgets.TableForm(fields=[
widgets.TextField("name"),
widgets.TextField("age", validator=validators.Int())
],
submit_text="Submit")
class Person(object):
name = "ed"
age = 892
output = form.render(Person(), format="xhtml")
assert 'value="ed"' in output
assert 'value="892"' in output
class OSVersions(AdminPage):
# For XMLRPC methods in this class.
exposed = False
id = widgets.HiddenField(name="id")
alias = widgets.TextField(name="alias",
validator=validators.UnicodeString(if_empty=None))
arches = CheckBoxList(name="arches", label="Arches",
options=lambda: [(arch.id, arch.arch) for arch in Arch.query],
validator=validators.Int())
osmajor_form = HorizontalForm(
fields = [id, alias],
submit_text = _(u"Edit OSMajor"),
)
osversion_form = HorizontalForm(
fields = [id, arches],
action = "edit osversion",
submit_text = _(u"Edit OSVersion"),
)
def __init__(self,*args,**kw):
kw['search_name'] = 'osversion'
kw['search_url'] = url("/osversions/by_name?anywhere=1")
super(OSVersions,self).__init__(*args,**kw)
self.search_col = OSMajor.osmajor
self.join = [OSVersion.osmajor]
self.search_mapper = OSVersion
self.add = False
@identity.require(identity.in_group("admin"))
@expose(template="bkr.server.templates.form")
def edit(self, id=None, *args, **kw):
try:
osversion = OSVersion.by_id(id)
except InvalidRequestError:
flash(_(u"Invalid OSVersion ID %s" % id))
redirect(".")
return dict(title = unicode(osversion),
value = dict(id = osversion.id,
arches = [arch.id for arch in osversion.arches]),
form = self.osversion_form,
action = "./save",
options = None)
@identity.require(identity.in_group("admin"))
@expose(template="bkr.server.templates.osmajor")
def edit_osmajor(self, id=None, *args, **kw):
try:
osmajor = OSMajor.by_id(id)
except InvalidRequestError:
flash(_(u"Invalid OSMajor ID %s" % id))
redirect(".")
return dict(title = "OSMajor",
value = osmajor,
form = self.osmajor_form,
action = "./save_osmajor",
options = None)
@identity.require(identity.in_group("admin"))
@expose()
@validate(form=osmajor_form)
def save_osmajor(self, id=None, alias=None, *args, **kw):
try:
osmajor = OSMajor.by_id(id)
except InvalidRequestError:
flash(_(u"Invalid OSMajor ID %s" % id))
redirect(".")
if osmajor.alias != alias:
if alias:
try:
existing = OSMajor.by_name_alias(alias)
except NoResultFound:
pass
else:
flash(_(u'Cannot save alias %s, it is already used by %s')
% (alias, existing))
redirect('.')
osmajor.alias = alias
flash(_(u"Changes saved for %s" % osmajor))
else:
flash(_(u"No changes for %s" % osmajor))
redirect(".")
@identity.require(identity.in_group('admin'))
@expose()
def save_osmajor_installopts(self, osmajor_id=None, installopts=None):
try:
osmajor = OSMajor.by_id(osmajor_id)
except InvalidRequestError:
flash(_(u"Invalid OSMajor ID %s" % id))
redirect(".")
for arch, options in installopts.iteritems():
# arch=None means applied to all arches
io = OSMajorInstallOptions.lazy_create(osmajor_id=osmajor.id,
arch_id=Arch.by_name(arch).id if arch else None)
io.ks_meta = options['ks_meta']
io.kernel_options = options['kernel_options']
io.kernel_options_post = options['kernel_options_post']
flash(_(u'Install options saved for %s') % osmajor)
redirect('.')
@identity.require(identity.in_group("admin"))
@expose()
@validate(form=osversion_form)
def save(self, id=None, arches=None, *args, **kw):
try:
osversion = OSVersion.by_id(id)
except InvalidRequestError:
flash(_(u"Invalid OSVersion ID %s" % id))
redirect(".")
arch_objects = [Arch.by_id(arch) for arch in arches]
if osversion.arches != arch_objects:
osversion.arches = arch_objects
flash(_(u"Changes Saved for %s" % osversion))
else:
flash(_(u"No Changes for %s" % osversion))
redirect(".")
@expose(format='json')
def by_name(self, input,*args,**kw):
input = input.lower()
if 'anywhere' in kw:
search = OSVersion.list_osmajor_by_name(input, find_anywhere=True)
else:
search = OSVersion.list_osmajor_by_name(input)
osmajors = ["%s" % (match.osmajor.osmajor) for match in search]
osmajors = list(set(osmajors))
return dict(matches=osmajors)
@expose(template="bkr.server.templates.admin_grid")
@paginate('list',limit=50, default_order='osmajor.osmajor')
def index(self,*args,**kw):
osversions = self.process_search(*args,**kw)
list_by_letters = []
for elem in osversions:
osmajor_name = elem.osmajor.osmajor
if osmajor_name:
list_by_letters.append(osmajor_name[0].capitalize())
alpha_nav_data = set(list_by_letters)
template_data = self.osversions(osversions,*args, **kw)
nav_bar = self._build_nav_bar(alpha_nav_data,self.search_name)
template_data['alpha_nav_bar'] = nav_bar
template_data['search_widget'] = self.search_widget_form
return template_data
def osversions(self, osversions=None, *args, **kw):
q = session.query(self.search_mapper) # This line +3 dupes the start of process_search
if osversions is None:
for j in self.join:
q = q.join(j)
osversions = q
osversions_grid = myPaginateDataGrid(fields=[
myPaginateDataGrid.Column(name='osmajor.osmajor', getter=lambda x: make_link(url = './edit_osmajor?id=%s' % x.osmajor.id, text = x.osmajor), title='OS Major', options=dict(sortable=True)),
myPaginateDataGrid.Column(name='osmajor.alias', getter=lambda x: x.osmajor.alias, title='Alias', options=dict(sortable=True)),
myPaginateDataGrid.Column(name='osminor', getter=lambda x: make_link(url = './edit?id=%s' % x.id, text = x.osminor), title='OS Minor', options=dict(sortable=True)),
myPaginateDataGrid.Column(name='arches', getter=lambda x: " ".join([arch.arch for arch in x.arches]), title='Arches', options=dict(sortable=True)),
])
return dict(title="OS Versions",
grid = osversions_grid,
addable = False,
list = osversions)
default = index
class SimpleFields(widgets.WidgetsList):
age = widgets.TextField(validator=validators.Int())
phone = widgets.TextField()
class SimpleSchema(validators.Schema):
phone = validators.Int()
class Configuration(AdminPage):
exposed = False
id = widgets.HiddenField(name='id')
value_str = widgets.TextArea(name='value', label=_(u'Value'))
value_int = widgets.TextField(name='value',
label=_(u'Value'),
validator=validators.Int())
valid_from = widgets.TextField(
name='valid_from',
label=_(u'Effective from date'),
help_text=
u"Enter date and time (YYYY-MM-DD HH:MM) in the future or leave blank for setting to take immediate effect"
)
string_form = HorizontalForm(
'configitem',
fields=[id, value_str, valid_from],
action='save_data',
submit_text=_(u'Save'),
)
int_form = HorizontalForm(
'configitem',
fields=[id, value_int, valid_from],
action='save_data',
submit_text=_(u'Save'),
)
value_grid = BeakerDataGrid(fields=[
('Value', lambda x: x.value),
('Effective from', lambda x: x.valid_from, {'datetime': True}),
('Set by', lambda x: x.user),
('Date set', lambda x: x.modified, {'datetime': True}),
('', lambda x: x.valid_from <= datetime.utcnow() and " " or \
make_link(url = 'delete?item=%s&id=%s' % (x.config_item.id, x.id), text = 'Delete')),
])
def __init__(self, *args, **kw):
kw['search_url'] = url("/configuration/by_name?anywhere=1"),
kw['search_name'] = 'name'
super(Configuration, self).__init__(*args, **kw)
self.search_col = ConfigItem.name
self.search_mapper = ConfigItem
@identity.require(identity.in_group("admin"))
@expose(template='bkr.server.templates.config_edit')
def edit(self, **kw):
if kw.get('id'):
item = ConfigItem.by_id(kw['id'])
form_values = dict(id=item.id,
numeric=item.numeric,
value=item.current_value())
else:
flash(_(u"Error: No item ID specified"))
raise redirect(".")
# Show all future values, and the previous five
config_values = item.values().filter(item.value_class.valid_from > datetime.utcnow()).order_by(item.value_class.valid_from.desc()).all() \
+ item.values().filter(item.value_class.valid_from <= datetime.utcnow()).order_by(item.value_class.valid_from.desc())[:5]
if item.readonly:
form = None
elif item.numeric:
form = self.int_form
else:
form = self.string_form
return dict(
title=item.name,
subtitle=item.description,
form=form,
action='./save',
options={},
value=form_values,
list=config_values,
grid=self.value_grid,
warn_msg=item.readonly and "This item is read-only",
)
@expose()
@error_handler(edit)
@identity.require(identity.in_group("admin"))
def save(self, **kw):
if 'id' in kw and kw['id']:
item = ConfigItem.by_id(kw['id'])
else:
flash(_(u"Error: No item ID"))
raise redirect(".")
if kw['valid_from']:
try:
valid_from = datetime.strptime(kw['valid_from'],
'%Y-%m-%d %H:%M')
except ValueError:
flash(
_(u"Invalid date and time specification, use: YYYY-MM-DD HH:MM"
))
raise redirect("/configuration/edit?id=%d" % item.id)
else:
valid_from = None
try:
item.set(kw['value'], valid_from, identity.current.user)
except Exception, msg:
flash(_(u"Failed to save setting: %s" % msg))
raise redirect("/configuration/edit?id=%d" % item.id)
flash(_(u"%s saved" % item.name))
redirect(".")
import re
import cherrypy
import turbogears.validators as validators
import turbogears.widgets as widgets
from turbogears.testutil import catch_validation_errors
from turbogears.widgets.meta import copy_schema
oldrequest = None
int_validator = validators.Int(if_empty=None)
s_validator = validators.Schema(age=int_validator, ignore_key_missing=True)
class Request:
validation_errors = {}
def setup_module():
global oldrequest
oldrequest = cherrypy.request
cherrypy.request = Request()
def teardown_module():
global oldrequest
cherrypy.request = oldrequest
#XXX: We ignore missing keys to make passing value easier in tests
class TestSchema(validators.Schema):
class NewUpdateForm(Form):
template = "bodhi.templates.new"
submit_text = "Save Update"
update_types = config.get('update_types').split()
request_types = ['Testing', 'Stable', 'None', None]
fields = [
AutoCompleteField('builds', label='Package',
search_controller=url('/new/search'),
search_param='name', result_name='pkgs',
template='bodhi.templates.packagefield',
validator=AutoCompleteValidator()),
CheckBox('inheritance', label='Follow Build inheritance',
validator=validators.StringBool(),
default=False, attrs={'title' : 'Build Inheritance - '
'TODO'}),
SingleSelectField('type_', label='Type', options=update_types,
validator=validators.OneOf(update_types)),
SingleSelectField('request', options=request_types,
validator=validators.OneOf(request_types +
[r.lower() for r in request_types if r]),
default='testing'),
TextField('bugs', validator=BugValidator(),
attrs={'title' : 'Bug Numbers - A space or comma '
'delimited list of bug numbers or '
'aliases. Example: #1234, 789 '
'CVE-2008-0001'}),
TextArea('notes', validator=validators.UnicodeString(),
rows=13, cols=65,
attrs={'title' : 'Advisory Notes - <p>Some details '
'about this update that will appear in '
'the notice.</p>'
'<p><strong>Example:</strong><br />'
'This is an update that fixes problems with '
'**<strong>connecting to a share</strong>**.</p>'
'<p>The following things *<em>break</em>*:</p>'
'<p>* Browsing with `<code>gnome-app-install</code>`<br />'
'* Emailing</p>'}),
CheckBox(name='close_bugs', help_text='Automatically close bugs',
validator=validators.StringBool(),
default=True, attrs={'title' : 'Close Bugs - '
'Automatically close bugs '
'when this update is '
'pushed as stable'}),
HiddenField('edited', default=None),
CheckBox(name='suggest_reboot', label='Suggest Reboot',
validator=validators.StringBool(),
default=False, attrs={'title': 'Suggest Reboot - '
'Recommend that the user '
'restarts their machine '
'after installing this '
'update'}),
CheckBox(name='autokarma', label='Enable karma automatism',
default=True, validator=validators.StringBool(),
attrs={'onchange':
'if ($("#form_autokarma").attr("checked")) {'
'$("#form_stable_karma").attr("disabled", false);'
'if ($("#form_stable_karma").attr("value") == 0) $("#form_stable_karma").attr("value", 3);'
'$("#form_unstable_karma").attr("disabled", false);'
'if ($("#form_unstable_karma").attr("value") == 0) $("#form_unstable_karma").attr("value", -3);'
' } else { '
'$("#form_stable_karma").attr("disabled", true);'
'$("#form_unstable_karma").attr("disabled", true);'
'}',
'title': 'Karma Automatism - Enable update request '
'automation based on user feedback',
}),
TextField('stable_karma', label='Threshold for pushing to stable',
validator=validators.Int(), default='3',
attrs={'title' : 'Stable Karma - The threshold for '
'automatically pushing this update to stable',
'size' : '1'}),
TextField('unstable_karma', label='Threshold for unpushing',
validator=validators.Int(), default='-3',
attrs={'title' : 'Unstable Karma - The threshold for '
'automatically unpushing an unstable update',
'size' : '1'})
]
class MyFields(widgets.WidgetsList):
age = widgets.TextField(validator=validators.Int())
email = widgets.TextArea(validator=validators.Email())
class Fields(widgets.WidgetsList):
name = widgets.TextField(validator=validators.UnicodeString())
age = widgets.TextField(validator=validators.Int())
passwd = widgets.PasswordField(validator=validators.NotEmpty())
passwd2 = widgets.PasswordField(validator=validators.UnicodeString())
class Foo(widgets.InputWidget):
validator = validators.Int()
class MyRoot(RootController):
def defaulterrorhandler(self, tg_source, tg_errors, tg_exceptions,
*args, **kw):
return dict(title="Default error handler",
errors=_errors_to_str(tg_errors), args=args, kw=kw)
def specialisederrorhandler(self, tg_source, tg_errors, *args, **kw):
return dict(title="Specialised error handler",
errors=_errors_to_str(tg_errors), args=args, kw=kw)
def defaulterror(self, bar=""):
return dict(title="Default error provider")
defaulterror = error_handler(defaulterrorhandler)(defaulterror)
defaulterror = validate(validators={"bar": validators.StringBoolean()})(
defaulterror)
defaulterror = expose()(defaulterror)
def specialisederror(self, bar="", baz=""):
return dict(title="Specialised error provider")
specialisederror = error_handler(defaulterrorhandler)(
specialisederror)
specialisederror = error_handler(specialisederrorhandler,
"'baz' in tg_errors")(specialisederror)
specialisederror = validate(validators={
"bar": validators.Int(not_empty=True),
"baz": validators.Email()})(specialisederror)
specialisederror = expose()(specialisederror)
def exceptionerror(self):
raise Exception("Exception 1")
exceptionerror = exception_handler(defaulterrorhandler)(exceptionerror)
exceptionerror = expose()(exceptionerror)
def exceptionerror2(self):
raise Exception("Exception 2")
exceptionerror2 = exception_handler(exceptionerror2)(exceptionerror2)
exceptionerror2 = expose()(exceptionerror2)
def recursiveerror(self, tg_errors=None, bar=""):
if tg_errors:
return dict(title="Recursive error handler")
else:
return dict(title="Recursive error provider")
recursiveerror = error_handler()(recursiveerror)
recursiveerror = validate(validators={
"bar": validators.Int(not_empty=True)})(recursiveerror)
recursiveerror = expose()(recursiveerror)
def impliciterror(self, tg_errors=None, bar=""):
if tg_errors:
return dict(title="Implicit error handler",
tg_errors=str(tg_errors))
else:
return dict(title="Implicit error provider")
impliciterror = validate(validators={
"bar": validators.Int(not_empty=True)})(impliciterror)
impliciterror = expose()(impliciterror)
def normalmethod(self):
return dict(title="Normal method")
normalmethod = expose()(normalmethod)
def normalmethodcaller(self, bar=""):
return dict(title="Normal method caller")
normalmethodcaller = error_handler(normalmethod)(normalmethodcaller)
normalmethodcaller = validate(validators={
"bar": validators.StringBoolean()})(normalmethodcaller)
normalmethodcaller = expose()(normalmethodcaller)
def infiniteloop(self):
try:
self.exceptionerror2()
except Exception, e:
return dict(title=str(e))
else:
return dict(title=str(e))
else:
return dict(title="Infinite loop provider")
infiniteloop = expose()(infiniteloop)
def positionalargs(self, first, second, *args, **kw):
self.first = first
self.second = second
self.third = args[0]
return dict(title="Positional arguments", first=first, second=second,
args=args, bar=kw["bar"])
positionalargs = error_handler(defaulterrorhandler)(
positionalargs)
positionalargs = validate(validators={
"bar": validators.StringBoolean(),
"second": validators.Int(not_empty=True)})(positionalargs)
positionalargs = expose()(positionalargs)
def missingargs(self, bar=""):
return dict(title="Missing args provider")
missingargs = error_handler(defaulterrorhandler)(missingargs)
missingargs = validate(validators={
"bar": validators.Int(not_empty=True)})(missingargs)
missingargs = expose()(missingargs)
def nohandler2(self, bar=""):
return dict(title="No handler inner")
nohandler2 = validate(validators={
"bar": validators.Int(not_empty=True)})(nohandler2)
nohandler2 = expose()(nohandler2)
import turbogears
import cherrypy
from turbogears import widgets
from turbogears import controllers
from turbogears import validators
from turbogears import testutil
myform = widgets.TableForm(fields = [
widgets.FieldSet(
name = "p_data",
fields = [
widgets.TextField(name="name"),
widgets.TextField(name="age",
validator=validators.Int()),
]),
])
class MyRoot(controllers.RootController):
def testform(self, p_data, tg_errors=None):
if tg_errors:
self.has_errors = True
self.name = p_data['name']
self.age = p_data['age']
testform = turbogears.validate(form=myform)(testform)
testform = turbogears.expose(template="turbogears.tests.othertemplate")(
testform)
def set_errors(self):
self.has_errors = True
def testform_new_style(self, p_data):
