def validate_for_api(self):
if not super(BaseForm, self).validate():
message = {'': ""}
for name, field in iteritems(self._fields):
if field.errors:
current_app.logger.error(
'form: %s, name: %s, errors: %s, json_data: %s',
self.__class__.__name__, name, field.errors,
self.json_data)
if isinstance(field, StringField):
message = {name: field.errors[0]}
break
if isinstance(field.errors, list):
message = {field.name: field.errors[0]}
break
elif isinstance(field.errors, dict):
for _, _field in iteritems(field.errors):
if _field:
message = {field.name: _field[0]}
break
print(
"form: %s, name: %s, errors: %s, json_data: %s" %
(self.__class__.__name__, name, field.errors, self.json_data))
return self, ParameterException(message=list(message.values())[0])
return self, None
def populate_obj(self, obj, ignore_none=False):
"""
Populates the attributes of the passed `obj` with data from the form's
fields.
:note: This is a destructive operation; Any attribute with the same name
as a field will be overridden. Use with caution.
"""
if ignore_none:
for name, field in iteritems(self._fields):
if field.data is not None:
field.populate_obj(obj, name)
else:
for name, field in iteritems(self._fields):
field.populate_obj(obj, name)
def __init__(self, formdata=None, obj=None, prefix="", data=None, meta=None, **kwargs):
"""
:param formdata:
Used to pass data coming from the enduser, usually `request.POST` or
equivalent. formdata should be some sort of request-data wrapper which
can get multiple parameters from the form input, and values are unicode
strings, e.g. a Werkzeug/Django/WebOb MultiDict
:param obj:
If `formdata` is empty or not provided, this object is checked for
attributes matching form field names, which will be used for field
values.
:param prefix:
If provided, all fields will have their name prefixed with the
value.
:param data:
Accept a dictionary of data. This is only used if `formdata` and
`obj` are not present.
:param meta:
If provided, this is a dictionary of values to override attributes
on this form's meta instance.
:param `**kwargs`:
If `formdata` is empty or not provided and `obj` does not contain
an attribute named the same as a field, form will assign the value
of a matching keyword argument to the field, if one exists.
"""
meta_obj = self._wtforms_meta()
if meta is not None and isinstance(meta, dict):
meta_obj.update_values(meta)
super(Form, self).__init__(self._unbound_fields, meta=meta_obj, prefix=prefix)
for name, field in iteritems(self._fields):
# Set all the fields to attributes so that they obscure the class
# attributes with the same names.
setattr(self, name, field)
self.process(formdata, obj, data=data, **kwargs)
def process(self, formdata=None, obj=None, **kwargs):
"""
Take form, object data, and keyword arg input and have the fields
process them.
:param formdata:
Used to pass data coming from the enduser, usually `request.POST` or
equivalent.
:param obj:
If `formdata` is empty or not provided, this object is checked for
attributes matching form field names, which will be used for field
values.
:param `**kwargs`:
If `formdata` is empty or not provided and `obj` does not contain
an attribute named the same as a field, form will assign the value
of a matching keyword argument to the field, if one exists.
"""
if formdata is not None and not hasattr(formdata, 'getlist'):
if hasattr(formdata, 'getall'):
formdata = WebobInputWrapper(formdata)
else:
raise TypeError("formdata should be a multidict-type wrapper that supports the 'getlist' method")
for name, field, in iteritems(self._fields):
if obj is not None and hasattr(obj, name):
field.process(formdata, getattr(obj, name))
elif name in kwargs:
field.process(formdata, kwargs[name])
else:
field.process(formdata)
def __init__(self, formdata=None, obj=None, prefix="", **kwargs):
"""
:param formdata:
Used to pass data coming from the enduser, usually `request.POST` or
equivalent.
:param obj:
If `formdata` is empty or not provided, this object is checked for
attributes matching form field names, which will be used for field
values.
:param prefix:
If provided, all fields will have their name prefixed with the
value.
:param `**kwargs`:
If `formdata` is empty or not provided and `obj` does not contain
an attribute named the same as a field, form will assign the value
of a matching keyword argument to the field, if one exists.
"""
super(Form, self).__init__(self._unbound_fields, prefix=prefix)
for name, field in iteritems(self._fields):
# Set all the fields to attributes so that they obscure the class
# attributes with the same names.
setattr(self, name, field)
self.process(formdata, obj, **kwargs)
def validate(self, filter=[], extra_validators=None, isParent=False):
if isParent:
return super(Form, self).validate()
self._errors = None
success = True
if callable(getattr(self, "_validate", None)):
_fields = self._validate()
else:
_fields = self._fields
for name, field in iteritems(_fields):
if name in filter or field in filter:
continue
if extra_validators is not None and name in extra_validators:
extra = extra_validators[name]
else:
extra = list()
inline = getattr(self.__class__, 'validate_%s' % name, None)
if inline is not None:
extra.append(inline)
if not field.validate(self, extra):
success = False
return success
def __init__(self, formdata=None, obj=None, prefix='', **kwargs):
"""
:param formdata:
Used to pass data coming from the enduser, usually `request.POST` or
equivalent.
:param obj:
If `formdata` is empty or not provided, this object is checked for
attributes matching form field names, which will be used for field
values.
:param prefix:
If provided, all fields will have their name prefixed with the
value.
:param `**kwargs`:
If `formdata` is empty or not provided and `obj` does not contain
an attribute named the same as a field, form will assign the value
of a matching keyword argument to the field, if one exists.
"""
super(Form, self).__init__(self._unbound_fields, prefix=prefix)
for name, field in iteritems(self._fields):
# Set all the fields to attributes so that they obscure the class
# attributes with the same names.
setattr(self, name, field)
self.process(formdata, obj, **kwargs)
def __init__(self, formdata=None, obj=None, prefix='', LOCALES=_unset_value, **kwargs):
"""
:param formdata:
Used to pass data coming from the enduser, usually `request.POST` or
equivalent. formdata should be some sort of request-data wrapper which
can get multiple parameters from the form input, and values are unicode
strings, e.g. a Werkzeug/Django/WebOb MultiDict
:param obj:
If `formdata` is empty or not provided, this object is checked for
attributes matching form field names, which will be used for field
values.
:param prefix:
If provided, all fields will have their name prefixed with the
value.
:param LOCALES:
If provided, this is a sequence of locale name strings that is
the priority order of locales to try to find validator message
translations at.
If `None`, then use the default gettext locale from the environ.
:param `**kwargs`:
If `formdata` is empty or not provided and `obj` does not contain
an attribute named the same as a field, form will assign the value
of a matching keyword argument to the field, if one exists.
"""
super(Form, self).__init__(self._unbound_fields, prefix=prefix, LOCALES=LOCALES)
for name, field in iteritems(self._fields):
# Set all the fields to attributes so that they obscure the class
# attributes with the same names.
setattr(self, name, field)
self.process(formdata, obj, **kwargs)
def process(self, formdata=None, obj=None, data=None, **kwargs):
"""
Take form, object data, and keyword arg input and have the fields
process them.
:param formdata:
Used to pass data coming from the enduser, usually `request.POST` or
equivalent.
:param obj:
If `formdata` is empty or not provided, this object is checked for
attributes matching form field names, which will be used for field
values.
:param data:
If provided, must be a dictionary of data. This is only used if
`formdata` is empty or not provided and `obj` does not contain
an attribute named the same as the field.
:param `**kwargs`:
If `formdata` is empty or not provided and `obj` does not contain
an attribute named the same as a field, form will assign the value
of a matching keyword argument to the field, if one exists.
"""
formdata = self.meta.wrap_formdata(self, formdata)
if data is not None:
# XXX we want to eventually process 'data' as a new entity.
# Temporarily, this can simply be merged with kwargs.
kwargs = dict(data, **kwargs)
for name, field in iteritems(self._fields):
if obj is not None and hasattr(obj, name):
field.process(formdata, getattr(obj, name))
elif name in kwargs:
field.process(formdata, kwargs[name])
else:
field.process(formdata)
def process(self, formdata=None, obj=None, data=None, **kwargs):
"""
This is identical to WTForm 2.1's implementation of 'process',
but it must pass in the User.studies.values() when it's called with
an object instead of just User.studies, since studies is a mapped
collection
"""
formdata = self.meta.wrap_formdata(self, formdata)
if data is not None:
# XXX we want to eventually process 'data' as a new entity.
# Temporarily, this can simply be merged with kwargs.
kwargs = dict(data, **kwargs)
for name, field, in iteritems(self._fields):
if obj is not None and hasattr(obj, name):
# This if statement is the only change made to the original
# code for BaseForm.process() - Dawn
if name == 'studies':
access_rights = []
for study in obj.studies:
access_rights.extend(obj.studies[study])
field.process(formdata, access_rights)
else:
field.process(formdata, getattr(obj, name))
elif name in kwargs:
field.process(formdata, kwargs[name])
else:
field.process(formdata)
def errors(self):
"""展平error"""
if self._errors is None:
self._errors = dict((name, flat_list(f.errors))
for name, f in iteritems(self._fields)
if f.errors)
return self._errors
def process(self, formdata=None, obj=None, data=None, **kwargs):
"""
Take form, object data, and keyword arg input and have the fields
process them.
:param formdata:
Used to pass data coming from the enduser, usually `request.POST` or
equivalent.
:param obj:
If `formdata` is empty or not provided, this object is checked for
attributes matching form field names, which will be used for field
values.
:param data:
If provided, must be a dictionary of data. This is only used if
`formdata` is empty or not provided and `obj` does not contain
an attribute named the same as the field.
:param `**kwargs`:
If `formdata` is empty or not provided and `obj` does not contain
an attribute named the same as a field, form will assign the value
of a matching keyword argument to the field, if one exists.
"""
formdata = self.meta.wrap_formdata(self, formdata)
if data is not None:
# XXX we want to eventually process 'data' as a new entity.
# Temporarily, this can simply be merged with kwargs.
kwargs = dict(data, **kwargs)
for name, field in iteritems(self._fields):
if obj is not None and hasattr(obj, name):
field.process(formdata, getattr(obj, name))
elif name in kwargs:
field.process(formdata, kwargs[name])
else:
field.process(formdata)
def process(self, formdata=None, obj=None, data=None, **kwargs):
"""
Overrides wtforms.form.py BaseForm.process.
Since we're going to load form fields from repeating fields in the object,
We have to play games with the field names.
"""
formdata = self.meta.wrap_formdata(self, formdata)
if data is not None:
# XXX we want to eventually process 'data' as a new entity.
# Temporarily, this can simply be merged with kwargs.
kwargs = dict(data, **kwargs)
for name, field, in iteritems(self._fields):
processed_from_obj = False
if obj is not None:
m = re.search(r'^(.+)_([0-6])$', name)
if m:
attr_name = m.group(1)
index = int(m.group(2))
day_prefs_obj = obj.days[index]
if hasattr(day_prefs_obj, attr_name):
field.process(formdata, getattr(day_prefs_obj, attr_name))
processed_from_obj = True
if not processed_from_obj:
if name in kwargs:
field.process(formdata, kwargs[name])
else:
field.process(formdata)
def html_params(**kwargs):
"""
Generate HTML attribute syntax from inputted keyword arguments.
The output value is sorted by the passed keys, to provide consistent output
each time this function is called with the same parameters. Because of the
frequent use of the normally reserved keywords `class` and `for`, suffixing
these with an underscore will allow them to be used.
In addition, the values ``True`` and ``False`` are special:
* ``attr=True`` generates the HTML compact output of a boolean attribute,
e.g. ``checked=True`` will generate simply ``checked``
* ``attr=`False`` will be ignored and generate no output.
>>> html_params(name='text1', id='f', class_='text')
'class="text" id="f" name="text1"'
>>> html_params(checked=True, readonly=False, name="text1", abc="hello")
'abc="hello" checked name="text1"'
"""
params = []
for k, v in sorted(iteritems(kwargs)):
if k in ('class_', 'class__', 'for_'):
k = k[:-1]
if v is True:
params.append(k)
elif v is False:
pass
else:
params.append('%s="%s"' % (text_type(k), escape(text_type(v), quote=True)))
return ' '.join(params)
def html_params(**kwargs):
"""
Generate HTML attribute syntax from inputted keyword arguments.
The output value is sorted by the passed keys, to provide consistent output
each time this function is called with the same parameters. Because of the
frequent use of the normally reserved keywords `class` and `for`, suffixing
these with an underscore will allow them to be used.
In addition, the values ``True`` and ``False`` are special:
* ``attr=True`` generates the HTML compact output of a boolean attribute,
e.g. ``checked=True`` will generate simply ``checked``
* ``attr=`False`` will be ignored and generate no output.
>>> html_params(name='text1', id='f', class_='text')
'class="text" id="f" name="text1"'
>>> html_params(checked=True, readonly=False, name="text1", abc="hello")
'abc="hello" checked name="text1"'
"""
params = []
for k, v in sorted(iteritems(kwargs)):
if k in ('class_', 'class__', 'for_'):
k = k[:-1]
if v is True:
params.append(k)
elif v is False:
pass
else:
params.append('%s="%s"' %
(text_type(k), escape(text_type(v), quote=True)))
return ' '.join(params)
def __init__(self, formdata=None, obj=None, prefix='', **kwargs):
"""
:param formdata:
Used to pass data coming from the enduser, usually `request.POST` or
equivalent. formdata should be some sort of request-data wrapper which
can get multiple parameters from the form input, and values are unicode
strings, e.g. a Werkzeug/Django/WebOb MultiDict
:param obj:
If `formdata` is empty or not provided, this object is checked for
attributes matching form field names, which will be used for field
values.
:param prefix:
If provided, all fields will have their name prefixed with the
value.
:param `**kwargs`:
If `formdata` is empty or not provided and `obj` does not contain
an attribute named the same as a field, form will assign the value
of a matching keyword argument to the field, if one exists.
"""
super(Form, self).__init__(self._unbound_fields, prefix=prefix)
for name, field in iteritems(self._fields):
# Set all the fields to attributes so that they obscure the class
# attributes with the same names.
setattr(self, name, field)
self.process(formdata, obj, **kwargs)
def html_params(**kwargs):
"""
This is Verbatim from WTForms BUT "aria_" is handled like "data_"
Generate HTML attribute syntax from inputted keyword arguments.
The output value is sorted by the passed keys, to provide consistent output
each time this function is called with the same parameters. Because of the
frequent use of the normally reserved keywords `class` and `for`, suffixing
these with an underscore will allow them to be used.
In order to facilitate the use of ``data-`` attributes, the first underscore
behind the ``data``-element is replaced with a hyphen.
>>> html_params(data_any_attribute='something')
'data-any_attribute="something"'
In addition, the values ``True`` and ``False`` are special:
* ``attr=True`` generates the HTML compact output of a boolean attribute,
e.g. ``checked=True`` will generate simply ``checked``
* ``attr=False`` will be ignored and generate no output.
>>> html_params(name='text1', id='f', class_='text')
'class="text" id="f" name="text1"'
>>> html_params(checked=True, readonly=False, name="text1", abc="hello")
'abc="hello" checked name="text1"'
"""
params = []
for k, v in sorted(iteritems(kwargs)):
if k in ('class_', 'class__', 'for_'):
k = k[:-1]
elif k.startswith('data_') or k.startswith('aria_') :
k = k.replace('_', '-', 1)
if v is True:
params.append(k)
elif v is False:
pass
else:
params.append('%s="%s"' % (text_type(k), escape(text_type(v), quote=True)))
return ' '.join(params)
def process(self, formdata=None, obj=None, **kwargs):
"""
Take form, object data, and keyword arg input and have the fields
process them.
:param formdata:
Used to pass data coming from the enduser, usually `request.POST` or
equivalent.
:param obj:
If `formdata` is empty or not provided, this object is checked for
attributes matching form field names, which will be used for field
values.
:param `**kwargs`:
If `formdata` is empty or not provided and `obj` does not contain
an attribute named the same as a field, form will assign the value
of a matching keyword argument to the field, if one exists.
"""
if formdata is not None and not hasattr(formdata, 'getlist'):
if hasattr(formdata, 'getall'):
formdata = WebobInputWrapper(formdata)
else:
raise TypeError(
"formdata should be a multidict-type wrapper that supports the 'getlist' method"
)
for name, field, in iteritems(self._fields):
if obj is not None and hasattr(obj, name):
field.process(formdata, getattr(obj, name))
elif name in kwargs:
field.process(formdata, kwargs[name])
else:
field.process(formdata)
def __init__(self, formdata=None, obj=None, prefix='', data=None, meta=None, **kwargs):
"""
:param formdata:
Used to pass data coming from the enduser, usually `request.POST` or
equivalent. formdata should be some sort of request-data wrapper which
can get multiple parameters from the form input, and values are unicode
strings, e.g. a Werkzeug/Django/WebOb MultiDict
:param obj:
If `formdata` is empty or not provided, this object is checked for
attributes matching form field names, which will be used for field
values.
:param prefix:
If provided, all fields will have their name prefixed with the
value.
:param data:
Accept a dictionary of data. This is only used if `formdata` and
`obj` are not present.
:param meta:
If provided, this is a dictionary of values to override attributes
on this form's meta instance.
:param `**kwargs`:
If `formdata` is empty or not provided and `obj` does not contain
an attribute named the same as a field, form will assign the value
of a matching keyword argument to the field, if one exists.
"""
meta_obj = self._wtforms_meta()
if meta is not None and isinstance(meta, dict):
meta_obj.update_values(meta)
super(Form, self).__init__(self._unbound_fields, meta=meta_obj, prefix=prefix)
for name, field in iteritems(self._fields):
# Set all the fields to attributes so that they obscure the class
# attributes with the same names.
setattr(self, name, field)
self.process(formdata, obj, data=data, **kwargs)
def validate(self, filter=[], extra_validators=None, isParent=False):
if isParent:
return super(Form, self).validate()
self._errors = None
success = True
if callable(getattr(self, "_validate", None)):
_fields = self._validate()
else:
_fields = self._fields
for name, field in iteritems(_fields):
if name in filter or field in filter:
continue
if extra_validators is not None and name in extra_validators:
extra = extra_validators[name]
else:
extra = list()
inline = getattr(self.__class__, 'validate_%s' % name, None)
if inline is not None:
extra.append(inline)
if not field.validate(self, extra):
success = False
return success
def patch_data(self):
data = {}
for name, f in iteritems(self._fields):
if f.raw_data and (f.data != f.object_data):
data[name] = f.data
return data
def populate_obj(self, obj):
for name, field in iteritems(self._fields):
if name in ['site_theme', 'invoice_theme']:
continue
field.populate_obj(obj, name)
obj.site_theme = SiteTheme.query.filter_by(name=self.site_theme.data).first()
obj.invoice_theme = InvoiceTheme.query.filter_by(name=self.invoice_theme.data).first()
def populate_obj(self, obj):
for name, field in iteritems(self._fields):
if not name.startswith('comment_service'):
field.populate_obj(obj, name)
csn = self._fields['comment_service_name']
csi = self._fields['comment_service_id']
if csn and csi:
obj.comment_service = '%s-%s' % (csn.data, csi.data)
def data(self):
for name, f in iteritems(self._fields):
if f.data is not None:
if isinstance(f.data, FileStorage):
file_name = f.data.filename
self._save_file(f.data, file_name)
return [{'name': file_name, 'key': self.save_key}]
else:
return [f.data]
def populate_obj(self, obj):
for name, field in iteritems(self._fields):
if not name.startswith('comment_service'):
field.populate_obj(obj, name)
csn = self._fields['comment_service_name']
csi = self._fields['comment_service_id']
if csn and csi:
obj.comment_service = '%s-%s' % (csn.data, csi.data)
def populate_obj(self, obj):
"""
Populates the attributes of the passed `obj` with data from the form's
fields.
:note: This is a destructive operation; Any attribute with the same name
as a field will be overridden. Use with caution.
"""
for name, field in iteritems(self._fields):
field.populate_obj(obj, name)
def populate_obj(self, obj):
"""
Populates the attributes of the passed `obj` with data from the forms's
fields.
:note: This is a destructive operation; Any attribute with the same name
as a field will be overridden. Use with caution.
"""
for name, field in iteritems(self._fields):
field.populate_obj(obj, name)
def validate_on_submit(self):
"""表单校验"""
primary_key = request.form.get('primary_key', '').strip()
ret = super(Form, self).validate_on_submit()
if ret is True or (not primary_key or primary_key == '0'):
return ret
# 编辑更新时文件上传是必填项报错问题
for name, field, in iteritems(self._fields):
if (isinstance(field, FileField) is True
and field.flags.required
and not field.data
and field.errors):
field.errors = ()
for name, field in iteritems(self._fields):
if field.errors:
return False
return True
def data(self):
"""DateRangeField一次提供了多个name"""
value_map = []
for name, field in iteritems(self._fields):
if isinstance(field, DateRangeField):
# 换成dataset，因为data要用于pre_validate
for extra_name, value in field.dataset.items():
value_map.append((extra_name, value))
else:
value_map.append((name, field.data))
return dict(value_map)
def __init__(self, extra_converters=None, simple_conversions=None):
converters = {}
if simple_conversions is None:
simple_conversions = self.DEFAULT_SIMPLE_CONVERSIONS
for field_type, django_fields in iteritems(simple_conversions):
converter = self.make_simple_converter(field_type)
for name in django_fields:
converters[name] = converter
if extra_converters:
converters.update(extra_converters)
super(ModelConverter, self).__init__(converters)
def fill_form(self, obj=None, data=None, **kwargs):
"""填充表单"""
if data is not None:
# XXX we want to eventually process 'data' as a new entity.
# Temporarily, this can simply be merged with kwargs.
kwargs = dict(data, **kwargs)
for name, field, in iteritems(self._fields):
if obj is not None and hasattr(obj, name):
field.data = getattr(obj, name)
elif name in kwargs:
field.data = kwargs[name]
def __init__(self, extra_converters=None, simple_conversions=None):
converters = {}
if simple_conversions is None:
simple_conversions = self.DEFAULT_SIMPLE_CONVERSIONS
for field_type, django_fields in iteritems(simple_conversions):
converter = self.make_simple_converter(field_type)
for name in django_fields:
converters[name] = converter
if extra_converters:
converters.update(extra_converters)
super(ModelConverter, self).__init__(converters)
def populate_obj(self, obj):
"""
Populate form to object.
Since Form's default `populate_obj` function populate all
the fields in this class, this function will do the same
function except `emails` field.
:param obj: Job Model object.
"""
for name, field in iteritems(self._fields):
if name not in ['query_time_out', 'emails', 'schedules']:
field.populate_obj(obj, name)
def populate_obj(self, obj):
"""
As with process, this implementation is the same as WTForm 2.1's
default with the 'studies' field treated as a special case to
account for the fact that it is a mapped collection
"""
for name, field in iteritems(self._fields):
if name == 'studies':
for study_form in self.studies.entries:
study_form.form.populate_obj(
obj.studies[study_form.study_id.data])
else:
field.populate_obj(obj, name)
def populate_obj(self, obj):
"""
Overrides wtforms.form.py BaseForm.process.
Since we're going to populate to repeating fields in the object,
We have to play games with the field names.
"""
for name, field in iteritems(self._fields):
m = re.search(r'^(.+)_([0-6])$', name)
if m:
attr_name = m.group(1)
index = int(m.group(2))
day_prefs_obj = obj.days[index]
field.populate_obj(day_prefs_obj, attr_name)
def data(self):
data_list = []
for name, f in iteritems(self._fields):
if f.data is not None:
for key in f.data:
# WUJG: 如果对应的值为空字符串或其他逻辑错的内容，我们可以默认设置为0
if key != 'type' and key != 'offsetType':
f.data[key] = float(f.data[key] or 0)
else:
f.data[key] = int(f.data[key] or 0)
data_list.append(f.data)
return data_list
def errors_with_data(self):
# Convert lazy_gettext error strings into unicode so they don't cause problems downstream
# (like when pickling)
return {
name: {
'data':
f.data,
'errors': [
six.text_type(e) if is_lazy_string(e) else e
for e in f.errors
]
}
for name, f in iteritems(self._fields) if f.errors
}
def __init__(self, handler=None, **kwargs):
formdata = MultiValueDict()
if handler:
for name in handler.request.arguments.keys():
formdata.setlist(name, handler.get_arguments(name))
# we should also iterate over request.files because
# get_arguments does not return list of filenames
for field, files in iteritems(handler.request.files):
names = []
for file in files:
names.append(file['filename'])
formdata.setlist(field, names)
super(Form, self).__init__(formdata, **kwargs)
def __init__(self, handler=None, **kwargs):
formdata = MultiValueDict()
if handler:
for name in handler.request.arguments.keys():
formdata.setlist(name, handler.get_arguments(name))
# we should also iterate over request.files because
# get_arguments does not return list of filenames
for field, files in iteritems(handler.request.files):
names = []
for file in files:
names.append(file['filename'])
formdata.setlist(field, names)
super(Form, self).__init__(formdata, **kwargs)
def populate_obj(self, obj, partial=False):
"""
Populates the attributes of the passed `obj` with data from the form's
fields.
:param partial:
If True allows for a partial update to be applied to an object
i.e. only updates attributes if matching field supplied
in formdata/data/kwargs
:note: This is a destructive operation; Any attribute with the same name
as a field will be overridden. Use with caution.
"""
for name, field in iteritems(self._fields):
if not partial or (partial and name in self._formkeys):
field.populate_obj(obj, name)
def populate_obj(self, obj, partial=False):
"""
Populates the attributes of the passed `obj` with data from the form's
fields.
:param partial:
If True allows for a partial update to be applied to an object
i.e. only updates attributes if matching field supplied
in formdata/data/kwargs
:note: This is a destructive operation; Any attribute with the same name
as a field will be overridden. Use with caution.
"""
for name, field in iteritems(self._fields):
if not partial or (partial and name in self._formkeys):
field.populate_obj(obj, name)
def html_params(**kwargs):
"""
Generate HTML attribute syntax from inputted keyword arguments.
The output value is sorted by the passed keys, to provide consistent output
each time this function is called with the same parameters. Because of the
frequent use of the normally reserved keywords `class` and `for`, suffixing
these with an underscore will allow them to be used.
In order to facilitate the use of ``data-`` and ``aria-`` attributes, if the
name of the attribute begins with ``data_`` or ``aria_``, then every
underscore will be replaced with a hyphen in the generated attribute.
>>> html_params(data_attr='user.name', aria_labeledby='name')
'data-attr="user.name" aria-labeledby="name"'
In addition, the values ``True`` and ``False`` are special:
* ``attr=True`` generates the HTML compact output of a boolean attribute,
e.g. ``checked=True`` will generate simply ``checked``
* ``attr=False`` will be ignored and generate no output.
>>> html_params(name='text1', id='f', class_='text')
'class="text" id="f" name="text1"'
>>> html_params(checked=True, readonly=False, name="text1", abc="hello")
'abc="hello" checked name="text1"'
.. versionchanged:: 3.0
``aria_`` args convert underscores to hyphens like ``data_``
args.
.. versionchanged:: 2.2
``data_`` args convert all underscores to hyphens, instead of
only the first one.
"""
params = []
for k, v in sorted(iteritems(kwargs)):
if k in ("class_", "class__", "for_"):
k = k[:-1]
elif k.startswith("data_") or k.startswith("aria_"):
k = k.replace("_", "-")
if v is True:
params.append(k)
elif v is False:
pass
else:
params.append('%s="%s"' % (text_type(k), escape(v)))
return " ".join(params)
def model_fields(model,
only=None,
exclude=None,
field_args=None,
converter=None):
"""
Extracts and returns a dictionary of form fields for a given
``db.Model`` class.
:param model:
The ``db.Model`` class to extract fields from.
:param only:
An optional iterable with the property names that should be included in
the form. Only these properties will have fields.
:param exclude:
An optional iterable with the property names that should be excluded
from the form. All other properties will have fields.
:param field_args:
An optional dictionary of field names mapping to a keyword arguments
used to construct each field object.
:param converter:
A converter to generate the fields based on the model properties. If
not set, ``ModelConverter`` is used.
"""
converter = converter or ModelConverter()
field_args = field_args or {}
# Get the field names we want to include or exclude, starting with the
# full list of model properties.
props = model.properties()
sorted_props = sorted(iteritems(props),
key=lambda prop: prop[1].creation_counter)
field_names = list(x[0] for x in sorted_props)
if only:
field_names = list(f for f in only if f in field_names)
elif exclude:
field_names = list(f for f in field_names if f not in exclude)
# Create all fields.
field_dict = {}
for name in field_names:
field = converter.convert(model, props[name], field_args.get(name))
if field is not None:
field_dict[name] = field
return field_dict
def html_params(**kwargs):
"""
Generate HTML attribute syntax from inputted keyword arguments.
The output value is sorted by the passed keys, to provide consistent output
each time this function is called with the same parameters. Because of the
frequent use of the normally reserved keywords `class` and `for`, suffixing
these with an underscore will allow them to be used.
In order to facilitate the use of ``data-`` and ``aria-`` attributes, if the
name of the attribute begins with ``data_`` or ``aria_``, then every
underscore will be replaced with a hyphen in the generated attribute.
>>> html_params(data_attr='user.name', aria_labeledby='name')
'data-attr="user.name" aria-labeledby="name"'
In addition, the values ``True`` and ``False`` are special:
* ``attr=True`` generates the HTML compact output of a boolean attribute,
e.g. ``checked=True`` will generate simply ``checked``
* ``attr=False`` will be ignored and generate no output.
>>> html_params(name='text1', id='f', class_='text')
'class="text" id="f" name="text1"'
>>> html_params(checked=True, readonly=False, name="text1", abc="hello")
'abc="hello" checked name="text1"'
.. versionchanged:: 3.0
``aria_`` args convert underscores to hyphens like ``data_``
args.
.. versionchanged:: 2.2
``data_`` args convert all underscores to hyphens, instead of
only the first one.
"""
params = []
for k, v in sorted(iteritems(kwargs)):
if k in ("class_", "class__", "for_"):
k = k[:-1]
elif k.startswith("data_") or k.startswith("aria_"):
k = k.replace("_", "-")
if v is True:
params.append(k)
elif v is False:
pass
else:
params.append('%s="%s"' % (text_type(k), escape(v)))
return " ".join(params)
def render(self, context):
try:
if "." in self.field_var:
base, field_name = self.field_var.rsplit(".", 1)
field = getattr(Variable(base).resolve(context), field_name)
else:
field = context[self.field_var]
except (template.VariableDoesNotExist, KeyError, AttributeError):
return settings.TEMPLATE_STRING_IF_INVALID
h_attrs = {}
for k, v in iteritems(self.html_attrs):
try:
h_attrs[k] = v.resolve(context)
except template.VariableDoesNotExist:
h_attrs[k] = settings.TEMPLATE_STRING_IF_INVALID
return field(**h_attrs)
def render(self, context):
try:
if '.' in self.field_var:
base, field_name = self.field_var.rsplit('.', 1)
field = getattr(Variable(base).resolve(context), field_name)
else:
field = context[self.field_var]
except (template.VariableDoesNotExist, KeyError, AttributeError):
return settings.TEMPLATE_STRING_IF_INVALID
h_attrs = {}
for k, v in iteritems(self.html_attrs):
try:
h_attrs[k] = v.resolve(context)
except template.VariableDoesNotExist:
h_attrs[k] = settings.TEMPLATE_STRING_IF_INVALID
return field(**h_attrs)
def model_fields(model, only=None, exclude=None, field_args=None,
converter=None):
"""
Extracts and returns a dictionary of form fields for a given
``db.Model`` class.
:param model:
The ``db.Model`` class to extract fields from.
:param only:
An optional iterable with the property names that should be included in
the form. Only these properties will have fields.
:param exclude:
An optional iterable with the property names that should be excluded
from the form. All other properties will have fields.
:param field_args:
An optional dictionary of field names mapping to a keyword arguments
used to construct each field object.
:param converter:
A converter to generate the fields based on the model properties. If
not set, ``ModelConverter`` is used.
"""
converter = converter or ModelConverter()
field_args = field_args or {}
# Get the field names we want to include or exclude, starting with the
# full list of model properties.
props = model.properties()
sorted_props = sorted(iteritems(props), key=lambda prop: prop[1].creation_counter)
field_names = list(x[0] for x in sorted_props)
if only:
field_names = list(f for f in only if f in field_names)
elif exclude:
field_names = list(f for f in field_names if f not in exclude)
# Create all fields.
field_dict = {}
for name in field_names:
field = converter.convert(model, props[name], field_args.get(name))
if field is not None:
field_dict[name] = field
return field_dict
def validate(self, extra_validators=None):
"""
Validates the form by calling `validate` on each field.
:param extra_validators:
If provided, is a dict mapping field names to a sequence of
callables which will be passed as extra validators to the field's
`validate` method.
Returns `True` if no errors occur.
"""
success = True
for name, field in iteritems(self._fields):
if extra_validators is not None and name in extra_validators:
extra = extra_validators[name]
else:
extra = tuple()
if not field.validate(self, extra):
success = False
return success
def populate_obj(self, obj, ignore_fields=None):
"""
Populates the attributes of the passed `obj` with data from the form's
fields.
:note: This is a destructive operation; Any attribute with the same name
as a field will be overridden. Use with caution.
:param ignore_fields:
Fields that should not be populated.
"""
if ignore_fields is None:
ignore_fields = []
for name, field in iteritems(self._fields):
if name in ignore_fields:
continue
if isinstance(field, (ExtendedFormField, ExtendedFieldList)):
field.populate_obj(obj, name, ignore_fields=ignore_fields)
else:
field.populate_obj(obj, name)
def validate(self, extra_validators=None):
"""
Validates the form by calling `validate` on each field.
:param extra_validators:
If provided, is a dict mapping field names to a sequence of
callables which will be passed as extra validators to the field's
`validate` method.
Returns `True` if no errors occur.
"""
self._errors = None
success = True
for name, field in iteritems(self._fields):
if extra_validators is not None and name in extra_validators:
extra = extra_validators[name]
else:
extra = tuple()
if not field.validate(self, extra):
success = False
return success
def html_params(**kwargs):
"""
Generate HTML parameters from inputted keyword arguments.
The output value is sorted by the passed keys, to provide consistent output
each time this function is called with the same parameters. Because of the
frequent use of the normally reserved keywords `class` and `for`, suffixing
these with an underscore will allow them to be used.
>>> html_params(name='text1', id='f', class_='text') == 'class="text" id="f" name="text1"'
True
"""
params = []
for k,v in sorted(iteritems(kwargs)):
if k in ('class_', 'class__', 'for_'):
k = k[:-1]
if v is True:
params.append(k)
else:
params.append('%s="%s"' % (text_type(k), escape(text_type(v), quote=True)))
return ' '.join(params)
def data(self):
return dict((name, f.data) for name, f in iteritems(self._fields)
if name not in self.MEETING_FLAGS)
def meeting_flags_data(self):
return dict((name, f.data) for name, f in iteritems(self._fields)
if name in self.MEETING_FLAGS)
def defaults(self):
return dict((name, f.default) for name,f in list(filter(lambda x: x[1].type not in ('SubmitField','ResetField') and x[1].default,iteritems(self._fields))))
def errors(self):
return dict((name, f.errors) for name, f in iteritems(self._fields) if f.errors)
def errors(self):
if self._errors is None:
self._errors = dict((name, f.errors) for name, f in iteritems(self._fields) if f.errors)
return self._errors
def data(self):
return dict((name, f.data) for name, f in iteritems(self._fields))
def errors_with_data(self):
return {name: {'data': f.data, 'errors': f.errors} for name, f in iteritems(self._fields) if f.errors}
def __init__(self, **kwargs):
for k, v in iteritems(kwargs):
setattr(self, k, v)
