def execute_function(self, entry, value, user=None):
if self.field_function == "GroupSubscription":
if value:
for val in self.function_params.split(','):
group = Group.objects.get(name=val)
if user:
try:
group_membership = GroupMembership.objects.get(group=group, member=user)
except GroupMembership.DoesNotExist:
group_membership = GroupMembership(group=group, member=user)
group_membership.creator_id = user.id
group_membership.creator_username = user.username
group_membership.role='subscriber'
group_membership.owner_id = user.id
group_membership.owner_username = user.username
group_membership.save()
else:
entry.subscribe(group) # subscribe form-entry to a group
def save(self):
data = self.cleaned_data
#delete old memberships
for old_m in self.old_memberships:
if old_m.group not in data['groups']:
print "membership to %s deleted" % old_m.group
log_defaults = {
'event_id' : 223000,
'event_data': '%s (%d) deleted by %s' % (old_m._meta.object_name, old_m.pk, self.editor),
'description': '%s deleted' % old_m._meta.object_name,
'user': self.editor,
'request': self.request,
'instance': old_m,
}
EventLog.objects.log(**log_defaults)
old_m.delete()
#create new memberships
for group in data['groups']:
try:
group_membership = GroupMembership.objects.get(group=group, member=self.user)
except GroupMembership.DoesNotExist:
group_membership = GroupMembership(group=group, member=self.user)
group_membership.creator_id = self.editor.id
group_membership.creator_username = self.editor.username
group_membership.owner_id = self.editor.id
group_membership.owner_username = self.editor.username
group_membership.save()
log_defaults = {
'event_id' : 221000,
'event_data': '%s (%d) added by %s' % (group_membership._meta.object_name, group_membership.pk, self.editor),
'description': '%s added' % group_membership._meta.object_name,
'user': self.editor,
'request': self.request,
'instance': group_membership,
}
EventLog.objects.log(**log_defaults)
def group_membership_self_add(request, slug, user_id):
group = get_object_or_404(Group, slug=slug)
user = get_object_or_404(User, pk=user_id)
if not has_view_perm(request.user,'user_groups.view_group', group) and not group.allow_self_add:
raise Http403
group_membership = GroupMembership.objects.filter(member=user, group=group)
if not group_membership:
group_membership = GroupMembership()
group_membership.group = group
group_membership.member = user
group_membership.creator_id = user.id
group_membership.creator_username = user.username
group_membership.owner_id = user.id
group_membership.owner_username = user.username
group_membership.save()
log_defaults = {
'event_id' : 221000,
'event_data': '%s (%d) added by %s' % (group_membership._meta.object_name, group_membership.pk, request.user),
'description': '%s added' % group_membership._meta.object_name,
'user': request.user,
'request': request,
'instance': group_membership,
}
EventLog.objects.log(**log_defaults)
messages.add_message(request, messages.SUCCESS, 'Successfully added yourself to group %s' % group)
else:
messages.add_message(request, messages.INFO, 'You are already in the group %s' % group)
return HttpResponseRedirect(reverse('group.search'))
def groupmembership_bulk_add(request, group_slug,
form_class=GroupMembershipBulkForm,
template_name="user_groups/member_add.html"):
group = get_object_or_404(Group, slug=group_slug)
if request.method == 'POST':
form = form_class(group, request.POST)
if form.is_valid():
members = form.cleaned_data['members']
old_members = GroupMembership.objects.filter(group=group)
#delete removed groupmemberships
if members:
for old_m in old_members:
try:
members.get(pk=old_m.member.pk)
except User.DoesNotExist:
log_defaults = {
'event_id' : 223000,
'event_data': '%s (%d) deleted by %s' % (old_m._meta.object_name, old_m.pk, request.user),
'description': '%s deleted' % old_m._meta.object_name,
'user': request.user,
'request': request,
'instance': old_m,
}
EventLog.objects.log(**log_defaults)
old_m.delete()
else: #when members is None
for old_m in old_members:
log_defaults = {
'event_id' : 223000,
'event_data': '%s (%d) deleted by %s' % (old_m._meta.object_name, old_m.pk, request.user),
'description': '%s deleted' % old_m._meta.object_name,
'user': request.user,
'request': request,
'instance': old_m,
}
EventLog.objects.log(**log_defaults)
old_m.delete()
for m in members:
try:
group_membership = GroupMembership.objects.get(group=group, member=m)
except GroupMembership.DoesNotExist:
group_membership = GroupMembership(group=group, member=m)
group_membership.creator_id = request.user.id
group_membership.creator_username = request.user.username
group_membership.role=form.cleaned_data['role']
group_membership.status=form.cleaned_data['status']
group_membership.status_detail=form.cleaned_data['status_detail']
group_membership.owner_id = request.user.id
group_membership.owner_username = request.user.username
group_membership.save()
log_defaults = {
'event_id' : 221000,
'event_data': '%s (%d) added by %s' % (group_membership._meta.object_name, group_membership.pk, request.user),
'description': '%s added' % group_membership._meta.object_name,
'user': request.user,
'request': request,
'instance': group_membership,
}
EventLog.objects.log(**log_defaults)
return HttpResponseRedirect(group.get_absolute_url())
else:
member_label = request.GET.get('member_label', 'username')
form = form_class(group, member_label=member_label)
return render_to_response(template_name, locals(), context_instance=RequestContext(request))
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 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 do_user_import(request, user, user_object_dict, setting_dict):
"""
the real work is here - do the insert or update
"""
insert = not bool(user) # insert or update
user = user or User() # existing or new user
override = setting_dict['override'] # update ALL fields
# insert/update user
for field in user_field_names:
if field == 'password' or field == 'username' or (not insert and field in setting_dict['key']):
continue
if user_object_dict.has_key(field):
if override:
setattr(user, field, user_object_dict[field])
else:
# fill out the blank field only
if getattr(user, field) == '':
setattr(user, field, user_object_dict[field])
if insert:
if 'username' in user_object_dict: # set username
user.username = user_object_dict['username']
# generate if not username
user.username = get_unique_username(user)
if 'password' in user_object_dict and (insert or override):
user.set_password(user_object_dict['password'])
if not user.password:
user.set_password(User.objects.make_random_password(length=8))
user.is_active = bool(setting_dict['interactive'])
if not bool(email_re.match(user.email)):
user.email = '' # if not valid; empty it out
# loop through user properties; truncate at max_length
for key, value in user.__dict__.items():
try: max_length = User._meta.get_field_by_name(key)[0].max_length
except FieldDoesNotExist as e: max_length = None
if max_length: # truncate per max_length field attribute
setattr(user, key, value[:max_length])
# username and email required
if user.username and user.email:
# insert/update record
if insert: user.save(force_insert=True)
else: user.save(force_update=True)
try: # get or create
profile = user.get_profile()
except Profile.DoesNotExist:
profile = Profile.objects.create(user=user,
creator=request.user,
creator_username=request.user.username,
owner=request.user,
owner_username=request.user.username,
email=user.email
)
for field in profile_field_names:
if user_object_dict.has_key(field):
if override:
setattr(profile, field, user_object_dict[field])
else:
# fill out the blank field only
if getattr(profile, field) == '':
setattr(profile, field, user_object_dict[field])
profile.save()
# add to group
if setting_dict['group']:
try:
gm = GroupMembership.objects.get(group=setting_dict['group'], member=user)
except GroupMembership.DoesNotExist:
gm = GroupMembership()
gm.member = user
gm.group = setting_dict['group']
gm.creator_id = request.user.id
gm.creator_username = request.user.username
gm.owner_id = request.user.id
gm.owner_username = request.user.username
gm.status =1
gm.status_detail = 'active'
gm.save()
return user