def register(request, success_url=None,
form_class=RegistrationForm, profile_callback=None,
template_name='registration/registration_form.html',
extra_context=None):
"""
Allow a new user to register an account.
Following successful registration, issue a redirect; by default,
this will be whatever URL corresponds to the named URL pattern
``registration_complete``, which will be
``/accounts/register/complete/`` if using the included URLConf. To
change this, point that named pattern at another URL, or pass your
preferred URL as the keyword argument ``success_url``.
By default, ``registration.forms.RegistrationForm`` will be used
as the registration form; to change this, pass a different form
class as the ``form_class`` keyword argument. The form class you
specify must have a method ``save`` which will create and return
the new ``User``, and that method must accept the keyword argument
``profile_callback`` (see below).
To enable creation of a site-specific user profile object for the
new user, pass a function which will create the profile object as
the keyword argument ``profile_callback``. See
``RegistrationManager.create_inactive_user`` in the file
``models.py`` for details on how to write this function.
By default, use the template
``registration/registration_form.html``; to change this, pass the
name of a template as the keyword argument ``template_name``.
**Required arguments**
None.
**Optional arguments**
``form_class``
The form class to use for registration.
``extra_context``
A dictionary of variables to add to the template context. Any
callable object in this dictionary will be called to produce
the end result which appears in the context.
``profile_callback``
A function which will be used to create a site-specific
profile instance for the new ``User``.
``success_url``
The URL to redirect to on successful registration.
``template_name``
A custom template to use.
**Context:**
``form``
The registration form.
Any extra variables supplied in the ``extra_context`` argument
(see above).
**Template:**
registration/registration_form.html or ``template_name`` keyword
argument.
"""
# check if this site allows self registration, if not, redirect to login page
allow_self_registration = get_setting('module', 'users', 'selfregistration')
if not allow_self_registration:
return HttpResponseRedirect(reverse('auth_login'))
if request.method == 'POST':
form = form_class(data=request.POST, files=request.FILES)
if form.is_valid():
new_user = form.save(profile_callback=profile_callback)
# success_url needs to be dynamically generated here; setting a
# a default value using reverse() will cause circular-import
# problems with the default URLConf for this application, which
# imports this file.
# add to the default group(s)
default_user_groups =[g.strip() for g in (get_setting('module', 'users', 'defaultusergroup')).split(',')]
if default_user_groups:
from user_groups.models import Group, GroupMembership
from django.db.models import Q
for group_name in default_user_groups:
groups = Group.objects.filter(Q(name=group_name) | Q(label=group_name)).filter(allow_self_add=1, status=1, status_detail='active')
if groups:
group = groups[0]
else:
# group doesnot exist, so create the group
group = Group()
group.name = group_name
group.label = group_name
group.type = 'distribution'
group.show_as_option = 1
group.allow_self_add = 1
group.allow_self_remove = 1
group.creator = new_user
group.creator_username = new_user.username
group.owner = new_user
group.owner_username = new_user.username
try:
group.save()
except:
group = None
if group:
gm = GroupMembership()
gm.group = group
gm.member = new_user
gm.creator_id = new_user.id
gm.creator_username = new_user.username
gm.owner_id = new_user.id
gm.owner_username = new_user.username
gm.save()
log_defaults = {
'event_id' : 121000,
'event_data': '%s (%d) self added by form' % (new_user._meta.object_name, new_user.pk),
'description': '%s self added' % new_user._meta.object_name,
'user': new_user,
'request': request,
'instance': new_user,
}
EventLog.objects.log(**log_defaults)
return HttpResponseRedirect(success_url or reverse('registration_complete'))
else:
form = form_class()
if extra_context is None:
extra_context = {}
context = RequestContext(request)
for key, value in extra_context.items():
context[key] = callable(value) and value() or value
return render_to_response(template_name,
{ 'form': form },
context_instance=context)
def authenticate(self, *args, **kwargs):
"""Authenticate user using social credentials
Authentication is made if this is the correct backend, backend
verification is made by kwargs inspection for current backend
name presence.
"""
# Validate backend and arguments. Require that the Social Auth
# response be passed in as a keyword argument, to make sure we
# don't match the username/password calling conventions of
# authenticate.
if not (self.name and kwargs.get(self.name) and 'response' in kwargs):
return None
response = kwargs.get('response')
request = kwargs.get('request')
details = self.get_user_details(response)
uid = self.get_user_id(details, response)
is_new = False
try:
social_user = UserSocialAuth.objects.select_related('user')\
.get(provider=self.name,
uid=uid)
except UserSocialAuth.DoesNotExist:
user = kwargs.get('user')
if user is None: # new user
if not CREATE_USERS:
return None
email = details.get('email')
if email and ASSOCIATE_BY_MAIL:
# try to associate accounts registered with the same email
# address, only if it's a single object. ValueError is
# raised if multiple objects are returned
try:
user = User.objects.get(email=email)
except MultipleObjectsReturned:
raise ValueError('Not unique email address supplied')
except User.DoesNotExist:
user = None
if not user:
username = self.username(details)
user = User.objects.create_user(username=username,
email=email)
is_new = True
default_user_groups =[g.strip() for g in (get_setting('module', 'users', 'defaultusergroup')).split(',')]
if default_user_groups:
from user_groups.models import Group, GroupMembership
from django.db.models import Q
for group_name in default_user_groups:
groups = Group.objects.filter(Q(name=group_name) | Q(label=group_name)).filter(allow_self_add=1, status=1, status_detail='active')
if groups:
group = groups[0]
else:
# group doesnot exist, so create the group
group = Group()
group.name = group_name
group.label = group_name
group.type = 'distribution'
group.show_as_option = 1
group.allow_self_add = 1
group.allow_self_remove = 1
group.creator = user
group.creator_username = user.username
group.owner = user
group.owner_username = user.username
try:
group.save()
except:
group = None
if group:
gm = GroupMembership()
gm.group = group
gm.member = user
gm.creator_id = user.id
gm.creator_username = user.username
gm.owner_id = user.id
gm.owner_username = user.username
gm.save()
log_defaults = {
'event_id' : 121000,
'event_data': '%s (%d) self added by form' % (user._meta.object_name, user.pk),
'description': '%s self added' % user._meta.object_name,
'user': user,
'request': request,
'instance': user,
}
EventLog.objects.log(**log_defaults)
social_user = self.associate_auth(user, uid, response, details)
else:
# This account was registered to another user, so we raise an
# error in such case and the view should decide what to do on
# at this moment, merging account is not an option because that
# would imply update user references on other apps, that's too
# much intrusive
if 'user' in kwargs and kwargs['user'] != social_user.user:
raise ValueError('Account already in use.', social_user)
user = social_user.user
# Update user account data.
self.update_user_details(user, response, details, is_new)
# Update extra_data storage, unless disabled by setting
if LOAD_EXTRA_DATA:
extra_data = self.extra_data(user, uid, response, details)
if extra_data and social_user.extra_data != extra_data:
social_user.extra_data = extra_data
social_user.save()
return user
def save_model(self, request, object, form, change):
instance = form.save(commit=False)
# save the expiration method fields
type_exp_method = form.cleaned_data['type_exp_method']
type_exp_method_list = type_exp_method.split(",")
for i, field in enumerate(form.type_exp_method_fields):
if field=='fixed_option2_can_rollover':
if type_exp_method_list[i]=='':
type_exp_method_list[i] = ''
else:
if type_exp_method_list[i]=='':
type_exp_method_list[i] = "0"
setattr(instance, field, type_exp_method_list[i])
if not change:
instance.creator = request.user
instance.creator_username = request.user.username
instance.owner = request.user
instance.owner_username = request.user.username
# create a group for this type
group = Group()
group.name = 'Membership: %s' % instance.name
group.slug = slugify(group.name)
# just in case, check if this slug already exists in group.
# if it does, make a unique slug
tmp_groups = Group.objects.filter(slug__istartswith=group.slug)
if tmp_groups:
t_list = [g.slug[len(group.slug):] for g in tmp_groups]
num = 1
while str(num) in t_list:
num += 1
group.slug = '%s%s' % (group.slug, str(num))
# group name is also a unique field
group.name = '%s%s' % (group.name, str(num))
group.label = instance.name
group.type = 'membership'
group.email_recipient = request.user.email
group.show_as_option = 0
group.allow_self_add = 0
group.allow_self_remove = 0
group.description = "Auto-generated with the membership type. Used for membership only"
group.notes = "Auto-generated with the membership type. Used for membership only"
#group.use_for_membership = 1
group.creator = request.user
group.creator_username = request.user.username
group.owner = request.user
group.owner_username = request.user.username
group.save()
instance.group = group
# save the object
instance.save()
#form.save_m2m()
return instance
