def test_save_html_email_template_name(self): """ Test the PasswordResetFOrm.save() method with html_email_template_name parameter specified. Test to ensure that a multipart email is sent with both text/plain and text/html parts. """ (user, username, email) = self.create_dummy_user() form = PasswordResetForm({"email": email}) self.assertTrue(form.is_valid()) form.save(html_email_template_name='registration/html_password_reset_email.html') self.assertEqual(len(mail.outbox), 1) self.assertEqual(len(mail.outbox[0].alternatives), 1) message = mail.outbox[0].message() self.assertEqual(message.get('subject'), 'Custom password reset on example.com') self.assertEqual(len(message.get_payload()), 2) self.assertTrue(message.is_multipart()) self.assertEqual(message.get_payload(0).get_content_type(), 'text/plain') self.assertEqual(message.get_payload(1).get_content_type(), 'text/html') self.assertEqual(message.get_all('to'), [email]) self.assertTrue(re.match(r'^http://example.com/reset/[\w/-]+', message.get_payload(0).get_payload())) self.assertTrue( re.match(r'^<html><a href="http://example.com/reset/[\w/-]+/">Link</a></html>$', message.get_payload(1).get_payload()) )
def user_password_reset(self, request, id, form_url=''): from django.contrib.auth.tokens import default_token_generator from django.contrib.auth.forms import PasswordResetForm if not self.has_change_permission(request): raise PermissionDenied user = get_object_or_404(self.get_queryset(request), pk=id) post_reset_redirect = urlresolvers.reverse('admin:%s_%s_change' % (self.model._meta.app_label, self.model._meta.model_name), args=(id,)) form = PasswordResetForm({'email': user.email}) if form.is_valid(): opts = { 'use_https': request.is_secure(), 'token_generator': default_token_generator, 'from_email': None, 'email_template_name': 'registration/password_reset_email.html', 'subject_template_name': 'registration/password_reset_subject.txt', 'request': request, } opts = dict(opts, domain_override=request.get_host()) form.save(**opts) msg = ugettext('Password reset link sent.') messages.success(request, msg) else: msg = ugettext('Error ocurred while sending password reset link.') messages.error(request, msg) return HttpResponseRedirect(post_reset_redirect)
def add_profile(request): if request.method == 'POST': profile_formset = ProfileFormset(request.POST) if profile_formset.is_valid(): user_added = False for form in profile_formset: if form.cleaned_data: username = form.cleaned_data['username'] first_name = form.cleaned_data['first_name'] last_name = form.cleaned_data['last_name'] email = form.cleaned_data['email'] password = generate_random_id() new_user = create_profile(username, email, password, first_name, last_name) activate_profile(new_user.profile) new_user.profile.send_welcome_email(request) user_added = True reset_form = PasswordResetForm({'email': email}) assert reset_form.is_valid() reset_form.save( request=request, use_https=request.is_secure(), email_template_name='profiles/reset_password.txt', ) if user_added: messages.success(request, _('The profiles have been created')) profile_formset = ProfileFormset() else: messages.warning(request, _('Please check the fields below for error')) else: profile_formset = ProfileFormset() return render(request, 'profiles/add_profile.html', {'profile_formset': profile_formset,})
def send_email(self, request): try: reset_form = PasswordResetForm({"email": self.cleaned_data["email"]}) assert reset_form.is_valid() reset_form.save( request=request, from_email="*****@*****.**", use_https=request.is_secure(), subject_template_name="bdiadmin/account_creation_subject.txt", email_template_name="bdiadmin/account_creation_email.html", ) messages.success( request, _("Profile created and mail sent to {0}.").format( self.cleaned_data["email"] ), ) except: messages.warning( request, _("Profil created, but unable to send mail to {0}.").format( self.cleaned_data["email"] ), ) pass
def handle_noargs(self, **options): # user = User.objects.get(pk=1) group = Group.objects.get(pk=2) # group.students.add(user) for student in sys.stdin: fields = student.strip().split(' ') email = fields[0] # print email, len(fields) if len(fields) > 3: continue username = email.split('@')[0] last_name = fields[1] first_name = fields[2] print email, username, last_name, first_name user, created = User.objects.get_or_create(username=username, first_name=first_name, last_name=last_name, email=email) group.students.add(user) reset_form = PasswordResetForm({'email': email}) print reset_form reset_form.save() group.save()
def password_reset(request): post_reset_redirect = reverse('django.contrib.auth.views.password_reset_done') if request.method == "POST": form = PasswordResetForm(request.POST) if form.is_valid(): opts = { 'use_https': request.is_secure(), 'token_generator': default_token_generator, 'from_email': None, 'email_template_name': 'mail/password_reset_body.html', 'subject_template_name': 'mail/password_reset_subject.txt', 'request': request, } form.save(**opts) return JsonResponse({'status': True, 'redirect': post_reset_redirect}) else: status = False else: form = PasswordResetForm() status = True context = { 'form': form, } if request.is_ajax(): return JsonResponse({'status': status, 'template': render_to_string( 'account/password_reset/reset_form.html', context, context_instance=RequestContext(request))}) return TemplateResponse(request, 'account/password_reset/reset_container.html', context)
def post(self, request, format=None): serializer = self.serializer_class(data=request.DATA) if serializer.is_valid(): # Create PasswordResetForm with the serializer password_reset_form = PasswordResetForm(data=serializer.data) if password_reset_form.is_valid(): # Set some values to be used for the send_email method. opts = { 'use_https': request.is_secure(), 'request': request, 'subject_template_name': self.subject_template_name, 'email_template_name': self.email_template_name, } password_reset_form.save(**opts) # Return the success message with OK HTTP status return Response(serializer.data) else: return Response(password_reset_form.errors, status=status.HTTP_400_BAD_REQUEST) # coming this far means there likely was a problem return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def handle(self, *args, **options): # We first retrieve all users accounts = Account.objects.all().filter(is_active=True) for account in accounts: password = Account.objects.make_random_password() account.set_password(password) account.save() opts = { 'use_https': True, 'from_email': getattr(settings, 'DEFAULT_FROM_EMAIL'), 'request': None, 'subject_template_name': 'email/authentication/welcome_subject.txt', 'html_email_template_name': 'email/authentication/html_welcome.html', 'email_template_name': 'email/authentication/welcome.html', 'domain_override': getattr(settings, 'SITE_URL'), 'extra_email_context': { 'site_url': getattr(settings, 'SITE_URL'), 'email': account.email, 'password': password } } reset_form = PasswordResetForm(dict(email=account.email)) if not reset_form.is_valid(): print reset_form.errors raise CommandError("Email not valid: " + account.email) reset_form.save(**opts)
def post(self, request): # Create a serializer with request.DATA serializer = self.serializer_class(data=request.DATA) if serializer.is_valid(): # Create PasswordResetForm with the serializer reset_form = PasswordResetForm(data=serializer.data) if reset_form.is_valid(): # Sett some values to trigger the send_email method. opts = { 'use_https': request.is_secure(), 'from_email': getattr(settings, 'DEFAULT_FROM_EMAIL'), 'request': request, } reset_form.save(**opts) # Return the success message with OK HTTP status return Response( {"success": "Password reset e-mail has been sent."}, status=status.HTTP_200_OK) else: return Response(reset_form._errors, status=status.HTTP_400_BAD_REQUEST) else: return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def password_reset(request): ''' Attempts to send a password reset e-mail. ''' if request.method != "POST": raise Http404 # By default, Django doesn't allow Users with is_active = False to reset their passwords, # but this bites people who signed up a long time ago, never activated, and forgot their # password. So for their sake, we'll auto-activate a user for whom password_reset is called. try: user = User.objects.get(email=request.POST['email']) user.is_active = True user.save() except: log.exception("Tried to auto-activate user to enable password reset, but failed.") form = PasswordResetForm(request.POST) if form.is_valid(): form.save(use_https=request.is_secure(), from_email=settings.DEFAULT_FROM_EMAIL, request=request, domain_override=request.get_host()) return HttpResponse(json.dumps({'success': True, 'value': render_to_string('registration/password_reset_done.html', {})})) else: return HttpResponse(json.dumps({'success': False, 'error': 'Invalid e-mail'}))
def password_reset(request): """ View for entering email of registered player to change password :param request: """ if request.user.is_authenticated(): return HttpResponseRedirect(reverse("index")) context = {} if request.method == "POST": form = PasswordResetForm(request.POST) if form.is_valid(): opts = { "use_https": request.is_secure(), "token_generator": default_token_generator, "from_email": settings.KASKA_EMAIL, "email_template_name": "players/email/email_template.html", "subject_template_name": "players/email/email_subject.txt", "request": request, } try: Player.objects.get(email__iexact=form.cleaned_data["email"]) except Player.DoesNotExist: return HttpResponseRedirect(reverse("players:password_reset_no_email")) else: form.save(**opts) return HttpResponseRedirect(reverse("players:password_reset_check_email")) else: form = PasswordResetForm() context.update({"form": form}) return render(request, "players/password_reset/password_reset.html", context)
def send_user_password_reset_email(user, request, new_user): """ Send a password reset email to the user. The http request object is also required in order to figure out the URL to include in the email. :param user: CtsUser :param request: HttpRequest :param new_user: Whether user is new """ # Code copied and adapted from django.contrib.auth.views.password_reset(). form_data = { 'email': user.email, } reset_form = PasswordResetForm(form_data) if reset_form.is_valid(): opts = { 'use_https': request.is_secure(), 'token_generator': PasswordResetTokenGenerator(), 'from_email': None, 'request': request, } if new_user: opts['email_template_name'] = 'accounts/new_account_email.html' opts['subject_template_name'] = 'accounts/new_account_subject.txt' else: opts['email_template_name'] = 'accounts/password_reset_email.html' opts['subject_template_name'] = 'accounts/password_reset_subject.txt' reset_form.save(**opts)
def post(self, request): # Create a serializer with request.DATA serializer = self.serializer_class(data=request.DATA) result = {'errCode':10000,'errDesc':errMsg[10000]} if serializer.is_valid(): # Create PasswordResetForm with the serializer reset_form = PasswordResetForm(data=serializer.data) if reset_form.is_valid(): # Sett some values to trigger the send_email method. opts = { 'use_https': request.is_secure(), 'from_email': getattr(settings, 'DEFAULT_FROM_EMAIL'), 'request': request, } reset_form.save(**opts) # Return the success message with OK HTTP status return Response(result, status=status.HTTP_200_OK) else: logger.debug(reset_form._errors) logger.debug(serializer.errors) result['errCode']=10009 result['errDesc']=errMsg[10009] return Response(result, status=status.HTTP_200_OK)
def request_password_change(email, orig_host, is_secure): """Email a single-use link for performing a password reset. Users must confirm the password change before we update their information. Args: email (string): An email address orig_host (string): An originating host, extracted from a request with get_host is_secure (Boolean): Whether the request was made with HTTPS Returns: None Raises: AccountUserNotFound AccountRequestError """ # Binding data to a form requires that the data be passed as a dictionary # to the Form class constructor. form = PasswordResetForm({'email': email}) # Validate that an active user exists with the given email address. if form.is_valid(): # Generate a single-use link for performing a password reset # and email it to the user. form.save( from_email=settings.DEFAULT_FROM_EMAIL, domain_override=orig_host, use_https=is_secure ) else: # No active user with the provided email address exists. raise AccountUserNotFound
def passwordReset(self, request, **kwargs): self.method_check(request, allowed=['post']) postData = simplejson.loads(request.raw_post_data) key = postData['token'] user = getUserByKey(key) if user is not None: if user.is_active: data = {'email': user.email} resetForm = PasswordResetForm(data) if resetForm.is_valid(): resetForm.save() return self.create_response(request,{'status':OK, 'message': 'check your email for instructions'}) else: return self.create_response(request, {'status': SYSTEM_ERROR, 'message': 'form not valid'}) else: return self.create_response(request, {'status':FORBIDDEN, 'message':'Account disabled'}) else: return self.create_response(request, {'status': UNAUTHORIZED, 'error': 'User does not exists'})
def password_reset(self, request, queryset): count = 0 for user in queryset: # Do the password reset stuff. form = PasswordResetForm({'email': user.email}) if form.is_valid(): opts = { 'use_https': request.is_secure(), 'token_generator': default_token_generator, 'from_email': 'OpenData Cincy<*****@*****.**>', 'email_template_name': 'registration/password_reset_email.html', 'subject_template_name': 'registration/password_reset_subject.txt', 'request': request, } opts = dict(opts, domain_override=request.get_host()) form.save(**opts) count += 1 if count == 1: message_bit = '1 user was' else: message_bit = '%s users were' % count self.message_user(request, '%s emailed password reset instructions' % message_bit)
def send_password_reset(request, user_id): user = get_object_or_404(User, id=user_id) form = PasswordResetForm({"email": user.email}) if form.is_valid(): form.save(email_template_name="auto_password_reset_email.html") messages.success(request, "Password reset email sent.") return HttpResponseRedirect(reverse("participant_overview", args=(user.id,)))
def test_cleaned_data(self): (user, username, email) = self.create_dummy_user() data = {'email': email} form = PasswordResetForm(data) self.assertTrue(form.is_valid()) form.save(domain_override='example.com') self.assertEqual(form.cleaned_data['email'], email) self.assertEqual(len(mail.outbox), 1)
def form_valid(self, form): self.object, new_position = form.save(commit=False) username = form.cleaned_data['username'] password = form.cleaned_data['password'] self.object.set_password(password) url = form.cleaned_data['picture'] if url and not str(url).find('Default'): domain, path = utils.split_url(str(url)) try: extension = utils.valid_url_extension(str.lower(path)) except not extension: error = 'File was not a valid image (jpg, jpeg, png, gif)' form.non_field_errors(error) try: pil_image = Image.open(url) except utils.valid_image_size(pil_image): form.non_field_errors('Image is too large (> 4mb)') # saving this for later # try: # passed = False # passed = utils.make_thumbnail(pil_image, domain, path) # except not passed: # form.non_field_errors("Couldn't make thumbnail image") form.save(commit=True) # automatically login after registering msg = "Thanks for registering. You are now logged in." messages.info(self.request, msg) new_user = authenticate(username=username, password=password) if new_user is not None and new_user.is_active: login(self.request, new_user) reset_form = PasswordResetForm(self.request.POST) reset_form.is_valid() # Must trigger validation # Copied from django/contrib/auth/views.py : password_reset opts = { 'use_https': self.request.is_secure(), 'email_template_name': 'registration/activate.html', 'subject_template_name': 'registration/activation_email_subject.txt', 'request': self.request, # 'html_email_template_name': # provide an HTML content template if you desire. } # This form sends the email on save() reset_form.save(**opts) return redirect(self.success_url)
def test_cleaned_data(self): # Regression test (user, username, email) = self.create_dummy_user() data = {"email": email} form = PasswordResetForm(data) self.assertTrue(form.is_valid()) form.save(domain_override="example.com") self.assertEqual(form.cleaned_data["email"], email) self.assertEqual(len(mail.outbox), 1)
def test_custom_email_field(self): email = '*****@*****.**' CustomEmailField.objects.create_user('test name', 'test password', email) form = PasswordResetForm({'email': email}) self.assertTrue(form.is_valid()) form.save() self.assertEqual(form.cleaned_data['email'], email) self.assertEqual(len(mail.outbox), 1) self.assertEqual(mail.outbox[0].to, [email])
def test_custom_email_subject(self): template_path = os.path.join(os.path.dirname(__file__), 'templates') with self.settings(TEMPLATE_DIRS=(template_path,)): data = {'email': '*****@*****.**'} form = PasswordResetForm(data) self.assertTrue(form.is_valid()) form.save() self.assertEqual(len(mail.outbox), 1) self.assertEqual(mail.outbox[0].subject, u'Custom password reset on example.com')
def test_password_recovery_form(active_user): user = active_user from django.contrib.auth.forms import PasswordResetForm from django.core import mail mail.outbox = [] form = PasswordResetForm({'email': user.email}) assert bool(form.is_valid()) form.save(domain_override='localhost') assert len(mail.outbox) == 1
def password(request): if request.method == 'POST': formulario = PasswordResetForm(request.POST) if formulario.is_valid: formulario.save() else: formulario = PasswordResetForm() return render(request, 'perfil.html', {'formulario': formulario})
def register(request): if waffle.switch_is_active('fxa-auth'): return login(request) if request.user.is_authenticated(): messages.info(request, _('You are already logged in to an account.')) form = None elif request.method == 'POST': form = forms.UserRegisterForm(request.POST) mkt_user = UserProfile.objects.filter(email=form.data['email'], password='') if form.is_valid(): try: u = form.save(commit=False) u.set_password(form.cleaned_data['password']) u.generate_confirmationcode() u.lang = request.LANG u.save() log.info(u'Registered new account for user (%s)', u) log_cef('New Account', 5, request, username=u.username, signature='AUTHNOTICE', msg='User created a new account') u.email_confirmation_code() msg = _('Congratulations! Your user account was ' 'successfully created.') messages.success(request, msg) msg = _(u'An email has been sent to your address {0} to ' 'confirm your account. Before you can log in, you ' 'have to activate your account by clicking on the ' 'link provided in this email.').format(u.email) messages.info(request, _('Confirmation Email Sent'), msg) except IntegrityError, e: # I was unable to reproduce this, but I suspect it happens # when they POST twice quickly and the slaves don't have the # new info yet (total guess). Anyway, I'm assuming the # first one worked properly, so this is still a success # case to the end user so we just log it... log.error('Failed to register new user (%s): %s' % (u, e)) return http.HttpResponseRedirect(reverse('users.login')) elif mkt_user.exists(): f = PasswordResetForm() f.users_cache = [mkt_user[0]] f.save(use_https=request.is_secure(), email_template_name='users/email/pwreset.ltxt', request=request) return render(request, 'users/newpw_sent.html', {}) else: messages.error(request, _('There are errors in this form'), _('Please correct them and resubmit.'))
def password_reset(request): form = PasswordResetForm() if request.method == 'POST': form = PasswordResetForm(request.POST) if form.is_valid(): form.save(request=request) messages.success(request, 'A link to reset the password is sent to your email.') else: messages.error(request, 'Could not send email. Please try again.') return render(request, 'registration/password_reset.html', {'form': form})
def test_custom_email_subject(self): data = {'email': '*****@*****.**'} form = PasswordResetForm(data) self.assertTrue(form.is_valid()) # Since we're not providing a request object, we must provide a # domain_override to prevent the save operation from failing in the # potential case where contrib.sites is not installed. Refs #16412. form.save(domain_override='example.com') self.assertEqual(len(mail.outbox), 1) self.assertEqual(mail.outbox[0].subject, 'Custom password reset on example.com')
def reset_password(request, template_name="accounts/reset_password_form.html"): form = PasswordResetForm() # if form was submitted, bind form instance. if request.method == "POST": form = PasswordResetForm(request.POST) if form.is_valid(): form.save() return HttpResponseRedirect(reverse("root")) form.fields["email"] = forms.EmailField(label="Votre e-mail", widget=MediumTextInput) return render_to_response(template_name, RequestContext(request, {"form": form}))
def post(self,request): if request.user.is_authenticated(): return HttpResponseRedirect('/') form = PasswordResetForm(data=request.POST) if form.is_valid(): form.save() HttpResponseRedirect('/') return render_to_response('registration/password_reset_form.html', {'form':form}, context_instance=RequestContext(request))
def post(self,request): if request.user.is_authenticated(): return HttpResponseRedirect('/') form = PasswordResetForm(data=request.POST) if form.is_valid(): form.save(from_email= settings.EMAIL_HOST_USER , email_template_name='registration/password_reset_email.html', request=request) return HttpResponseRedirect('/') return render_to_response('registration/password_reset_form.html', {'form':form}, context_instance=RequestContext(request))
def test_custom_email_subject(self): template_path = os.path.join(os.path.dirname(upath(__file__)), 'templates') with self.settings(TEMPLATE_DIRS=(template_path,)): data = {'email': '*****@*****.**'} form = PasswordResetForm(data) self.assertTrue(form.is_valid()) # Since we're not providing a request object, we must provide a # domain_override to prevent the save operation from failing in the # potential case where contrib.sites is not installed. Refs #16412. form.save(domain_override='example.com') self.assertEqual(len(mail.outbox), 1) self.assertEqual(mail.outbox[0].subject, 'Custom password reset on example.com')
def password_reset(request): if request.method == 'POST': form = PasswordResetForm(request.POST) if form.is_valid(): form.save( request=request, from_email='*****@*****.**', email_template_name='registration/password_reset_body.html' ) return redirect('home') form = PasswordResetForm(None) return render(request, 'auth/password_reset.html', {'form': form})
def test_unusable_password(self): user = User.objects.create_user('testuser', '*****@*****.**', 'test') data = {"email": "*****@*****.**"} form = PasswordResetForm(data) self.assertTrue(form.is_valid()) user.set_unusable_password() user.save() form = PasswordResetForm(data) # The form itself is valid, but no email is sent self.assertTrue(form.is_valid()) form.save() self.assertEqual(len(mail.outbox), 0)
def post(self, request, *args, **kwargs): """Send password reset email so user changes automatically-generated random password.""" post = super(UsersCreateView, self).post(request, *args, **kwargs) form = PasswordResetForm({"email": request.POST.get("email")}) form.is_valid() form.save( request=self.request, subject_template_name="users/password_initial_set_subject.txt", email_template_name="users/password_initial_set_email.html", ) return post
def forgot(request): if request.method == "POST": form = PasswordResetForm(request.POST) if form.is_valid(): form.save( from_email=settings.DEFAULT_FROM_EMAIL, request=request, email_template_name="main/password_reset_email.txt", ) messages.success(request, "Password reset email sent!") else: form = PasswordResetForm() return render(request, "main/forgot.html", {"form": form})
def post(self, request): if request.user.is_authenticated(): return HttpResponseRedirect('/') form = PasswordResetForm(data=request.POST) if form.is_valid(): form.save( from_email=settings.EMAIL_HOST_USER, email_template_name='registration/password_reset_email.html', request=request) return HttpResponseRedirect('/') return render_to_response('registration/password_reset_form.html', {'form': form}, context_instance=RequestContext(request))
def create_users(file_name): email_file = open(file_name, 'r') emails = email_file.readlines() for email in emails: if email.__contains__('@') and email.__contains__('.'): user = User.objects.create_user(username=email, password='******', email=email) user.save() password_reset = PasswordResetForm({'email': email}) password_reset.save() else: print("Invalid email " + email)
def reset_psw(request): if request.method == 'POST': form = PasswordResetForm(request.POST) if form.is_valid(): form.save(domain_override=request.get_host(), from_email=DEFAULT_FROM_EMAIL, email_template_name='users/password_reset_email.html') return render_to_response('users/reset_psw_sended.html', {}) else: return TemplateResponse(request, 'users/reset_psw.html', {'form': form}) form = PasswordResetForm() return TemplateResponse(request, 'users/reset_psw.html', {'form': form})
def ResetPwd(self, request): reset_form = PasswordResetForm({'email': self.user.email}) print(self.user.email) assert reset_form.is_valid() print(reset_form) reset_form.save( request=request, use_https=request.is_secure(), subject_template_name= 'registration/create_user_invitation_email_subject.txt', email_template_name= 'registration/create_user_invitation_email.html', )
def create_and_invite_user(email, request): form = PasswordResetForm(data={"email": email}) if form.errors: raise ValidationError(form.errors) user = User.objects.create(email=email, is_active=True) user.set_password(uuid.uuid4()) user.save() form.save( request=request, from_email=settings.DEFAULT_FROM_EMAIL, subject_template_name="registration/set_initial_password_subject.txt", email_template_name="registration/set_initial_password_email.html") return user
def claim_profile(request, username): profile = get_object_or_404(Profile, user__username=username) reset_form = PasswordResetForm({'email': profile.user.email}) try: assert reset_form.is_valid() reset_form.save( domain_override="composerscouch.com", email_template_name='accounts/email_profile_claim_message.txt', ) return redirect('userena_password_reset_done') except: return redirect('claim_profile_error', username=username, error="error")
def post(self, request, *args, **kwargs): self.user_form = StaffInitForm(request.POST) if self.user_form.is_valid(): user = self.user_form.save(commit=False) user.is_staff = True user.save() setpsw = PasswordResetForm(data={'email': user.email}) if setpsw.is_valid(): setpsw.save(subject_template_name=self.subject_template_name, email_template_name=self.email_template_name) messages.success(request, "Invitation email sent to %s" % user.email) return redirect(self.get_redirect_url()) return self.render_to_response(self.get_context_data())
def send_password_set_email(email, host, subject_template, template='registration/password_set_email_.html'): form = PasswordResetForm({'email': email}) logger.debug("Sending Password reset to", email) if form.is_valid(): form.save(subject_template_name=subject_template, html_email_template_name=template, domain_override=host) logger.debug("Sent!") else: logger.warn("Email to " + str(email) + " not sent because form is invalid")
def send_email_invitation(self, request, queryset): for user in queryset: if user.is_active == False: user.is_active = True user.save() reset_form = PasswordResetForm({'email': user.email}, request.POST) assert reset_form.is_valid() reset_form.save(subject_template_name= 'registration/account_creation_subject.txt', request=request) user.is_active = False user.save() self.message_user(request, 'Email invitation sent successfully')
def reset_password(request): """Reset user's password.""" form = PasswordResetForm(json.loads(request.body.decode("utf-8"))) if form.is_valid(): opts = { "use_https": request.is_secure(), "token_generator": default_token_generator, "email_template_name": "registration/password_reset_email.html", "subject_template_name": "registration/password_reset_subject.txt", "request": request, } form.save(**opts) return JsonResponse({}) return JsonResponse({"email": "Not found or not valid"}, status=400)
def password_reset(request, is_admin_site=False, template_name='registration/password_reset_form.html', email_template_name='registration/password_reset_email.html'): new_data, errors = {}, {} form = PasswordResetForm() if request.POST: new_data = request.POST.copy() errors = form.get_validation_errors(new_data) if not errors: if is_admin_site: form.save(domain_override=request.META['HTTP_HOST']) else: form.save(email_template_name=email_template_name) return HttpResponseRedirect('%sdone/' % request.path) return render_to_response(template_name, {'form': oldforms.FormWrapper(form, new_data, errors)}, context_instance=RequestContext(request))
def create_user_profile(sender, instance, created, **kwargs): if created: Profile.objects.get_or_create(user=instance) public = Book.objects.create(name='%s\'s Drinks' % instance.first_name, public=True) BookUser.objects.create(book=public, user=instance, owner=True) if instance.email: form = PasswordResetForm({'email': instance.email}) if form.is_valid(): form.save(subject_template_name='email/welcome_subject.txt', email_template_name='email/welcome.txt', html_email_template_name='email/welcome.html', domain_override=settings.ALLOWED_HOSTS[0], use_https=True)
def send_new_event_notify(request, email): # ADD PW RESET CALL HERE baseurl = request.get_host() print('baseurl: ' + baseurl) domain, port = split_domain_port(baseurl) print('domain: ' + domain + ' port: ' + port) form = PasswordResetForm({'email': email}) if form.is_valid(): request = HttpRequest() request.META['SERVER_NAME'] = domain request.META['SERVER_PORT'] = port form.save(request=request, use_https=False, from_email="*****@*****.**", email_template_name='events/event_new_notify.html')
def obj_create(self, bundle, **kwargs): """Custom user creation that sends a password reset email.""" value = super(UserResource, self).obj_create(bundle, **kwargs) # Send the password reset email so the user can set its own password. from django.contrib.auth.forms import PasswordResetForm from django.conf import settings form = PasswordResetForm({'email': bundle.obj.email}) form.full_clean() tpl = "account/password_reset_email_for_api_user_creation.html" form.save(email_template_name=tpl, from_email=settings.DEFAULT_FROM_EMAIL) return value
def send_invite(user): """Sends an email invite to a User instance, using Django's PasswordResetForm. """ if user.email: form = PasswordResetForm({'email': user.email}) form.is_valid() # Needed for the `save()` to work. form.save(domain_override=site_url.split('://')[-1], email_template_name='registration/invitation_email.txt', subject_template_name='registration/invitation_subject.txt', extra_email_context={ 'recipient': user.first_name, 'site_name': site_name, 'site_url': site_url })
def post(self, request): form = PasswordResetForm(request.POST) if form.is_valid(): opts = { 'domain_override': get_current_site(request).name, 'use_https': request.is_secure(), 'from_email': 'noreply@' + get_current_site(request).name } form.save(**opts) message = "You will receive a password reset link shortly at you email {}. If you do not receive it please check yor spam folder and try again.".format( request.POST['email']) messages.info(request, message) return redirect('home') messages.info(request, "Invalid Email!") return redirect('home')
def passwordreset(request): if request.method == 'POST': form = PasswordResetForm(request.POST) if form.is_valid(): form.save(domain_override=settings.DOMAIN_NAME, email_template_name='accounts/password_reset_email.txt') messages.success( request, 'An email has been sent to the provided email address.') return HttpResponseRedirect(reverse('password-reset')) else: form = PasswordResetForm() return render(request, 'accounts/password-reset.html', { 'form': form, })
def reset_password(request): resetform = PasswordResetForm({"email": request.REQUEST["email"]}) if (resetform.is_valid()): opts = { 'use_https': request.is_secure(), 'token_generator': default_token_generator, 'from_email': None, 'email_template_name': 'reset_email_password.html', 'request': request} resetform.save(**opts) return {"status": "success"} else: raise HttpBadRequestException()
def reset_password(email, request): form = PasswordResetForm({'email': email}) if form.is_valid(): return form.save( from_email=settings.EMAIL_HOST_USER, email_template_name='registration/password_reset_email.html', request=request)
def password_reset(request): form = PasswordResetForm(request.POST or None) if request.method == 'POST': if form.is_valid(): form.save(from_email='*****@*****.**', request=request) messages.success(request, "link sent") return redirect('/login/') else: return HttpResponse("Invalid Request") else: form = PasswordResetForm() return render(request, 'password_reset_form.html', { 'form': form, 'title': 'Password Reset' })
def save(self): # Creating the stuff for the email request = HttpRequest() request.META = request.META request.META['SERVER_NAME'] = 'localhost' request.META['SERVER_PORT'] = '8000' reset_form = PasswordResetForm({'email': self.EMail}) assert reset_form.is_valid() reset_form.save( request=request, subject_template_name='registration/password_reset_subject.txt', email_template_name='registration/password_reset_email.html', ) super(Employee, self).save()
def create_user_profile(sender, instance, created, **kwargs): """ Method to Send Password reset email to the user, when an Administrator creates the User """ if created: form = PasswordResetForm({'email': instance.email}) if form.is_valid(): current_site = get_current_site(request=None) request = HttpRequest() request.META['HTTP_HOST'] = current_site.domain form.save(request=request, use_https=False, from_email=settings.DEFAULT_FROM_EMAIL, html_email_template_name= 'registration/new_user_html_password_reset_email.html')
def reset_password(email, from_email, template='email/welcome.html'): """ Reset the password for all (active) users with given E-Mail adress """ form = PasswordResetForm({'email': email}) form.is_valid() return form.save(from_email=from_email, email_template_name=template)
def save(self, commit=True): cleaned_data = self.clean() instance = super().save() opponent = cleaned_data["opponent"] if opponent.is_guest: invite_form = PasswordResetForm(data={"email": opponent.email}) invite_form.is_valid() invite_form.save( self, subject_template_name='registration/guest_email_subject.txt', email_template_name='registration/guest_email.html', from_email=settings.FROM_EMAIL, ) else: send_invite_email(instance.opponent, instance.creator) return instance
def save(self, commit=True): """ Save the model instance with the correct Auth Group based on the user_level question """ instance = super(UserCreationForm, self).save(commit=commit) random_password = ''.join( random.choice(string.ascii_uppercase + string.digits) for x in range(32)) instance.set_password(random_password) instance.save() email_form = PasswordResetForm({'email': self.cleaned_data['email']}) email_form.is_valid() email_form.save(email_template_name='accounts/welcome_email.html') return instance