def edit_account_info(request):
if request.user.is_authenticated and request.user.patient.role == "Patient":
if request.POST:
user_form = UserForm(
request.POST,
instance=request.user,
)
patient_form = PatientForm(request.POST,
instance=request.user.patient)
if user_form.is_valid() and patient_form.is_valid():
username = request.POST['username']
password = request.POST['password']
user = authenticate(username=username, password=password)
if user is not None:
if not all(x.isdigit()
for x in request.POST["phone_number"]):
return render(
request, 'customer/edit_account_info.html', {
'other_errors':
ErrorDict({
"Phone Number":
ErrorDict({
'':
"Phone number should be made of digits only"
})
})
})
user = user_form.save(commit=False)
user.set_password(request.POST["password"])
user.save()
patient = patient_form.save(commit=False)
patient.user = user
patient.save()
login(request, user)
else:
return render(
request, 'customer/edit_account_info.html', {
'user_form_error':
user_form.errors,
'patient_form_error':
patient_form.errors,
'other_errors':
ErrorDict({
"Password":
ErrorDict({'': "Wrong Password"})
})
})
return redirect('/customer/account/')
else:
return render(
request, 'customer/edit_account_info.html', {
'user_form_error': user_form.errors,
'patient_form_error': patient_form.errors
})
return render(request, 'customer/edit_account_info.html')
return redirect('/customer/login')
def _clean_fields(self):
super()._clean_fields()
if settings.SEND_CONFIRMATION_EMAIL:
uid = self.cleaned_data.get('uid', None)
if self.errors and uid not in (None, ''):
try:
self.cleaned_data.update(
secure_pickle.loads(cache.get(uid)))
self._errors = ErrorDict()
except TypeError: # nocv
self._errors = ErrorDict()
def edit_doctor(request, doctor_pk):
if request.user.is_authenticated and request.user.manager.role == "Manager":
doctor_info = Doctor.objects.get(pk=doctor_pk)
if request.POST:
user_form = UserForm(request.POST, instance=doctor_info.user)
doctor_form = DoctorForm(request.POST, instance=doctor_info)
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/edit_doctor.html', {
'doctor':
doctor_info,
'other_errors':
ErrorDict({
"Years of Experience":
ErrorDict({
'':
"Years of experience cannot be equal or greater than age"
})
})
})
if not all(x.isdigit() for x in request.POST["phone_number"]):
return render(
request, 'manager/edit_doctor.html', {
'doctor':
doctor_info,
'other_errors':
ErrorDict({
"Phone Number":
ErrorDict({
'':
"Phone number should be made of digits only"
})
})
})
user = user_form.save(commit=False)
user.save(update_fields=[
'username', 'first_name', 'last_name', 'email'
])
doctor_form.save()
return redirect('/manager/get_report')
else:
return render(
request, 'manager/edit_doctor.html', {
'user_form_error': user_form.errors,
'doctor_form_error': doctor_form.errors,
'doctor': doctor_info
})
return render(request, 'manager/edit_doctor.html',
{'doctor': doctor_info})
return redirect('/')
def test_error_dict_is_json_serializable(self):
init_errors = ErrorDict([
(
"__all__",
ErrorList([
ValidationError("Sorry this form only works on leap days.")
]),
),
("name", ErrorList([ValidationError("This field is required.")])),
])
min_value_error_list = ErrorList([
ValidationError("Ensure this value is greater than or equal to 0.")
])
e = ErrorDict(
init_errors,
date=ErrorList([
ErrorDict({
"day": min_value_error_list,
"month": min_value_error_list,
"year": min_value_error_list,
}),
]),
)
e["renderer"] = ErrorList([
ValidationError(
"Select a valid choice. That choice is not one of the "
"available choices."),
])
self.assertJSONEqual(
json.dumps(e),
{
"__all__": ["Sorry this form only works on leap days."],
"name": ["This field is required."],
"date": [
{
"day":
["Ensure this value is greater than or equal to 0."],
"month":
["Ensure this value is greater than or equal to 0."],
"year":
["Ensure this value is greater than or equal to 0."],
},
],
"renderer": [
"Select a valid choice. That choice is not one of the "
"available choices."
],
},
)
def _patch(self, data):
'''
Update an instance from supplied data.
'''
self._errors = errors = ErrorDict()
for name in self._field_names:
if self._fields[name].readonly:
continue
try:
value = data[name]
except KeyError:
continue
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=False)
if self._errors:
raise ValidationError(self._errors)
return self._obj
def is_valid(self):
# need to make one of the detail forms required, depending on our value
if "is_completion_date_known" in self.data.keys():
is_completion_date_known = self.data["is_completion_date_known"]
required_form = self.detail_form_for_key(is_completion_date_known)
if required_form:
form_is_valid = super().is_valid()
# 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()
# 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"{required_form.prefix}-{field}"] = error
return all(
(
form_is_valid,
required_form_is_valid,
)
)
return super().is_valid()
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 get(self, request, *args, **kwargs):
errors = ErrorDict()
errors[NON_FIELD_ERRORS] = ErrorList([
ValidationError(
_('Your feedback could not be sent, please try again later'))
])
return self.make_response(errors=errors)
def security_errors(self):
"""Return just those errors associated with security"""
errors = ErrorDict()
for f in ["honeypot", "timestamp", "security_hash"]:
if f in self.errors:
errors[f] = self.errors[f]
return errors
def test__post_clean(self, secret, monkeypatch):
form = APIKeyAdminCreateForm(data={
"name": "Test Secret Key",
"secret": secret
})
# Manually invoking internals of Form.full_clean() to isolate
# Form._post_clean
form._errors = ErrorDict()
form.cleaned_data = {}
form._clean_fields()
form._clean_form()
# assert form is valid but instance is not yet saved in the db.
assert form.instance.pk is None
assert form.is_valid() is True
# assert that the instance does not have the owner account populated
assert form.instance.djstripe_owner_account is None
# Invoke _post_clean()
form._post_clean()
if secret.startswith("sk_"):
assert form.instance.type == enums.APIKeyType.secret
assert (form.instance.djstripe_owner_account.id ==
FAKE_PLATFORM_ACCOUNT["id"])
elif secret.startswith("rk_"):
assert form.instance.type == enums.APIKeyType.restricted
assert form.instance.djstripe_owner_account is None
def merge_form_errors(forms_to_merge=None):
forms_to_merge = forms_to_merge or []
form_errors = ErrorDict()
for form in forms_to_merge:
# check if form
if isinstance(form, BaseForm):
for field, errors in form.errors.items():
if field == NON_FIELD_ERRORS:
key = NON_FIELD_MESSAGE
else:
key = form.fields[field].label
form_errors[key] = errors
# check if formset
if isinstance(form, BaseFormSet):
for inner_form in form.forms:
for field, errors in inner_form.errors.items():
if field == NON_FIELD_ERRORS:
key = NON_FIELD_MESSAGE
else:
key = inner_form.fields[field].label
if not key:
key = 'Other'
form_errors[key] = errors
return form_errors
def _add_error(self, message, field=NON_FIELD_ERRORS):
try:
self._errors[field].append(message)
except (KeyError, TypeError):
if not self._errors:
self._errors = ErrorDict()
self._errors[field] = self.error_class([message])
def addmodelpage(request):
p_id = ''
if request.method == 'POST':
if 'pk' in request.GET:
"""Обновление данных модели"""
category = Category.objects.get(pk=int(request.GET['pk']))
form = AddPostModelForm(request.POST, request.FILES, instance=category)
if form.is_valid():
form.save()
else:
""" Создание новой модель """
form = AddPostModelForm(request.POST, request.FILES)
if form.is_valid():
_values = form.cleaned_data
p = Category(**_values)
p.save()
p_id = '?pk=' + str(p.id)
else:
if 'pk' in request.GET:
""" Отображение существующей модели """
p = Category.objects.values().get(pk=int(request.GET['pk']))
form = AddPostModelForm(p)
p_id = '?pk=' + str(p.get('id'))
form._errors = ErrorDict() # отключение валидации полей
else:
""" Отображение новой модель """
form = AddPostModelForm()
return render(request, 'forms/addpage.html', {'form': form, 'p_id': p_id, 'title': 'Добавление статьи'})
def __init__(self, *args, **kwargs):
check_roles = kwargs.pop('check_roles', False)
super(BaseUserFormSet, self).__init__(*args, **kwargs)
if not check_roles:
return
for form in self.forms:
if not form.initial:
continue
user = form.initial['user']
site = form.initial['current_site']
roles_with_sites = get_user_roles_on_sites_ids(user)
roles_for_current_site = []
for role_id, sites_ids in roles_with_sites.items():
if site.id in sites_ids:
roles_for_current_site.append(role_id)
if len(roles_for_current_site) <= 1:
continue
role_names = Role.objects.filter(
id__in=roles_for_current_site).values_list('name', flat=True)
form._errors = ErrorDict()
form._errors['__all__'] = ErrorList([
'User %s has multiple roles: %s. '
'A user can\'t have multiple roles in the same site. '
'Unassign this user until this error disappears.' % (
user.email or user.username, ', '.join(role_names))])
def add_file(request: HttpRequest, department_id: int):
dep: Department = Department.objects.get(id=department_id)
form = DepartmentFileForm()
errors: ErrorDict = ErrorDict()
if request.method == 'POST':
form = DepartmentFileForm(
request.POST or None, request.FILES or None, instance=None)
if form.is_valid():
obj: DepartmentFile = form.save(commit=False)
obj.uploader = request.user
obj.department = dep
obj.save()
return redirect(department, dep.pk)
else:
errors = form.errors
context = {
'errors': errors,
'form': form,
}
return render(request, 'dashboard/upload-file.html', context)
def task(request, dept_id, task_id=None):
dept = Department.objects.get(id=dept_id)
task = Task.objects.get(id=task_id) if not task_id == None else None
form = TaskForm(instance=task)
errors: ErrorDict = ErrorDict()
if request.method == 'POST':
if not task_id == None:
task = Task.objects.get(id=task_id)
form = TaskForm(request.POST or None, instance=task)
else:
form = TaskForm(request.POST)
if form.is_valid():
obj = form.save() if task_id == None else form.save(commit=False)
obj.department.add(dept)
obj.creator = request.user
obj.save()
return redirect(department, dept.id)
else:
errors = form.errors
context = {
'form': form,
'task': task,
'errors': errors,
'dept_id': dept_id,
}
return render(request, 'dashboard/task_v2.html', context)
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 full_clean(self):
if self.is_bound and self.type_is_empty():
# skip any other validation in this case
self._errors = ErrorDict()
self.cleaned_data = {}
else:
super(EventRepeatForm, self).full_clean()
def full_clean(self):
"""
Clean all of self._data and populate self._errors and self._cleaned_data.
"""
self._errors = ErrorDict()
self._cleaned_data = {}
self._clean_fields()
def full_clean(self):
if not self.find_enabled_value():
self.cleaned_data = {
'enabled': False,
}
self._errors = ErrorDict()
else:
return super(AccountForm, self).full_clean()
def is_valid(self):
result = super(ChartForm, self).is_valid()
if result:
result = self.cleaned_data['fromDate'] <= self.cleaned_data['toDate']
if not result:
errors = ErrorDict()
errors['toDate'] = 'End date must not be before Start date'
self._errors = errors
else:
result = (self.cleaned_data['toDate'] -
self.cleaned_data['fromDate']).days < 12
if not result:
errors = ErrorDict()
errors['fromDate'] = 'The maximum number of days shown in the chart is 11 days'
self._errors = errors
return result
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
self._clean_fields()
if not self.cleaned_data.get('reviewer_submitted', True):
self._errors = ErrorDict()
if self.instance.invitation.review.is_complete:
self.add_error(field=None, error='Feedback cannot be updated on a completed review')
# FIXME: we should not rely on internal marked methods, need to clean this up
self._clean_form()
self._post_clean()
def clean(self):
"""Override the clean method, in order to ensure that forms for
creating new objects are not marked as invalid if there is no
data relevant to them."""
if self.is_new_form and not self.has_post_data():
self._errors = ErrorDict()
self.cleaned_data = {}
else:
self.cleaned_data = super(EditForm, self).clean()
return self.cleaned_data
def nice_errors(form, non_field_msg='General form errors'):
nice_errors = ErrorDict()
if isinstance(form, forms.BaseForm):
for field, errors in list(form.errors.items()):
if field == NON_FIELD_ERRORS:
key = non_field_msg
else:
key = form.fields[field].label
nice_errors[key] = errors
return nice_errors
def security_errors(self):
'''
Include the reCAPTCHA field in security errors.
'''
errors = ErrorDict()
for field_name in ['spam_protection', 'timestamp', 'security_hash']:
if field_name in self.errors:
errors[field_name] = self.errors[field_name]
return errors
def clean(self):
super().clean()
if settings.SEND_CONFIRMATION_EMAIL:
uid = self.cleaned_data.get('uid', False)
if uid and not cache.get(uid, False):
self._errors = ErrorDict()
self.add_error(
'uid',
_('Confirmation link is invalid or expired, please register again'
))
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 nice_errors(form, non_field_msg="General form errors"):
result = ErrorDict()
if isinstance(form, BaseForm):
for field, errors in form.errors.items():
if field == NON_FIELD_ERRORS:
key = non_field_msg
else:
key = form.fields[field].label
result[key] = errors
return result
def validate_formset(question_group, formset):
if question_group.required:
answers = extract_form_answers(question_group, formset)
# Needed to unset all of the errors
formset._errors = ErrorDict()
formset.cleaned_data = formset.data
if not (any(answers)) or not ('on' in six.itervalues(answers)):
return False
return True
def add_patient(request):
if request.user.is_authenticated and request.user.manager.role == "Manager":
if request.POST:
user_form = UserForm(request.POST)
patient_form = PatientForm(request.POST)
if user_form.is_valid() and patient_form.is_valid():
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_patient.html',
{'user_form_error': ErrorDict(errAsDict)})
passwordConfirm = request.POST["passwordConfirm"]
if password != passwordConfirm:
return render(
request, 'manager/add_patient.html', {
'other_errors':
ErrorDict({
"Password":
ErrorDict({'': "Passwords do not match"})
})
})
user.set_password(password)
user.save()
patient = patient_form.save(commit=False)
patient.user = user
patient.role = "Patient"
patient.save()
return redirect('/manager/get_report')
else:
return render(
request, 'manager/add_patient.html', {
'user_form_error': user_form.errors,
'patient_form_error': patient_form.errors
})
else:
return render(request, 'manager/add_patient.html')
return redirect('/')
