def user(request):
if not request.user.is_authenticated():
messages.error(request, "Authentication required to access account information.")
return redirect("/")
u = User.objects.get(username=request.user)
if request.method == "POST":
pform = SetPasswordForm(user=u, data=request.POST)
if pform.is_valid():
pform.save()
messages.success(request, "Password Updated.")
#else:
# messages.warning(request, "Invalid Password.")
mform = UserEmailForm(request.POST)
if mform.is_valid():
m = mform.cleaned_data["email"]
if m != u.email:
u.email = m
u.save()
messages.success(request, "Email Address Updated.")
else:
messages.warning(request, "Invalid Email Address.")
return redirect(".")
#rc = RequestContext(request, {
c = {
'form': QueryForm(),
'authform': AuthenticationForm(),
'passform': SetPasswordForm(request.user),
'emailform': UserEmailForm(instance=u),
'redirect': request.path,
}
#return render_to_response("account.html", rc)
return render(request, "account.html", c)
def password_change(request,
template_name='usuario/perfil/cambiar_clave.html',
current_app=None, extra_context=None, expresion=None, tipo_mensaje=None, mensaje=None, palabra_clave=None):
context = {}
context.update(csrf(request))
# Determinar cuál formulario usar.
# 'Asignar' no necesita contraseña anterior
# 'Cambiar' necesita contraseña anterior
accion = ''
if palabra_clave == 'asignar':
form = SetPasswordForm(user=request.user, data=request.POST or None)
accion = 'cambiada'
elif palabra_clave == 'cambiar':
accion = 'actualizada'
form = PasswordChangeForm(user=request.user, data=request.POST or None)
if form.is_valid():
form.save()
mensaje = u'Contraseña %s exitosamente' %(accion)
tipo_mensaje = 'success'
else:
tipo_mensaje = 'error'
for error in form.errors:
mensaje = form.errors['%s' %(error)].as_text().replace('* ','')
(tipo_mensaje, expresion) = msj_expresion(tipo_mensaje)
context.update({'formulario':form})
context.update({'request':request})
context.update({'mensaje':mensaje})
context.update({'tipo_mensaje':tipo_mensaje})
context.update({'expresion':expresion})
return render_to_response(template_name, context)
def password_reset_confirm(request, uidb36=None, token=None):
"""View that checks the hash in a password reset link and presents a
form for entering a new password.
Based on django.contrib.auth.views.
"""
try:
uid_int = base36_to_int(uidb36)
except ValueError:
raise Http404
user = get_object_or_404(User, id=uid_int)
context = {}
if default_token_generator.check_token(user, token):
context['validlink'] = True
if request.method == 'POST':
form = SetPasswordForm(user, request.POST)
if form.is_valid():
form.save()
return HttpResponseRedirect(reverse('users.pw_reset_complete'))
else:
form = SetPasswordForm(None)
else:
context['validlink'] = False
form = None
context['form'] = form
return render(request, 'users/pw_reset_confirm.html', context)
def reset_password(request):
if request.user.is_authenticated():
return HttpResponse(status=400)
uidb36 = request.POST['uidb36']
token = request.POST['token']
try:
uid_int = base36_to_int(uidb36)
user = User.objects.get(id=uid_int)
except (ValueError, ObjectDoesNotExist):
user = None
if user is not None and default_token_generator.check_token(user, token):
form = SetPasswordForm(user, request.POST)
if form.is_valid():
form.save()
user = auth.authenticate(
username=user.username,
password=request.POST['new_password1'])
auth.login(request, user)
return HttpResponse(JSON_SUCCESS)
else:
return get_json_errors(form.errors)
else:
return HttpResponse(status=400)
def mutate_and_get_payload(cls, input, request, info):
errors = []
UserModel = User._meta.model
try:
# urlsafe_base64_decode() decodes to bytestring on Python 3
uid = force_text(urlsafe_base64_decode(input.get('uidb64')))
user = UserModel.objects.get(pk=uid)
except (TypeError, ValueError, OverflowError, UserModel.DoesNotExist):
user = None
if user and default_token_generator.check_token(user, input.get('token')):
form = SetPasswordForm(user=user, data=input)
if form.is_valid():
user = form.save(commit=False)
user.save(request=request)
# workarout to re authenticate the user
# when as change the user on the DB it gets disconected
user.backend = settings.DEFAULT_AUTHENTICATION_BACKENDS
auth_login(request, user)
else:
errors = form_erros(form, errors)
else:
errors.append(Error(
code='password_reset_incorrect_token',
message=_('Password reset failed')
))
return PasswordResetComplete(errors=errors)
def confirm_reset_password(request, username, confirmation_code):
logout(request)
tagging = RecipientUserTagging.get_or_none(user__username=username)
error = None
if not tagging:
error = "Unknown username"
#elif tagging.is_confirmed:
# error = "Registration is already complete."
elif not tagging.confirm(confirmation_code):
error = "Error confirming confirmation_code %s" % confirmation_code
else:
if request.POST:
form = SetPasswordForm(tagging.user, request.POST)
if form.is_valid():
form.save()
success = tagging.confirm(confirmation_code)
if not success:
return render_response(request, 'procrasdonate/recipient_organizer_pages/account/confirmation_error.html', locals())
user = authenticate(username=username, password=form.cleaned_data['new_password1'])
if user.is_active:
login(request, user)
user.message_set.create(message='Password reset complete!')
return HttpResponseRedirect(reverse('recipient_organizer_dashboard'))
else:
return HttpResponseRedirect(reverse('login'))
form = SetPasswordForm(tagging.user)
instructions = """Enter a new password. It can be whatever you want, but it will
be more secure if you use numbers and uppercase letters in addition to lowercase letters."""
return render_response(request, 'procrasdonate/recipient_organizer_pages/account/confirm.html', locals())
def change_pass(request):
code = request.GET.get('code', '')
if code:
try:
uid = fb_utils.get_userid(code, change_pass)
if uid != request.user.fbprofile.fb_userid:
messages.error(request, "Your facebook account did not" +\
" match the one registered with LitHub.")
return redirect('bookswap.views.my_account')
form = SetPasswordForm(user=request.user)
if request.method=="POST":
form = SetPasswordForm(request.user, request.POST)
if form.is_valid():
form.save()
messages.success(request, "Your password was "+\
"successfully changed.")
return redirect("bookswap.views.my_account")
return render(request, "fbconnect/password_change.html",
{'form':form},)
except ObjectDoesNotExist:
return redirect('bookswap.views.my_account')
except ValueError:
return render(request, "fbconnect/code_error.html")
else:
messages.error(request, "There was an error getting your " +\
"information from facebook.")
return redirect('django.contrib.auth.views.login')
def test_password_verification(self):
# The two new passwords do not match.
user = User.objects.get(username="******")
data = {"new_password1": "abc123", "new_password2": "abc"}
form = SetPasswordForm(user, data)
self.assertFalse(form.is_valid())
self.assertEqual(form["new_password2"].errors, [force_unicode(form.error_messages["password_mismatch"])])
def profileupdate(request):
## profile update form
if request.method == 'POST' and 'profileupdate' in request.POST:
profileform = ProfileUpdateForm(request.POST, request.FILES, instance=request.user)
if profileform.is_valid():
profileform.save()
messages.success(request, 'Profile details updated')
return HttpResponseRedirect(reverse('profile-update'))
else:
profileform = ProfileUpdateForm(instance=request.user)
## password change form
if request.method == 'POST' and 'passwordchange' in request.POST:
passwordform = SetPasswordForm(request.user, request.POST)
if passwordform.is_valid():
passwordform.save()
messages.success(request, 'Password changed')
return HttpResponseRedirect(reverse('profile-update') + '#body')
else:
passwordform = SetPasswordForm(request.user)
return render(request, 'accounts/update.html', {
'profileform': profileform,
'passwordform': passwordform,
})
def post(self, request,username):
# Create a serializer with request.DATA
serializer = self.serializer_class(data=request.DATA)
old_password = request.DATA.get('old_password','')
new_password1 = request.DATA.get('new_password1', '')
new_password2 = request.DATA.get('new_password2', '')
user = authenticate(username=username, password=old_password)
result = {}
result['errCode'] = 10000
result['errDesc'] = errMsg[10000]
if user is None:
result['errCode'] = 10003
result['errDesc'] = errMsg[10003]
return Response(result, status=status.HTTP_200_OK)
if not old_password or not new_password1 or not new_password2:
result['errCode'] = 10018
result['errDesc'] = errMsg[10018]
return Response(result, status=status.HTTP_200_OK)
if serializer.is_valid():
# Construct the SetPasswordForm instance
form = SetPasswordForm(user=user, data=serializer.data)
if form.is_valid():
form.save()
# Return the success message with OK HTTP status
return Response(result, status=status.HTTP_200_OK)
result['errCode'] = 10004
result['errDesc'] = errMsg[10004]
logger.debug(serializer.errors)
return Response(result, status=status.HTTP_200_OK)
def password_reset_confirm(request, uidb36=None, token=None):
"""
View that checks the hash in a password reset link and presents a
form for entering a new password.
"""
assert uidb36 is not None and token is not None # checked by URLconf
post_reset_redirect = reverse('django.contrib.auth.views.password_reset_complete')
try:
uid_int = base36_to_int(uidb36)
user = User.objects.get(pk=uid_int)
except (ValueError, OverflowError, User.DoesNotExist):
user = None
if user is not None and default_token_generator.check_token(user, token):
validlink = True
if request.method == 'POST':
form = SetPasswordForm(user, request.POST)
if form.is_valid():
form.save()
return JsonResponse({'status': True, 'redirect': post_reset_redirect})
else:
status = False
else:
form = SetPasswordForm(None)
status = True
else:
raise Http404
context = {'form': form, 'validlink': validlink, 'uidb36': uidb36, 'token': token}
if request.is_ajax():
return JsonResponse({'status': status, 'template': render_to_string(
'account/password_reset/confirm_form.html', context, context_instance=RequestContext(request))})
return TemplateResponse(request, 'account/password_reset/confirm_container.html', context)
def password_reset_confirm(request, key):
try:
reset = PasswordReset.objects.get(key=key)
user = reset.user
except PasswordReset.DoesNotExist:
user = None
if user is not None:
validlink = True
if request.method == 'POST':
form = SetPasswordForm(user, request.POST)
if form.is_valid():
form.save()
reset.delete()
return redirect('accounts.password_reset_done')
else:
form = SetPasswordForm(None)
else:
validlink = False
form = None
return render(request, 'accounts/password_reset_confirm.j.html', {
'validlink': validlink,
'form': form
})
def reset_password(request, hash):
"""Perform a password change.
If the request method is set to GET and the hash matches a form
will be displayed to the user allowing the password change.
If the request method is POST the user password will be changed
to the newly set data.
"""
profile = get_object_or_404(UserProfile, verification_hash=hash)
user = profile.user
form = SetPasswordForm(profile.user)
template_data = {"form": form, "hash": hash}
if request.method == "GET":
return render_to_response("account_change_password.html", template_data, RequestContext(request))
form = SetPasswordForm(user, request.POST)
template_data.update({"form": form})
if not form.is_valid():
return render_to_response("account_change_password.html", template_data, RequestContext(request))
profile.verification_hash = "verified"
profile.save()
user.set_password(form.cleaned_data.get("new_password1"))
user.save()
template_data.update({"msg": _(u"Password changed successfully!"), "msg_css_class": "success"})
return render_to_response("account_message.html", template_data, RequestContext(request))
def set_password(request):
# This shows the signup form and displays errors
if request.method == 'POST':
# This form has been filled in by the user
form = SetPasswordForm(request.user, request.POST)
if form.is_valid():
form.save()
logger.debug('Set password for ' + request.user.email)
# Set a message and redirect
# Django logs the user out after successful password set :( WTF
# Crazy hack: http://stackoverflow.com/questions/15192808/django-automatic-login-after-user-registration-1-4
request.user.backend = "django.contrib.auth.backends.ModelBackend"
auth_login(request, request.user)
message = "Your password has been set!"
messages.add_message(request, messages.SUCCESS, message)
logger.debug(message)
return redirect('accounts:profile')
else:
# initial, empty form
form = SetPasswordForm(user=request.user)
context = {
'form': form,
}
return render(request, 'registration/password_set_form.html', context)
def reset_password_new_user(request, uidb36, token):
"""
Checks the link the user clicked and prompts for a new password
:param request: the standard request given by Django
:param uidb36: the id's hash
:param token: token created dynamically
"""
try:
uid_int = base36_to_int(uidb36)
user = User.objects.get(pk=uid_int)
except (ValueError, OverflowError, User.DoesNotExist):
user = None
if user is not None and not user.has_usable_password() \
and default_token_generator.check_token(user, token):
validlink = True
if request.method == "POST":
form = SetPasswordForm(user, request.POST)
if form.is_valid():
user = form.save()
user.is_active = True
user.save()
user.backend = 'django.contrib.auth.backends.ModelBackend'
login(request, user)
return HttpResponseRedirect(reverse('index'))
else:
form = SetPasswordForm(None)
else:
validlink = False
form = None
return render(request, 'registration/reset_password_complete.html', {
'form': form,
'validlink': validlink
})
def update(request, id):
user = User.objects.get(id=id)
if request.POST:
user_form = UserForm(request.POST, instance=user)
setpassword_form = SetPasswordForm(user, request.POST)
new_password1 = request.POST.get('new_password1', '')
new_password2 = request.POST.get('new_password2', '')
if not new_password1 and not new_password2:
if user_form.is_valid():
user_form.save()
return HttpResponseRedirect(reverse('account_index'))
else:
if user_form.is_valid() and setpassword_form.is_valid():
user_form.save()
setpassword_form.save()
return HttpResponseRedirect(reverse('account_index'))
else:
user_form = UserForm(instance=user)
setpassword_form = SetPasswordForm(user)
return {
'user_form':user_form,
'setpassword_form':setpassword_form,
'id':id
}
def resetpassword(self,request):
uidb64 = self.request.POST.get("uidb64","")
token = self.request.POST.get("token","")
password1 = self.request.POST.get("password1","")
password2 = self.request.POST.get("password2","")
try:
uid = urlsafe_base64_decode(uidb64)
user = User.objects.get(id=uid)
except (TypeError,ValueError,OverflowError,User.DoesNotExist):
user = None
token_generator = default_token_generator
if user is not None and token_generator.check_token(user,token):
form = SetPasswordForm(user,request.POST)
error = []
if form.is_valid():
user = form.save()
else:
#如果表单不正确，保存错误到errors列表中
for k,v in form.errors.items():
errors.append(v.as_text())
else:
return HttpResponse("密码重设失败！\n密码重置链接无效，可能因为它已使用。可以请求一次新的密码重设.",status=403)
def user_password(request):
name = _("Update Password")
if request.method == 'POST':
form = SetPasswordForm(request.user, request.POST)
if form.is_valid():
form.save()
messages.success(request, _("Password successfully updated."))
return HttpResponseRedirect(reverse('home'))
else:
# The form is invalid
messages.error(
request, _("Please correct the errors in the form."))
return render(request,
'djmongo/console/generic/bootstrapform.html',
{'form': form,
'name': name,
})
# this is a GET
context = {'name': name,
'form': SetPasswordForm(user=request.user)
}
return render(request, 'djmongo/console/generic/bootstrapform.html',
context)
def change_password(request):
can_change_password = request.user.has_usable_password()
if can_change_password:
if request.POST:
form = SetPasswordForm(request.user, request.POST)
if form.is_valid():
form.save()
if django.VERSION >= (1, 7):
from django.contrib.auth import update_session_auth_hash
update_session_auth_hash(request, form.user)
messages.success(request, _("Your password has been changed successfully!"))
return redirect('wagtailadmin_account')
else:
form = SetPasswordForm(request.user)
else:
form = None
return render(request, 'wagtailadmin/account/change_password.html', {
'form': form,
'can_change_password': can_change_password,
})
def change_pass(request):
try:
if request.method == "GET":
fb = fb_utils.FBConnect(request.GET.get('code', ''), change_pass)
if fb.userid != request.user.fbprofile.fb_userid:
messages.error(request, "Your facebook account did not" +\
" match the one registered with LitHub.")
return redirect('bookswap.views.my_account')
request.session['fb_password_uuid'] = str(uuid4())
form = SetPasswordForm(user=request.user)
post_uuid = request.POST.get('uuid', '')
if request.method=="POST" and post_uuid and \
post_uuid == request.session["fb_password_uuid"]:
form = SetPasswordForm(request.user, request.POST)
if form.is_valid():
form.save()
request.session['fb_password_uuid'] = ""
messages.success(request, "Your password was "+\
"successfully changed.")
return redirect("bookswap.views.my_account")
return render(request, "fbconnect/password_change.html",
{'form':form, 'uuid':request.session["fb_password_uuid"]},)
except ObjectDoesNotExist:
messages.error(request, "Your facebook account was not recognized.")
except ValueError:
messages.error(request, "There was an error getting your " +\
"information from facebook.")
return redirect('bookswap.views.my_account')
def test_password_whitespace_not_stripped(self):
user = User.objects.get(username="******")
data = {"new_password1": " password ", "new_password2": " password "}
form = SetPasswordForm(user, data)
self.assertTrue(form.is_valid())
self.assertEqual(form.cleaned_data["new_password1"], data["new_password1"])
self.assertEqual(form.cleaned_data["new_password2"], data["new_password2"])
def password_reset_confirm(request, uidb36=None, token=None):
token_generator = default_token_generator
try:
uid_int = base36_to_int(uidb36)
user = User.objects.get(id=uid_int)
except (ValueError, User.DoesNotExist):
user = None
if user is not None and token_generator.check_token(user, token):
validlink = True
if request.method == 'POST':
form = SetPasswordForm(user, request.POST)
if form.is_valid():
form.save()
messages.success(request, _(u'Пароль изменён'))
return redirect('/')
else:
form = SetPasswordForm(None)
else:
validlink = False
form = None
context = {
'form': form,
'validlink': validlink,
}
return render(request, 'account/password_reset_confirm.html', context)
def post(self, request, *args, **kwargs):
self.object = self.get_object()
forms_valid = True
change_password = False
form = self.get_form(self.get_form_class())
if not form.is_valid():
forms_valid = False
if self.request.POST.get('new_password1'):
change_password = True
self.password_form = SetPasswordForm(
data=request.POST, user=request.user)
if not self.password_form.is_valid():
forms_valid = False
else:
self.password_form = SetPasswordForm(user=request.user)
if forms_valid:
form.save()
if change_password:
self.password_form.save()
self.notifications_form.save()
return HttpResponseRedirect(self.get_success_url())
else:
return self.render_to_response(
self.get_context_data(form=form))
def change_password(request):
if not password_management_enabled():
raise Http404
can_change_password = request.user.has_usable_password()
if can_change_password:
if request.POST:
form = SetPasswordForm(request.user, request.POST)
if form.is_valid():
form.save()
update_session_auth_hash(request, form.user)
messages.success(request, _("Your password has been changed successfully!"))
return redirect('wagtailadmin_account')
else:
form = SetPasswordForm(request.user)
else:
form = None
return render(request, 'wagtailadmin/account/change_password.html', {
'form': form,
'can_change_password': can_change_password,
})
def password_reset_confirm(request, uidb64=None, token=None):
if request.user.is_authenticated():
return HttpResponseRedirect(reverse("index"))
context = {}
UserModel = get_user_model()
assert uidb64 is not None and token is not None
try:
uid = force_text(urlsafe_base64_decode(uidb64))
user = UserModel._default_manager.get(pk=uid)
except (TypeError, ValueError, OverflowError, UserModel.DoesNotExist):
user = None
if user is not None and default_token_generator.check_token(user, token):
valid_link = True
title = _("Enter new password")
if request.method == "POST":
form = SetPasswordForm(user, request.POST)
if form.is_valid():
form.save()
return HttpResponseRedirect(reverse("players:password_reset_complete"))
else:
form = SetPasswordForm(user)
else:
valid_link = False
title = _("Password reset failed")
form = None
context.update({"form": form, "title": title, "valid_link": valid_link})
context.update({"request": request})
return render(request, "players/password_reset/confirm.html", context)
def post(self, request, *args, **kwargs):
"""
request associate profile
"""
response_data = {}
response_data['status'] = True
if request.is_ajax():
user_id = request.POST.get('user_id')
try:
if request.POST.get('associate'):
user = User.objects.get(id=user_id)
else:
store_user = StoreAccountProfile.objects.get(id=user_id)
user = User.objects.get(id=store_user.user.id)
password_form = SetPasswordForm(user, request.POST)
if password_form.is_valid():
password = password_form.cleaned_data.get('new_password1')
user.set_password(password)
user.save()
else:
response_data['status'] = False
response_data['errors'] = password_form.errors
except User.DoesNotExist:
response_data['status'] = False
return HttpResponse(json.dumps(response_data), content_type="application/json")
def resetpassword(self, request):
uidb64 = self.request.POST.get("uidb64", "")
token = self.request.POST.get("token", "")
password1 = self.request.POST.get("password1", "")
password2 = self.request.POST.get("password2", "")
try:
uid = urlsafe_base64_decode(uidb64)
user = JoklinUser._default_manager.get(pk=uid)
except (TypeError, ValueError, OverflowError, JoklinUser.DoesNotExist):
user = None
token_generator = default_token_generator
if user is not None and token_generator.check_token(user, token):
form = SetPasswordForm(user, request.POST)
errors = []
if form.is_valid():
user = form.save()
else:
# 如果表单不正确,保存错误到errors列表中
for k, v in form.errors.items():
# v.as_text() 详见django.forms.util.ErrorList 中
errors.append(v.as_text())
mydict = {"errors": errors}
return HttpResponse(json.dumps(mydict), content_type="application/json")
else:
logger.error(u"[UserControl]用户重置密码连接错误:[{}]/[{}]".format(uid64, token))
return HttpResponse(u"密码重设失败!\n密码重置链接无效，可能是因为它已使用。可以请求一次新的密码重置.", status=403)
def new_password(request, activation_key):
"""
Display form for recovering password
**Context**
set password Form
**Template:**
:template:`new_password.html`
"""
try:
embigo_user = EmbigoUser.objects.get(activation_key=activation_key)
if embigo_user.key_expires > timezone.now() and embigo_user.hash_type == "PASSWORD_HASH":
if request.method == 'POST':
form = SetPasswordForm(embigo_user.user, request.POST)
if form.is_valid():
embigo_user.activation_key = None
embigo_user.save()
form.save()
context = {'message': "Twoje hasło zostało zmienione"}
return render(request, 'confirmation.html', context)
else:
form = SetPasswordForm(embigo_user.user)
context = {'form': form}
return render(request, 'new_password.html', context)
else:
context = {'message': "Błąd, podany link jest nieaktywny."}
except ObjectDoesNotExist:
context = {'message': "Błąd, podany link jest nieaktywny."}
return render(request, 'confirmation.html', context)
class Edit(generic.edit.UpdateView):
"""
User profile editing
"""
template_name = 'identity/edit.html'
form_class = UserEditForm
success_url = reverse_lazy('homepage')
model = Identity
@method_decorator(never_cache)
@method_decorator(login_required)
def dispatch(self, request, *args, **kwargs):
return super(Edit, self).dispatch(request, *args, **kwargs)
def get(self, request, *args, **kwargs):
self.password_form = SetPasswordForm(user=request.user)
return super(Edit, self).get(request, *args, **kwargs)
def post(self, request, *args, **kwargs):
self.object = self.get_object()
forms_valid = True
change_password = False
form = self.get_form(self.get_form_class())
if not form.is_valid():
forms_valid = False
if self.request.POST.get('new_password1'):
change_password = True
self.password_form = SetPasswordForm(
data=request.POST, user=request.user)
if not self.password_form.is_valid():
forms_valid = False
else:
self.password_form = SetPasswordForm(user=request.user)
if forms_valid:
form.save()
if change_password:
self.password_form.save()
self.notifications_form.save()
return HttpResponseRedirect(self.get_success_url())
else:
return self.render_to_response(
self.get_context_data(form=form))
def get_object(self):
return self.request.user
def get_context_data(self, **kwargs):
return super(Edit, self).get_context_data(
password_form=self.password_form,
notifications_form=self.notifications_form,
**kwargs
)
def test_success(self):
user = User.objects.get(username='******')
data = {
'new_password1': 'abc123',
'new_password2': 'abc123',
}
form = SetPasswordForm(user, data)
self.assertTrue(form.is_valid())
def test_password_verification(self):
# The two new passwords do not match.
user = User.objects.get(username='******')
data = {
'new_password1': 'abc123',
'new_password2': 'abc',
}
form = SetPasswordForm(user, data)
self.assertFalse(form.is_valid())
self.assertEqual(form["new_password2"].errors,
[force_text(form.error_messages['password_mismatch'])])
def test_password_verification(self):
# The two new passwords do not match.
user = User.objects.get(username='******')
data = {
'new_password1': 'abc123',
'new_password2': 'abc',
}
form = SetPasswordForm(user, data)
self.assertFalse(form.is_valid())
self.assertEqual(form["new_password2"].errors,
[u"The two password fields didn't match."])
def password_reset_confirm(request, key):
template_name = 'accounts/password_reset_confirm.html' # Define o template que será utilizado
context = {}
# Busca o registro no banco de dados, caso não encontre informa erro 404.
reset = get_object_or_404(PasswordReset, key=key)
form = SetPasswordForm(user=reset.user, data=request.POST or None)
# Verifica se a nova senha é correta
if form.is_valid():
form.save() # Salva nova senha
context['success'] = True
context['form'] = form # Adiciona o formulário ao dicionário
return render(request, template_name, context) # Renderiza template
def _process_password_reset_success(self, request, token, uidb64, extra_context):
self.user = self.get_user(uidb64)
form = SetPasswordForm(self.user, request.POST)
if self.token_generator.check_token(self.user, token) and form.is_valid():
self.form_valid(form)
url = reverse('password_reset_complete')
return HttpResponseRedirect(url)
else:
context = self.get_context_data()
if extra_context is not None:
context.update(extra_context)
return self.render_to_response(context)
def password_reset_confirm(request, key):
template_name = 'accounts/password_reset_confirm.html'
context = dict()
reset = get_object_or_404(PasswordReset, key=key)
form = SetPasswordForm(user=reset.user, data=request.POST or None)
if form.is_valid():
form.save()
messages.success(request, 'Sua senha foi criada com sucesso!!')
context['form'] = form
return render(request, template_name, context)
def form(self, request: HttpRequest, params: Dict) -> 'forms.Form':
token_generator = default_token_generator
user = user_utils.get_user(params.pop('uidb64'))
try:
if token_generator.check_token(user, params['token']):
return SetPasswordForm(user, params)
except:
pass
form = SetPasswordForm(user, params)
form.add_error(None, "There's been a validation issue. Try getting another password reset email.")
return form
def reset_senha_confirm(request, key):
template_name = 'accounts/reset_senha_confirm.html'
context = {}
reset = get_object_or_404(NovaSenha, key=key)
form = SetPasswordForm(user=reset.user, data=request.POST or None)
if form.is_valid():
form.save()
context['success'] = True
return redirect('accounts:login')
context['form'] = form
return render(request, template_name, context)
def test_password_whitespace_not_stripped(self):
user = User.objects.get(username="******")
data = {
"new_password1": " password ",
"new_password2": " password ",
}
form = SetPasswordForm(user, data)
self.assertTrue(form.is_valid())
self.assertEqual(form.cleaned_data["new_password1"],
data["new_password1"])
self.assertEqual(form.cleaned_data["new_password2"],
data["new_password2"])
def password_reset_confirm(request, key):
template_name = 'user/password_reset_confirm.html'
context = {}
reset = get_object_or_404(PasswordReset, key=key)
form = SetPasswordForm(user=reset.user, data=request.POST or None)
if form.is_valid():
form.save()
messages.success(request,
'Sua senha foi resetada com sucesso')
return redirect('user:dashboard')
context['form'] = form
return render(request, template_name, context)
def password_reset_confirm(request, key):
template_name = 'accounts/password_reset_confirm.html'
context = {}
reset = get_object_or_404(PasswordReset, key=key)
form = SetPasswordForm(user=reset.user, data=request.POST or None)
if form.is_valid():
form.save()
context['success'] = True
context['form'] = form
return render(request, template_name, context)
def test_password_whitespace_not_stripped(self):
user = User.objects.get(username='******')
data = {
'new_password1': ' password ',
'new_password2': ' password ',
}
form = SetPasswordForm(user, data)
self.assertTrue(form.is_valid())
self.assertEqual(form.cleaned_data['new_password1'],
data['new_password1'])
self.assertEqual(form.cleaned_data['new_password2'],
data['new_password2'])
def __init__(self, *args, **kwargs):
SetPasswordForm.__init__(self, *args, **kwargs)
self.helper = FormHelper(self)
self.helper.label_class = 'col-md-4'
self.helper.field_class = 'col-md-8'
self.helper.layout.append(
HTML(u"""<div class="form-group row">
<div class="col-md-offset-4 col-md-8">
<button type="submit" class="btn btn-secondary">"""
+ _(u'Применить') + """</button>
</div>
</div>"""))
def test_password_verification(self):
# The two new passwords do not match.
user = User.objects.get(username="******")
data = {
"new_password1": "abc123",
"new_password2": "abc",
}
form = SetPasswordForm(user, data)
self.assertFalse(form.is_valid())
self.assertEqual(
form["new_password2"].errors,
[str(form.error_messages["password_mismatch"])],
)
def post(self, request, user):
selected_user = User.objects.filter(id=user).first()
form = SetPasswordForm(selected_user, request.POST)
if form.is_valid():
form.save()
messages.success(request, 'The password was successfully updated')
return redirect('priv:user_mgmt')
else:
messages.error(request, 'Please correct the error below')
return render(request, 'hda_privileged/password_reset.html', {
'usr': selected_user,
'form': form
})
def post(self, request):
form = SetPasswordForm(self.user, request.POST)
if form.is_valid():
form.save()
self.user.password_reset_token = (
User.password_reset_token.field.get_default())
self.user.password_reset_expiration_date = (
User.password_reset_expiration_date.field.get_default())
self.user.save()
LOGGER.info("Password reset successful for %r", self.user)
messages.success(request, _("Password was reset successfully."))
return redirect("home")
return super().get(request, form=form)
def updateAthleteProfile(request, pk):
perm = general_methods.control_access(request)
if not perm:
logout(request)
return redirect('accounts:login')
user = User.objects.get(pk=pk)
directory_user = Athlete.objects.get(user=user)
person = Person.objects.get(pk=directory_user.person.pk)
communication = Communication.objects.get(
pk=directory_user.communication.pk)
user_form = DisabledUserForm(request.POST or None, instance=user)
person_form = DisabledPersonForm(request.POST or None,
request.FILES or None,
instance=person)
communication_form = DisabledCommunicationForm(request.POST or None,
instance=communication)
password_form = SetPasswordForm(request.user, request.POST)
if request.method == 'POST':
if user_form.is_valid() and communication_form.is_valid(
) and person_form.is_valid() and password_form.is_valid():
user.username = user_form.cleaned_data['email']
user.first_name = user_form.cleaned_data['first_name'].upper()
user.last_name = user_form.cleaned_data['last_name'].upper()
user.email = user_form.cleaned_data['email']
user.set_password(password_form.cleaned_data['new_password1'])
user.save()
person_form.save()
communication_form.save()
password_form.save()
messages.success(request, 'Sporcu Başarıyla Güncellenmiştir.')
return redirect('sbs:sporcu-profil-guncelle')
else:
messages.warning(request, 'Alanları Kontrol Ediniz ')
return render(
request, 'sporcu/sporcu-profil-guncelle.html', {
'user_form': user_form,
'communication_form': communication_form,
'person_form': person_form,
'password_form': password_form
})
def user_edit(request, id):
action = "Edit"
edit_user = get_object_or_404(get_user_model(), id=id)
user_form = settings_forms.UserChangeForm(request.POST or None, instance=edit_user)
password_form = SetPasswordForm(data=request.POST or None, user=edit_user)
if 'user' in request.POST and user_form.is_valid():
user_form.save()
messages.success(request, "User information saved.")
return redirect('user_list')
elif 'password' in request.POST and password_form.is_valid():
password_form.save()
messages.success(request, "Password changed.")
return redirect('user_list')
return render(request, 'administration/user_form.html', locals())
def post(self, request, *args, **kwargs):
form = SetPasswordForm(
request.user,
request.POST,
label_suffix='',
)
if form.is_valid():
form.save()
context = self.get_context_data(**kwargs)
messages.success(request, 'Password changed.')
else:
context = self.get_context_data(form=form, **kwargs)
context['show_info'], context['show_pas'] = '', 'show active'
return self.render_to_response(context)
def test_validates_password(self):
user = User.objects.get(username='******')
data = {
'new_password1': 'testclient',
'new_password2': 'testclient',
}
form = SetPasswordForm(user, data)
self.assertFalse(form.is_valid())
self.assertEqual(len(form["new_password2"].errors), 2)
self.assertIn('The password is too similar to the username.',
form["new_password2"].errors)
self.assertIn(
'This password is too short. It must contain at least 12 characters.',
form["new_password2"].errors)
def edit_user_password(request, object_id=None):
user = User.objects.get(id=object_id)
form = SetPasswordForm(user, request.POST)
# Save new/edited component
if request.method == 'POST' and form.is_valid():
dataPosted = request.POST
user.password = hashlib.sha1(dataPosted['new_password2']).hexdigest()
user.save()
return HttpResponseRedirect('/user/')
return render_to_response('vulture/userpassword_form.html', {
'form': form,
'user': request.user
})
def validate(self, attributes):
try:
user = get_user_model().objects.get(
username=attributes.get('username'))
except get_user_model().DoesNotExist:
raise serializers.ValidationError(
{'username': _('User does not exist.')})
if not default_token_generator.check_token(user, attributes['token']):
raise serializers.ValidationError({'token': _('Incorrect token.')})
self.set_password_form = SetPasswordForm(user=user, data=attributes)
if not self.set_password_form.is_valid():
raise serializers.ValidationError(self.set_password_form.errors)
return attributes
def password_reset_confirm(request, key):
template_name = 'password_change_form.html'
context = {}
reset = get_object_or_404(PasswordReset, key=key)
form = SetPasswordForm(user=reset.user, data=request.POST or None)
print(form)
if request.method == 'POST':
if form.is_valid():
form.save()
messages.success(request, 'Senha alterada com sucesso')
return redirect('accounts:gate')
else:
messages.warning(request, form.errors)
context['form'] = form
return render(request, template_name, context)
def senha_reset_confirmar(request, key):
template_name = 'conta/senha_reset_confirmar.html'
context = {}
reset = get_object_or_404(SenhaReset, key=key)
if reset.confirmed == True:
context['key_usada'] = True
return render(request, template_name, context)
form = SetPasswordForm(user=reset.user, data=request.POST or None)
if form.is_valid():
reset.confirmed = True
reset.save()
form.save()
context['success'] = True
context['form'] = form
return render(request, template_name, context)
def password_reset_confirm(request, key):
template_name = 'accounts/password_reset_confirm.html'
context = {}
reset = get_object_or_404(
PasswordReset,
key=key) # Pega a chave que está no html e busca o model.
form = SetPasswordForm(
user=reset.user, data=request.POST
or None) # Se não der o erro 404 acima, faz o reset.user
if form.is_valid():
form.save()
context[
'success'] = True # Variável do template usada para informar ao usuário se os dados foram ou não validados recebe True.
context['form'] = form # Adiciona o form ao contexto
return render(request, template_name, context)
def post(self, request):
"""
api endpoint to set password for a given user
:param request:
:return:
"""
try:
payload = json.loads(request.body)
except ValueError:
return JsonResponse({"error": "Unable to parse request body"},
status=400)
form = SetPasswordForm(payload)
if form.is_valid():
user = User.objects.filter(pk=self.request.user.id)
def superuser_change_form_handler(request, user_id):
"""Process the requests from the group superuser Change Account Settings
page for the user selected on the superuser home page. This includes
requests from the profile change form and the set password form.
Parameters:
request - The request object that contains the POST data from the froms.
user_id - The ID number of the user that should be represented and
modified by the change forms.
"""
changing_user = User.objects.get(id=user_id)
changing_profile = changing_user.get_profile()
if request.POST:
# Process profile change form
if 'profile_input' in request.POST:
profile_change_form = UserProfileForm(data=request.POST,
instance=changing_profile)
if profile_change_form.is_valid():
profile_change_form.save()
return HttpResponseRedirect(
reverse('confirm_superuser_changes',
kwargs={'user_id': user_id}))
set_password_form = SetPasswordForm(user=changing_user)
# Process password change form
elif 'password_input' in request.POST:
set_password_form = SetPasswordForm(user=changing_user,
data=request.POST)
if set_password_form.is_valid():
set_password_form.save()
return HttpResponseRedirect(
reverse('confirm_superuser_changes',
kwargs={'user_id': user_id}))
profile_change_form = FullProfileChangeForm(
instance=changing_profile)
else:
return HttpResponseRedirect(
reverse('superuser_change_account_settings',
kwargs={'user_id': user_id}))
else:
set_password_form = SetPasswordForm(user=changing_user)
profile_change_form = UserProfileForm(instance=changing_profile)
return render_to_response('superuser_change_account_settings.html', {
'username': changing_user.username,
'set_password_form': set_password_form,
'profile_change_form': profile_change_form,
'auth_url': GIT_AUTH_URL
},
context_instance=RequestContext(request))
def updateDirectoryProfile(request):
perm =general_methods.control_access(request)
if not perm:
logout(request)
return redirect('accounts:login')
user = request.user
directory_user = DirectoryMember.objects.get(user=user)
person = Person.objects.get(pk=directory_user.person.pk)
communication = Communication.objects.get(pk=directory_user.communication.pk)
user_form = DisabledUserForm(request.POST or None, instance=user)
person_form = DisabledPersonForm(request.POST or None, instance=person)
communication_form = DisabledCommunicationForm(request.POST or None, instance=communication)
member_form = DisabledDirectoryForm(request.POST or None, instance=directory_user)
password_form = SetPasswordForm(request.user, request.POST)
if request.method == 'POST':
if user_form.is_valid() and communication_form.is_valid() and person_form.is_valid() and member_form.is_valid() and password_form.is_valid():
user.username = user_form.cleaned_data['email']
user.first_name = user_form.cleaned_data['first_name']
user.last_name = user_form.cleaned_data['last_name']
user.email = user_form.cleaned_data['email']
user.set_password(password_form.cleaned_data['new_password1'])
user.save()
person_form.save()
communication_form.save()
member_form.save()
password_form.save()
messages.success(request, 'Yönetim Kurul Üyesi Başarıyla Güncellenmiştir.')
return redirect('wushu:yonetim-kurul-profil-guncelle')
else:
messages.warning(request, 'Alanları Kontrol Ediniz')
return render(request, 'yonetim/yonetim-kurul-profil-guncelle.html',
{'user_form': user_form, 'communication_form': communication_form,
'person_form': person_form, 'password_form': password_form, 'member_form': member_form})
def post(self, request):
try:
username, key = request.POST.get('username'), UUID(request.POST.get('key')).hex
rp = ResetPassword.objects.get(key=key, user__username=username)
if rp.expired:
return self.render_to_json({'error': {"key": ["The link has expired."]}}, status=500)
except (ObjectDoesNotExist, ValidationError):
return self.render_to_json({'error': {"key": ["Invalid. Please retry from the link you received by e-mail."]}}, status=500)
form = SetPasswordForm(User.objects.get(username=username), request.POST)
if form.is_valid():
form.save()
rp.expired = True
rp.save()
return self.render_to_json({})
return self.render_to_json({'error': form.errors}, status=500)
def validate(self, attrs):
self._errors = {}
try:
uid = force_text(uid_decoder(attrs['uid']))
self.user = User._default_manager.get(pk=uid)
except (TypeError, ValueError, OverflowError, User.DoesNotExist):
raise ValidationError({'uid': ['Valor invalido']})
self.set_password_form = SetPasswordForm(user=self.user, data=attrs)
if not self.set_password_form.is_valid():
raise serializers.ValidationError(self.set_password_form.errors)
if not default_token_generator.check_token(self.user, attrs['token']):
raise ValidationError({'token': ['Valor invalido']})
return attrs
def get(self, request, user):
selected_user = User.objects.filter(id=user).first()
form = SetPasswordForm(selected_user)
return render(request, 'hda_privileged/password_reset.html', {
'usr': selected_user,
'form': form
})
