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
