Merge branch 'feature_admin_update' into 'master'

Improve admin site lists for users, groups and service users

See merge request allianceauth/allianceauth!1164

allianceauth/groupmanagement/admin.py

@@ -1,11 +1,24 @@
+from django.conf import settings
+
 from django.contrib import admin
 from django.contrib.auth.models import Group as BaseGroup
-from django.db.models.signals import pre_save, post_save, pre_delete, post_delete, m2m_changed
+from django.db.models import Count
+from django.db.models.functions import Lower
+from django.db.models.signals import pre_save, post_save, pre_delete, \
+    post_delete, m2m_changed
 from django.dispatch import receiver
+
 from .models import AuthGroup
 from .models import GroupRequest
 from . import signals
 
+if 'allianceauth.eveonline.autogroups' in settings.INSTALLED_APPS:
+    _has_auto_groups = True
+    from allianceauth.eveonline.autogroups.models import *
+else:
+    _has_auto_groups = False
+
+
 class AuthGroupInlineAdmin(admin.StackedInline):
     model = AuthGroup
     filter_horizontal = ('group_leaders', 'group_leader_groups', 'states',)
@@ -13,6 +26,17 @@ class AuthGroupInlineAdmin(admin.StackedInline):
     verbose_name_plural = 'Auth Settings'
     verbose_name = ''
 
+    def formfield_for_manytomany(self, db_field, request, **kwargs):
+        """overriding this formfield to have sorted lists in the form"""
+        if db_field.name == "group_leaders":
+            kwargs["queryset"] = User.objects\
+                .filter(profile__state__name='Member')\
+                .order_by(Lower('username'))
+        elif db_field.name == "group_leader_groups":
+            kwargs["queryset"] = Group.objects\
+                .order_by(Lower('name'))
+        return super().formfield_for_manytomany(db_field, request, **kwargs)
+
     def has_add_permission(self, request):
         return False
 
@@ -23,7 +47,116 @@ class AuthGroupInlineAdmin(admin.StackedInline):
         return request.user.has_perm('auth.change_group')
 
 
-class GroupAdmin(admin.ModelAdmin):
+if _has_auto_groups:
+    class IsAutoGroupFilter(admin.SimpleListFilter):
+        title = 'auto group'
+        parameter_name = 'is_auto_group__exact'
+
+        def lookups(self, request, model_admin):
+            return (
+                ('yes', 'Yes'),
+                ('no', 'No'),
+            )
+
+        def queryset(self, request, queryset):
+            value = self.value()
+            if value == 'yes':
+                return queryset.exclude(
+                    managedalliancegroup__isnull=True, 
+                    managedcorpgroup__isnull=True
+                )
+            elif value == 'no':
+                return queryset.filter(
+                    managedalliancegroup__isnull=True, 
+                    managedcorpgroup__isnull=True
+                )
+            else:
+                return queryset
+
+
+class HasLeaderFilter(admin.SimpleListFilter):
+    title = 'has leader'
+    parameter_name = 'has_leader__exact'
+
+    def lookups(self, request, model_admin):
+        return (
+            ('yes', 'Yes'),
+            ('no', 'No'),
+        )
+
+    def queryset(self, request, queryset):
+        value = self.value()
+        if value == 'yes':
+            return queryset.filter(authgroup__group_leaders__isnull=False)
+        elif value == 'no':
+            return queryset.filter(authgroup__group_leaders__isnull=True)
+        else:
+            return queryset
+
+class GroupAdmin(admin.ModelAdmin):    
+    list_select_related = True
+    ordering = ('name', )
+    list_display = (
+        'name', 
+        '_description', 
+        '_properties', 
+        '_member_count', 
+        'has_leader'
+    )
+    list_filter = (
+        'authgroup__internal', 
+        'authgroup__hidden', 
+        'authgroup__open', 
+        'authgroup__public',
+        IsAutoGroupFilter,
+        HasLeaderFilter
+    )
+    search_fields = ('name', 'authgroup__description')
+    
+    def get_queryset(self, request):
+        qs = super().get_queryset(request)                
+        qs = qs.annotate(
+            member_count=Count('user', distinct=True),
+        )        
+        return qs
+
+    def _description(self, obj):
+        return obj.authgroup.description
+
+    def _member_count(self, obj):
+        return obj.member_count
+
+    _member_count.short_description = 'Members'
+    _member_count.admin_order_field = 'member_count'
+    
+    def has_leader(self, obj):
+        return obj.authgroup.group_leaders.exists()
+    
+    has_leader.boolean = True    
+
+    def _properties(self, obj):
+        properties = list()       
+        if _has_auto_groups and (
+            obj.managedalliancegroup_set.exists() 
+            or obj.managedcorpgroup_set.exists()
+        ):
+            properties.append('Auto Group')
+        elif obj.authgroup.internal:
+            properties.append('Internal')
+        else:
+            if obj.authgroup.hidden:
+                properties.append('Hidden')
+            if obj.authgroup.open:
+                properties.append('Open')
+            if obj.authgroup.public:
+                properties.append('Public')
+        if not properties:
+            properties.append('Default')
+                    
+        return properties
+
+    _properties.short_description = "properties"
+
     filter_horizontal = ('permissions',)
     inlines = (AuthGroupInlineAdmin,)
 

allianceauth/groupmanagement/tests/test_admin.py

@@ -0,0 +1,379 @@
+from unittest.mock import patch
+
+from django.test import TestCase, RequestFactory
+from django.contrib import admin
+from django.contrib.admin.sites import AdminSite
+from django.contrib.auth.models import User
+
+from allianceauth.authentication.models import CharacterOwnership, State
+from allianceauth.eveonline.autogroups.models import AutogroupsConfig
+from allianceauth.eveonline.models import (
+    EveCharacter, EveCorporationInfo, EveAllianceInfo
+)
+
+from ..admin import (
+   IsAutoGroupFilter,
+   HasLeaderFilter,
+   GroupAdmin,   
+   Group
+)
+
+
+MODULE_PATH = 'allianceauth.groupmanagement.admin'
+
+
+class MockRequest(object):
+    
+    def __init__(self, user=None):
+        self.user = user
+
+
+class TestGroupAdmin(TestCase):
+
+    @classmethod
+    def setUpClass(cls):
+        super().setUpClass()
+
+        # group 1 - has leader
+        cls.group_1 = Group.objects.create(name='Group 1')        
+        cls.group_1.authgroup.description = 'Default Group'
+        cls.group_1.authgroup.internal = False
+        cls.group_1.authgroup.hidden = False
+        cls.group_1.authgroup.save()
+
+        # group 2 - no leader
+        cls.group_2 = Group.objects.create(name='Group 2')
+        cls.group_2.authgroup.description = 'Internal Group'
+        cls.group_2.authgroup.internal = True        
+        cls.group_2.authgroup.save()
+
+        # group 3 - has leader
+        cls.group_3 = Group.objects.create(name='Group 3')
+        cls.group_3.authgroup.description = 'Hidden Group'
+        cls.group_3.authgroup.internal = False
+        cls.group_3.authgroup.hidden = True
+        cls.group_3.authgroup.save()
+
+        # group 4 - no leader
+        cls.group_4 = Group.objects.create(name='Group 4')
+        cls.group_4.authgroup.description = 'Open Group'
+        cls.group_4.authgroup.internal = False
+        cls.group_4.authgroup.hidden = False
+        cls.group_4.authgroup.open = True
+        cls.group_4.authgroup.save()
+
+        # group 5 - no leader
+        cls.group_5 = Group.objects.create(name='Group 5')
+        cls.group_5.authgroup.description = 'Public Group'
+        cls.group_5.authgroup.internal = False
+        cls.group_5.authgroup.hidden = False
+        cls.group_5.authgroup.public = True
+        cls.group_5.authgroup.save()
+
+        # group 6 - no leader
+        cls.group_6 = Group.objects.create(name='Group 6')
+        cls.group_6.authgroup.description = 'Mixed Group'
+        cls.group_6.authgroup.internal = False
+        cls.group_6.authgroup.hidden = True
+        cls.group_6.authgroup.open = True
+        cls.group_6.authgroup.public = True
+        cls.group_6.authgroup.save()
+        
+        # user 1 - corp and alliance, normal user
+        cls.character_1 = EveCharacter.objects.create(
+            character_id='1001',
+            character_name='Bruce Wayne',
+            corporation_id='2001',
+            corporation_name='Wayne Technologies',
+            corporation_ticker='WT',
+            alliance_id='3001',
+            alliance_name='Wayne Enterprises',
+            alliance_ticker='WE',
+        )
+        cls.character_1a = EveCharacter.objects.create(
+            character_id='1002',
+            character_name='Batman',
+            corporation_id='2001',
+            corporation_name='Wayne Technologies',
+            corporation_ticker='WT',
+            alliance_id='3001',
+            alliance_name='Wayne Enterprises',
+            alliance_ticker='WE',
+        )
+        alliance = EveAllianceInfo.objects.create(
+            alliance_id='3001',
+            alliance_name='Wayne Enterprises',
+            alliance_ticker='WE',            
+            executor_corp_id='2001'
+        )
+        EveCorporationInfo.objects.create(
+            corporation_id='2001',
+            corporation_name='Wayne Technologies',
+            corporation_ticker='WT',            
+            member_count=42,
+            alliance=alliance
+        )        
+        cls.user_1 = User.objects.create_user(
+            cls.character_1.character_name.replace(' ', '_'),
+            'abc@example.com',
+            'password'
+        )
+        CharacterOwnership.objects.create(
+            character=cls.character_1,
+            owner_hash='x1' + cls.character_1.character_name,
+            user=cls.user_1
+        )
+        CharacterOwnership.objects.create(
+            character=cls.character_1a,
+            owner_hash='x1' + cls.character_1a.character_name,
+            user=cls.user_1
+        )
+        cls.user_1.profile.main_character = cls.character_1
+        cls.user_1.profile.save()
+        cls.user_1.groups.add(cls.group_1)
+        cls.group_1.authgroup.group_leaders.add(cls.user_1)
+
+        # user 2 - corp only, staff
+        cls.character_2 = EveCharacter.objects.create(
+            character_id=1003,
+            character_name='Clark Kent',
+            corporation_id=2002,
+            corporation_name='Daily Planet',
+            corporation_ticker='DP',
+            alliance_id=None
+        )
+        EveCorporationInfo.objects.create(
+            corporation_id=2002,
+            corporation_name='Daily Plane',
+            corporation_ticker='DP',            
+            member_count=99,
+            alliance=None
+        )
+        cls.user_2 = User.objects.create_user(
+            cls.character_2.character_name.replace(' ', '_'),
+            'abc@example.com',
+            'password'
+        )
+        CharacterOwnership.objects.create(
+            character=cls.character_2,
+            owner_hash='x1' + cls.character_2.character_name,
+            user=cls.user_2
+        )
+        cls.user_2.profile.main_character = cls.character_2
+        cls.user_2.profile.save()
+        cls.user_2.groups.add(cls.group_2)
+        cls.user_2.is_staff = True
+        cls.user_2.save()
+        
+        # user 3 - no main, no group, superuser
+        cls.character_3 = EveCharacter.objects.create(
+            character_id=1101,
+            character_name='Lex Luthor',
+            corporation_id=2101,
+            corporation_name='Lex Corp',
+            corporation_ticker='LC',
+            alliance_id=None
+        )
+        EveCorporationInfo.objects.create(
+            corporation_id=2101,
+            corporation_name='Lex Corp',
+            corporation_ticker='LC',            
+            member_count=666,
+            alliance=None
+        )
+        EveAllianceInfo.objects.create(
+            alliance_id='3101',
+            alliance_name='Lex World Domination',
+            alliance_ticker='LWD',
+            executor_corp_id=''
+        )
+        cls.user_3 = User.objects.create_user(
+            cls.character_3.character_name.replace(' ', '_'),
+            'abc@example.com',
+            'password'
+        )
+        CharacterOwnership.objects.create(
+            character=cls.character_3,
+            owner_hash='x1' + cls.character_3.character_name,
+            user=cls.user_3
+        )
+        cls.user_3.is_superuser = True
+        cls.user_3.save()
+        cls.user_3.groups.add(cls.group_3)
+        cls.group_3.authgroup.group_leaders.add(cls.user_3)
+
+    def setUp(self):
+        self.factory = RequestFactory()
+        self.modeladmin = GroupAdmin(
+            model=Group, admin_site=AdminSite()
+        )
+
+    def _create_autogroups(self):
+        """create autogroups for corps and alliances"""
+        autogroups_config = AutogroupsConfig(
+            corp_groups = True,
+            alliance_groups = True
+        )
+        autogroups_config.save()
+        for state in State.objects.all():
+            autogroups_config.states.add(state)        
+        autogroups_config.update_corp_group_membership(self.user_1)        
+    
+    # column rendering
+
+    def test_description(self):
+        expected = 'Default Group'
+        result = self.modeladmin._description(self.group_1)
+        self.assertEqual(result, expected)
+
+    def test_member_count(self):        
+        expected = 1
+        obj = self.modeladmin.get_queryset(MockRequest(user=self.user_1))\
+            .get(pk=self.group_1.pk)
+        result = self.modeladmin._member_count(obj)
+        self.assertEqual(result, expected)
+
+    def test_has_leader(self):        
+        result = self.modeladmin.has_leader(self.group_1)
+        self.assertTrue(result)
+
+    def test_properties_1(self):
+        expected = ['Default']
+        result = self.modeladmin._properties(self.group_1)
+        self.assertListEqual(result, expected)
+
+    def test_properties_2(self):
+        expected = ['Internal']
+        result = self.modeladmin._properties(self.group_2)
+        self.assertListEqual(result, expected)
+
+    def test_properties_3(self):
+        expected = ['Hidden']
+        result = self.modeladmin._properties(self.group_3)
+        self.assertListEqual(result, expected)
+
+    def test_properties_4(self):
+        expected = ['Open']
+        result = self.modeladmin._properties(self.group_4)
+        self.assertListEqual(result, expected)
+
+    def test_properties_5(self):
+        expected = ['Public']
+        result = self.modeladmin._properties(self.group_5)
+        self.assertListEqual(result, expected)
+
+    def test_properties_6(self):
+        expected = ['Hidden', 'Open', 'Public']
+        result = self.modeladmin._properties(self.group_6)
+        self.assertListEqual(result, expected)
+
+    @patch(MODULE_PATH + '._has_auto_groups', True)
+    def test_properties_6(self):
+        self._create_autogroups()
+        expected = ['Auto Group']
+        my_group = Group.objects\
+            .filter(managedcorpgroup__isnull=False)\
+            .first()
+        result = self.modeladmin._properties(my_group)
+        self.assertListEqual(result, expected)
+
+    # actions
+   
+    # filters
+    
+    @patch(MODULE_PATH + '._has_auto_groups', True)
+    def test_filter_is_auto_group(self):
+        
+        class GroupAdminTest(admin.ModelAdmin): 
+            list_filter = (IsAutoGroupFilter,)
+                
+        self._create_autogroups()        
+        my_modeladmin = GroupAdminTest(Group, AdminSite())
+
+        # Make sure the lookups are correct
+        request = self.factory.get('/')
+        request.user = self.user_1
+        changelist = my_modeladmin.get_changelist_instance(request)
+        filters = changelist.get_filters(request)
+        filterspec = filters[0][0]
+        expected = [
+            ('yes', 'Yes'),
+            ('no', 'No'),
+        ]
+        self.assertEqual(filterspec.lookup_choices, expected)
+
+        # Make sure the correct queryset is returned - no
+        request = self.factory.get(
+            '/', {'is_auto_group__exact': 'no'}
+        )
+        request.user = self.user_1
+        changelist = my_modeladmin.get_changelist_instance(request)
+        queryset = changelist.get_queryset(request)
+        expected = [
+            self.group_1,
+            self.group_2,
+            self.group_3,
+            self.group_4,
+            self.group_5,
+            self.group_6
+        ]
+        self.assertSetEqual(set(queryset), set(expected))
+
+        # Make sure the correct queryset is returned - yes
+        request = self.factory.get(
+            '/', {'is_auto_group__exact': 'yes'}
+        )
+        request.user = self.user_1
+        changelist = my_modeladmin.get_changelist_instance(request)
+        queryset = changelist.get_queryset(request)
+        expected = Group.objects.exclude(
+                    managedalliancegroup__isnull=True, 
+                    managedcorpgroup__isnull=True
+        )
+        self.assertSetEqual(set(queryset), set(expected))
+         
+    def test_filter_has_leader(self):
+        
+        class GroupAdminTest(admin.ModelAdmin): 
+            list_filter = (HasLeaderFilter,)
+                
+        self._create_autogroups()        
+        my_modeladmin = GroupAdminTest(Group, AdminSite())
+
+        # Make sure the lookups are correct
+        request = self.factory.get('/')
+        request.user = self.user_1
+        changelist = my_modeladmin.get_changelist_instance(request)
+        filters = changelist.get_filters(request)
+        filterspec = filters[0][0]
+        expected = [
+            ('yes', 'Yes'),
+            ('no', 'No'),
+        ]
+        self.assertEqual(filterspec.lookup_choices, expected)
+
+        # Make sure the correct queryset is returned - no
+        request = self.factory.get(
+            '/', {'has_leader__exact': 'no'}
+        )
+        request.user = self.user_1
+        changelist = my_modeladmin.get_changelist_instance(request)
+        queryset = changelist.get_queryset(request)
+        expected = Group.objects.exclude(pk__in=[
+            self.group_1.pk, self.group_3.pk
+        ])
+        self.assertSetEqual(set(queryset), set(expected))
+
+        # Make sure the correct queryset is returned - yes
+        request = self.factory.get(
+            '/', {'has_leader__exact': 'yes'}
+        )
+        request.user = self.user_1
+        changelist = my_modeladmin.get_changelist_instance(request)
+        queryset = changelist.get_queryset(request)
+        expected = [
+            self.group_1,            
+            self.group_3
+        ]
+        self.assertSetEqual(set(queryset), set(expected))
+