def get_gql_errors(errors: ErrorDict) -> str:
res = []
for field, filed_errors in errors.items():
for error_msg in filed_errors:
res.append(error_msg)
return "\n".join(res)
def get_gql_errors_dict(errors: ErrorDict) -> dict:
res = {}
for field, filed_errors in errors.items():
field_res = []
for error_msg in filed_errors:
field_res.append(error_msg)
res[field] = "\n".join(field_res)
return res
class NgModelFormMixin(NgFormBaseMixin):
"""
Add this NgModelFormMixin to every class derived from ``forms.Form``, if that custom ``Form``
shall be managed through an Angular controller.
It adds attributes ``ng-model``, and optionally ``ng-change``, ``ng-class`` and ``ng-style``
to each of your input fields.
If form validation fails, the ErrorDict is rewritten in a way, so that the Angular controller
can access the error strings using the same key values as for its models.
"""
add_djng_error = False
def __init__(self, data=None, *args, **kwargs):
self.scope_prefix = kwargs.pop('scope_prefix', getattr(self, 'scope_prefix', None))
self.ng_directives = {}
for key in list(kwargs.keys()):
if key.startswith('ng_'):
fmtstr = kwargs.pop(key)
self.ng_directives[key.replace('_', '-')] = fmtstr
if hasattr(self, 'Meta') and hasattr(self.Meta, 'ng_models'):
if not isinstance(getattr(self.Meta, 'ng_models'), list):
raise TypeError('Meta.ng_model is not of type list')
elif 'ng-model' not in self.ng_directives:
self.ng_directives['ng-model'] = '%(model)s'
self.prefix = kwargs.get('prefix')
if self.prefix and data:
if data.get(self.prefix):
data = {self.add_prefix(name): value for (name, value) in data.get(self.prefix).items()}
else:
data = {name : value for (name, value) in data.items() if name.startswith(self.prefix + '.')}
super(NgModelFormMixin, self).__init__(data, *args, **kwargs)
if self.scope_prefix == self.form_name:
raise ValueError("The form's name may not be identical with its scope_prefix")
def _post_clean(self):
"""
Rewrite the error dictionary, so that its keys correspond to the model fields.
"""
super(NgModelFormMixin, self)._post_clean()
if self._errors and self.prefix:
self._errors = ErrorDict((self.add_prefix(name), value) for name, value in self._errors.items())
def get_initial_data(self):
"""
Return a dictionary specifying the defaults for this form. This dictionary can be used to
inject the initial values for an Angular controller using the directive:
``ng-init={{ thisform.get_initial_data|js|safe }}``.
"""
data = {}
ng_models = hasattr(self, 'Meta') and getattr(self.Meta, 'ng_models', []) or []
for name, field in self.fields.items():
if 'ng-model' in self.ng_directives or name in ng_models:
data[name] = self.initial.get(name) if self.initial else field.initial
return data
def get_field_errors(self, field):
errors = super(NgModelFormMixin, self).get_field_errors(field)
if field.is_hidden:
return errors
identifier = format_html('{0}.{1}', self.form_name, field.html_name)
errors.append(SafeTuple((identifier, self.field_error_css_classes, '$pristine', '$message', 'invalid', '$message')))
return errors
def non_field_errors(self):
errors = super(NgModelFormMixin, self).non_field_errors()
errors.append(SafeTuple((self.form_name, self.form_error_css_classes, '$pristine', '$message', 'invalid', '$message')))
return errors
def get_widget_attrs(self, bound_field):
attrs = super(NgModelFormMixin, self).get_widget_attrs(bound_field)
identifier = self.add_prefix(bound_field.name)
ng = {
'name': bound_field.name,
'identifier': identifier,
'model': ('%s[\'%s\']' % (self.scope_prefix, identifier)) if self.scope_prefix else identifier
}
if hasattr(self, 'Meta') and bound_field.name in getattr(self.Meta, 'ng_models', []):
attrs['ng-model'] = ng['model']
for key, fmtstr in self.ng_directives.items():
attrs[key] = fmtstr % ng
return attrs
class APIForm(forms.Form):
def full_clean(self):
"""
Clean all of self.data and populate self._errors and self.cleaned_data.
"""
self._errors = ErrorDict()
if not self.is_bound: # Stop further processing.
return
self.cleaned_data = {}
# If the form is permitted to be empty, and none of the form data has
# changed from the initial data, short circuit any validation.
if self.empty_permitted and not self.has_changed():
return
self._clean_fields()
if len(self._errors) > 0:
return
self._clean_form()
if len(self._errors) > 0:
return
self._post_clean()
def _clean_fields(self):
for name, field in self.fields.items():
self._clean_field(name, field)
def _clean_field(self, name, field):
# value_from_datadict() gets the data from the data dictionaries.
# Each widget type knows how to retrieve its own data, because some
# widgets split data over several HTML fields.
if field.disabled:
value = self.get_initial_for_field(field, name)
else:
value = field.widget.value_from_datadict(self.data, self.files,
self.add_prefix(name))
if value is None and field.required:
value = self.get_initial_for_field(field, name)
try:
if isinstance(field, FileField):
initial = self.get_initial_for_field(field, name)
value = field.clean(value, initial)
else:
value = field.clean(value)
self.cleaned_data[name] = value
if hasattr(self, 'clean_%s' % name):
value = getattr(self, 'clean_%s' % name)()
self.cleaned_data[name] = value
except ValidationError as e:
self.add_error(name, e)
def get_initial_for_field(self, field, field_name):
"""
Return initial data for field on form. Use initial data from the form
or the field, in that order. Evaluate callable values.
"""
value = self.initial.get(field_name, field.initial)
if value is None:
vale = field.initial
if callable(value):
value = value()
return value
def add_prefix(self, field_name):
field = self.fields[field_name]
if field.label is not None:
return field.label
return field_name
def _post_clean(self):
if hasattr(self, 'name_map'):
self.cleaned_data = {
self.name_map[k] if k in self.name_map else k: v
for k, v in self.cleaned_data.items()
}
def get_errors(self):
errors = {}
for name, value in self._errors.items():
if name != NON_FIELD_ERRORS:
errors[self.add_prefix(name)] = value
else:
errors[NON_FIELD_ERRORS] = value
return errors
