Permalink
Switch branches/tags
Nothing to show
Find file
Fetching contributors…
Cannot retrieve contributors at this time
950 lines (796 sloc) 32.3 KB
# -*- coding: utf-8 -*-
# Copyright (c) 2007, 2008, Benoît Chesneau
# Copyright (c) 2007 Simon Willison, original work on django-openid
#
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions are
# met:
#
# * Redistributions of source code must retain the above copyright
# * notice, this list of conditions and the following disclaimer.
# * Redistributions in binary form must reproduce the above copyright
# * notice, this list of conditions and the following disclaimer in the
# * documentation and/or other materials provided with the
# * distribution. Neither the name of the <ORGANIZATION> nor the names
# * of its contributors may be used to endorse or promote products
# * derived from this software without specific prior written
# * permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
# IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
# THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
# PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
# CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
# EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
# PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
# OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
from django.http import HttpResponseRedirect, get_host, Http404
from django.shortcuts import render_to_response as render
from django.template import RequestContext, loader, Context
from django.conf import settings
from django.contrib.auth.models import User
from django.contrib.auth import logout #for login I've added wrapper below - called login
from django.contrib.auth.decorators import login_required
from django.core.urlresolvers import reverse
from django.utils.encoding import smart_unicode
from django.utils.html import escape
from django.utils.translation import ugettext as _
from django.contrib.sites.models import Site
from django.utils.http import urlquote_plus
from django.core.mail import send_mail
from django.views.defaults import server_error
from openid.consumer.consumer import Consumer, \
SUCCESS, CANCEL, FAILURE, SETUP_NEEDED
from openid.consumer.discover import DiscoveryFailure
from openid.extensions import sreg
# needed for some linux distributions like debian
try:
from openid.yadis import xri
except ImportError:
from yadis import xri
import re
import urllib
from django_authopenid.util import OpenID, DjangoOpenIDStore, from_openid_response, clean_next
from django_authopenid.models import UserAssociation, UserPasswordQueue
from django_authopenid.forms import OpenidSigninForm, OpenidAuthForm, OpenidRegisterForm, \
OpenidVerifyForm, RegistrationForm, ChangepwForm, ChangeemailForm, \
ChangeopenidForm, DeleteForm, EmailPasswordForm
def login(request,user):
from django.contrib.auth import login as _login
from forum.models import user_logged_in #custom signal
#1) get old session key
session_key = request.session.session_key
#2) login and get new session key
_login(request,user)
#3) send signal with old session key as argument
user_logged_in.send(user=user,session_key=session_key,sender=None)
def get_url_host(request):
if request.is_secure():
protocol = 'https'
else:
protocol = 'http'
host = escape(get_host(request))
return '%s://%s' % (protocol, host)
def get_full_url(request):
return get_url_host(request) + request.get_full_path()
def ask_openid(request, openid_url, redirect_to, on_failure=None,
sreg_request=None):
""" basic function to ask openid and return response """
request.encoding = 'UTF-8'
on_failure = on_failure or signin_failure
trust_root = getattr(
settings, 'OPENID_TRUST_ROOT', get_url_host(request) + '/'
)
if xri.identifierScheme(openid_url) == 'XRI' and getattr(
settings, 'OPENID_DISALLOW_INAMES', False
):
msg = _("i-names are not supported")
return on_failure(request, msg)
consumer = Consumer(request.session, DjangoOpenIDStore())
try:
auth_request = consumer.begin(openid_url)
except DiscoveryFailure:
msg = _(u"OpenID %(openid_url)s is invalid" % {'openid_url':openid_url})
return on_failure(request, msg)
if sreg_request:
auth_request.addExtension(sreg_request)
redirect_url = auth_request.redirectURL(trust_root, redirect_to)
return HttpResponseRedirect(redirect_url)
def complete(request, on_success=None, on_failure=None, return_to=None):
""" complete openid signin """
on_success = on_success or default_on_success
on_failure = on_failure or default_on_failure
consumer = Consumer(request.session, DjangoOpenIDStore())
# make sure params are encoded in utf8
params = dict((k,smart_unicode(v)) for k, v in request.GET.items())
openid_response = consumer.complete(params, return_to)
if openid_response.status == SUCCESS:
return on_success(request, openid_response.identity_url,
openid_response)
elif openid_response.status == CANCEL:
return on_failure(request, 'The request was canceled')
elif openid_response.status == FAILURE:
return on_failure(request, openid_response.message)
elif openid_response.status == SETUP_NEEDED:
return on_failure(request, 'Setup needed')
else:
assert False, "Bad openid status: %s" % openid_response.status
def default_on_success(request, identity_url, openid_response):
""" default action on openid signin success """
request.session['openid'] = from_openid_response(openid_response)
return HttpResponseRedirect(clean_next(request.GET.get('next')))
def default_on_failure(request, message):
""" default failure action on signin """
return render('openid_failure.html', {
'message': message
})
def not_authenticated(func):
""" decorator that redirect user to next page if
he is already logged."""
def decorated(request, *args, **kwargs):
if request.user.is_authenticated():
next = request.GET.get("next", "/")
return HttpResponseRedirect(next)
return func(request, *args, **kwargs)
return decorated
@not_authenticated
def signin(request,newquestion=False,newanswer=False):
"""
signin page. It manage the legacy authentification (user/password)
and authentification with openid.
url: /signin/
template : authopenid/signin.htm
"""
request.encoding = 'UTF-8'
on_failure = signin_failure
next = clean_next(request.GET.get('next'))
form_signin = OpenidSigninForm(initial={'next':next})
form_auth = OpenidAuthForm(initial={'next':next})
if request.POST:
if 'bsignin' in request.POST.keys() or 'openid_username' in request.POST.keys():
form_signin = OpenidSigninForm(request.POST)
if form_signin.is_valid():
next = clean_next(form_signin.cleaned_data.get('next'))
sreg_req = sreg.SRegRequest(optional=['nickname', 'email'])
redirect_to = "%s%s?%s" % (
get_url_host(request),
reverse('user_complete_signin'),
urllib.urlencode({'next':next})
)
return ask_openid(request,
form_signin.cleaned_data['openid_url'],
redirect_to,
on_failure=signin_failure,
sreg_request=sreg_req)
elif 'blogin' in request.POST.keys():
# perform normal django authentification
form_auth = OpenidAuthForm(request.POST)
if form_auth.is_valid():
user_ = form_auth.get_user()
login(request, user_)
next = clean_next(form_auth.cleaned_data.get('next'))
return HttpResponseRedirect(next)
question = None
if newquestion == True:
from forum.models import AnonymousQuestion as AQ
session_key = request.session.session_key
qlist = AQ.objects.filter(session_key=session_key).order_by('-added_at')
if len(qlist) > 0:
question = qlist[0]
answer = None
if newanswer == True:
from forum.models import AnonymousAnswer as AA
session_key = request.session.session_key
alist = AA.objects.filter(session_key=session_key).order_by('-added_at')
if len(alist) > 0:
answer = alist[0]
return render('authopenid/signin.html', {
'question':question,
'answer':answer,
'form1': form_auth,
'form2': form_signin,
'msg': request.GET.get('msg',''),
'sendpw_url': reverse('user_sendpw'),
}, context_instance=RequestContext(request))
def complete_signin(request):
""" in case of complete signin with openid """
return complete(request, signin_success, signin_failure,
get_url_host(request) + reverse('user_complete_signin'))
def signin_success(request, identity_url, openid_response):
"""
openid signin success.
If the openid is already registered, the user is redirected to
url set par next or in settings with OPENID_REDIRECT_NEXT variable.
If none of these urls are set user is redirectd to /.
if openid isn't registered user is redirected to register page.
"""
openid_ = from_openid_response(openid_response) #create janrain OpenID object
request.session['openid'] = openid_
try:
rel = UserAssociation.objects.get(openid_url__exact = str(openid_))
except:
# try to register this new user
return register(request)
user_ = rel.user
if user_.is_active:
user_.backend = "django.contrib.auth.backends.ModelBackend"
login(request, user_)
next = clean_next(request.GET.get('next'))
return HttpResponseRedirect(next)
def is_association_exist(openid_url):
""" test if an openid is already in database """
is_exist = True
try:
uassoc = UserAssociation.objects.get(openid_url__exact = openid_url)
except:
is_exist = False
return is_exist
@not_authenticated
def register(request):
"""
register an openid.
If user is already a member he can associate its openid with
its account.
A new account could also be created and automaticaly associated
to the openid.
url : /complete/
template : authopenid/complete.html
"""
is_redirect = False
next = clean_next(request.GET.get('next'))
openid_ = request.session.get('openid', None)
if not openid_:
return HttpResponseRedirect(reverse('user_signin') + next)
nickname = openid_.sreg.get('nickname', '')
email = openid_.sreg.get('email', '')
form1 = OpenidRegisterForm(initial={
'next': next,
'username': nickname,
'email': email,
})
form2 = OpenidVerifyForm(initial={
'next': next,
'username': nickname,
})
user_ = None
if request.POST:
just_completed = False
if 'bnewaccount' in request.POST.keys():
form1 = OpenidRegisterForm(request.POST)
if form1.is_valid():
next = clean_next(form1.cleaned_data.get('next'))
is_redirect = True
tmp_pwd = User.objects.make_random_password()
user_ = User.objects.create_user(form1.cleaned_data['username'],
form1.cleaned_data['email'], tmp_pwd)
# make association with openid
uassoc = UserAssociation(openid_url=str(openid_),
user_id=user_.id)
uassoc.save()
# login
user_.backend = "django.contrib.auth.backends.ModelBackend"
login(request, user_)
elif 'bverify' in request.POST.keys():
form2 = OpenidVerifyForm(request.POST)
if form2.is_valid():
is_redirect = True
next = clean_next(form2.cleaned_data.get('next'))
user_ = form2.get_user()
uassoc = UserAssociation(openid_url=str(openid_),
user_id=user_.id)
uassoc.save()
login(request, user_)
#check if we need to post a question that was added anonymously
#this needs to be a function call becase this is also done
#if user just logged in and did not need to create the new account
if user_ != None and settings.EMAIL_VALIDATION == 'on':
send_new_email_key(user_,nomessage=True)
output = validation_email_sent(request)
set_email_validation_message(user_) #message set after generating view
return output
elif user_.is_authenticated():
return HttpResponseRedirect('/')
else:
raise server_error('')
openid_str = str(openid_)
bits = openid_str.split('/')
base_url = bits[2] #assume this is base url
url_bits = base_url.split('.')
provider_name = url_bits[-2].lower()
providers = {'yahoo':'<font color="purple">Yahoo!</font>',
'flickr':'<font color="#0063dc">flick</font><font color="#ff0084">r</font>&trade;',
'google':'Google&trade;',
'aol':'<font color="#31658e">AOL</font>',
}
if provider_name not in providers:
provider_logo = provider_name
else:
provider_logo = providers[provider_name]
return render('authopenid/complete.html', {
'form1': form1,
'form2': form2,
'provider':provider_logo,
'nickname': nickname,
'email': email
}, context_instance=RequestContext(request))
def signin_failure(request, message):
"""
falure with openid signin. Go back to signin page.
template : "authopenid/signin.html"
"""
next = clean_next(request.GET.get('next'))
form_signin = OpenidSigninForm(initial={'next': next})
form_auth = OpenidAuthForm(initial={'next': next})
return render('authopenid/signin.html', {
'msg': message,
'form1': form_auth,
'form2': form_signin,
}, context_instance=RequestContext(request))
@not_authenticated
def signup(request):
"""
signup page. Create a legacy account
url : /signup/"
templates: authopenid/signup.html, authopenid/confirm_email.txt
"""
action_signin = reverse('user_signin')
next = clean_next(request.GET.get('next'))
form = RegistrationForm(initial={'next':next})
form_signin = OpenidSigninForm(initial={'next':next})
if request.POST:
form = RegistrationForm(request.POST)
if form.is_valid():
next = clean_next(form.cleaned_data.get('next'))
user_ = User.objects.create_user( form.cleaned_data['username'],
form.cleaned_data['email'], form.cleaned_data['password1'])
user_.backend = "django.contrib.auth.backends.ModelBackend"
login(request, user_)
# send email
current_domain = Site.objects.get_current().domain
subject = _("Welcome")
message_template = loader.get_template(
'authopenid/confirm_email.txt'
)
message_context = Context({
'site_url': 'http://%s/' % current_domain,
'username': form.cleaned_data['username'],
'password': form.cleaned_data['password1']
})
message = message_template.render(message_context)
send_mail(subject, message, settings.DEFAULT_FROM_EMAIL,
[user_.email])
return HttpResponseRedirect(next)
return render('authopenid/signup.html', {
'form': form,
'form2': form_signin,
}, context_instance=RequestContext(request))
@login_required
def signout(request):
"""
signout from the website. Remove openid from session and kill it.
url : /signout/"
"""
try:
del request.session['openid']
except KeyError:
pass
next = clean_next(request.GET.get('next'))
logout(request)
return HttpResponseRedirect(next)
def xrdf(request):
url_host = get_url_host(request)
return_to = [
"%s%s" % (url_host, reverse('user_complete_signin'))
]
return render('authopenid/yadis.xrdf', {
'return_to': return_to
}, context_instance=RequestContext(request))
@login_required
def account_settings(request):
"""
index pages to changes some basic account settings :
- change password
- change email
- associate a new openid
- delete account
url : /
template : authopenid/settings.html
"""
msg = request.GET.get('msg', '')
is_openid = True
try:
uassoc = UserAssociation.objects.get(
user__username__exact=request.user.username
)
except:
is_openid = False
return render('authopenid/settings.html', {
'msg': msg,
'is_openid': is_openid
}, context_instance=RequestContext(request))
@login_required
def changepw(request):
"""
change password view.
url : /changepw/
template: authopenid/changepw.html
"""
user_ = request.user
if request.POST:
form = ChangepwForm(request.POST, user=user_)
if form.is_valid():
user_.set_password(form.cleaned_data['password1'])
user_.save()
msg = _("Password changed.")
redirect = "%s?msg=%s" % (
reverse('user_account_settings'),
urlquote_plus(msg))
return HttpResponseRedirect(redirect)
else:
form = ChangepwForm(user=user_)
return render('authopenid/changepw.html', {'form': form },
context_instance=RequestContext(request))
def find_email_validation_messages(user):
msg_text = _('your email needs to be validated')
return user.message_set.filter(message__exact=msg_text)
def set_email_validation_message(user):
messages = find_email_validation_messages(user)
msg_text = _('your email needs to be validated')
if len(messages) == 0:
user.message_set.create(message=msg_text)
def clear_email_validation_message(user):
messages = find_email_validation_messages(user)
messages.delete()
def set_new_email(user, new_email, nomessage=False):
if new_email != user.email:
user.email = new_email
user.email_isvalid = False
user.save()
if settings.EMAIL_VALIDATION == 'on':
send_new_email_key(user,nomessage=nomessage)
def _send_email_key(user):
"""private function. sends email containing validation key
to user's email address
"""
subject = _("Welcome")
message_template = loader.get_template('authopenid/email_validation.txt')
import settings
message_context = Context({
'validation_link': '%s/email/verify/%d/%s/' % (settings.APP_URL ,user.id,user.email_key)
})
message = message_template.render(message_context)
send_mail(subject, message, settings.DEFAULT_FROM_EMAIL, [user.email])
def send_new_email_key(user,nomessage=False):
import random
random.seed()
user.email_key = '%032x' % random.getrandbits(128)
user.save()
_send_email_key(user)
if nomessage==False:
set_email_validation_message(user)
@login_required
def send_email_key(request):
"""
url = /email/sendkey/
view that is shown right after sending email key
email sending is called internally
raises 404 if email validation is off
if current email is valid shows 'key_not_sent' view of
authopenid/changeemail.html template
"""
if settings.EMAIL_VALIDATION != 'off':
if request.user.email_isvalid:
return render('authopenid/changeemail.html',
{ 'email': request.user.email,
'action_type': 'key_not_sent',
'change_link': reverse('user_changeemail')},
context_instance=RequestContext(request)
)
else:
_send_email_key(request.user)
return validation_email_sent(request)
else:
raise Http404
#internal server view used as return value by other views
def validation_email_sent(request):
return render('authopenid/changeemail.html',
{ 'email': request.user.email, 'action_type': 'validate', },
context_instance=RequestContext(request))
def verifyemail(request,id=None,key=None):
"""
view that is shown when user clicks email validation link
url = /email/verify/{{user.id}}/{{user.email_key}}/
"""
if settings.EMAIL_VALIDATION != 'off':
user = User.objects.get(id=id)
if user:
if user.email_key == key:
user.email_isvalid = True
clear_email_validation_message(user)
user.save()
return render('authopenid/changeemail.html', {
'action_type': 'validation_complete',
}, context_instance=RequestContext(request))
raise Http404
@login_required
def changeemail(request):
"""
changeemail view. It require password or openid to allow change.
url: /email/*
template : authopenid/changeemail.html
"""
msg = request.GET.get('msg', '')
extension_args = {}
user_ = request.user
redirect_to = get_url_host(request) + reverse('user_changeemail')
action = 'change'
if request.POST:
form = ChangeemailForm(request.POST, user=user_)
if form.is_valid():
if not form.test_openid:
new_email = form.cleaned_data['email']
if new_email != user_.email:
if settings.EMAIL_VALIDATION == 'on':
action = 'validate'
else:
action = 'done_novalidate'
set_new_email(user_, new_email,nomessage=True)
else:
action = 'keep'
else:
#what does this branch do?
return server_error('')
request.session['new_email'] = form.cleaned_data['email']
return ask_openid(request, form.cleaned_data['password'],
redirect_to, on_failure=emailopenid_failure)
elif not request.POST and 'openid.mode' in request.GET:
return complete(request, emailopenid_success,
emailopenid_failure, redirect_to)
else:
form = ChangeemailForm(initial={'email': user_.email},
user=user_)
output = render('authopenid/changeemail.html', {
'form': form,
'email': user_.email,
'action_type': action,
'msg': msg
}, context_instance=RequestContext(request))
if action == 'validate':
set_email_validation_message(user_)
return output
def emailopenid_success(request, identity_url, openid_response):
openid_ = from_openid_response(openid_response)
user_ = request.user
try:
uassoc = UserAssociation.objects.get(
openid_url__exact=identity_url
)
except:
return emailopenid_failure(request,
_("No OpenID %s found associated in our database" % identity_url))
if uassoc.user.username != request.user.username:
return emailopenid_failure(request,
_("The OpenID %s isn't associated to current user logged in" %
identity_url))
new_email = request.session.get('new_email', '')
if new_email:
user_.email = new_email
user_.save()
del request.session['new_email']
msg = _("Email Changed.")
redirect = "%s?msg=%s" % (reverse('user_account_settings'),
urlquote_plus(msg))
return HttpResponseRedirect(redirect)
def emailopenid_failure(request, message):
redirect_to = "%s?msg=%s" % (
reverse('user_changeemail'), urlquote_plus(message))
return HttpResponseRedirect(redirect_to)
@login_required
def changeopenid(request):
"""
change openid view. Allow user to change openid
associated to its username.
url : /changeopenid/
template: authopenid/changeopenid.html
"""
extension_args = {}
openid_url = ''
has_openid = True
msg = request.GET.get('msg', '')
user_ = request.user
try:
uopenid = UserAssociation.objects.get(user=user_)
openid_url = uopenid.openid_url
except:
has_openid = False
redirect_to = get_url_host(request) + reverse('user_changeopenid')
if request.POST and has_openid:
form = ChangeopenidForm(request.POST, user=user_)
if form.is_valid():
return ask_openid(request, form.cleaned_data['openid_url'],
redirect_to, on_failure=changeopenid_failure)
elif not request.POST and has_openid:
if 'openid.mode' in request.GET:
return complete(request, changeopenid_success,
changeopenid_failure, redirect_to)
form = ChangeopenidForm(initial={'openid_url': openid_url }, user=user_)
return render('authopenid/changeopenid.html', {
'form': form,
'has_openid': has_openid,
'msg': msg
}, context_instance=RequestContext(request))
def changeopenid_success(request, identity_url, openid_response):
openid_ = from_openid_response(openid_response)
is_exist = True
try:
uassoc = UserAssociation.objects.get(openid_url__exact=identity_url)
except:
is_exist = False
if not is_exist:
try:
uassoc = UserAssociation.objects.get(
user__username__exact=request.user.username
)
uassoc.openid_url = identity_url
uassoc.save()
except:
uassoc = UserAssociation(user=request.user,
openid_url=identity_url)
uassoc.save()
elif uassoc.user.username != request.user.username:
return changeopenid_failure(request,
_('This OpenID is already associated with another account.'))
request.session['openids'] = []
request.session['openids'].append(openid_)
msg = _("OpenID %s is now associated with your account." % identity_url)
redirect = "%s?msg=%s" % (
reverse('user_account_settings'),
urlquote_plus(msg))
return HttpResponseRedirect(redirect)
def changeopenid_failure(request, message):
redirect_to = "%s?msg=%s" % (
reverse('user_changeopenid'),
urlquote_plus(message))
return HttpResponseRedirect(redirect_to)
@login_required
def delete(request):
"""
delete view. Allow user to delete its account. Password/openid are required to
confirm it. He should also check the confirm checkbox.
url : /delete
template : authopenid/delete.html
"""
extension_args = {}
user_ = request.user
redirect_to = get_url_host(request) + reverse('user_delete')
if request.POST:
form = DeleteForm(request.POST, user=user_)
if form.is_valid():
if not form.test_openid:
user_.delete()
return signout(request)
else:
return ask_openid(request, form.cleaned_data['password'],
redirect_to, on_failure=deleteopenid_failure)
elif not request.POST and 'openid.mode' in request.GET:
return complete(request, deleteopenid_success, deleteopenid_failure,
redirect_to)
form = DeleteForm(user=user_)
msg = request.GET.get('msg','')
return render('authopenid/delete.html', {
'form': form,
'msg': msg,
}, context_instance=RequestContext(request))
def deleteopenid_success(request, identity_url, openid_response):
openid_ = from_openid_response(openid_response)
user_ = request.user
try:
uassoc = UserAssociation.objects.get(
openid_url__exact=identity_url
)
except:
return deleteopenid_failure(request,
_("No OpenID %s found associated in our database" % identity_url))
if uassoc.user.username == user_.username:
user_.delete()
return signout(request)
else:
return deleteopenid_failure(request,
_("The OpenID %s isn't associated to current user logged in" %
identity_url))
msg = _("Account deleted.")
redirect = "/?msg=%s" % (urlquote_plus(msg))
return HttpResponseRedirect(redirect)
def deleteopenid_failure(request, message):
redirect_to = "%s?msg=%s" % (reverse('user_delete'), urlquote_plus(message))
return HttpResponseRedirect(redirect_to)
def sendpw(request):
"""
send a new password to the user. It return a mail with
a new pasword and a confirm link in. To activate the
new password, the user should click on confirm link.
url : /sendpw/
templates : authopenid/sendpw_email.txt, authopenid/sendpw.html
"""
msg = request.GET.get('msg','')
if request.POST:
form = EmailPasswordForm(request.POST)
if form.is_valid():
new_pw = User.objects.make_random_password()
confirm_key = UserPasswordQueue.objects.get_new_confirm_key()
try:
uqueue = UserPasswordQueue.objects.get(
user=form.user_cache
)
except:
uqueue = UserPasswordQueue(
user=form.user_cache
)
uqueue.new_password = new_pw
uqueue.confirm_key = confirm_key
uqueue.save()
# send email
current_domain = Site.objects.get_current().domain
subject = _("Request for new password")
message_template = loader.get_template(
'authopenid/sendpw_email.txt')
message_context = Context({
'site_url': 'http://%s' % current_domain,
'confirm_key': confirm_key,
'username': form.user_cache.username,
'password': new_pw,
'url_confirm': reverse('user_confirmchangepw'),
})
message = message_template.render(message_context)
send_mail(subject, message, settings.DEFAULT_FROM_EMAIL,
[form.user_cache.email])
msg = _("A new password has been sent to your email address.")
else:
form = EmailPasswordForm()
return render('authopenid/sendpw.html', {
'form': form,
'msg': msg
}, context_instance=RequestContext(request))
def confirmchangepw(request):
"""
view to set new password when the user click on confirm link
in its mail. Basically it check if the confirm key exist, then
replace old password with new password and remove confirm
ley from the queue. Then it redirect the user to signin
page.
url : /sendpw/confirm/?key
"""
confirm_key = request.GET.get('key', '')
if not confirm_key:
return HttpResponseRedirect('/')
try:
uqueue = UserPasswordQueue.objects.get(
confirm_key__exact=confirm_key
)
except:
msg = _("Could not change password. Confirmation key '%s'\
is not registered." % confirm_key)
redirect = "%s?msg=%s" % (
reverse('user_sendpw'), urlquote_plus(msg))
return HttpResponseRedirect(redirect)
try:
user_ = User.objects.get(id=uqueue.user.id)
except:
msg = _("Can not change password. User don't exist anymore \
in our database.")
redirect = "%s?msg=%s" % (reverse('user_sendpw'),
urlquote_plus(msg))
return HttpResponseRedirect(redirect)
user_.set_password(uqueue.new_password)
user_.save()
uqueue.delete()
msg = _("Password changed for %s. You may now sign in." %
user_.username)
redirect = "%s?msg=%s" % (reverse('user_signin'),
urlquote_plus(msg))
return HttpResponseRedirect(redirect)