def validation_error_as_text(error):
"""
Given a ValidationError object, return a string representing the errors.
"""
try:
ed = ErrorDict(error.message_dict)
return ed.as_text()
except AttributeError:
el = ErrorList(error.messages)
return el.as_text()
def render(self, context):
"""Render."""
form = self.form.resolve(context, True)
hidden_fields_errors = ErrorDict()
for field in form.hidden_fields():
if field.errors:
hidden_fields_errors.update({field.name: field.errors})
context[self.as_var] = hidden_fields_errors
return ''
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 test_error_dict_copy(self):
e = ErrorDict()
e['__all__'] = ErrorList([
ValidationError(
message='message %(i)s',
params={'i': 1},
),
ValidationError(
message='message %(i)s',
params={'i': 2},
),
])
e_copy = copy.copy(e)
self.assertEqual(e, e_copy)
self.assertEqual(e.as_data(), e_copy.as_data())
e_deepcopy = copy.deepcopy(e)
self.assertEqual(e, e_deepcopy)
def add_doctor(request):
if request.user.is_authenticated and request.user.manager.role == "Manager":
if request.POST:
user_form = UserForm(request.POST)
doctor_form = DoctorForm(request.POST)
if user_form.is_valid() and doctor_form.is_valid():
if int(request.POST["age"]) <= int(
request.POST["years_of_experience"]):
return render(
request, 'manager/add_doctor.html', {
'other_errors':
ErrorDict({
"Years of Experience":
ErrorDict({
'':
"Years of experience cannot be equal or greater than age"
})
})
})
user = user_form.save(commit=False)
password = request.POST["password"]
try:
password_validation.validate_password(password)
except Exception as e:
errAsDict = {
'password': ErrorDict({'': '\n'.join(e.messages)})
}
return render(request, 'manager/add_doctor.html',
{'user_form_error': ErrorDict(errAsDict)})
passwordConfirm = request.POST["passwordConfirm"]
if password != passwordConfirm:
return render(
request, 'manager/add_doctor.html', {
'other_errors':
ErrorDict({
"Password":
ErrorDict({'': "Passwords do not match"})
})
})
user.set_password(password)
user.save()
doctor = doctor_form.save(commit=False)
doctor.user = user
doctor.role = "Doctor"
doctor.save()
return redirect('/manager/get_report')
else:
return render(
request, 'manager/add_doctor.html', {
'user_form_error': user_form.errors,
'doctor_form_error': doctor_form.errors
})
else:
return render(request, 'manager/add_doctor.html')
return redirect('/')
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()
self._clean_form()
self._post_clean()
def full_clean(self):
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
# Don't run _post_clean() as this will run StockItem.clean()
self._clean_fields()
self._clean_form()
def full_clean(self):
"""
Cleans all of self.data and populates 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
for name, field in self.fields.items():
# 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.
value = field.widget.value_from_datadict(self.data, self.files,
self.add_prefix(name))
try:
if isinstance(field, FileField):
initial = self.initial.get(name, field.initial)
value = field.clean(value, initial)
elif isinstance(field, CharField):
if (value is not None and isinstance(value, basestring)
and len(value) > 0):
value = str(smart_str(value))
else:
value = field.clean(value)
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._errors[name] = self.error_class(e.messages)
if name in self.cleaned_data:
del self.cleaned_data[name]
try:
self.cleaned_data = self.clean()
except ValidationError as e:
self._errors[forms.Form.NON_FIELD_ERRORS] = \
self.error_class(e.messages)
if self._errors:
delattr(self, 'cleaned_data')
def full_clean(self):
"""验证表单并将通过验证的表单项填入映射类实例的相应字段
"""
# self 是表单类实例
print('【django.forms.forms.BaseForm.full_clean】表单类实例进行表单项验证')
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() # 验证表单信息，此方法就在下面
self._clean_form()
self._post_clean() # 把合适的数据填入映射类实例的相应字段
def _apply(self, data):
'''
Update an instance from supplied data.
All fields marked required=True MUST be provided.
All fields omitted will have their default used, if provided.
'''
self._errors = errors = ErrorDict()
for name in self._field_names:
if self._fields[name].readonly:
continue
required = self._fields[name].required
default = self._fields[name].default
try:
value = data[name]
except KeyError:
if required:
if default is NOT_PROVIDED:
if name not in errors:
errors[name] = ErrorList()
errors[name].append(
ValidationError('This field is required'))
continue
elif default is NOT_PROVIDED:
continue
value = default
if callable(value):
value = value()
try:
setattr(self, name, value)
except ValidationError as e:
if name not in errors:
errors[name] = ErrorList()
errors[name].append(e)
# Allow a final pass of cleaning
self._clean(data, full=True)
if self._errors:
raise ValidationError(self._errors)
return self._obj
def full_clean(self):
"""
Taken from Django master as of 5e06fa1469180909c51c07151692412269e51ea3
but is mostly a copy-paste all the way back to 1.3.1
Basically we want to keep cleaned_data around, not remove it
if errors occured.
"""
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()
self._clean_form()
self._post_clean()
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
# 基于字段的验证: 字段必填, 字段名匹配, 执行自定义validator
self._clean_fields()
# 基于表单的验证: 检查用户是否存在, 并检查密码是否一致.
self._clean_form()
# 验证hook.
self._post_clean()
def index(request):
if 'error' in request.GET:
#zipcode_form = variety_trials_forms.SelectLocationByZipcodeForm(request.GET)
zipcode_form = variety_trials_forms.SelectLocationByZipcodeForm()
if zipcode_form._errors is None:
zipcode_form._errors = ErrorDict()
errors = zipcode_form._errors['zipcode'] = ErrorList(
) # errors for field 'zipcode'
if request.GET['error'] == 'no_zipcode':
errors.append(
u"Please enter your zipcode. The retrieved data are sorted by distance from your zipcode."
)
elif request.GET['error'] == 'bad_zipcode':
errors.append(u"Sorry, that zipcode didn't match any records.")
else:
zipcode_form = variety_trials_forms.SelectLocationByZipcodeForm()
return render(request, 'main_ndsu.html', {
'zipcode_form': zipcode_form,
'home_url': HOME_URL,
})
def post(self, request, *args, **kwargs):
try:
with transaction.atomic():
return super(HostUpdateCreateMixin,
self).post(request, *args, **kwargs)
except ValidationError as e:
form_class = self.get_form_class()
form = self.get_form(form_class)
if not getattr(form, "_errors"):
form._errors = ErrorDict()
error_list = form._errors.setdefault(NON_FIELD_ERRORS, ErrorList())
if hasattr(e, "error_dict"):
for key, errors in list(e.message_dict.items()):
for error in errors:
error_list.append(error)
else:
error_list.append(e.message)
error_list.append("Please try again.")
return self.form_invalid(form)
def _clean_fields(self):
self._errors = ErrorDict()
num_errors = 0
if not self.is_bound: # Stop further processing.
return
self.cleaned_data = {}
# check for 'on' checkbox value for patient relative checkbox ( which means create patient )\
# this 'on' value from widget is replaced by the pk of the created patient
for name, field in list(self.fields.items()):
try:
value = field.widget.value_from_datadict(
self.data, self.files, self.add_prefix(name))
if name == "relative_patient":
if value == "on":
self.cleaned_data[name] = None
self.create_patient_flag = True
else:
self.cleaned_data[name] = value
elif name == 'date_of_birth':
try:
self.cleaned_data[name] = self._set_date_of_birth(
value)
except Exception:
raise ValidationError(
"Date of Birth must be dd-mm-yyyy")
elif name == 'patient':
continue # this was causing error in post clean - we set this ourselves
else:
self.cleaned_data[name] = value
except ValidationError as e:
num_errors += 1
self._errors[name] = self.error_class(e.messages)
if name in self.cleaned_data:
del self.cleaned_data[name]
self.tag = self.cleaned_data["given_names"] + self.cleaned_data[
"family_name"]
def _clean_dependency(self, name=None):
if name is None:
names = self._cleaned_data.keys()
else:
names = [name]
errors = ErrorDict()
for name in names:
if name in self._dependency:
try:
field, pairs = self._dependency[name]
try:
_ = field.clean(self._cleaned_data[name])
except forms.ValidationError:
continue
for sub_name, sub_field in pairs:
_ = sub_field.clean(self._cleaned_data[sub_name]) # NOQA
except forms.ValidationError as exc:
error_dict = TextErrorDict([(sub_name, exc.messages)])
errors[name] = [error_dict]
del self._cleaned_data[name]
if errors:
raise forms.ValidationError(errors)
def is_valid(self):
if "implementation_rag_rating" in self.data.keys():
implementation_rag_rating = self.data["implementation_rag_rating"]
required_form = self.detail_form_for_key(implementation_rag_rating)
if required_form:
# we need the detail form field to be required for validation,
# but not on the client as then they can't change their minds…
required_form.make_field_required()
required_form_is_valid = required_form.is_valid()
required_form.make_field_not_required()
form_is_valid = super().is_valid()
# now ensure that any errors on the contained forms are also on the containing form
if self._errors is None:
self._errors = ErrorDict()
if required_form.errors is not None:
for field, error in required_form.errors.items():
self._errors[f"{field}"] = error
return all(
(
form_is_valid,
required_form_is_valid,
)
)
return super().is_valid()
def full_clean(self):
"""
Cleans all of self.data and populates self._errors and
self.cleaned_data.
"""
self._errors = ErrorDict()
# Stop further processing.
if not self.is_bound:
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()
# UPDATE: 如果输入数据通过不了field本身的校验，直接返回错误信息，
# 不进行接下来的验证
if not self.is_valid():
return
self._clean_form()
self._post_clean()
if self._errors:
del self.cleaned_data
def edit_password(request):
if request.user.is_authenticated and request.user.doctor.role == "Doctor":
if request.POST:
oldpass = request.POST["passwordold"]
user = request.user.username
user = authenticate(username=user, password=oldpass)
if user is not None:
try:
passwordnew1 = request.POST["passwordnew1"]
password_validation.validate_password(passwordnew1)
except Exception as e:
errAsDict = {
'password': ErrorDict({'': '\n'.join(e.messages)})
}
return render(request, 'doctor/edit_password.html',
{'errors': ErrorDict(errAsDict)})
passwordnew2 = request.POST["passwordnew2"]
if passwordnew1 != passwordnew2:
return render(
request, 'doctor/edit_password.html', {
'errors':
ErrorDict({
"Password":
ErrorDict({'': "Passwords do not match"})
})
})
user.set_password(passwordnew1)
user.save()
login(request, user)
return redirect('/doctor/dashboard/')
else:
return render(
request, 'doctor/edit_password.html', {
'errors':
ErrorDict({
"Password":
ErrorDict({'': "Old password is incorrect"})
})
})
return render(request, 'doctor/edit_password.html')
return redirect('/doctor/login/')
def errors(self):
_errors = ErrorDict()
for form in self._subforms:
_errors.update({self._get_error_key(form.prefix, name): error for name, error in form.errors.items()})
return _errors
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
def add_form_error(self, message):
if not self._errors:
self._errors = ErrorDict()
if not NON_FIELD_ERRORS in self._errors:
self._errors[NON_FIELD_ERRORS] = self.error_class()
self._errors[NON_FIELD_ERRORS].append(message)
def full_clean(self):
super(AddressForm, self).full_clean()
if self.is_bound and self['use_primary_address'].value():
# reset errors, since then the form is always regarded as valid
self._errors = ErrorDict()
def full_clean(self):
if self.data.get(self.prefix + '-remove') != 'on':
super().full_clean()
else:
self._errors = ErrorDict()
self.cleaned_data = {'remove': True}
current_data['grade_min'] = Tag.getProgramTag(
'teacherreg_default_min_grade', prog)
if 'grade_max' in hidden_fields:
current_data['grade_max'] = Tag.getProgramTag(
'teacherreg_default_max_grade', prog)
if 'class_size_max' in hidden_fields:
current_data['class_size_max'] = Tag.getProgramTag(
'teacherreg_default_class_size_max', prog)
if not populateonly:
context['class'] = newclass
if action == 'edit':
reg_form = TeacherClassRegForm(self.crmi, current_data)
# TODO: remove private API use
if populateonly: reg_form._errors = ErrorDict()
elif action == 'editopenclass':
reg_form = TeacherOpenClassRegForm(self.crmi, current_data)
# TODO: remove private API use
if populateonly: reg_form._errors = ErrorDict()
# Todo...
ds = newclass.default_section()
class_requests = ResourceRequest.objects.filter(target=ds)
# Program the multiple-checkbox forms if static requests are used.
resource_formset = ResourceRequestFormSet(
resource_type=resource_types, prefix='request')
initial_requests = {}
for x in class_requests:
if x.res_type.name not in initial_requests:
initial_requests[x.res_type.name] = []
def test_validation_error(self):
###################
# ValidationError #
###################
# Can take a string.
self.assertHTMLEqual(
str(ErrorList(ValidationError("There was an error.").messages)),
'<ul class="errorlist"><li>There was an error.</li></ul>')
# Can take a unicode string.
self.assertHTMLEqual(
six.text_type(ErrorList(ValidationError("Not \u03C0.").messages)),
'<ul class="errorlist"><li>Not π.</li></ul>')
# Can take a lazy string.
self.assertHTMLEqual(
str(ErrorList(ValidationError(ugettext_lazy("Error.")).messages)),
'<ul class="errorlist"><li>Error.</li></ul>')
# Can take a list.
self.assertHTMLEqual(
str(
ErrorList(
ValidationError(["Error one.", "Error two."]).messages)),
'<ul class="errorlist"><li>Error one.</li><li>Error two.</li></ul>'
)
# Can take a mixture in a list.
self.assertHTMLEqual(
str(
ErrorList(
ValidationError([
"First error.", "Not \u03C0.",
ugettext_lazy("Error.")
]).messages)),
'<ul class="errorlist"><li>First error.</li><li>Not π.</li><li>Error.</li></ul>'
)
@python_2_unicode_compatible
class VeryBadError:
def __str__(self):
return "A very bad error."
# Can take a non-string.
self.assertHTMLEqual(
str(ErrorList(ValidationError(VeryBadError()).messages)),
'<ul class="errorlist"><li>A very bad error.</li></ul>')
# Escapes non-safe input but not input marked safe.
example = 'Example of link: <a href="http://www.example.com/">example</a>'
self.assertHTMLEqual(
str(ErrorList([example])),
'<ul class="errorlist"><li>Example of link: <a href="http://www.example.com/">example</a></li></ul>'
)
self.assertHTMLEqual(
str(ErrorList([mark_safe(example)])),
'<ul class="errorlist"><li>Example of link: <a href="http://www.example.com/">example</a></li></ul>'
)
self.assertHTMLEqual(
str(ErrorDict({'name': example})),
'<ul class="errorlist"><li>nameExample of link: <a href="http://www.example.com/">example</a></li></ul>'
)
self.assertHTMLEqual(
str(ErrorDict({'name': mark_safe(example)})),
'<ul class="errorlist"><li>nameExample of link: <a href="http://www.example.com/">example</a></li></ul>'
)
def full_clean(self):
super(AddressForm, self).full_clean()
if not self.is_primary:
if self.is_bound and self['use_primary_address'].value():
self._errors = ErrorDict()
def full_clean(self):
if len(self.data) == 0:
# form wasn't submitted
self._errors = ErrorDict()
return
super().full_clean()
def test_error_dict_html_safe(self):
e = ErrorDict()
e['username'] = '******'
self.assertTrue(hasattr(ErrorDict, '__html__'))
self.assertEqual(force_text(e), e.__html__())
def test_validation_error(self):
###################
# ValidationError #
###################
# Can take a string.
self.assertHTMLEqual(
str(ErrorList(ValidationError("There was an error.").messages)),
'<ul class="errorlist"><li>There was an error.</li></ul>')
# Can take a unicode string.
self.assertHTMLEqual(
str(ErrorList(ValidationError("Not \u03C0.").messages)),
'<ul class="errorlist"><li>Not π.</li></ul>')
# Can take a lazy string.
self.assertHTMLEqual(
str(ErrorList(ValidationError(gettext_lazy("Error.")).messages)),
'<ul class="errorlist"><li>Error.</li></ul>')
# Can take a list.
self.assertHTMLEqual(
str(
ErrorList(
ValidationError(["Error one.", "Error two."]).messages)),
'<ul class="errorlist"><li>Error one.</li><li>Error two.</li></ul>'
)
# Can take a dict.
self.assertHTMLEqual(
str(
ErrorList(
sorted(
ValidationError({
'error_1': "1. Error one.",
'error_2': "2. Error two."
}).messages))),
'<ul class="errorlist"><li>1. Error one.</li><li>2. Error two.</li></ul>'
)
# Can take a mixture in a list.
self.assertHTMLEqual(
str(
ErrorList(
sorted(
ValidationError([
"1. First error.",
"2. Not \u03C0.",
gettext_lazy("3. Error."),
{
'error_1': "4. First dict error.",
'error_2': "5. Second dict error.",
},
]).messages))), '<ul class="errorlist">'
'<li>1. First error.</li>'
'<li>2. Not π.</li>'
'<li>3. Error.</li>'
'<li>4. First dict error.</li>'
'<li>5. Second dict error.</li>'
'</ul>')
class VeryBadError:
def __str__(self):
return "A very bad error."
# Can take a non-string.
self.assertHTMLEqual(
str(ErrorList(ValidationError(VeryBadError()).messages)),
'<ul class="errorlist"><li>A very bad error.</li></ul>')
# Escapes non-safe input but not input marked safe.
example = 'Example of link: <a href="http://www.example.com/">example</a>'
self.assertHTMLEqual(
str(ErrorList([example])),
'<ul class="errorlist"><li>Example of link: '
'<a href="http://www.example.com/">example</a></li></ul>'
)
self.assertHTMLEqual(
str(ErrorList([mark_safe(example)])),
'<ul class="errorlist"><li>Example of link: '
'<a href="http://www.example.com/">example</a></li></ul>')
self.assertHTMLEqual(
str(ErrorDict({'name': example})),
'<ul class="errorlist"><li>nameExample of link: '
'<a href="http://www.example.com/">example</a></li></ul>'
)
self.assertHTMLEqual(
str(ErrorDict({'name': mark_safe(example)})),
'<ul class="errorlist"><li>nameExample of link: '
'<a href="http://www.example.com/">example</a></li></ul>')
def errors(self):
errors = ErrorDict(super(forms.Form, self).errors)
if not self.is_sign_up():
errors.pop('password_confirm', None)
errors.pop('name', None)
return errors
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
def __init__(self, initial, data=None, files=None):
self.data = data or {}
self.files = files or {}
self.errors = ErrorDict()
self.initial = initial
def order_create(request):
if request.method == "POST":
if request.user.is_authenticated:
form = CabinetOrderForm(request.POST)
else:
form = OrderForm(request.POST, initial={})
novalidate = int(request.POST.get('novalidate', 0))
if form.is_valid():
order = form.save(commit=False)
if request.user.is_authenticated:
order.user = request.user
else:
order.user = User.objects.filter(
email=form.cleaned_data.get('email')).first()
if not order.user_id:
plain_password = randomStringDigits(8)
order.user = User.register(form.cleaned_data.get('name'),
form.cleaned_data.get('email'),
form.cleaned_data.get('phone'),
plain_password)
if not order.user_id:
messages.add_message(
request, messages.ERROR,
'Регистрация не удалась, хрень какая-то')
return HttpResponse(
'Регистрация не удалась, хрень какая-то')
else:
messages.add_message(
request, messages.SUCCESS,
'Ваша заявка зарегистрирована. На вашу электронную почту выслан доступ в личный кабинет.'
)
d = {
'user': order.user,
'plain_password': plain_password
}
template_t = get_template('email/user-registered.txt')
message = template_t.render(d)
try:
send_mail('Регистрация на сайте', message,
settings.DEFAULT_FROM_EMAIL,
[order.user.email])
except BadHeaderError:
return HttpResponse('Invalid header found.')
else:
messages.add_message(request, messages.SUCCESS,
'Ваша заявка зарегистрирована')
order.save()
d = {'user': order.user, 'order': order}
template_t = get_template('email/user-order-created.txt')
template_a = get_template('email/adm-order-created.txt')
message_a = template_a.render(d)
message_t = template_t.render(d)
try:
send_mail('Заказ', message_a, settings.DEFAULT_FROM_EMAIL,
[settings.NOTIFY_EMAIL])
send_mail('Оформление заказа на сайте', message_t,
settings.DEFAULT_FROM_EMAIL, [order.user.email])
except BadHeaderError:
return HttpResponse('Invalid header found.')
messages.add_message(
request, messages.SUCCESS, 'Ваш ' + str(order) +
' оформлен и поступил на обработку к нашим менеджерам. Обработка выполняется в '
'течении нескольких рабочих часов, по результатам обработки вы получите счет на '
'оплату услуг. В случае возникновения вопросов менеджер свяжется с вами.'
)
return redirect(reverse('orders.created'))
else:
form._errors = ErrorDict()
form.full_clean = form._full_clean
else:
if request.user.is_authenticated:
form = CabinetOrderForm()
else:
form = OrderForm()
return render(request, 'website/cabinet/orders-create.html',
{'form': form})
def full_clean(self):
if not self.instance.id:
self.cleaned_data = {}
self._errors = ErrorDict()
return
return super().full_clean()
def post(self, request, *args, **kwargs):
print(request.POST)
response_dict = {}
if request.POST.get('form_key') == 'edit_profile':
form_a = self.user_form(pk=request.user.pk, data=request.POST)
form_b = self.profile_form(user=request.user, data=request.POST)
errors = ErrorDict()
if form_a.errors:
errors.update(form_a.errors)
if form_b.errors:
errors.update(form_b.errors)
if not (form_a.is_valid() and form_b.is_valid()):
response_dict.update({
'status': 0,
'message': errors.as_ul()
})
elif authenticate(username=request.user.username, password=request.POST.get('password')):
u1 = form_a.save()
u2 = form_b.save()
response_dict.update({
'status': 1,
'message': 'User was successfully updated.',
'instance': {
'username': u1.username,
'email': u1.email,
'about_me': u2.about_me,
}
})
else:
response_dict.update({
'status': 0,
'message': 'Password is incorrect.'
})
return HttpResponse(json.dumps(response_dict, cls=DjangoJSONEncoder))
elif request.POST.get('form_key') == 'change_pw':
form = self.password_form(pk=request.user.pk, data=request.POST)
if not form.is_valid():
response_dict.update({
'status': 0,
'message': form.errors.as_ul()
})
elif authenticate(username=request.user.username, password=request.POST.get('old_password')):
form.save()
response_dict.update({
'status': 1,
'message': 'Password was successfully updated.'
})
else:
response_dict.update({
'status': 0,
'message': 'Old password is incorrect.'
})
return HttpResponse(json.dumps(response_dict, cls=DjangoJSONEncoder))
return super(ProfileView, self).get(request, *args, **kwargs)
def test_error_dict_html_safe(self):
e = ErrorDict()
e['username'] = '******'
self.assertTrue(hasattr(ErrorDict, '__html__'))
self.assertEqual(force_text(e), e.__html__())
def full_clean(self):
self._errors = ErrorDict()
if hasattr(self, 'cleaned_data'):
del self.cleaned_data
