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