def test_user_can_reset_password(self): url = reverse("password_new") beverly = UserFactory(username="******") beverly.set_password("jack") beverly.save() mismatch_password_data = { "uid": urlsafe_base64_encode(force_bytes(beverly.pk)).decode(), "token": default_token_generator.make_token(beverly), "password": encode_string("wesley"), "confirm_password": encode_string("WESLEY") } response = self.client.post(url, mismatch_password_data, format='json') self.assertEqual(response.status_code, 400) self.assertFalse(User.objects.get(username='******').check_password('wesley')) bad_uid_data = { "uid": urlsafe_base64_encode(force_bytes(UserFactory().pk)).decode(), "token": default_token_generator.make_token(beverly), "password": encode_string("wesley"), "confirm_password": encode_string("wesley") } response = self.client.post(url, bad_uid_data, format='json') self.assertEqual(response.status_code, 400) self.assertFalse(User.objects.get(username='******').check_password('wesley')) good_data = { "uid": urlsafe_base64_encode(force_bytes(beverly.pk)).decode(), "token": default_token_generator.make_token(beverly), "password": encode_string("wesley"), "confirm_password": encode_string("wesley") } self.assertSchemaPost(url, "$setPasswordRequest", "$userResponse", good_data, None, status_OK=True) self.assertTrue(User.objects.get(username='******').check_password('wesley'))
def test_recovery_valid_token_empty_passwords(self): token = default_token_generator.make_token(self.user) response = self.client.get('/control/forgot/recover?id=%d&token=%s' % (self.user.id, token)) self.assertEqual(response.status_code, 200) response = self.client.post( '/control/forgot/recover?id=%d&token=%s' % (self.user.id, token), { 'password': '******', 'password_repeat': '' } ) self.assertEqual(response.status_code, 200) self.user = User.objects.get(id=self.user.id) self.assertTrue(self.user.check_password('demo')) token = default_token_generator.make_token(self.user) response = self.client.get('/control/forgot/recover?id=%d&token=%s' % (self.user.id, token)) self.assertEqual(response.status_code, 200) response = self.client.post( '/control/forgot/recover?id=%d&token=%s' % (self.user.id, token), { 'password': '', 'password_repeat': 'foobarbar' } ) self.assertEqual(response.status_code, 200) self.user = User.objects.get(id=self.user.id) self.assertTrue(self.user.check_password('demo'))
def test_password_policy_on_password_reset(self): """ This makes sure the proper asserts on password policy also works on password reset """ staff_email, _ = self._setup_user(is_staff=True, password="******") success_msg = "Your Password Reset is Complete" # try to reset password, it should fail user = User.objects.get(email=staff_email) token = default_token_generator.make_token(user) uidb36 = int_to_base36(user.id) # try to do a password reset with the same password as before resp = self.client.post( "/password_reset_confirm/{0}-{1}/".format(uidb36, token), {"new_password1": "foo", "new_password2": "foo"}, follow=True, ) self.assertNotIn(success_msg, resp.content) # try to reset password with a long enough password user = User.objects.get(email=staff_email) token = default_token_generator.make_token(user) uidb36 = int_to_base36(user.id) # try to do a password reset with the same password as before resp = self.client.post( "/password_reset_confirm/{0}-{1}/".format(uidb36, token), {"new_password1": "foofoo", "new_password2": "foofoo"}, follow=True, ) self.assertIn(success_msg, resp.content)
def post(self, request, *args, **kwargs): form = self.form_class(request.POST) if form.is_valid(): data= form.cleaned_data["email_or_username"] if self.validate_email_address(data) is True: associated_users= User.objects.filter(Q(email=data)|Q(username=data)) if associated_users.exists(): for user in associated_users: c = { 'email': user.email, 'domain': request.META['HTTP_HOST'], 'site_name': 'SinComplique', 'uid': urlsafe_base64_encode(force_bytes(user.pk)), 'user': user, 'token': default_token_generator.make_token(user), 'protocol': 'http', } subject_template_name = 'users/password_reset_subject.txt' email_template_name = 'users/password_reset_subject.html' subject = 'Cambio de Contraseña' subject = ''.join(subject.splitlines()) email_txt = loader.render_to_string(subject_template_name, c) email_html = loader.render_to_string(email_template_name, c) send_mail(subject, email_html, settings.DEFAULT_FROM_EMAIL, [user.email]) result = self.form_valid(form) messages.success(request, 'An email has been sent to ' + data +". Please check its inbox to continue reseting password.") return result result = self.form_invalid(form) messages.warning(request, 'No user is associated with this email address') return result else: associated_users= User.objects.filter(username=data) if associated_users.exists(): for user in associated_users: c = { 'email': user.email, 'domain': request.META['HTTP_HOST'], 'site_name': 'SinComplique', 'uid': urlsafe_base64_encode(force_bytes(user.pk)), 'user': user, 'token': default_token_generator.make_token(user), 'protocol': 'http', } subject_template_name='users/password_reset_subject.txt' email_template_name='users/password_reset_subject.html' subject = loader.render_to_string(subject_template_name, c) subject = ''.join(subject.splitlines()) email_txt = loader.render_to_string(subject_template_name, c) email_html = loader.render_to_string(email_template_name, c) send_mail(subject, email_html, settings.DEFAULT_FROM_EMAIL , [user.email]) result = self.form_valid(form) messages.success(request, 'Email has been sent to ' + data +"'s email address. Please check its inbox to continue reseting password.") return result result = self.form_invalid(form) messages.error(request, 'This username does not exist in the system.') return result messages.error(request, 'Invalid Input') return self.form_invalid(form)
def send_signup_confirm_email(request, user): uid = urlsafe_base64_encode(force_bytes(user.pk)) token = token_generator.make_token(user) context = { 'user': user, 'host': request.scheme + '://' + request.META['HTTP_HOST'], 'uid': urlsafe_base64_encode(force_bytes(user.pk)) 'token': token_generator.make_token(user), }
def send_signup_confirm_email(request, user): uid = urlsafe_base64_encode(force_bytes(user.pk)) token = token_generator.make_token(user) context = { 'user': user, 'host': request.scheme + '://' + request.META['HTTP_HOST'], 'uid': urlsafe_base64_encode(force_bytes(user.pk)), 'token': token_generator.make_token(user), } subject = render_to_string('accounts/signup_confirm_subject.txt', context).splitlines() [0] # newline 이 포함될 수 없습니다. body = render_to_string('accounts/signup_confirm_body.txt', context) to_email = [user.email] send_mail(subject, body, None, to_email, fail_silently=False)
def send_signup_confirm_email(request, user): uid = urlsafe_base64_encode(force_bytes(user.pk)) token = token_generator.make_token(user) context = { "user": user, "host": request.scheme + "://" + request.META["HTTP_HOST"], "uid": urlsafe_base64_encode(force_bytes(user.pk)), "token": token_generator.make_token(user), } subject = render_to_string("accounts/signup_confirm_subject.txt", context) body = render_to_string("accounts/signup_confirm_body.txt", context) to_email = [user.email] send_mail(subject, body, None, to_email, fail_silently=False)
def email_verification_form(request,sent=""): if request.user.email_verified: return HttpResponseRedirect('/') if request.method == "POST": user = request.user email_template_name = "users/verification_email.html" current_site = get_current_site(request) site_name = current_site.name domain = current_site.domain use_https = request.is_secure() c = { 'email': user.email, 'domain': domain, 'site_name': site_name, 'uid': urlsafe_base64_encode(force_bytes(user.pk)), 'user': user, 'token': default_token_generator.make_token(user), 'protocol': 'https' if use_https else 'http', } subject = "Verification the e-mail address of user "+user.user_profile.name content = loader.render_to_string(email_template_name, c) send_mail(subject, content, None, [user.email]) return HttpResponseRedirect(reverse('users:email-verification-form', kwargs={'sent':'sent/'})) else: return render(request, 'users/email_verification_form.html', {'sent':sent})
def setUp(self): super(PasswordResetTests, self).setUp() self.u = user(email="*****@*****.**", save=True) self.uidb36 = int_to_base36(self.u.id) self.token = default_token_generator.make_token(self.u) self.orig_debug = settings.DEBUG settings.DEBUG = True
def reset_password(self, user, request): c = { 'email': user.email, 'domain': request.META['HTTP_HOST'], 'site_name': 'your site', 'uid': urlsafe_base64_encode(force_bytes(user.pk)), 'user': user, 'token': default_token_generator.make_token(user), 'protocol': 'http', } subject_template_name = 'password_reset_subject.txt' # copied from # django/contrib/admin/templates/registration/password_reset_subject.txt # to templates directory email_template_name = 'password_reset_email.html' # copied from # django/contrib/admin/templates/registration/password_reset_email.html # to templates directory subject = loader.render_to_string(subject_template_name, c) # Email subject *must not* contain newlines subject = ''.join(subject.splitlines()) email = loader.render_to_string(email_template_name, c) send_mail(subject, email, DEFAULT_FROM_EMAIL, [user.email], fail_silently=False) print(subject) print(email)
def mylogin(request): if request.method == 'POST': form = FormLogin(request.POST) if form.is_valid(): first_name = form.cleaned_data["first_name"] last_name = form.cleaned_data["last_name"] year = form.cleaned_data["year"] token_sent = True try: user = User.objects.filter(alumnus__year=year).filter(last_name=last_name).get(first_name=first_name) subject = 'Login to the MVA Alumni Directory' token = default_token_generator.make_token(user) mail_message = render_to_string('mail_token.txt', {'user': user, 'token': token, 'PROTOCOL': settings.PROTOCOL, 'DOMAIN': settings.DOMAIN, 'EMAIL_CONTACT': settings.EMAIL_CONTACT}) send_mail(subject, mail_message, settings.EMAIL_TOKEN, [user.email], fail_silently=True) except ObjectDoesNotExist: pass except MultipleObjectsReturned: pass else: message_error = u"Invalid form !" else: form = FormLogin() EMAIL_CONTACT = settings.EMAIL_CONTACT return render(request, 'login.html', locals())
def test_student_password_reset_reuse(self): """ Goes through the password reset flows to make sure the various password reuse policies are enforced """ student_email, _ = self._setup_user() user = User.objects.get(email=student_email) err_msg = 'You are re-using a password that you have used recently. You must have 1 distinct password' success_msg = 'Your Password Reset is Complete' token = default_token_generator.make_token(user) uidb36 = int_to_base36(user.id) # try to do a password reset with the same password as before resp = self.client.post('/password_reset_confirm/{0}-{1}/'.format(uidb36, token), { 'new_password1': 'foo', 'new_password2': 'foo' }, follow=True) self.assertPasswordResetError(resp, err_msg) # now retry with a different password resp = self.client.post('/password_reset_confirm/{0}-{1}/'.format(uidb36, token), { 'new_password1': 'bar', 'new_password2': 'bar' }, follow=True) self.assertIn(success_msg, resp.content)
def post(self, request, *args, **kwargs): if self.form.is_valid(): user = self.form.cleaned_data["user"] mail( user.email, _("Password recovery"), "pretixpresale/email/forgot.txt", { "user": user, "event": self.request.event, "url": build_absolute_uri( "presale:event.forgot.recover", kwargs={"event": self.request.event.slug, "organizer": self.request.event.organizer.slug}, ) + "?id=%d&token=%s" % (user.id, default_token_generator.make_token(user)), }, self.request.event, locale=user.locale, ) messages.success(request, _("We sent you an e-mail containing further instructions.")) return redirect( "presale:event.forgot", organizer=self.request.event.organizer.slug, event=self.request.event.slug ) else: return self.get(request, *args, **kwargs)
def register(request): context = {} login_form = LoginForm() context['login_form'] = login_form if request.method == 'GET': context['register_form'] = RegistrationForm() return render(request, 'register.html', context) register_form = RegistrationForm(request.POST) context['register_form'] = register_form if not register_form.is_valid(): return render(request, 'register.html', context) if request.method == 'POST': if not register_form.is_valid(): print "Register NOT Valid!" else: username = register_form.cleaned_data.get('username') print username # register_form.save() new_user = User.objects.create_user(username=register_form.cleaned_data['username'], email=register_form.cleaned_data['email'], password=register_form.cleaned_data['password'], first_name=register_form.cleaned_data['first_name'], last_name=register_form.cleaned_data['last_name']) # We need to activate every new user. new_user.is_active = False new_user.save() # Create related profile for this new user profile = Profile(user=new_user) profile.save() token = default_token_generator.make_token(new_user) # Send the validation email. confirm_message = """ Welcome to Grumblr!\n Please click the link below to verify your email address:\n http://%s%s """ % (request.get_host(), reverse('confirm', args=(new_user.username, token, ))) confirm_link = """ http://%s%s """ % (request.get_host(), reverse('confirm', args=(new_user.username, token, ))) send_mail(subject = "Hello from Grumblr!", message = confirm_message, from_email="*****@*****.**", recipient_list = [new_user.email]) context['username'] = new_user.username context['email'] = new_user.email context['confirm_message'] = confirm_message context['confirm_link'] = confirm_link return render(request, 'activation.html', context) return redirect('/') return render(request, 'register.html', {})
def get_email_context_data(self, user, **kwargs): token_view_name = kwargs.get('token_view_name', self.token_view_name) if not token_view_name: raise ImproperlyConfigured("No token_view_name defined.") site = Site.objects.get_current() token = default_token_generator.make_token(user) uidb36 = int_to_base36(user.id) static_url = settings.STATIC_URL token_url = reverse(token_view_name, kwargs={'uidb36': uidb36, 'token': token}) if hasattr(self, 'request'): token_url = self.request.build_absolute_uri(token_url) if '://' not in static_url: static_url = self.request.build_absolute_uri(static_url) else: token_url = 'http://%s%s' % (site.domain, token_url) return { 'user': user, 'uid': uidb36, 'token': token, 'token_url': token_url, 'site': site, 'static_url': static_url, }
def get_password_reset_url(user, token_generator=default_token_generator): """ Generate a password-reset URL for a given user """ return reverse('password-reset-confirm', kwargs={ 'uidb36': int_to_base36(user.id), 'token': default_token_generator.make_token(user)})
def send_verification_mail(request, user, verification_type): """ Sends an email with a verification link to users when ``ACCOUNTS_VERIFICATION_REQUIRED`` is ```True`` and they're signing up, or when they reset a lost password. The ``verification_type`` arg is both the name of the urlpattern for the verification link, as well as the names of the email templates to use. """ verify_url = ( reverse( verification_type, kwargs={"uidb36": int_to_base36(user.id), "token": default_token_generator.make_token(user)}, ) + "?next=" + request.GET.get("next", "/") ) context = {"request": request, "user": user, "verify_url": verify_url} subject_template_name = "email/%s_subject.txt" % verification_type subject = subject_template(subject_template_name, context) send_mail_template( subject, "email/%s" % verification_type, settings.DEFAULT_FROM_EMAIL, user.email, context=context, fail_silently=settings.DEBUG, )
def post(self, request, *args, **kwargs): form = self.form_class(request.POST) if form.is_valid(): data = form.cleaned_data["email"] else: data = False if self.validate_email_address(data) is True: associated_users = User.objects.filter(email=data) if associated_users.exists(): for user in associated_users: c = { 'email': user.email, 'domain': request.META['HTTP_HOST'], 'site_name': 'your site', 'uid': urlsafe_base64_encode(force_bytes(user.pk)), 'user': user, 'token': default_token_generator.make_token(user), 'protocol': 'http', } subject = 'Password reset from CBSCA' subject = ''.join(subject.splitlines()) email = loader.render_to_string('ondeparei/login/password_reset_email.html', c) send_mail(subject, email, DEFAULT_FROM_EMAIL, [user.email], fail_silently=False) result = self.form_valid(form) messages.success(request, 'An email has been sent to ' + data + ". Please check its inbox to continue reseting password.") return result result = self.form_invalid(form) messages.error(request, 'No user is associated with this email address') return result messages.error(request, 'Invalid Input') return self.form_invalid(form)
def form_valid(self, form): kwargs = {} form.save() user = User.objects.get(email=self.request.POST.get('email')) kwargs['token'] = default_token_generator.make_token(user) kwargs['uidb64'] = urlsafe_base64_encode(force_bytes(user.pk)) assunto = "UnB Alerta - Confirmação de Conta" full_url = self.request.get_raw_uri(), url_base = full_url[0][:full_url[0].find('usuario') - 1], mensagem = ("Este e-mail foi utilizado para fazer cadastro no " + "UnB Alerta.\n" + "Caso você não tenha feito este cadastro, por favor " + "ignore esta mensagem. Caso tenha, clique " + "no link abaixo\n" + url_base[0] + reverse('confirmar_email', kwargs=kwargs)) remetente = settings.EMAIL_HOST_USER destinatario = [self.request.POST.get('email'), settings.EMAIL_HOST_USER] send_mail(assunto, mensagem, remetente, destinatario, fail_silently=False) if form.data['placa']: usuario = Usuario.objects.get(user_id=user.id) placa = PlacaCarro(numero=form.data['placa'], usuario=usuario) placa.save() return redirect(reverse('solicita_confirmacao'))
def email_login(self, email): user, created = MyUser.objects.get_or_create(email=email, defaults={'password': make_password(None)}) context = { 'domain': self.request.get_host(), 'uid': int_to_base36(user.pk), 'token': default_token_generator.make_token(user), }
def test_account(self): """ Test account creation. """ # Verification not required - test an active user is created. data = self.account_data("test1") settings.ACCOUNTS_VERIFICATION_REQUIRED = False response = self.client.post(reverse("signup"), data, follow=True) self.assertEqual(response.status_code, 200) users = User.objects.filter(email=data["email"], is_active=True) self.assertEqual(len(users), 1) # Verification required - test an inactive user is created, settings.ACCOUNTS_VERIFICATION_REQUIRED = True data = self.account_data("test2") emails = len(mail.outbox) response = self.client.post(reverse("signup"), data, follow=True) self.assertEqual(response.status_code, 200) users = User.objects.filter(email=data["email"], is_active=False) self.assertEqual(len(users), 1) # Test the verification email. self.assertEqual(len(mail.outbox), emails + 1) self.assertEqual(len(mail.outbox[0].to), 1) self.assertEqual(mail.outbox[0].to[0], data["email"]) # Test the verification link. new_user = users[0] verification_url = reverse("signup_verify", kwargs={ "uidb36": int_to_base36(new_user.id), "token": default_token_generator.make_token(new_user), }) response = self.client.get(verification_url, follow=True) self.assertEqual(response.status_code, 200) users = User.objects.filter(email=data["email"], is_active=True) self.assertEqual(len(users), 1)
def reset_password_by_email(request): user = get_object_or_404(User, id=request.user.id) new_password = hash_password(user.password) user.set_password(new_password) user.save() token = default_token_generator.make_token(user) email_body = """ Your password has been reset: %s Please click the link below to verify your email address and complete the resetting process with the new password given, and reset your password as soon as possible: http://%s%s """ % (new_password, request.get_host(), reverse('confirm_reset_password', args=(user.username, token))) email = EmailMessage(subject="Verify your email address", body= email_body, from_email=settings.EMAIL_HOST_USER, to=[user.email]) email.send() context = {} context['email'] = user.email return render(request, 'moneyclub/reset-password-needs-confirmation.html', context)
def email_context(self, site, user): return { 'protocol': 'https', 'site': site, 'token': default_token_generator.make_token(user), 'uid': urlsafe_base64_encode(force_bytes(user.pk)), }
def test_set_password_using_the_HTML(self): """Can we reset our password after generating a confirmation link?""" # Generate a token and use it to visit a generated reset URL up = UserProfile.objects.get(pk=1) token = default_token_generator.make_token(up.user) url = '{host}{path}'.format( host=self.live_server_url, path=reverse('confirm_password', kwargs={ 'uidb64': urlsafe_base64_encode(str(up.user.pk)), 'token': token, }), ) self.selenium.get(url) #self.selenium.save_screenshot('/home/mlissner/phantom.png') self.assertIn( "Enter New Password", self.selenium.page_source ) # Next, change the user's password and submit the form. pwd1 = self.selenium.find_element_by_name('new_password1') pwd1.send_keys('password') pwd2 = self.selenium.find_element_by_name('new_password2') pwd2.send_keys('password') pwd2.submit() self.assertEqual( self.selenium.current_url, '{host}{path}'.format( host=self.live_server_url, path=reverse('password_reset_complete'), ) )
def forget_password(request): errors = [] context = {} if request.method == 'GET': return render(request, 'forget.html', {}) if not 'email' in request.POST or not request.POST['email']: errors.append('please enter your email') return render(request, 'forget.html',{'errors':errors}) try: user = User.objects.get(email=request.POST['email']) except ObjectDoesNotExist: errors.append('Wrong email address') return render(request, 'forget.html',{'errors':errors}) token = default_token_generator.make_token(user) email_body = """ Welcome to the Knot. Please click the link below to reset your password: http://%s%s """ % (request.get_host(), reverse('reset', args=(request.POST['email'], token))) send_mail(subject="reset your password", message= email_body, from_email="*****@*****.**", recipient_list=[user.email]) context['email'] = request.POST['email'] return render(request, 'reset_confirmation.html', context)
def get(self, request, *args, **kwargs): try: user = User.objects.get(id=kwargs['user_id']) except User.DoesNotExist: raise Http404 if user.is_active: raise Http404 site_name = get_current_site(self.request).name uid = int_to_base36(user.pk) token = default_token_generator.make_token(user) link = request.build_absolute_uri(reverse('check_confirmation', kwargs={'user_id' : user.pk, 'token' : token})) context = { 'email': user.email, 'site_name': site_name, 'validation_link': link, 'user': user } subject = "Validate your registration at %s" % site_name email = loader.render_to_string(self.email_template_name, context) user.email_user(subject,email) return super(SendConfirmationView,self).get(self, request, *args, **kwargs)
def account_activate_manually(request): if request.user.is_authenticated(): return HttpResponseRedirect(reverse('login')) template_name = 'registration/account_activate_manually.html' if request.method == "GET": return render(request, template_name) elif request.method == "POST": data = request.POST email = data.get('email') if email and TheUser.objects.filter(email__iexact=email).exists() and \ len(TheUser.objects.filter(email__iexact=email)) == 1: the_user = TheUser.objects.get(email__iexact=email) if not the_user.is_active: user_email = the_user.email current_site = get_current_site(request) site_name = current_site.name domain = current_site.domain context = { 'email': user_email, 'domain': domain, 'site_name': site_name, 'uid': urlsafe_base64_encode(force_bytes(the_user.id)), 'the_user': the_user, 'token': default_token_generator.make_token(the_user), 'protocol': 'http', } send_activate_email('registration/email/account_activate_subject.txt', 'registration/email/account_activate_body.html', context, settings.DEFAULT_FROM_MAIL, user_email) return HttpResponseRedirect(reverse('account_activate')) else: return HttpResponseRedirect(reverse('login'))
def confirm_account(self, template='users/email/account_confirmation.html', extra_context={}, subject=None): ''' Sends out an account confirm email. Which contains a link to set the user's password. This method is also used for the password_reset mechanism. ''' conf = self.appconfig bcc = settings.ADDITIONALLY_SEND_TO subject = subject or conf.CONFIRM_EMAIL_SUBJECT if settings.IGNORE_USER_EMAIL: receipients = bcc bcc = None else: receipients = [self.email] token = default_token_generator.make_token(self) context = { 'user': self, 'password_reset_confirm_url': self.get_confirm_link(self.urlnames.password_reset_confirm_urlname, token), 'account_confirm_url': self.get_confirm_link(self.urlnames.account_confirm_urlname, token), 'login_url': self._get_domain() + settings.LOGIN_URL } context.update(extra_context) email = HtmlEmail( from_email = conf.FROM_EMAIL, to = receipients, bcc = bcc, subject = subject, template = template, context = context ) email.send()
def create_for_user(self, user): """ create password reset for specified user """ # support passing email address too if type(user) is unicode: from .profile import Profile as User user = User.objects.get(email=user) temp_key = token_generator.make_token(user) # save it to the password reset model password_reset = PasswordReset(user=user, temp_key=temp_key) password_reset.save() # send the password reset email subject = _("Password reset email sent") message = render_to_string("profiles/email_messages/password_reset_key_message.txt", { "user": user, "uid": int_to_base36(user.id), "temp_key": temp_key, "site_url": settings.SITE_URL, "site_name": settings.SITE_NAME }) send_mail(subject, message, settings.DEFAULT_FROM_EMAIL, [user.email]) return password_reset
def reset_password_email_view(request): email_form = EmailForm() if request.method == 'POST': email_form = EmailForm(request.POST) if email_form.is_valid(): receiver = email_form.cleaned_data.get('email') user = Hacker.objects.get(email=receiver) subject = _('Hack4LT password reset') body = render_to_string('accounts/mail/reset_password.html', { 'username': user.username, 'url': reverse_lazy('reset-password', kwargs={ 'uidb36': int_to_base36(user.pk), 'token': default_token_generator.make_token(user) }), }) sender = settings.DEFAULT_FROM_EMAIL send_mail(subject, body, sender, [receiver]) return render(request, 'hack4lt/message.html', { 'message': _('Recovery email sent to: ') + receiver, }) else: email_form = EmailForm() return render(request, 'accounts/reset_password.html', { 'form': email_form, })
def password_reset(request, username=None, email=None): """ Generates a one-use only link for resetting password and sends to the user. """ from django.utils.http import urlsafe_base64_encode from django.core.mail import send_mail from django.contrib.sites.models import get_current_site from django.utils.encoding import force_bytes from django.contrib.auth.tokens import default_token_generator dajax = Dajax() # To hold the json if username: active_users = User.objects.filter(username__iexact=username, is_active=True) count = 0 for user in active_users: if not user.has_usable_password(): continue c = { 'email': user.email, 'site_url': settings.SITE_URL, 'uid': urlsafe_base64_encode(force_bytes(user.pk)), 'user': user, 'token': default_token_generator.make_token(user), 'protocol': 'http', } subject = 'NSS-IITM Password Reset Request' email = render_to_string('emails/password_reset.html', c) ret_val = send_mail(subject, email, settings.DEFAULT_FROM_EMAIL, [user.email]) print ret_val count = count + 1 print count, "emails sent !" if count: dajax.script('alert(\'Username sent!\')') # To hold the json else: dajax.script('alert(\'Username not found!\')') # To hold the json else: dajax.script('alert(\'Please enter a username !\')') return dajax.json()
def dispatch(self, request, *args, **kwargs): """ Функция сброса пароля ЛогикаЖ 1. принимаем и валидируем форму\ 2. находим пользователя по email из формы 3. генерируем письмо со сслыкой для сброса пароля 4. отправляем письмо :param request: :param args: :param kwargs: :return: """ if request.method == "POST": password_reset_form = PasswordResetForm(request.POST) if password_reset_form.is_valid(): data = password_reset_form.cleaned_data['email'] associated_users = User.objects.filter(Q(email=data)) if associated_users.exists(): for user in associated_users: subject = "Password Reset Requested" email_template_name = "main/account/password_reset_email.txt" c = { "email": user.email, 'domain': '127.0.0.1:8000', 'site_name': 'Website', "uid": urlsafe_base64_encode(force_bytes(user.pk)), "user": user, 'token': default_token_generator.make_token(user), 'protocol': 'http', } email = render_to_string(email_template_name, c) try: send_mail(subject, email, '*****@*****.**', [user.email], fail_silently=False) except BadHeaderError: return HttpResponse('Invalid header found.') return redirect("/password_reset/done/") password_reset_form = PasswordResetForm() return render(request=request, template_name=self.template_name, context={"password_reset_form": password_reset_form})
def register(request): context = {} errors = [] context['errors'] = errors if request.method == 'GET': context['form'] = RegistrationForm() return render(request, 'register.html', context) form = RegistrationForm(request.POST) context['form'] = form if not form.is_valid(): return render(request, 'register.html', context) # Creates the new user from the valid form data new_user = form.save() token = default_token_generator.make_token(new_user) email_body = """ Welcome to Grumblr! Please click the link below to verify your email address and complete the registration of your account: http://%s%s """ % (request.get_host(), reverse('confirm', args=(new_user.username, token))) send_mail(subject="Verify your email address", message=email_body, from_email="*****@*****.**", recipient_list=[new_user.email]) context['email'] = form.cleaned_data['email'] # Logs in the new user and redirects to his/her home stream # new_user = authenticate(username=request.POST['username'], \ # password=request.POST['password']) # login(request, new_user) return render(request, 'needs-confirmation.html', context)
def user_password_reset_request(request): reset_email_address = request.POST["email"] from establishment.webapp.throttle import UserActionThrottler reset_password_throttler = UserActionThrottler( request.user or 0, "reset-password-" + reset_email_address, 60 * 60, 2) if not reset_password_throttler.increm(): return AccountsError.TOO_MANY_PASSWORD_RESETS logger.info("Requesting a password reset for email " + str(reset_email_address)) try: user = get_user_manager().get(email__iexact=reset_email_address) except: return AccountsError.INVALID_EMAIL_ADDRESS #TODO: A logged in user can only request a password reset for themselves reset_token = password_reset_token_generator.make_token(user) # Send the password reset email # TODO: is this reverse the best way of doing this? path = reverse("user_password_reset_from_token", kwargs=dict(user_base36=int_to_base36(user.id), reset_token=reset_token)) url = request.build_absolute_uri(path) from django.contrib.sites.models import Site context = { "password_reset_url": url, "current_site": Site.objects.get_current(request=request) } send_template_mail("account/email/password_reset_key", reset_email_address, context) return {"success": True}
def send_invitation_email(user_email, invitator_name, organization_name, body_template='emails/invite_login_token.txt'): """Send a login email to the user invited. The email contains a token that can be used once to login. We use the default django token generator, that is usually used for password resets. """ try: user = User.objects.get(email=user_email) except User.DoesNotExist: # In case we could not find any valid user with the given email # we don't raise any exception, because we can't give any hints # about whether or not any particular email has an account # on our site. return user_uid = urlsafe_base64_encode(force_bytes(user.pk)) login_token = default_token_generator.make_token(user) login_url = reverse('token_login', args=[user_uid, login_token]) base_url = get_base_url() full_login_url = '{base_url}{url}'.format(base_url=base_url, url=login_url) login_email_body = render_to_string( body_template, { 'base_url': base_url, 'invitator_name': invitator_name, 'organization_name': organization_name, 'user_name': user.full_name, 'full_login_url': full_login_url }) send_email(subject=LOGIN_SUBJECT, body=login_email_body, recipient_list=[user.email], from_email=settings.DEFAULT_FROM_EMAIL, tags=['connexion', settings.ENV_NAME], fail_silently=False)
def mutate_and_get_payload(cls, input, context, info): if graph_auth_settings.CUSTOM_PASSWORD_RESET_TEMPLATE is not None and graph_auth_settings.EMAIL_FROM is not None and graph_auth_settings.PASSWORD_RESET_URL_TEMPLATE is not None: from mail_templated import EmailMessage for user in UserModel.objects.filter(email=input.get('email')): uid = urlsafe_base64_encode(force_bytes(user.pk)).decode() token = token_generator.make_token(user) link = graph_auth_settings.PASSWORD_RESET_URL_TEMPLATE.format( token=token, uid=uid) input_data = { "email": user.email, "first_name": user.first_name, "last_name": user.last_name, "link": link } message = EmailMessage( graph_auth_settings.CUSTOM_PASSWORD_RESET_TEMPLATE, input_data, graph_auth_settings.EMAIL_FROM, [user.email]) message.send() else: data = { 'email': input.get('email'), } reset_form = PasswordResetForm(data=data) if not reset_form.is_valid(): raise Exception("The email is not valid") options = { 'use_https': context.is_secure(), 'from_email': getattr(settings, 'DEFAULT_FROM_EMAIL'), 'request': context } reset_form.save(**options) return ResetPasswordRequest(ok=True)
def register(request): context = {} if request.method == 'GET': context['RegistrationForm'] = RegistrationForm() return render(request, 'studentnest/register.html', context) form = RegistrationForm(request.POST) context['RegistrationForm'] = form if not form.is_valid(): return render(request, 'studentnest/register.html', context) new_user = User.objects.create_user( username=form.cleaned_data['username'], password=form.cleaned_data['password1'], email=form.cleaned_data['username'], first_name=form.cleaned_data['first_name'], last_name=form.cleaned_data['last_name']) new_user.is_active = False new_user.save() new_profile = Profile(user=new_user, university=form.cleaned_data['university'], major=form.cleaned_data['major']) new_profile.save() token = default_token_generator.make_token(new_user) email_body = """ Welcome to StudentNest. Please click the link below to verify your emaill address and complete the registration of your account: http://%s%s """ % (request.get_host(), reverse('studentnest:confirm', args=(new_user.username, token))) send_mail(subject="Verify your email address", message=email_body, from_email="*****@*****.**", recipient_list=[new_user.email]) context['email'] = new_user.email return render(request, 'studentnest/needs-confirmation.html', context)
def forgetpass(request): """Define forget password display function.""" context = footer_and_category() if request.method == "POST": email = request.POST["email"] try: email_pass = validate_email(email) _ = email_pass.email Check.valid_email_pass = True except EmailNotValidError: Check.valid_email_pass = False if not Check.valid_email_pass: messages.error(request, "Please supply a valid email") elif not get_user_model().objects.filter(email=email).exists(): messages.error(request, "This Email does not exists") else: user = get_user_model().objects.filter(email=email) domain = request.get_host() message = render_to_string( "email_reset.html", { "user": user[0], "domain": domain, "uidb64": urlsafe_base64_encode(force_bytes(user[0].pk)), "token": default_token_generator.make_token(user), }, ) email = EmailMessage( "Password reset Instructions", # subject message, "*****@*****.**", to=[email], # to ) EmailThread(email).start() return render(request, "emailSendConfirmation.html", context) return render(request, "forgetPassword.html", context)
def resetPasswordInsertView(request): if not request.user.is_authenticated: if request.method == 'POST': # envia email e da redirect para a proxima pagina form = ResetPasswordForm(request.POST) if form.is_valid(): formData = form.cleaned_data if BaseUser.objects.filter(email=formData["email"]).exists(): user = BaseUser.objects.filter( email=formData["email"]).get() c = { 'email': user.email, 'domain': request.META['HTTP_HOST'], 'site_name': 'Malta e Companhia Website', 'uid': urlsafe_base64_encode(force_bytes(user.pk)), 'user': user, 'token': default_token_generator.make_token(user), 'protocol': 'http', } subject_template_name = 'password_reset_subject.txt' email_template_name = 'password_reset_email.html' subject = loader.render_to_string(subject_template_name, c) subject = ''.join(subject.splitlines()) email = loader.render_to_string(email_template_name, c) send_mail(subject, email, settings.DEFAULT_FROM_EMAIL, [user.email], fail_silently=False) infoMsg = "Pedido de reset de password enviado para o email." return render(request, "reset-password-insert.html", {'infoMsg': infoMsg}) else: errorMsg = "Email nao existente." else: errorMsg = "Email nao valido" return render(request, "reset-password-insert.html", {'errorMsg': errorMsg}) else: return render(request, "reset-password-insert.html") else: return redirect('/home', foo='bar')
def register(self, conf): error_message = "Error: " for (key, value) in conf.items(): if key == "request": continue if not value or len(value) == 0: error_message += key + " can't be empty." return False, error_message if len(User.objects.filter(username=conf["username"])): error_message += "the username isn't available. Please try another." return False, error_message request = conf["request"] user = User.objects.create_user(username=conf["username"], first_name=conf["firstname"], last_name=conf["lastname"], password=conf["password"], email=conf["email"]) user.is_active = False user.save() # Generate a one-time use token and an email message body token = default_token_generator.make_token(user) email_body = """ Please click the link below to verify your email address and complete the registration of your account: http://{host}{path} """.format(host=request.get_host(), path=reverse('confirm', args=(user.username, token))) send_mail(subject="Verify your email address", message=email_body, from_email="*****@*****.**", recipient_list=[user.email]) return True, None
def register(request): if request.method == 'POST': form = UserRegisterForm(request.POST) if form.is_valid(): save_it = form.save(commit=False) save_it.save() username = form.cleaned_data.get('username') messages.success(request, "You are now logged in " + username) user = authenticate(username=form.cleaned_data['username'], password=form.cleaned_data['password1']) login(request, user) text_content = 'Account Activation Email' subject = 'Email Activation' template_name = "users/activation.html" from_email = settings.EMAIL_HOST_USER recipients = [user.email] kwargs = { "uidb64": user.pk, "token": default_token_generator.make_token(user) } activation_url = reverse("activate_user_account", kwargs=kwargs) activate_url = "{0}://{1}{2}".format(request.scheme, request.get_host(), activation_url) context = {'user': user, 'activate_url': activate_url} html_content = render_to_string(template_name, context) email = EmailMultiAlternatives(subject, text_content, from_email, recipients) email.attach_alternative(html_content, "text/html") email.send() return redirect('createprofile') else: print(form.errors) else: form = UserRegisterForm() return render(request, 'users/register.html', {'form': form})
def register(request): context = {} if request.method == 'GET': context['form'] = RegistrationForm() return render(request, 'wah/Registration.html', context) form = RegistrationForm(request.POST) context['form'] = form if not form.is_valid(): return render(request, 'wah/Registration.html', context) new_user = User.objects.create_user( username=form.cleaned_data['username'], password=form.cleaned_data['password1'], first_name=form.cleaned_data['first_name'], last_name=form.cleaned_data['last_name'], email=form.cleaned_data['email']) new_user.is_active = False new_user.save() token = default_token_generator.make_token(new_user) email_body = """ Welcome to Where Amazing Happen! Please click the link below to verify your email address and complete the registration of your account: http://%s%s """ % (request.get_host(), reverse('confirm', args=(new_user.id, token))) send_mail(subject="Verify your email address", message=email_body, from_email="*****@*****.**", recipient_list=[new_user.email]) context['email'] = form.cleaned_data['email'] new_profile = Profile(first_name=new_user.first_name, last_name=new_user.last_name, profile_user=new_user) new_profile.save() new_user = authenticate(username=form.cleaned_data['username'], password=form.cleaned_data['password1']) return render(request, 'wah/confirmation-needed.html', context)
def password_reset_request(request): exception = False if request.method == "POST": password_reset_form = PasswordResetForm(request.POST) if password_reset_form.is_valid(): data = password_reset_form.cleaned_data['email'] try: user = User.objects.get(email=data) subject = "Creditask Passwort Zurücksetzung angefordert" email_template_name = "password/password_reset_email.txt" c = { "email": user.email, "public_name": user.public_name, 'domain': 'creditask.ch', 'site_name': 'Creditask', "uid": urlsafe_base64_encode(force_bytes(user.pk)), "user": user, 'token': default_token_generator.make_token(user), 'protocol': 'https', } email = render_to_string(email_template_name, c) try: send_mail(subject, email, '*****@*****.**', [user.email], fail_silently=False) except BadHeaderError: return HttpResponse('Invalid header found.') return redirect("/password/password_reset/done/") except Exception as e: # TODO log print(str(e)) pass else: exception = True password_reset_form = PasswordResetForm() return render(request=request, template_name="password/password_reset.html", context={ "password_reset_form": password_reset_form, "exception": exception })
def email_reset(request): if request.method == "POST": form = EmailResetForm(request.POST, user=request.user) if form.is_valid(): # Save new email info to DB (temporal) try: rer = ResetEmailRequest.objects.get(user=request.user) rer.email = form.cleaned_data['email'] except ResetEmailRequest.DoesNotExist: rer = ResetEmailRequest(user=request.user, email=form.cleaned_data['email']) rer.save() # Send email to the new address user = request.user email = form.cleaned_data["email"] current_site = get_current_site(request) site_name = current_site.name domain = current_site.domain c = { 'email': email, 'domain': domain, 'site_name': site_name, 'uid': int_to_base36(user.id), 'user': user, 'token': default_token_generator.make_token(user), 'protocol': 'http', } subject = loader.render_to_string( 'accounts/email_reset_subject.txt', c) subject = ''.join(subject.splitlines()) email_body = loader.render_to_string( 'accounts/email_reset_email.html', c) send_mail(subject=subject, email_body=email_body, email_to=[email]) return HttpResponseRedirect( reverse('accounts.views.email_reset_done')) else: form = EmailResetForm(user=request.user) tvars = {'form': form} return render(request, 'accounts/email_reset_form.html', tvars)
def test_add_customer_and_set_password(admin_client): url = reverse("dashboard:customer-create") data = { "first_name": "John", "last_name": "Doe", "email": "*****@*****.**", "is_active": True, } response = admin_client.post(url, data) assert response.status_code == 302 new_user = User.objects.get(email=data["email"]) assert new_user.first_name == data["first_name"] assert new_user.last_name == data["last_name"] assert not new_user.password uid = urlsafe_base64_encode(force_bytes(new_user.pk)) token = default_token_generator.make_token(new_user) response = admin_client.get( reverse( "account:reset-password-confirm", kwargs={"uidb64": uid, "token": token} ) ) assert response.status_code == 302 post_data = {"new_password1": "password", "new_password2": "password"} response = admin_client.post(response["Location"], post_data) assert response.status_code == 302 assert response["Location"] == reverse("account:reset-password-complete") new_user = User.objects.get(email=data["email"]) assert new_user.has_usable_password() # Retrieve the events and ensure it was properly generated account_creation_event, password_reset_email_sent_event = ( account_events.CustomerEvent.objects.all() ) assert account_creation_event.type == account_events.CustomerEvents.ACCOUNT_CREATED assert account_creation_event.user.pk == new_user.pk assert ( password_reset_email_sent_event.type == account_events.CustomerEvents.PASSWORD_RESET ) assert password_reset_email_sent_event.user.pk == new_user.pk
def password_reset(request): if request.method == "POST": form = PasswordReset(request.POST) if form.is_valid(): data = form.cleaned_data['email'] associated_users = User.objects.filter( Q(email=data) | Q(username=data)) if associated_users.exists(): for user in associated_users: subject = "Password Reset Requested" htmltemp = template.loader.get_template( 'password_reset_email.html') c = { "email": user.email, 'domain': '127.0.0.1:8000', 'site_name': 'Website', "uid": urlsafe_base64_encode(force_bytes(user.pk)).decode(), "user": user, 'token': default_token_generator.make_token(user), 'protocol': 'http', } html_content = htmltemp.render(c) try: msg = EmailMultiAlternatives( subject, text_content, '*****@*****.**', [email]) msg.attach_alternative(html_content, "text/html") msg.send() except BadHeaderError: return HttpResponse('Invalid header found.') messages.info( request, "Password reset instructions have been sent to the email address entered." ) return redirect("index") form = PasswordReset() return render(request=request, template_name="password_reset_email.html", context={"form": form})
def register(request): context = {} if request.method == 'GET': context['form'] = RegistrationForm() return render(request, 'chat/register.html', context) form = RegistrationForm(request.POST) context['form'] = form if not form.is_valid(): return render(request, 'chat/register.html', context) try: new_user = User.objects.create_user( username=form.cleaned_data['username'], password=form.cleaned_data['password1'], email=form.cleaned_data['email'],) new_user.is_active = 0 new_user.save() token = default_token_generator.make_token(new_user) email_body = """ I am waiting for you for a long time! So great to see you here! Welcome to ChatRoom ( ̄∇ ̄) There is only one last step to be our member! Simply click this link and enjoy~ http://%s%s """ % (request.get_host(), reverse('confirm', args=(new_user.username, token))) send_mail( subject='Welcome to ChatRoom! One more step: Verify your email adress!', message=email_body, from_email='*****@*****.**', recipient_list=[new_user.email] ) new_userProfile = userProfile.objects.create(user=new_user, email= form.cleaned_data[ 'email'], ) new_userProfile.save() return render(request, 'chat/emailConfirm.html') except: return render(request, 'chat/register.html', { 'error': 'Sorry! The username is registered! Try another one!'})
def register(request): context = {} # Just display the registration form if this is a GET request. if request.method == 'GET': context['form'] = RegistrationForm() return render(request, 'register.html', context) form = RegistrationForm(request.POST) context['form'] = form # Validates the form. if not form.is_valid(): return render(request, 'register.html', context) # If we get here the form data was valid. Register and login the user. new_user = User.objects.create_user(username=form.cleaned_data['username'], password=form.cleaned_data['password'], first_name=form.cleaned_data['first_name'], last_name=form.cleaned_data['last_name'], email=form.cleaned_data['email'], is_active=False) new_user.save() token = default_token_generator.make_token(new_user) email_body = """ Welcome to DailyPoker! Please click the link below to verify your email address and complete the registration of your account: http://%s%s """ % (request.get_host(), reverse('regconfirm', args=(new_user.username, token))) send_mail(subject="DailyPoker - Verify your email address", message=email_body, from_email="*****@*****.**", recipient_list=[new_user.email]) context['email'] = form.cleaned_data['email'] return render(request, 'email_confirm.html', context)
def register(request): context = {} if request.method == 'GET': context['form'] = RegistrationForm() return render(request, 'grumblr/registration.html', context) form = RegistrationForm(request.POST) context['form'] = form #checks the validity of the form data if not form.is_valid(): return render(request, 'grumblr/registration.html', context) new_user = User.objects.create_user(username = form.cleaned_data['username'], password = request.POST['password1'], first_name = form.cleaned_data['firstname'], last_name = form.cleaned_data['lastname'], email = form.cleaned_data['email']) new_profile = Profile(user = new_user) new_profile.save() new_user.save() new_user = authenticate(username=request.POST['username'], password=request.POST['password1']) login(request, new_user) token = default_token_generator.make_token(new_user) email_body = """ Click following link to confirm: http://%s%s """%(request.get_host(), reverse('confirm', args=(new_user.username, token))) send_mail(subject="Confirm your registration", message = email_body, from_email="*****@*****.**", recipient_list=[new_user.email]) return redirect('/grumblr/')
def post(self, request): password_reset_form = PasswordResetForm(request.POST) if password_reset_form.is_valid(): data = password_reset_form.cleaned_data['email'] associated_users = User.objects.filter(email=data) if associated_users.exists(): for user in associated_users: if user.is_superuser: name = 'Admin' else: name = user.getProfile().Name subject = "Password Reset Requested" email_template_name = "password/reset_Email.txt" info = { "user": user, 'full_user_name': name, "email": user.email, 'domain': '127.0.0.1:8000', 'site_name': 'Desitech', 'uid': urlsafe_base64_encode(force_bytes(user.pk)), 'token': default_token_generator.make_token(user), 'protocol': 'http' } email = render_to_string(email_template_name, info) try: send_mail(subject, email, EMAIL_HOST_USER, [user.email], fail_silently=False) except Exception: return HttpResponse( 'Invalid request, check your internet connection or try again !!.' ) return redirect("/accounts/password_reset/done/")
def create(self, validated_data): if getattr(settings, "SAML_ENFORCED", False): raise serializers.ValidationError( "Password reset is disabled because SAML login is enforced.", code="saml_enforced" ) if not is_email_available(): raise serializers.ValidationError( "Cannot reset passwords because email is not configured for your instance. Please contact your administrator.", code="email_not_available", ) email = validated_data.pop("email") try: user = User.objects.filter(is_active=True).get(email=email) except User.DoesNotExist: user = None if user: token = default_token_generator.make_token(user) message = EmailMessage( campaign_key=f"password-reset-{user.uuid}-{timezone.now()}", subject=f"Reset your PostHog password", template_name="password_reset", template_context={ "preheader": "Please follow the link inside to reset your password.", "link": f"/reset/{user.uuid}/{token}", "cloud": settings.MULTI_TENANCY, "site_url": settings.SITE_URL, "social_providers": list(user.social_auth.values_list("provider", flat=True)), }, ) message.add_recipient(email) message.send() # TODO: Limit number of requests for password reset emails return True
def register(request): if request.method == 'POST': form = RegistrationForm(request.POST) if form.is_valid(): first_name = form.cleaned_data['first_name'] last_name = form.cleaned_data['last_name'] phone_number = form.cleaned_data['phone_number'] email = form.cleaned_data['email'] password = form.cleaned_data['password'] username = email.split("@")[0] user = Account.objects.create_user(first_name=first_name, last_name=last_name, email=email, username=username, password=password) user.phone_number = phone_number user.save() # Create a user profile profile = UserProfile() profile.user_id = user.id profile.profile_picture = 'default/default-user.png' profile.save() # USER ACTIVATION current_site = get_current_site(request) mail_subject = 'Please activate your account' message = render_to_string('accounts/account_verification_email.html', { 'user': user, 'domain': current_site, 'uid': urlsafe_base64_encode(force_bytes(user.pk)), 'token': default_token_generator.make_token(user), }) to_email = email send_email = EmailMessage(mail_subject, message, to=[to_email]) send_email.send() # messages.success(request, 'Thank you for registering with us. We have sent you a verification email to your email address [[email protected]]. Please verify it.') return redirect('/accounts/login/?command=verification&email='+email) else: form = RegistrationForm() context = { 'form': form, } return render(request, 'accounts/register.html', context)
def simple_upload(request): if request.method == 'POST': user_list = UserListResource() dataset = Dataset() new_person = request.FILES['myfile'] if not new_person.name.endswith('xlsx'): messages.info(request, 'Wrong Format') return render(request, 'socius/upload.html') imported_data = dataset.load(new_person.read(), format='xlsx') #print(imported_data) d = [] for data in imported_data: d.append(data[2]) value = UserList( data[0], data[1], data[2], ) value.save() l = d user = User.objects.filter(is_superuser='******').first() current_site = get_current_site(request) mail_subject = 'Invite to Socius' message = render_to_string( 'accounts/invite.html', { 'user': user, 'domain': current_site.domain, 'uid': urlsafe_base64_encode(force_bytes(user.pk)), 'token': default_token_generator.make_token(user), }) for i in l: #reciever_list.append(i['email']) to_email = i email = EmailMessage(mail_subject, message, to=[to_email]) email.send() return HttpResponse('Invitations sended') return render(request, 'socius/upload.html')
def signup(request): context = {} if request.method == 'GET': context['form'] = RegistrationForm() return render(request, 'registration.html', context) form = RegistrationForm(request.POST) context['form'] = form if not form.is_valid(): return render(request, 'registration.html', context) new_user = User.objects.create_user(username=form.cleaned_data['username1'], password=form.cleaned_data['password'], email=form.cleaned_data['email_add']) new_user.save() new_profile = Profile(user=new_user,first_name=form.cleaned_data['first_name'], last_name=form.cleaned_data['last_name']) new_profile.save() new_user1 = authenticate(username=form.cleaned_data['username1'], password=form.cleaned_data['password']) # login(request, new_user1) token = default_token_generator.make_token(request.user) email_body = """ This is an email sent from Grumblr. Please click the link below to verify your email address: http://%s%s """ % (request.get_host(), reverse('verify', args=(request.user.username, token))) send_mail(subject="Grumblr - Verify your email address", message=email_body, #from_email="*****@*****.**", from_email="*****@*****.**", recipient_list=[new_user.email], fail_silently=False, ) text = "One email has been sent to your email address. Please click the link in the email to verify your email address." context['text'] = text return render(request, 'registration.html', context)
def signup(request): context = {} if request.method == "GET": return render(request, 'app_user/index.html', context) elif request.method == "POST": username = request.POST.get('Username') email = request.POST.get('email') password = request.POST.get('password') if email is not None: user = User.objects.create_user(username=username, email=email) user.set_password(password) user.is_active = False user.save() domain = request.get_host() # current_site = get_current_site(request).domain message = render_to_string( 'app_user/active_email.html', { 'user': user, 'domain': domain, 'uid': urlsafe_base64_encode(force_bytes(user.pk)), 'token': default_token_generator.make_token(user), }) email = EmailMessage( 'Activate your account', # subject message, # body settings.EMAIL_HOST, # from to=[email], # to ) email.send() return HttpResponse('sign-up') else: user = authenticate(username=username, password=password) if user is not None: login(request, user) u = 'Hello ' + str(request.user) return HttpResponse(u) else: messages.error(request, "Username and password did not matched") return render(request, 'app_user/index.html', context)
def form_valid(self, form): ret = super().form_valid(form) site_name = 'Local Forum' domain = 'localhost' uid = int_to_base36(self.object.id) token = default_token_generator.make_token(self.object) mail_context = { 'email': self.object.email, 'domain': domain, 'site_name': site_name, 'uid': uid, 'user': self.object, 'token': token, 'url': self.request.build_absolute_uri( reverse('user:signup-confirm', kwargs={ 'uidb36': uid, 'token': token })) } send_mail( from_email=settings.DEFAULT_FROM_EMAIL, recipient_list=[self.object.email], message='', subject=_('Спасибо, ваша регистрация прошла успешно!'), html_message=render_to_string( template_name='user/email/signup.html', context=mail_context), ) return ret
def test_reset_password_mail(self): uid = urlsafe_base64_encode(force_bytes(self.user.pk)) token = default_token_generator.make_token(self.user) context = { "email": self.user.email, "domain": "test:8000", "site_name": "test_site", "uid": uid, "token": token, "protocol": "http", } extra = {"recipients": [self.user.email]} user = { "app_label": self.user._meta.app_label, "model": self.user._meta.model_name, "id": self.user.id, "context_key": "user", } context["uid"] = context["uid"].decode("utf-8") tasks.send_mail(context, "password_reset", objects_to_fetch=[user], extra=extra) self.assertEqual(mail.outbox[0].to, [self.user.email]) self.assertEqual(mail.outbox[0].subject, tasks.MAIL_TYPE_DATA["password_reset"]["subject"]) self.assertEqual(mail.outbox[0].body, "\nYou're receiving this email because you requested a password "\ "reset for your user account at test_site.\n\nPlease go to the "\ "following page and choose a new password:\n\n"\ "http://test:8000/en/reset/"\ "%s/"\ "%s/\n\n"\ "Your username, in case you've forgotten: %s\n\n"\ "Thanks for using our site!\n\nThe test_site team\n\n\n" % ( context["uid"], token, self.user.username, ) )
def signup_view(request): if request.method == "POST": form = SignupForm(request.POST) print(request.POST) if form.is_valid(): print("form is valid") print(form.cleaned_data) print(request.POST) user = User( username=form.cleaned_data['username'], first_name=form.cleaned_data["first_name"], last_name=form.cleaned_data["last_name"], email=form.cleaned_data["email"], ) user.save() user.set_password(form.cleaned_data['password']) user.save() current_site = get_current_site(request) mail_subject = 'Activate your account.' message = render_to_string( 'app/account_activate.html', { 'user': user, 'domain': current_site.domain, 'uid': urlsafe_base64_encode(force_bytes(user.id)), 'token': default_token_generator.make_token(user), }) to_email = form.cleaned_data.get('email') email = EmailMessage(mail_subject, message, to=[to_email]) email.send() return HttpResponse( 'Please confirm your email address to complete the registration' ) elif request.method == "GET": if request.user.is_authenticated: return redirect("/account/profile/") form = SignupForm() return render(request, "app/signup.html", {"form": form})
def get_email_service_body(body, party): request = get_request() if request: current_site = get_current_site(request) site_name = current_site.name else: site_name = settings.SITE_NAME email = '' settings_url = '' if request: absolute_uri = request.build_absolute_uri('/') else: absolute_uri = settings.SITE_URL + '/' if party.__class__ is User: uid = urlsafe_base64_encode(force_bytes(party.pk)) token = default_token_generator.make_token(party) body = body.replace('href="/', 'href="%s' % absolute_uri) settings_url = absolute_uri[0:-1] + reverse('account_settings_confirm', args=(uid, token)) email = party.email elif party.__class__ is Organization: body = body.replace('href="/', 'href="%s' % absolute_uri) email = party.email_of_contact_person output = render_to_string( 'notification/email.html', { 'body': body, 'email': email, 'site_name': site_name, 'settings_url': settings_url }) return output.replace('\n', '<br />')
def get_serializer_context(self): user = self.request.user if not user.pk: return uid = urlsafe_base64_encode(force_bytes(user.pk)) token = default_token_generator.make_token(user) password_reset_urls = app_settings.PASSWORD_RESET_URLS default_url = password_reset_urls.get('default') if getattr(self, 'swagger_fake_view', False): organization_pk, organization_slug = None, None # pragma: no cover else: organization_pk = self.organization.pk organization_slug = self.organization.slug password_reset_url = password_reset_urls.get(str(organization_pk), default_url) password_reset_url = password_reset_url.format( organization=organization_slug, uid=uid, token=token) context = { 'request': self.request, 'password_reset_url': password_reset_url } return context