Пример #1
0
 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
Пример #2
0
 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)
Пример #3
0
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'))
Пример #4
0
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))
Пример #5
0
    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
Пример #6
0
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)
Пример #7
0
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