def openid_new_user(request):
next = get_next(request)
if request.method == 'POST':
form = SSORegistrationForm(request.POST, request=request)
if form.is_valid():
from django_openidauth.models import associate_openid
from django.contrib.auth import load_backend
new_user = form.save()
associate_openid( new_user, request.openid )
backend = load_backend('django.contrib.auth.backends.ModelBackend')
new_user.backend = '%s.%s' % (
backend.__module__, backend.__class__.__name__
)
auth_login(request, new_user)
return new_user_registered_redirect(request, next or '/')
else:
initial = dict(
next=next,
)
form = SSORegistrationForm(initial=initial, request=request)
return direct_to_template(request, "account/sso_registration.html", {
'form':form,
})
def is_unattached_openid(request):
if not settings.OPENID:
return False
if request.openid and request.openid.openid:
from django_openidauth.models import UserOpenID, associate_openid
res = UserOpenID.objects.filter(openid=request.openid.openid)
if res:
# connected openid user exists: login user
user = res[0].user
user.backend = 'django.contrib.auth.backends.ModelBackend'
login(request, user)
return False
elif DELAYED_REGISTRATION_SESSION_KEY in request.session:
# 1. create account previously registered
# 2. associate with OpenID
# 3. login
# 1.
data = request.session[DELAYED_REGISTRATION_SESSION_KEY]
user = Profile.objects.create_inactive_user(data['username'],
data['email'],
data['password'],
data['preferred_language'],
send_email = False,
)
user.first_name = data['firstname']
user.last_name = data['lastname']
profile = user.get_profile()
profile.is_temp = False
profile.save()
# 2.
associate_openid(user,request.openid)
# 3.
user.backend = 'django.contrib.auth.backends.ModelBackend'
login(request, user)
else:
return True
return False
def register(request, success_url='/accounts/register/complete/',
template_name='openid_register.html', already_registered_url='/'):
"""
Allows a new user to register an account. A customised variation of the
view of the same name from django-registration.
Context::
form
The registration form
Template::
registration/registration_form.html (or template_name argument)
"""
if request.method == 'POST':
form = SSORegistrationForm(request.POST)
if form.is_valid():
new_user = form.save()
associate_openid( new_user, request.openid )
next = form.cleaned_data['next']
print 'next',next
# Unfortunately we have to annotate the user with the
# 'django.contrib.auth.backends.ModelBackend' backend, or stuff breaks
backend = load_backend('django.contrib.auth.backends.ModelBackend')
new_user.backend = '%s.%s' % (
backend.__module__, backend.__class__.__name__
)
log_user_in(request, new_user)
return HttpResponseRedirect(next or success_url)
else:
if request.user.is_authenticated():
return HttpResponseRedirect( already_registered_url )
form = SSORegistrationForm(initial={'next':request.GET.get('next','')})
return render_to_response(template_name, { 'form': form },
context_instance=RequestContext(request))
def openid_assign(request):
user_openids = set(o.openid for o in UserOpenID.objects.filter(user=request.user).order_by('created_at'))
last_openid = request.openids and request.openids[-1].openid
if last_openid and last_openid not in user_openids:
associate_openid(request.user, last_openid)
return HttpResponseRedirect(reverse('associations'))
def signup(request):
if not request.user.is_anonymous():
return redirect(reverse('index'))
if request.method == 'POST':
if request.openid:
form = SignupForm(
request.POST, request.FILES, openid=request.openid
)
else:
form = SignupForm(request.POST, request.FILES)
if form.is_valid():
# First create the user
creation_args = {
'username': form.cleaned_data['username'],
'email': form.cleaned_data['email'],
}
if form.cleaned_data.get('password1'):
creation_args['password'] = form.cleaned_data['password1']
user = User.objects.create_user(**creation_args)
user.first_name = form.cleaned_data['first_name']
user.last_name = form.cleaned_data['last_name']
user.save()
if request.openid:
associate_openid(user, str(request.openid))
region = None
if form.cleaned_data['region']:
region = Region.objects.get(
country__iso_code = form.cleaned_data['country'],
code = form.cleaned_data['region']
)
# Now create the DjangoPerson
person = DjangoPerson.objects.create(
user = user,
bio = form.cleaned_data['bio'],
country = Country.objects.get(
iso_code = form.cleaned_data['country']
),
region = region,
latitude = form.cleaned_data['latitude'],
longitude = form.cleaned_data['longitude'],
location_description = form.cleaned_data['location_description']
)
# Set up the various machine tags
for fieldname, (namespace, predicate) in \
MACHINETAGS_FROM_FIELDS.items():
if form.cleaned_data.has_key(fieldname) and \
form.cleaned_data[fieldname].strip():
value = form.cleaned_data[fieldname].strip()
person.add_machinetag(namespace, predicate, value)
# Stash their blog and looking_for_work
if form.cleaned_data['blog']:
person.add_machinetag(
'profile', 'blog', form.cleaned_data['blog']
)
if form.cleaned_data['looking_for_work']:
person.add_machinetag(
'profile', 'looking_for_work',
form.cleaned_data['looking_for_work']
)
# Finally, set their skill tags
person.skilltags = form.cleaned_data['skilltags']
# Log them in and redirect to their profile page
# HACK! http://groups.google.com/group/django-users/
# browse_thread/thread/39488db1864c595f
user.backend='django.contrib.auth.backends.ModelBackend'
auth.login(request, user)
return redirect(person.get_absolute_url())
else:
if request.openid and request.openid.sreg:
sreg = request.openid.sreg
first_name = ''
last_name = ''
username = ''
if sreg.get('fullname'):
bits = sreg['fullname'].split()
first_name = bits[0]
if len(bits) > 1:
last_name = ' '.join(bits[1:])
# Find a not-taken username
if sreg.get('nickname'):
username = derive_username(sreg['nickname'])
form = SignupForm(initial = {
'first_name': first_name,
'last_name': last_name,
'email': sreg.get('email', ''),
'username': username,
}, openid = request.openid)
elif request.openid:
form = SignupForm(openid = request.openid)
else:
form = SignupForm()
return render(request, 'signup.html', {
'form': form,
'openid': request.openid,
})
def associations(request, template_name='openid_associations.html', post_login_redirect='/openid/complete/'):
"""
A view for managing the OpenIDs associated with a user account.
"""
if 'openid_url' in request.POST:
# They entered a new OpenID and need to authenticate it - kick off the
# process and make sure they are redirected back here afterwards
return consumer_views.begin(request, redirect_to=post_login_redirect)
messages = []
associated_openids = [
rec.openid
for rec in UserOpenID.objects.filter(user__id = request.user.id)
]
# OpenIDs are associated and de-associated based on their key - which is a
# hash of the OpenID, user ID and SECRET_KEY - this gives us a nice key for
# submit button names or checkbox values and provides CSRF protection at
# the same time. We need to pre-calculate the hashes for the user's OpenIDs
# in advance.
add_hashes = dict([
(_make_hash('add', request.user, openid), str(openid))
for openid in request.openids
if str(openid) not in associated_openids
])
del_hashes = dict([
(_make_hash('del', request.user, openid), openid)
for openid in associated_openids
])
# We can now cycle through the keys in POST, looking for stuff to add or
# delete. First though we check for the ?direct=1 argument and directly add
# any OpenIDs that were authenticated in the last 5 seconds - this supports
# the case where a user has entered an OpenID in the form on this page,
# authenticated it and been directed straight back here.
# TODO: Reconsider this technique now that it's easier to create custom
# behaviour when an OpenID authentication is successful.
if request.GET.get('direct') and request.openids and \
request.openids[-1].issued > int(time.time()) - 5 and \
str(request.openids[-1]) not in associated_openids:
new_openid = str(request.openids[-1])
associate_openid(request.user, new_openid)
associated_openids.append(new_openid)
messages.append('%s has been associated with your account' % escape(
new_openid
))
# Now cycle through POST.keys() looking for OpenIDs to add or remove
for key in request.POST.keys():
if key in add_hashes:
openid = add_hashes[key]
if openid not in associated_openids:
associate_openid(request.user, openid)
associated_openids.append(openid)
messages.append('%s has been associated with your account' % \
escape(openid)
)
if key in del_hashes:
openid = del_hashes[key]
if openid in associated_openids:
unassociate_openid(request.user, openid)
associated_openids.remove(openid)
messages.append('%s has been removed from your account' % \
escape(openid)
)
# At this point associated_openids represents the current set of associated
# OpenIDs, and messages contains any messages that should be displayed. The
# final step is to work out which OpenIDs they have that are currently
# logged in BUT are not associated - these are the ones that should be
# displayed with an "associate this?" buttons.
potential_openids = [
str(openid) for openid in request.openids
if str(openid) not in associated_openids
]
# Finally, calculate the button hashes we are going to need for the form.
add_buttons = [
{'openid': openid, 'hash': _make_hash('add', request.user, openid)}
for openid in potential_openids
]
del_buttons = [
{'openid': openid, 'hash': _make_hash('del', request.user, openid)}
for openid in associated_openids
]
return render(template_name, {
'user': request.user,
'messages': messages,
'action': request.path,
'add_buttons': add_buttons,
'del_buttons': del_buttons, # This is also used to generate the list of
# of associated OpenIDs
},
context_instance=RequestContext(request))
def register_view(request):
next_activate = ''
if request.method == 'POST':
if is_unattached_openid(request):
form = RegisterFormWithoutPw(request.POST)
else:
form = RegisterForm(request.POST)
if form.is_valid():
data = form.cleaned_data
if is_unattached_openid(request):
pw = ''
send = False
else:
pw = data['password']
send = True
if 'openid_url' in data and data['openid_url']:
# the user is registering with OpendID authentification
request.session[DELAYED_REGISTRATION_SESSION_KEY] = data
from django_openidconsumer.views import begin
return begin(request, redirect_to = reverse('openid-complete'))
else:
# no OpenID:
# - redirect from an OpenID login
# - plain old register
user = Profile.objects.create_inactive_user(data['username'],
data['email'],
pw,
data['preferred_language'],
send_email = send,
next_activate = request.POST.get('next_activate',''),
)
user.first_name = data['firstname']
user.last_name = data['lastname']
user.save()
# newsletter
if data['newsletter'] and settings.HAS_NEWSLETTER and not settings.DEBUG:
register_mailman(data['email'], settings.NEWSLETTER_ADR, data['username'])
# opend id?
if is_unattached_openid(request):
# activate user
profile = user.get_profile()
profile.is_temp = False
profile.save()
user.is_active = True
user.save()
# attach it
from django_openidauth.models import associate_openid
associate_openid(user,request.openid)
# login
user.backend = 'django.contrib.auth.backends.ModelBackend'
login(request, user)
request.session['message'] = _(u"OpenId Registration successful!")
return HttpResponseRedirect("/")
else:
request.session['message'] = _(u"Registration successful! Check your email to activate your account.")
return HttpResponseRedirect("/")
else:
if 'django_language' in request.session:
default_lang = request.session['django_language']
elif request.LANGUAGE_CODE:
default_lang = request.LANGUAGE_CODE
else:
default_lang = 'en'
next_activate = request.GET.get("next_activate",'')
if is_unattached_openid(request):
form = RegisterFormWithoutPw(
initial={'preferred_language': default_lang}
)
else:
form = RegisterForm(
initial={'preferred_language': default_lang}
)
TOU_TXT = get_tou_txt()
return render_to_response('accounts/register.html', {'has_newsletter':settings.HAS_NEWSLETTER,
'TOU_TXT':TOU_TXT,
'form': form,
'next_activate': base64.b64encode(next_activate),
} , context_instance=RequestContext(request))
def signup(request):
if not request.user.is_anonymous():
return HttpResponseRedirect("/")
if request.method == "POST":
if request.openid:
form = SignupForm(request.POST, request.FILES, openid=request.openid)
else:
form = SignupForm(request.POST, request.FILES)
if form.is_valid():
# First create the user
creation_args = {"username": form.cleaned_data["username"], "email": form.cleaned_data["email"]}
if form.cleaned_data.get("password1"):
creation_args["password"] = form.cleaned_data["password1"]
user = User.objects.create_user(**creation_args)
user.first_name = form.cleaned_data["first_name"]
user.last_name = form.cleaned_data["last_name"]
user.save()
if request.openid:
associate_openid(user, str(request.openid))
region = None
if form.cleaned_data["region"]:
region = Region.objects.get(
country__iso_code=form.cleaned_data["country"], code=form.cleaned_data["region"]
)
# Now create the DjangoPerson
person = DjangoPerson.objects.create(
user=user,
bio=form.cleaned_data["bio"],
country=Country.objects.get(iso_code=form.cleaned_data["country"]),
region=region,
latitude=form.cleaned_data["latitude"],
longitude=form.cleaned_data["longitude"],
location_description=form.cleaned_data["location_description"],
)
# Set up the various machine tags
for fieldname, (namespace, predicate) in MACHINETAGS_FROM_FIELDS.items():
if form.cleaned_data.has_key(fieldname) and form.cleaned_data[fieldname].strip():
value = form.cleaned_data[fieldname].strip()
person.add_machinetag(namespace, predicate, value)
# Stash their blog and looking_for_work
if form.cleaned_data["blog"]:
person.add_machinetag("profile", "blog", form.cleaned_data["blog"])
if form.cleaned_data["looking_for_work"]:
person.add_machinetag("profile", "looking_for_work", form.cleaned_data["looking_for_work"])
# Finally, set their skill tags
person.skilltags = form.cleaned_data["skilltags"]
# Log them in and redirect to their profile page
# HACK! http://groups.google.com/group/django-users/
# browse_thread/thread/39488db1864c595f
user.backend = "django.contrib.auth.backends.ModelBackend"
auth.login(request, user)
return HttpResponseRedirect(person.get_absolute_url())
else:
if request.openid and request.openid.sreg:
sreg = request.openid.sreg
first_name = ""
last_name = ""
username = ""
if sreg.get("fullname"):
bits = sreg["fullname"].split()
first_name = bits[0]
if len(bits) > 1:
last_name = " ".join(bits[1:])
# Find a not-taken username
if sreg.get("nickname"):
username = derive_username(sreg["nickname"])
form = SignupForm(
initial={
"first_name": first_name,
"last_name": last_name,
"email": sreg.get("email", ""),
"username": username,
},
openid=request.openid,
)
elif request.openid:
form = SignupForm(openid=request.openid)
else:
form = SignupForm()
return render(
request, "signup.html", {"form": form, "api_key": settings.GOOGLE_MAPS_API_KEY, "openid": request.openid}
)