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 """ 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_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})