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