Added generic assign remove view and converted the user management and permissions apps to use it

apps/common/views.py

@@ -2,6 +2,13 @@ from django.shortcuts import redirect
 from django.utils.translation import ugettext_lazy as _
 from django.contrib import messages
 from django.http import HttpResponseRedirect
+from django.shortcuts import render_to_response, get_object_or_404
+from django.template import RequestContext
+from django.contrib import messages
+from django.contrib.contenttypes.models import ContentType
+
+from common.utils import generate_choices_w_labels
+from common.forms import ChoiceForm
 
 
 def password_change_done(request):
@@ -31,3 +38,96 @@ def multi_object_action_view(request):
         return HttpResponseRedirect(request.META.get('HTTP_REFERER', '/'))
 
     return HttpResponseRedirect('%s?id_list=%s' % (action, id_list))
+
+
+def get_obj_from_content_type_string(string):
+    model, pk = string.split(u',')
+    ct = ContentType.objects.get(model=model)
+    return ct.get_object_for_this_type(pk=pk)
+    
+
+def assign_remove(request, left_list, right_list, add_method, remove_method, left_list_title, right_list_title, obj=None, object_name=None, decode_content_type=False):
+    left_list_name = u'left_list'
+    right_list_name = u'right_list'
+    
+    if request.method == 'POST':
+        if u'%s-submit' % left_list_name in request.POST.keys():
+            unselected_list = ChoiceForm(request.POST,
+                prefix=left_list_name,
+                choices=left_list())
+            if unselected_list.is_valid():
+                for selection in unselected_list.cleaned_data['selection']:
+                    label = dict(left_list())[selection]
+                    if decode_content_type:
+                        selection_obj = get_obj_from_content_type_string(selection)
+                    else:
+                        selection_obj = selection
+                    try:
+                        add_method(selection_obj)
+                        messages.success(request, _(u'%(selection)s added successfully added to %(right_list_title)s.') % {
+                            'selection': label, 'right_list_title': right_list_title})
+                    except:
+                        messages.error(request, _(u'Unable to add %(selection)s to %(right_list_title)s.') % {
+                            'selection': label, 'right_list_title': right_list_title})
+
+        elif u'%s-submit' % right_list_name in request.POST.keys():
+            selected_list = ChoiceForm(request.POST,
+                prefix=right_list_name,
+                choices=right_list())
+            if selected_list.is_valid():
+                for selection in selected_list.cleaned_data['selection']:
+                    label = dict(right_list())[selection]
+                    if decode_content_type:
+                        selection = get_obj_from_content_type_string(selection)
+                    try:
+                        remove_method(selection)
+                        messages.success(request, _(u'%(selection)s added successfully removed from %(right_list_title)s.') % {
+                            'selection': label, 'right_list_title': right_list_title})
+                    except:
+                        messages.error(request, _(u'Unable to add %(selection)s to %(right_list_title)s.') % {
+                            'selection': label, 'right_list_title': right_list_title})
+    unselected_list = ChoiceForm(prefix=left_list_name,
+        choices=left_list())
+    selected_list = ChoiceForm(prefix=right_list_name,
+        choices=right_list())
+
+    context = {
+        'subtemplates_list': [
+            {
+                'name':'generic_form_subtemplate.html',
+                'grid': 6,
+                'context': {
+                    'form': unselected_list,
+                    'title': left_list_title,
+                    'submit_label': _(u'Add'),
+                }
+            },        
+            {
+                'name':'generic_form_subtemplate.html',
+                'grid': 6,
+                'grid_clear': True,
+                'context': {
+                    'form': selected_list,
+                    'title': right_list_title,
+                    'submit_label': _(u'Remove'),
+                }
+            },
+
+        ],
+    }
+    if obj:
+        context.update(
+            {
+                'object': obj
+            }
+        )
+        
+    if object_name:
+        context.update(
+            {
+                'object_name': object_name,
+            }
+        )
+        
+    return render_to_response('generic_form.html', context,
+        context_instance=RequestContext(request))

apps/permissions/views.py

@@ -11,7 +11,7 @@ from django.contrib.contenttypes.models import ContentType
 from django.core.exceptions import ObjectDoesNotExist
 from django.contrib.auth.models import User, Group
 
-from common.forms import ChoiceForm
+from common.views import assign_remove
 from common.utils import generate_choices_w_labels
 
 from permissions.models import Role, Permission, PermissionHolder, RoleMember
@@ -39,18 +39,18 @@ def role_list(request):
 def _role_permission_link(requester, permission, permission_list):
     ct = ContentType.objects.get_for_model(requester)
 
-    template = '<span class="nowrap"><a href="%(url)s"><span class="famfam active famfam-%(icon)s"></span>%(text)s</a></span>'
+    template = u'<span class="nowrap"><a href="%(url)s"><span class="famfam active famfam-%(icon)s"></span>%(text)s</a></span>'
 
     if permission in permission_list:
         return template % {
             'url': reverse('permission_revoke',
                 args=[permission.pk, ct.app_label, ct.model, requester.pk]),
-            'icon': 'delete', 'text': ugettext(u'Revoke')}
+            'icon': u'delete', 'text': ugettext(u'Revoke')}
     else:
         return template % {
             'url': reverse('permission_grant',
                 args=[permission.pk, ct.app_label, ct.model, requester.pk]),
-            'icon': 'add', 'text': ugettext(u'Grant')}
+            'icon': u'add', 'text': ugettext(u'Grant')}
 
 
 def role_permissions(request, role_id):
@@ -62,13 +62,13 @@ def role_permissions(request, role_id):
     role_permissions_list = Permission.objects.get_for_holder(role)
     subtemplates_list = [
         {
-            'name':'generic_list_subtemplate.html',
+            'name': u'generic_list_subtemplate.html',
             'context': {
                 'title': _(u'permissions'),
                 'object_list': Permission.objects.all(),
                 'extra_columns': [
-                    {'name':_(u'namespace'), 'attribute':'namespace'},
+                    {'name': _(u'namespace'), 'attribute': u'namespace'},
-                    {'name':_(u'name'), 'attribute':'label'},
+                    {'name': _(u'name'), 'attribute': u'label'},
                     {
                         'name':_(u'state'),
                         'attribute': lambda x: _role_permission_link(role, x, role_permissions_list),
@@ -185,75 +185,33 @@ def get_non_role_members(role):
     return list(users | groups)
 
 
+def add_role_member(role, selection):
+    model, pk = selection.split(u',')
+    ct = ContentType.objects.get(model=model)
+    new_member, created = RoleMember.objects.get_or_create(role=role, member_type=ct, member_id=pk)
+    if not created:
+        raise Exception
+    
+    
+def remove_role_member(role, selection):
+    model, pk = selection.split(u',')
+    ct = ContentType.objects.get(model=model)
+    member = RoleMember.objects.get(role=role, member_type=ct, member_id=pk)
+    member.delete()    
+    
+
 def role_members(request, role_id):
     check_permissions(request.user, 'permissions', [PERMISSION_ROLE_EDIT])
     role = get_object_or_404(Role, pk=role_id)
     
-    if request.method == 'POST':
+    return assign_remove(
-        if 'unselected-users-submit' in request.POST.keys():
+        request,
-            unselected_users_form = ChoiceForm(request.POST,
+        left_list=lambda: generate_choices_w_labels(get_non_role_members(role)),
-                prefix='unselected-users',
+        right_list=lambda: generate_choices_w_labels(get_role_members(role)),
-                choices=generate_choices_w_labels(get_non_role_members(role)))
+        add_method=lambda x: add_role_member(role, x),
-            if unselected_users_form.is_valid():
+        remove_method=lambda x: remove_role_member(role, x),
-                for selection in unselected_users_form.cleaned_data['selection']:
+        left_list_title=_(u'non members of role: %s') % role,
-                    model, pk = selection.split(u',')
+        right_list_title=_(u'members of role: %s') % role,
-                    ct = ContentType.objects.get(model=model)
+        obj=role,
-                    obj = ct.get_object_for_this_type(pk=pk)
+        object_name=_(u'role'),
-                    new_member, created = RoleMember.objects.get_or_create(role=role, member_type=ct, member_id=pk)
+    )
-                    if created:
-                        messages.success(request, _(u'%(obj)s added successfully to the role: %(role)s.') % {
-                            'obj': generate_choices_w_labels([obj])[0][1], 'role': role})
-
-        elif 'selected-users-submit' in request.POST.keys():
-            selected_users_form = ChoiceForm(request.POST,
-                prefix='selected-users',
-                choices=generate_choices_w_labels(get_role_members(role)))
-            if selected_users_form.is_valid():
-                for selection in selected_users_form.cleaned_data['selection']:
-                    model, pk = selection.split(u',')
-                    ct = ContentType.objects.get(model=model)
-                    obj = ct.get_object_for_this_type(pk=pk)
-
-                    try:
-                        member = RoleMember.objects.get(role=role, member_type=ct, member_id=pk)
-                        member.delete()
-                        messages.success(request, _(u'%(obj)s removed successfully from the role: %(role)s.') % {
-                            'obj': generate_choices_w_labels([obj])[0][1], 'role': role})
-                    except member.DoesNotExist:
-                        messages.error(request, _(u'Unable to remove %(obj)s from the role: %(role)s.') % {
-                            'obj': generate_choices_w_labels([obj])[0][1], 'role': role})
-
-    unselected_users_form = ChoiceForm(prefix='unselected-users',
-        choices=generate_choices_w_labels(get_non_role_members(role)))
-    selected_users_form = ChoiceForm(prefix='selected-users',
-        choices=generate_choices_w_labels(get_role_members(role)))
-
-    context = {
-        'object': role,
-        'object_name': _(u'role'),
-        'subtemplates_list': [
-            {
-                'name':'generic_form_subtemplate.html',
-                'grid': 6,
-                'context': {
-                    'form': unselected_users_form,
-                    'title': _(u'non members of role: %s') % role,
-                    'submit_label': _(u'Add'),
-                }
-            },        
-            {
-                'name':'generic_form_subtemplate.html',
-                'grid': 6,
-                'grid_clear': True,
-                'context': {
-                    'form': selected_users_form,
-                    'title': _(u'members of role: %s') % role,
-                    'submit_label': _(u'Remove'),
-                }
-            },
-
-        ],
-    }
-
-    return render_to_response('generic_form.html', context,
-        context_instance=RequestContext(request))

apps/user_management/views.py

@@ -9,8 +9,8 @@ from django.contrib.auth.models import User, Group
 from django.contrib.contenttypes.models import ContentType
 
 from permissions.api import check_permissions
-from common.forms import ChoiceForm
 from common.utils import generate_choices_w_labels, two_state_template
+from common.views import assign_remove
 
 from user_management import PERMISSION_USER_VIEW, \
     PERMISSION_USER_EDIT, PERMISSION_USER_CREATE, \
@@ -333,67 +333,15 @@ def group_members(request, group_id):
     check_permissions(request.user, 'user_management', [PERMISSION_GROUP_EDIT])
     group = get_object_or_404(Group, pk=group_id)
     
-    if request.method == 'POST':
+    return assign_remove(
-        if 'unselected-users-submit' in request.POST.keys():
+        request,
-            unselected_users_form = ChoiceForm(request.POST,
+        left_list=lambda: generate_choices_w_labels(get_non_group_members(group), display_object_type=False),
-                prefix='unselected-users',
+        right_list=lambda: generate_choices_w_labels(get_group_members(group), display_object_type=False),
-                choices=generate_choices_w_labels(get_non_group_members(group), display_object_type=False))
+        add_method=lambda x:  group.user_set.add(x),
-            if unselected_users_form.is_valid():
+        remove_method=lambda x: group.user_set.remove(x),
-                for selection in unselected_users_form.cleaned_data['selection']:
+        left_list_title=_(u'non members of group: %s') % group,
-                    model, pk = selection.split(u',')
+        right_list_title=_(u'members of group: %s') % group,
-                    ct = ContentType.objects.get(model=model)
+        obj=group,
-                    obj = ct.get_object_for_this_type(pk=pk)
+        object_name=_(u'group'),
-                    group.user_set.add(obj)
+        decode_content_type=True,
-                    messages.success(request, _(u'%(obj)s added successfully to the group: %(group)s.') % {
+    )
-                        'obj': generate_choices_w_labels([obj])[0][1], 'group': group})
-        elif 'selected-users-submit' in request.POST.keys():
-            selected_users_form = ChoiceForm(request.POST,
-                prefix='selected-users',
-                choices=generate_choices_w_labels(get_group_members(group), display_object_type=False))
-            if selected_users_form.is_valid():
-                for selection in selected_users_form.cleaned_data['selection']:
-                    model, pk = selection.split(u',')
-                    ct = ContentType.objects.get(model=model)
-                    obj = ct.get_object_for_this_type(pk=pk)
-                    try:
-                        group.user_set.remove(obj)
-                        messages.success(request, _(u'%(obj)s removed successfully from the group: %(group)s.') % {
-                            'obj': generate_choices_w_labels([obj])[0][1], 'group': group})
-                    except obj.DoesNotExist:
-                        messages.error(request, _(u'Unable to remove %(obj)s from the group: %(group)s.') % {
-                            'obj': generate_choices_w_labels([obj])[0][1], 'group': group})
-    unselected_users_form = ChoiceForm(prefix='unselected-users',
-        choices=generate_choices_w_labels(get_non_group_members(group), display_object_type=False))
-    selected_users_form = ChoiceForm(prefix='selected-users',
-        choices=generate_choices_w_labels(get_group_members(group), display_object_type=False))
-
-    context = {
-        'object': group,
-        'object_name': _(u'group'),
-        'subtemplates_list': [
-            {
-                'name': u'generic_form_subtemplate.html',
-                'context': {
-                    'form': unselected_users_form,
-                    'title': _(u'non members of group: %s') % group,
-                    'submit_label': _(u'Add'),
-                },
-                'grid': 6,
-                'grid_clear': False,
-            },
-            {
-                'name': u'generic_form_subtemplate.html',
-                'context': {
-                    'form': selected_users_form,
-                    'title': _(u'members of group: %s') % group,
-                    'submit_label': _(u'Remove'),
-                },
-                'grid': 6,
-                'grid_clear': True,
-            },
-
-        ],
-    }
-
-    return render_to_response('generic_form.html', context,
-        context_instance=RequestContext(request))