def validator(key, data, errors, context):
value = ""
for name, text in data.items():
if name == key:
if text:
value = text
# Parse from extras into a dictionary and save it as a json dump
if not value:
found = {}
prefix = key[-1] + '-'
extras = data.get(key[:-1] + ('__extras', ), {})
extras_to_delete = []
for name, text in extras.items():
if not name.startswith(prefix):
continue
# if not text:
# continue
subfield = name.split('-', 1)[1]
found[subfield] = text
extras_to_delete += [name]
if not found:
data[key] = ""
else:
item_is_empty = composite_all_empty(field, found)
item_is_empty_and_optional = item_is_empty and not sh.scheming_field_required(
field)
# Check if there is any mandatory subfield required
for schema_subfield in field['subfields']:
if schema_subfield.get(
'required',
False) and not item_is_empty_and_optional:
subfield_label = schema_subfield.get(
'label', schema_subfield.get('field_name', ''))
subfield_value = found.get(
schema_subfield.get('field_name', ''), "")
composite_not_empty_subfield(key, subfield_label,
subfield_value, errors)
if item_is_empty:
found = {}
data[key] = json.dumps(found, ensure_ascii=False)
# delete the extras to avoid duplicate fields
for extra in extras_to_delete:
del extras[extra]
# Check if the field is required
if sh.scheming_field_required(field):
not_empty(key, data, errors, context)
def _field_validators(f, schema, convert_extras):
"""
Return the validators for a scheming field f
"""
if 'validators' in f:
validators = validation.validators_from_string(
f['validators'],
f,
schema
)
elif helpers.scheming_field_required(f):
validators = [not_empty]
else:
validators = [ignore_missing]
if convert_extras:
validators.append(convert_to_extras)
# If this field contains children, we need a special validator to handle
# them.
if 'repeating_subfields' in f:
validators = {
sf['field_name']: _field_validators(sf, schema, False)
for sf in f['repeating_subfields']
}
return validators
def validator(key, data, errors, context):
value = ""
for name,text in data.iteritems():
if name == key:
if text:
value = text
# parse from extra into a list of dictionaries and save it as a json dump
if not value:
found = {}
prefix = key[-1] + '-'
extras = data.get(key[:-1] + ('__extras',), {})
extras_to_delete = []
for name, text in extras.iteritems():
if not name.startswith(prefix):
continue
#if not text:
# continue
index = int(name.split('-', 2)[1])
subfield = name.split('-', 2)[2]
extras_to_delete += [name]
if not found.has_key(index):
found[index] = {}
found[index][subfield] = text
found_list = [element[1] for element in sorted(found.items())]
if not found_list:
data[key] = ""
else:
# check if there are required subfields missing for every item
for index in found:
item = found[index]
for schema_subfield in field['subfields']:
if schema_subfield.get('required', False):
if type(schema_subfield.get('label', '')) is dict:
subfield_label = schema_subfield.get('field_name', '') + " " + str(index)
else:
subfield_label = schema_subfield.get('label', schema_subfield.get('field_name', '')) + " " + str(index)
subfield_value = item.get(schema_subfield.get('field_name', ''), "")
composite_not_empty_subfield(key, subfield_label, subfield_value, errors)
# dump the list to a string
data[key] = json.dumps(found_list, ensure_ascii=False)
# delete the extras to avoid duplicate fields
for extra in extras_to_delete:
del extras[extra]
# check if the field is required
if sh.scheming_field_required(field):
not_empty(key, data, errors, context)
def _field_validators(f, schema, convert_extras):
"""
Return the validators for a scheming field f
"""
validators = []
if 'validators' in f:
validators = validators_from_string(f['validators'], f, schema)
elif helpers.scheming_field_required(f):
validators = [not_empty, unicode]
else:
validators = [ignore_missing, unicode]
if convert_extras:
validators = validators + [convert_to_extras]
return validators
def _field_validators(f, schema, convert_extras):
"""
Return the validators for a scheming field f
"""
validators = []
if 'validators' in f:
validators = validators_from_string(f['validators'], f, schema)
elif helpers.scheming_field_required(f):
validators = [not_empty, unicode]
else:
validators = [ignore_missing, unicode]
if convert_extras:
validators = validators + [convert_to_extras]
return validators
def _field_validators(f, schema, convert_extras):
"""
Return the validators for a scheming field f
"""
if 'validators' in f:
validators = validation.validators_from_string(f['validators'], f,
schema)
elif helpers.scheming_field_required(f):
validators = [not_empty]
else:
validators = [ignore_missing]
if convert_extras:
validators.append(convert_to_extras)
# If this field contains children, we need a special validator to handle
# them.
if 'subfields' in f:
validators = [validation.composite_form(f, schema)] + validators
return validators
def validator(key, data, errors, context):
value = ""
for name,text in data.iteritems():
if name == key:
if text:
value = text
# Parse from extras into a dictionary and save it as a json dump
if not value:
found = {}
prefix = key[-1] + '-'
extras = data.get(key[:-1] + ('__extras',), {})
extras_to_delete = []
for name, text in extras.iteritems():
if not name.startswith(prefix):
continue
#if not text:
# continue
subfield = name.split('-', 1)[1]
found[subfield] = text
extras_to_delete += [name]
if not found:
data[key] = ""
else:
# Check if there is any mandatory subfield required
for schema_subfield in field['subfields']:
if schema_subfield.get('required', False):
subfield_label = schema_subfield.get('label', schema_subfield.get('field_name', ''))
subfield_value = found.get(schema_subfield.get('field_name', ''), "")
composite_not_empty_subfield(key, subfield_label, subfield_value, errors)
data[key] = json.dumps(found, ensure_ascii=False)
# delete the extras to avoid duplicate fields
for extra in extras_to_delete:
del extras[extra]
# Check if the field is required
if sh.scheming_field_required(field):
not_empty(key, data, errors, context)
def test_not_empty_not_in_validators(self):
assert_equals(False, scheming_field_required({
'validators': 'maybe_not_empty'}))
def test_not_empty_in_validators(self):
assert_equals(True, scheming_field_required({
'validators': 'not_empty unicode'}))
def test_explicit_required_false(self):
assert_equals(False, scheming_field_required({'required': False}))
def test_explicit_required_true(self):
assert_equals(True, scheming_field_required({'required': True}))
def test_not_empty_not_in_validators(self):
assert_equals(
False, scheming_field_required({'validators': 'maybe_not_empty'}))
def test_not_empty_in_validators(self):
assert_equals(
True, scheming_field_required({'validators': 'not_empty unicode'}))
def test_explicit_required_false(self):
assert_equals(False, scheming_field_required({'required': False}))
def test_explicit_required_true(self):
assert_equals(True, scheming_field_required({'required': True}))
def test_not_empty_not_in_validators(self):
assert not scheming_field_required({"validators": "maybe_not_empty"})
def test_not_empty_in_validators(self):
assert scheming_field_required({"validators": "not_empty unicode"})
def test_explicit_required_false(self):
assert not scheming_field_required({"required": False})
def test_explicit_required_true(self):
assert scheming_field_required({"required": True})
