Version bump.

Enable django-esi 2.0 dependency

See merge request allianceauth/allianceauth!1232

allianceauth/__init__.py

@@ -1,7 +1,7 @@
 # This will make sure the app is always imported when
 # Django starts so that shared_task will use this app.
 
-__version__ = '2.7.1'
+__version__ = '2.7.3'
 __title__ = 'Alliance Auth'
 __url__ = 'https://gitlab.com/allianceauth/allianceauth'
 NAME = '%s v%s' % (__title__, __version__)

allianceauth/authentication/backends.py

@@ -1,7 +1,8 @@
-from django.contrib.auth.backends import ModelBackend
-from django.contrib.auth.models import Permission
-from django.contrib.auth.models import User
 import logging
+
+from django.contrib.auth.backends import ModelBackend
+from django.contrib.auth.models import User, Permission
+
 from .models import UserProfile, CharacterOwnership, OwnershipRecord
 
 
@@ -11,9 +12,11 @@ logger = logging.getLogger(__name__)
 class StateBackend(ModelBackend):
     @staticmethod
     def _get_state_permissions(user_obj):
-        profile_state_field = UserProfile._meta.get_field('state')
-        user_state_query = 'state__%s__user' % profile_state_field.related_query_name()
-        return Permission.objects.filter(**{user_state_query: user_obj})
+        """returns permissions for state of given user object"""        
+        if hasattr(user_obj, "profile") and user_obj.profile:
+            return Permission.objects.filter(state=user_obj.profile.state)            
+        else:
+            return Permission.objects.none()
 
     def get_state_permissions(self, user_obj, obj=None):
         return self._get_permissions(user_obj, obj, 'state')

allianceauth/authentication/models.py

@@ -73,11 +73,17 @@ class UserProfile(models.Model):
             if commit:
                 logger.info('Updating {} state to {}'.format(self.user, self.state))
                 self.save(update_fields=['state'])
-                notify(self.user, _('State Changed'),
-                       _('Your user state has been changed to %(state)s') % ({'state': state}),
-                       'info')
+                notify(
+                    self.user, 
+                    _('State changed to: %s' % state),
+                    _('Your user\'s state is now: %(state)s')
+                    % ({'state': state}),
+                    'info'
+                )
                 from allianceauth.authentication.signals import state_changed
-                state_changed.send(sender=self.__class__, user=self.user, state=self.state)
+                state_changed.send(
+                    sender=self.__class__, user=self.user, state=self.state
+                )
 
     def __str__(self):
         return str(self.user)

allianceauth/authentication/signals.py

@@ -23,9 +23,7 @@ def trigger_state_check(state):
     check_states = State.objects.filter(priority__lt=state.priority)
     for profile in UserProfile.objects.filter(state__in=check_states):
         if state.available_to_user(profile.user):
-            profile.state = state
-            profile.save(update_fields=['state'])
-            state_changed.send(sender=state.__class__, user=profile.user, state=state)
+            profile.assign_state(state)
 
 
 @receiver(m2m_changed, sender=State.member_characters.through)

allianceauth/authentication/templates/authentication/dashboard.html

@@ -14,7 +14,11 @@
             <div class="col-sm-6 text-center">
                 <div class="panel panel-primary" style="height:100%">
                     <div class="panel-heading">
-                        <h3 class="panel-title">{% trans "Main Character" %}</h3>
+                        <h3 class="panel-title">
+                            {% blocktrans with state=request.user.profile.state %}
+                                Main Character (State: {{ state }})
+                            {% endblocktrans %}
+                        </h3>
                     </div>
                     <div class="panel-body">
                         {% if request.user.profile.main_character %}

allianceauth/authentication/tests/test_admin.py

@@ -69,33 +69,33 @@ class TestCaseWithTestData(TestCase):
 
         # user 1 - corp and alliance, normal user
         character_1 = EveCharacter.objects.create(
-            character_id='1001',
+            character_id=1001,
             character_name='Bruce Wayne',
-            corporation_id='2001',
+            corporation_id=2001,
             corporation_name='Wayne Technologies',
             corporation_ticker='WT',
-            alliance_id='3001',
+            alliance_id=3001,
             alliance_name='Wayne Enterprises',
             alliance_ticker='WE',
         )
         character_1a = EveCharacter.objects.create(
-            character_id='1002',
+            character_id=1002,
             character_name='Batman',
-            corporation_id='2001',
+            corporation_id=2001,
             corporation_name='Wayne Technologies',
             corporation_ticker='WT',
-            alliance_id='3001',
+            alliance_id=3001,
             alliance_name='Wayne Enterprises',
             alliance_ticker='WE',
         )
         alliance = EveAllianceInfo.objects.create(
-            alliance_id='3001',
+            alliance_id=3001,
             alliance_name='Wayne Enterprises',
             alliance_ticker='WE',            
-            executor_corp_id='2001'
+            executor_corp_id=2001
         )
         EveCorporationInfo.objects.create(
-            corporation_id='2001',
+            corporation_id=2001,
             corporation_name='Wayne Technologies',
             corporation_ticker='WT',            
             member_count=42,
@@ -169,10 +169,10 @@ class TestCaseWithTestData(TestCase):
             alliance=None
         )
         EveAllianceInfo.objects.create(
-            alliance_id='3101',
+            alliance_id=3101,
             alliance_name='Lex World Domination',
             alliance_ticker='LWD',
-            executor_corp_id=''
+            executor_corp_id=2101
         )
         cls.user_3 = User.objects.create_user(
             character_3.character_name.replace(' ', '_'),
@@ -510,8 +510,8 @@ class TestUserAdmin(TestCaseWithTestData):
         filters = changelist.get_filters(request)
         filterspec = filters[0][0]
         expected = [            
-            ('2002', 'Daily Planet'),
-            ('2001', 'Wayne Technologies'),
+            (2002, 'Daily Planet'),
+            (2001, 'Wayne Technologies'),
         ]
         self.assertEqual(filterspec.lookup_choices, expected)
 
@@ -540,7 +540,7 @@ class TestUserAdmin(TestCaseWithTestData):
         filters = changelist.get_filters(request)
         filterspec = filters[0][0]
         expected = [            
-            ('3001', 'Wayne Enterprises'),            
+            (3001, 'Wayne Enterprises'),            
         ]
         self.assertEqual(filterspec.lookup_choices, expected)
 

allianceauth/authentication/tests/test_backend.py

@@ -0,0 +1,149 @@
+from django.contrib.auth.models import User, Group
+from django.test import TestCase
+
+from allianceauth.eveonline.models import EveCharacter
+from allianceauth.tests.auth_utils import AuthUtils
+
+from esi.models import Token
+
+from ..backends import StateBackend
+from ..models import CharacterOwnership, UserProfile, OwnershipRecord
+
+MODULE_PATH = 'allianceauth.authentication'
+
+PERMISSION_1 = "authentication.add_user"
+PERMISSION_2 = "authentication.change_user"
+
+
+class TestStatePermissions(TestCase):
+
+    def setUp(self):
+        # permissions
+        self.permission_1 = AuthUtils.get_permission_by_name(PERMISSION_1)
+        self.permission_2 = AuthUtils.get_permission_by_name(PERMISSION_2)
+
+        # group
+        self.group_1 = Group.objects.create(name="Group 1")        
+        self.group_2 = Group.objects.create(name="Group 2")
+
+        # state
+        self.state_1 = AuthUtils.get_member_state()        
+        self.state_2 = AuthUtils.create_state("Other State", 75)
+        
+        # user
+        self.user = AuthUtils.create_user("Bruce Wayne")
+        self.main = AuthUtils.add_main_character_2(self.user, self.user.username, 123)
+
+    def test_user_has_user_permissions(self):
+        self.user.user_permissions.add(self.permission_1)
+        
+        user = User.objects.get(pk=self.user.pk)
+        self.assertTrue(user.has_perm(PERMISSION_1))
+
+    def test_user_has_group_permissions(self):        
+        self.group_1.permissions.add(self.permission_1)
+        self.user.groups.add(self.group_1)
+        
+        user = User.objects.get(pk=self.user.pk)
+        self.assertTrue(user.has_perm(PERMISSION_1))
+
+    def test_user_has_state_permissions(self):
+        self.state_1.permissions.add(self.permission_1)
+        self.state_1.member_characters.add(self.main)
+        user = User.objects.get(pk=self.user.pk)
+
+        self.assertTrue(user.has_perm(PERMISSION_1))
+
+    def test_when_user_changes_state_perms_change_accordingly(self):
+        self.state_1.permissions.add(self.permission_1)        
+        self.state_1.member_characters.add(self.main)
+        user = User.objects.get(pk=self.user.pk)
+        self.assertTrue(user.has_perm(PERMISSION_1))
+
+        self.state_2.permissions.add(self.permission_2)
+        self.state_2.member_characters.add(self.main)
+        self.state_1.member_characters.remove(self.main)
+        user = User.objects.get(pk=self.user.pk)
+        self.assertFalse(user.has_perm(PERMISSION_1))
+        self.assertTrue(user.has_perm(PERMISSION_2))
+
+    def test_state_permissions_are_returned_for_current_user_object(self):
+        # verify state permissions are returns for the current user object 
+        # and not for it's instance in the database, which might be outdated        
+        self.state_1.permissions.add(self.permission_1)
+        self.state_2.permissions.add(self.permission_2)        
+        self.state_1.member_characters.add(self.main)
+        user = User.objects.get(pk=self.user.pk)
+        user.profile.state = self.state_2
+        self.assertFalse(user.has_perm(PERMISSION_1))
+        self.assertTrue(user.has_perm(PERMISSION_2))
+    
+
+class TestAuthenticate(TestCase):
+    @classmethod
+    def setUpTestData(cls):
+        cls.main_character = EveCharacter.objects.create(
+            character_id=1,
+            character_name='Main Character',
+            corporation_id=1,
+            corporation_name='Corp',
+            corporation_ticker='CORP',
+        )
+        cls.alt_character = EveCharacter.objects.create(
+            character_id=2,
+            character_name='Alt Character',
+            corporation_id=1,
+            corporation_name='Corp',
+            corporation_ticker='CORP',
+        )
+        cls.unclaimed_character = EveCharacter.objects.create(
+            character_id=3,
+            character_name='Unclaimed Character',
+            corporation_id=1,
+            corporation_name='Corp',
+            corporation_ticker='CORP',
+        )
+        cls.user = AuthUtils.create_user('test_user', disconnect_signals=True)
+        cls.old_user = AuthUtils.create_user('old_user', disconnect_signals=True)
+        AuthUtils.disconnect_signals()
+        CharacterOwnership.objects.create(user=cls.user, character=cls.main_character, owner_hash='1')
+        CharacterOwnership.objects.create(user=cls.user, character=cls.alt_character, owner_hash='2')
+        UserProfile.objects.update_or_create(user=cls.user, defaults={'main_character': cls.main_character})
+        AuthUtils.connect_signals()
+
+    def test_authenticate_main_character(self):
+        t = Token(character_id=self.main_character.character_id, character_owner_hash='1')
+        user = StateBackend().authenticate(token=t)
+        self.assertEquals(user, self.user)
+
+    def test_authenticate_alt_character(self):
+        t = Token(character_id=self.alt_character.character_id, character_owner_hash='2')
+        user = StateBackend().authenticate(token=t)
+        self.assertEquals(user, self.user)
+
+    def test_authenticate_unclaimed_character(self):
+        t = Token(character_id=self.unclaimed_character.character_id, character_name=self.unclaimed_character.character_name, character_owner_hash='3')
+        user = StateBackend().authenticate(token=t)
+        self.assertNotEqual(user, self.user)
+        self.assertEqual(user.username, 'Unclaimed_Character')
+        self.assertEqual(user.profile.main_character, self.unclaimed_character)
+
+    def test_authenticate_character_record(self):
+        t = Token(character_id=self.unclaimed_character.character_id, character_name=self.unclaimed_character.character_name, character_owner_hash='4')
+        OwnershipRecord.objects.create(user=self.old_user, character=self.unclaimed_character, owner_hash='4')
+        user = StateBackend().authenticate(token=t)
+        self.assertEqual(user, self.old_user)
+        self.assertTrue(CharacterOwnership.objects.filter(owner_hash='4', user=self.old_user).exists())
+        self.assertTrue(user.profile.main_character)
+
+    def test_iterate_username(self):
+        t = Token(character_id=self.unclaimed_character.character_id,
+                  character_name=self.unclaimed_character.character_name, character_owner_hash='3')
+        username = StateBackend().authenticate(token=t).username
+        t.character_owner_hash = '4'
+        username_1 = StateBackend().authenticate(token=t).username
+        t.character_owner_hash = '5'
+        username_2 = StateBackend().authenticate(token=t).username
+        self.assertNotEqual(username, username_1, username_2)
+        self.assertTrue(username_1.endswith('_1'))
+        self.assertTrue(username_2.endswith('_2'))

allianceauth/authentication/tests/test_commands.py

@@ -0,0 +1,35 @@
+from io import StringIO
+
+from django.core.management import call_command
+from django.test import TestCase
+
+from allianceauth.tests.auth_utils import AuthUtils
+
+from ..models import CharacterOwnership, UserProfile
+
+
+class ManagementCommandTestCase(TestCase):
+    @classmethod
+    def setUpTestData(cls):
+        cls.user = AuthUtils.create_user('test user', disconnect_signals=True)
+        AuthUtils.add_main_character(cls.user, 'test character', '1', '2', 'test corp', 'test')
+        character = UserProfile.objects.get(user=cls.user).main_character
+        CharacterOwnership.objects.create(user=cls.user, character=character, owner_hash='test')
+
+    def setUp(self):
+        self.stdout = StringIO()
+
+    def test_ownership(self):
+        call_command('checkmains', stdout=self.stdout)
+        self.assertFalse(UserProfile.objects.filter(main_character__isnull=True).count())
+        self.assertNotIn(self.user.username, self.stdout.getvalue())
+        self.assertIn('All main characters', self.stdout.getvalue())
+
+    def test_no_ownership(self):
+        user = AuthUtils.create_user('v1 user', disconnect_signals=True)
+        AuthUtils.add_main_character(user, 'v1 character', '10', '20', 'test corp', 'test')
+        self.assertFalse(UserProfile.objects.filter(main_character__isnull=True).count())
+
+        call_command('checkmains', stdout=self.stdout)
+        self.assertEqual(UserProfile.objects.filter(main_character__isnull=True).count(), 1)
+        self.assertIn(user.username, self.stdout.getvalue())

allianceauth/authentication/tests/test_decorators.py

@@ -0,0 +1,68 @@
+from unittest import mock
+from urllib import parse
+
+from django.conf import settings
+from django.contrib.auth.models import AnonymousUser
+from django.http.response import HttpResponse
+from django.shortcuts import reverse
+from django.test import TestCase
+from django.test.client import RequestFactory
+
+from allianceauth.eveonline.models import EveCharacter
+from allianceauth.tests.auth_utils import AuthUtils
+
+from ..decorators import main_character_required
+from ..models import CharacterOwnership
+
+
+MODULE_PATH = 'allianceauth.authentication'
+
+
+class DecoratorTestCase(TestCase):
+    @staticmethod
+    @main_character_required
+    def dummy_view(*args, **kwargs):
+        return HttpResponse(status=200)
+
+    @classmethod
+    def setUpTestData(cls):
+        cls.main_user = AuthUtils.create_user('main_user', disconnect_signals=True)
+        cls.no_main_user = AuthUtils.create_user(
+            'no_main_user', disconnect_signals=True
+        )
+        main_character = EveCharacter.objects.create(
+            character_id=1,
+            character_name='Main Character',
+            corporation_id=1,
+            corporation_name='Corp',
+            corporation_ticker='CORP',
+        )
+        CharacterOwnership.objects.create(
+            user=cls.main_user, character=main_character, owner_hash='1'
+        )
+        cls.main_user.profile.main_character = main_character
+
+    def setUp(self):
+        self.request = RequestFactory().get('/test/')
+
+    @mock.patch(MODULE_PATH + '.decorators.messages')
+    def test_login_redirect(self, m):
+        setattr(self.request, 'user', AnonymousUser())
+        response = self.dummy_view(self.request)
+        self.assertEqual(response.status_code, 302)
+        url = getattr(response, 'url', None)
+        self.assertEqual(parse.urlparse(url).path, reverse(settings.LOGIN_URL))
+
+    @mock.patch(MODULE_PATH + '.decorators.messages')
+    def test_main_character_redirect(self, m):
+        setattr(self.request, 'user', self.no_main_user)
+        response = self.dummy_view(self.request)
+        self.assertEqual(response.status_code, 302)
+        url = getattr(response, 'url', None)
+        self.assertEqual(url, reverse('authentication:dashboard'))
+
+    @mock.patch(MODULE_PATH + '.decorators.messages')
+    def test_successful_request(self, m):
+        setattr(self.request, 'user', self.main_user)
+        response = self.dummy_view(self.request)
+        self.assertEqual(response.status_code, 200)

allianceauth/authentication/tests/test_models.py

@@ -1,147 +1,20 @@
 from unittest import mock
-from io import StringIO
-from urllib import parse
 
-from django.conf import settings
-from django.contrib.auth.models import AnonymousUser, User
-from django.core.management import call_command
-from django.http.response import HttpResponse
-from django.shortcuts import reverse
+from django.contrib.auth.models import User
 from django.test import TestCase
-from django.test.client import RequestFactory
 
-
-from allianceauth.authentication.decorators import main_character_required
 from allianceauth.eveonline.models import EveCharacter, EveCorporationInfo,\
     EveAllianceInfo
 from allianceauth.tests.auth_utils import AuthUtils
 from esi.errors import IncompleteResponseError
 from esi.models import Token
 
-from ..backends import StateBackend
-from ..models import CharacterOwnership, UserProfile, State, get_guest_state,\
-    OwnershipRecord
+from ..models import CharacterOwnership, State, get_guest_state
 from ..tasks import check_character_ownership
 
 MODULE_PATH = 'allianceauth.authentication'
 
 
-class DecoratorTestCase(TestCase):
-    @staticmethod
-    @main_character_required
-    def dummy_view(*args, **kwargs):
-        return HttpResponse(status=200)
-
-    @classmethod
-    def setUpTestData(cls):
-        cls.main_user = AuthUtils.create_user('main_user', disconnect_signals=True)
-        cls.no_main_user = AuthUtils.create_user('no_main_user', disconnect_signals=True)
-        main_character = EveCharacter.objects.create(
-            character_id=1,
-            character_name='Main Character',
-            corporation_id=1,
-            corporation_name='Corp',
-            corporation_ticker='CORP',
-        )
-        CharacterOwnership.objects.create(user=cls.main_user, character=main_character, owner_hash='1')
-        cls.main_user.profile.main_character = main_character
-
-    def setUp(self):
-        self.request = RequestFactory().get('/test/')
-
-    @mock.patch(MODULE_PATH + '.decorators.messages')
-    def test_login_redirect(self, m):
-        setattr(self.request, 'user', AnonymousUser())
-        response = self.dummy_view(self.request)
-        self.assertEqual(response.status_code, 302)
-        url = getattr(response, 'url', None)
-        self.assertEqual(parse.urlparse(url).path,  reverse(settings.LOGIN_URL))
-
-    @mock.patch(MODULE_PATH + '.decorators.messages')
-    def test_main_character_redirect(self, m):
-        setattr(self.request, 'user', self.no_main_user)
-        response = self.dummy_view(self.request)
-        self.assertEqual(response.status_code, 302)
-        url = getattr(response, 'url', None)
-        self.assertEqual(url, reverse('authentication:dashboard'))
-
-    @mock.patch(MODULE_PATH + '.decorators.messages')
-    def test_successful_request(self, m):
-        setattr(self.request, 'user', self.main_user)
-        response = self.dummy_view(self.request)
-        self.assertEqual(response.status_code, 200)
-
-
-class BackendTestCase(TestCase):
-    @classmethod
-    def setUpTestData(cls):
-        cls.main_character = EveCharacter.objects.create(
-            character_id=1,
-            character_name='Main Character',
-            corporation_id=1,
-            corporation_name='Corp',
-            corporation_ticker='CORP',
-        )
-        cls.alt_character = EveCharacter.objects.create(
-            character_id=2,
-            character_name='Alt Character',
-            corporation_id=1,
-            corporation_name='Corp',
-            corporation_ticker='CORP',
-        )
-        cls.unclaimed_character = EveCharacter.objects.create(
-            character_id=3,
-            character_name='Unclaimed Character',
-            corporation_id=1,
-            corporation_name='Corp',
-            corporation_ticker='CORP',
-        )
-        cls.user = AuthUtils.create_user('test_user', disconnect_signals=True)
-        cls.old_user = AuthUtils.create_user('old_user', disconnect_signals=True)
-        AuthUtils.disconnect_signals()
-        CharacterOwnership.objects.create(user=cls.user, character=cls.main_character, owner_hash='1')
-        CharacterOwnership.objects.create(user=cls.user, character=cls.alt_character, owner_hash='2')
-        UserProfile.objects.update_or_create(user=cls.user, defaults={'main_character': cls.main_character})
-        AuthUtils.connect_signals()
-
-    def test_authenticate_main_character(self):
-        t = Token(character_id=self.main_character.character_id, character_owner_hash='1')
-        user = StateBackend().authenticate(token=t)
-        self.assertEquals(user, self.user)
-
-    def test_authenticate_alt_character(self):
-        t = Token(character_id=self.alt_character.character_id, character_owner_hash='2')
-        user = StateBackend().authenticate(token=t)
-        self.assertEquals(user, self.user)
-
-    def test_authenticate_unclaimed_character(self):
-        t = Token(character_id=self.unclaimed_character.character_id, character_name=self.unclaimed_character.character_name, character_owner_hash='3')
-        user = StateBackend().authenticate(token=t)
-        self.assertNotEqual(user, self.user)
-        self.assertEqual(user.username, 'Unclaimed_Character')
-        self.assertEqual(user.profile.main_character, self.unclaimed_character)
-
-    def test_authenticate_character_record(self):
-        t = Token(character_id=self.unclaimed_character.character_id, character_name=self.unclaimed_character.character_name, character_owner_hash='4')
-        record = OwnershipRecord.objects.create(user=self.old_user, character=self.unclaimed_character, owner_hash='4')
-        user = StateBackend().authenticate(token=t)
-        self.assertEqual(user, self.old_user)
-        self.assertTrue(CharacterOwnership.objects.filter(owner_hash='4', user=self.old_user).exists())
-        self.assertTrue(user.profile.main_character)
-
-    def test_iterate_username(self):
-        t = Token(character_id=self.unclaimed_character.character_id,
-                  character_name=self.unclaimed_character.character_name, character_owner_hash='3')
-        username = StateBackend().authenticate(token=t).username
-        t.character_owner_hash = '4'
-        username_1 = StateBackend().authenticate(token=t).username
-        t.character_owner_hash = '5'
-        username_2 = StateBackend().authenticate(token=t).username
-        self.assertNotEqual(username, username_1, username_2)
-        self.assertTrue(username_1.endswith('_1'))
-        self.assertTrue(username_2.endswith('_2'))
-
-
 class CharacterOwnershipTestCase(TestCase):
     @classmethod
     def setUpTestData(cls):
@@ -343,10 +216,10 @@ class CharacterOwnershipCheckTestCase(TestCase):
         cls.user = AuthUtils.create_user('test_user', disconnect_signals=True)
         AuthUtils.add_main_character(cls.user, 'Test Character', '1', corp_id='1', alliance_id='1',
                                      corp_name='Test Corp', alliance_name='Test Alliance')
-        cls.character = EveCharacter.objects.get(character_id='1')
+        cls.character = EveCharacter.objects.get(character_id=1)
         cls.token = Token.objects.create(
             user=cls.user,
-            character_id='1',
+            character_id=1,
             character_name='Test',
             character_owner_hash='1',
         )
@@ -378,30 +251,3 @@ class CharacterOwnershipCheckTestCase(TestCase):
         filter.return_value.exists.return_value = False
         check_character_ownership(self.ownership)
         self.assertTrue(filter.return_value.delete.called)
-
-
-class ManagementCommandTestCase(TestCase):
-    @classmethod
-    def setUpTestData(cls):
-        cls.user = AuthUtils.create_user('test user', disconnect_signals=True)
-        AuthUtils.add_main_character(cls.user, 'test character', '1', '2', 'test corp', 'test')
-        character = UserProfile.objects.get(user=cls.user).main_character
-        CharacterOwnership.objects.create(user=cls.user, character=character, owner_hash='test')
-
-    def setUp(self):
-        self.stdout = StringIO()
-
-    def test_ownership(self):
-        call_command('checkmains', stdout=self.stdout)
-        self.assertFalse(UserProfile.objects.filter(main_character__isnull=True).count())
-        self.assertNotIn(self.user.username, self.stdout.getvalue())
-        self.assertIn('All main characters', self.stdout.getvalue())
-
-    def test_no_ownership(self):
-        user = AuthUtils.create_user('v1 user', disconnect_signals=True)
-        AuthUtils.add_main_character(user, 'v1 character', '10', '20', 'test corp', 'test')
-        self.assertFalse(UserProfile.objects.filter(main_character__isnull=True).count())
-
-        call_command('checkmains', stdout=self.stdout)
-        self.assertEqual(UserProfile.objects.filter(main_character__isnull=True).count(), 1)
-        self.assertIn(user.username, self.stdout.getvalue())

allianceauth/authentication/tests/test_templatetags.py

@@ -70,15 +70,16 @@ class TestStatusOverviewTag(TestCase):
             'notifications': GITHUB_NOTIFICATION_ISSUES[:5]
         }
         mock_current_notifications.return_value = notifications
-            
         version_info = {
             'latest_major': True,
             'latest_minor': True,
             'latest_patch': True,
+            'latest_beta': False,
             'current_version': TEST_VERSION,
-            'latest_major_version': '2.0.0',
+            'latest_major_version': '2.4.5',
             'latest_minor_version': '2.4.0',
             'latest_patch_version': '2.4.5',
+            'latest_beta_version': '2.4.4a1',
         }
         mock_current_version_info.return_value = version_info
         mock_fetch_celery_queue_length.return_value = 3
@@ -90,10 +91,12 @@ class TestStatusOverviewTag(TestCase):
             'latest_major': True,
             'latest_minor': True,
             'latest_patch': True,
+            'latest_beta': False,
             'current_version': TEST_VERSION,
-            'latest_major_version': '2.0.0',
+            'latest_major_version': '2.4.5',
             'latest_minor_version': '2.4.0',
             'latest_patch_version': '2.4.5',
+            'latest_beta_version': '2.4.4a1',
             'task_queue_length': 3,
         }
         self.assertEqual(result, expected)
@@ -146,6 +149,7 @@ class TestVersionTags(TestCase):
         self.assertEqual(result['latest_major_version'], '2.0.0')
         self.assertEqual(result['latest_minor_version'], '2.4.0')
         self.assertEqual(result['latest_patch_version'], '2.4.5')
+        self.assertEqual(result['latest_beta_version'], '2.4.6a1')
 
     @patch(MODULE_PATH + '.admin_status.__version__', TEST_VERSION)
     @patch(MODULE_PATH + '.admin_status.cache')
@@ -174,30 +178,33 @@ class TestLatestsVersion(TestCase):
         tags = create_tags_list(
             ['2.1.1', '2.1.0', '2.0.0', '2.1.1a1', '1.1.1', '1.1.0', '1.0.0']
         )
-        major, minor, patch = _latests_versions(tags)
+        major, minor, patch, beta = _latests_versions(tags)
         self.assertEqual(major, Pep440Version('2.0.0'))
         self.assertEqual(minor, Pep440Version('2.1.0'))
         self.assertEqual(patch, Pep440Version('2.1.1'))
+        self.assertEqual(beta, Pep440Version('2.1.1a1'))
 
     def test_major_and_minor_not_defined_with_zero(self):
         
         tags = create_tags_list(
             ['2.1.2', '2.1.1', '2.0.1', '2.1.1a1', '1.1.1', '1.1.0', '1.0.0']
         )
-        major, minor, patch = _latests_versions(tags)
+        major, minor, patch, beta = _latests_versions(tags)
         self.assertEqual(major, Pep440Version('2.0.1'))
         self.assertEqual(minor, Pep440Version('2.1.1'))
         self.assertEqual(patch, Pep440Version('2.1.2'))
+        self.assertEqual(beta, Pep440Version('2.1.1a1'))
         
     def test_can_ignore_invalid_versions(self):
         
         tags = create_tags_list(
             ['2.1.1', '2.1.0', '2.0.0', '2.1.1a1', 'invalid']
         )
-        major, minor, patch = _latests_versions(tags)
+        major, minor, patch, beta = _latests_versions(tags)
         self.assertEqual(major, Pep440Version('2.0.0'))
         self.assertEqual(minor, Pep440Version('2.1.0'))
         self.assertEqual(patch, Pep440Version('2.1.1'))
+        self.assertEqual(beta, Pep440Version('2.1.1a1'))
 
 
 class TestFetchListFromGitlab(TestCase):

allianceauth/corputils/auth_hooks.py

@@ -8,7 +8,7 @@ class CorpStats(MenuItemHook):
     def __init__(self):
         MenuItemHook.__init__(self,
                               _('Corporation Stats'),
-                              'fa fa-share-alt fa-fw',
+                              'fas fa-share-alt fa-fw',
                               'corputils:view',
                               navactive=['corputils:'])
 

allianceauth/corputils/tests.py

@@ -17,9 +17,9 @@ class CorpStatsManagerTestCase(TestCase):
         cls.user = AuthUtils.create_user('test')
         AuthUtils.add_main_character(cls.user, 'test character', '1', corp_id='2', corp_name='test_corp', corp_ticker='TEST', alliance_id='3', alliance_name='TEST')
         cls.user.profile.refresh_from_db()
-        cls.alliance = EveAllianceInfo.objects.create(alliance_id='3', alliance_name='test alliance', alliance_ticker='TEST', executor_corp_id='2')
-        cls.corp = EveCorporationInfo.objects.create(corporation_id='2', corporation_name='test corp', corporation_ticker='TEST', alliance=cls.alliance, member_count=1)
-        cls.token = Token.objects.create(user=cls.user, access_token='a', character_id='1', character_name='test character', character_owner_hash='z')
+        cls.alliance = EveAllianceInfo.objects.create(alliance_id=3, alliance_name='test alliance', alliance_ticker='TEST', executor_corp_id=2)
+        cls.corp = EveCorporationInfo.objects.create(corporation_id=2, corporation_name='test corp', corporation_ticker='TEST', alliance=cls.alliance, member_count=1)
+        cls.token = Token.objects.create(user=cls.user, access_token='a', character_id=1, character_name='test character', character_owner_hash='z')
         cls.corpstats = CorpStats.objects.create(corp=cls.corp, token=cls.token)
         cls.view_corp_permission = Permission.objects.get_by_natural_key('view_corp_corpstats', 'corputils', 'corpstats')
         cls.view_alliance_permission = Permission.objects.get_by_natural_key('view_alliance_corpstats', 'corputils', 'corpstats')
@@ -66,9 +66,9 @@ class CorpStatsUpdateTestCase(TestCase):
     @classmethod
     def setUpTestData(cls):
         cls.user = AuthUtils.create_user('test')
-        AuthUtils.add_main_character(cls.user, 'test character', '1', corp_id='2', corp_name='test_corp', corp_ticker='TEST', alliance_id='3', alliance_name='TEST')
-        cls.token = Token.objects.create(user=cls.user, access_token='a', character_id='1', character_name='test character', character_owner_hash='z')
-        cls.corp = EveCorporationInfo.objects.create(corporation_id='2', corporation_name='test corp', corporation_ticker='TEST', member_count=1)
+        AuthUtils.add_main_character(cls.user, 'test character', '1', corp_id=2, corp_name='test_corp', corp_ticker='TEST', alliance_id=3, alliance_name='TEST')
+        cls.token = Token.objects.create(user=cls.user, access_token='a', character_id=1, character_name='test character', character_owner_hash='z')
+        cls.corp = EveCorporationInfo.objects.create(corporation_id=2, corporation_name='test corp', corporation_ticker='TEST', member_count=1)
 
     def setUp(self):
         self.corpstats = CorpStats.objects.get_or_create(token=self.token, corp=self.corp)[0]
@@ -88,11 +88,11 @@ class CorpStatsUpdateTestCase(TestCase):
         SwaggerClient.from_spec.return_value.Corporation.get_corporations_corporation_id_members.return_value.result.return_value = [1]
         SwaggerClient.from_spec.return_value.Universe.post_universe_names.return_value.result.return_value = [{'id': 1, 'name': 'test character'}]
         self.corpstats.update()
-        self.assertTrue(CorpMember.objects.filter(character_id='1', character_name='test character', corpstats=self.corpstats).exists())
+        self.assertTrue(CorpMember.objects.filter(character_id=1, character_name='test character', corpstats=self.corpstats).exists())
 
     @mock.patch('esi.clients.SwaggerClient')
     def test_update_remove_member(self, SwaggerClient):
-        CorpMember.objects.create(character_id='2', character_name='old test character', corpstats=self.corpstats)
+        CorpMember.objects.create(character_id=2, character_name='old test character', corpstats=self.corpstats)
         SwaggerClient.from_spec.return_value.Character.get_characters_character_id.return_value.result.return_value = {'corporation_id': 2}
         SwaggerClient.from_spec.return_value.Corporation.get_corporations_corporation_id_members.return_value.result.return_value = [1]
         SwaggerClient.from_spec.return_value.Universe.post_universe_names.return_value.result.return_value = [{'id': 1, 'name': 'test character'}]
@@ -130,15 +130,15 @@ class CorpStatsPropertiesTestCase(TestCase):
     @classmethod
     def setUpTestData(cls):
         cls.user = AuthUtils.create_user('test')
-        AuthUtils.add_main_character(cls.user, 'test character', '1', corp_id='2', corp_name='test_corp', corp_ticker='TEST', alliance_id='3', alliance_name='TEST')
+        AuthUtils.add_main_character(cls.user, 'test character', '1', corp_id=2, corp_name='test_corp', corp_ticker='TEST', alliance_id=3, alliance_name='TEST')
         cls.user.profile.refresh_from_db()
-        cls.token = Token.objects.create(user=cls.user, access_token='a', character_id='1', character_name='test character', character_owner_hash='z')
-        cls.corp = EveCorporationInfo.objects.create(corporation_id='2', corporation_name='test corp', corporation_ticker='TEST', member_count=1)
+        cls.token = Token.objects.create(user=cls.user, access_token='a', character_id=1, character_name='test character', character_owner_hash='z')
+        cls.corp = EveCorporationInfo.objects.create(corporation_id=2, corporation_name='test corp', corporation_ticker='TEST', member_count=1)
         cls.corpstats = CorpStats.objects.create(token=cls.token, corp=cls.corp)
-        cls.character = EveCharacter.objects.create(character_name='another test character', character_id='4', corporation_id='2', corporation_name='test corp', corporation_ticker='TEST')
+        cls.character = EveCharacter.objects.create(character_name='another test character', character_id=4, corporation_id=2, corporation_name='test corp', corporation_ticker='TEST')
 
     def test_member_count(self):
-        member = CorpMember.objects.create(corpstats=self.corpstats, character_id='1', character_name='test character')
+        member = CorpMember.objects.create(corpstats=self.corpstats, character_id=2, character_name='test character')
         self.assertEqual(self.corpstats.member_count, 1)
         member.delete()
         self.assertEqual(self.corpstats.member_count, 0)
@@ -147,7 +147,7 @@ class CorpStatsPropertiesTestCase(TestCase):
         AuthUtils.disconnect_signals()
         co = CharacterOwnership.objects.create(character=self.character, user=self.user, owner_hash='a')
         AuthUtils.connect_signals()
-        CorpMember.objects.create(corpstats=self.corpstats, character_id='4', character_name='test character')
+        CorpMember.objects.create(corpstats=self.corpstats, character_id=4, character_name='test character')
         self.assertEqual(self.corpstats.user_count, 1)
         co.delete()
         self.assertEqual(self.corpstats.user_count, 0)
@@ -156,7 +156,8 @@ class CorpStatsPropertiesTestCase(TestCase):
         AuthUtils.disconnect_signals()
         co = CharacterOwnership.objects.create(character=self.character, user=self.user, owner_hash='a')
         AuthUtils.connect_signals()
-        member = CorpMember.objects.create(corpstats=self.corpstats, character_id='4', character_name='test character')
+        member = CorpMember.objects.create(corpstats=self.corpstats, character_id=4, character_name='test character')
+        self.corpstats.refresh_from_db()
         self.assertIn(member, self.corpstats.registered_members)
         self.assertEqual(self.corpstats.registered_member_count, 1)
 
@@ -165,7 +166,7 @@ class CorpStatsPropertiesTestCase(TestCase):
         self.assertEqual(self.corpstats.registered_member_count, 0)
 
     def test_unregistered_members(self):
-        member = CorpMember.objects.create(corpstats=self.corpstats, character_id='4', character_name='test character')
+        member = CorpMember.objects.create(corpstats=self.corpstats, character_id=4, character_name='test character')
         self.corpstats.refresh_from_db()
         self.assertIn(member, self.corpstats.unregistered_members)
         self.assertEqual(self.corpstats.unregistered_member_count, 1)
@@ -178,13 +179,13 @@ class CorpStatsPropertiesTestCase(TestCase):
 
     def test_mains(self):
         # test when is a main
-        member = CorpMember.objects.create(corpstats=self.corpstats, character_id='1', character_name='test character')
+        member = CorpMember.objects.create(corpstats=self.corpstats, character_id=1, character_name='test character')
         self.assertIn(member, self.corpstats.mains)
         self.assertEqual(self.corpstats.main_count, 1)
 
         # test when is an alt
         old_main = self.user.profile.main_character
-        character = EveCharacter.objects.create(character_name='other character', character_id=10, corporation_name='test corp', corporation_id='2', corporation_ticker='TEST')
+        character = EveCharacter.objects.create(character_name='other character', character_id=10, corporation_name='test corp', corporation_id=2, corporation_ticker='TEST')
         AuthUtils.disconnect_signals()
         co = CharacterOwnership.objects.create(character=character, user=self.user, owner_hash='b')
         self.user.profile.main_character = character
@@ -208,7 +209,7 @@ class CorpStatsPropertiesTestCase(TestCase):
         self.assertEqual(self.corpstats.corp_logo(size=128), 'https://images.evetech.net/corporations/2/logo?size=128')
         self.assertEqual(self.corpstats.alliance_logo(size=128), 'https://images.evetech.net/alliances/1/logo?size=128')
 
-        alliance = EveAllianceInfo.objects.create(alliance_name='test alliance', alliance_id='3', alliance_ticker='TEST', executor_corp_id='2')
+        alliance = EveAllianceInfo.objects.create(alliance_name='test alliance', alliance_id=3, alliance_ticker='TEST', executor_corp_id=2)
         self.corp.alliance = alliance
         self.corp.save()
         self.assertEqual(self.corpstats.alliance_logo(size=128), 'https://images.evetech.net/alliances/3/logo?size=128')
@@ -221,14 +222,14 @@ class CorpMemberTestCase(TestCase):
         cls.user = AuthUtils.create_user('test')
         AuthUtils.add_main_character(cls.user, 'test character', '1', corp_id='2', corp_name='test_corp', corp_ticker='TEST', alliance_id='3', alliance_name='TEST')
         cls.user.profile.refresh_from_db()
-        cls.token = Token.objects.create(user=cls.user, access_token='a', character_id='1', character_name='test character', character_owner_hash='a')
-        cls.corp = EveCorporationInfo.objects.create(corporation_id='2', corporation_name='test corp', corporation_ticker='TEST', member_count=1)
+        cls.token = Token.objects.create(user=cls.user, access_token='a', character_id=1, character_name='test character', character_owner_hash='a')
+        cls.corp = EveCorporationInfo.objects.create(corporation_id=2, corporation_name='test corp', corporation_ticker='TEST', member_count=1)
         cls.corpstats = CorpStats.objects.create(token=cls.token, corp=cls.corp)
-        cls.member = CorpMember.objects.create(corpstats=cls.corpstats, character_id='2', character_name='other test character')
+        cls.member = CorpMember.objects.create(corpstats=cls.corpstats, character_id=2, character_name='other test character')
 
     def test_character(self):
         self.assertIsNone(self.member.character)
-        character = EveCharacter.objects.create(character_id='2', character_name='other test character', corporation_id='2', corporation_name='test corp', corporation_ticker='TEST')
+        character = EveCharacter.objects.create(character_id=2, character_name='other test character', corporation_id=2, corporation_name='test corp', corporation_ticker='TEST')
         self.assertEqual(self.member.character, character)
 
     def test_main_character(self):
@@ -238,7 +239,7 @@ class CorpMemberTestCase(TestCase):
         self.assertIsNone(self.member.main_character)
 
         # test when member.character is not None but also not a main
-        character = EveCharacter.objects.create(character_id='2', character_name='other test character', corporation_id='2', corporation_name='test corp', corporation_ticker='TEST')
+        character = EveCharacter.objects.create(character_id=2, character_name='other test character', corporation_id=2, corporation_name='test corp', corporation_ticker='TEST')
         CharacterOwnership.objects.create(character=character, user=self.user, owner_hash='b')
         self.member.refresh_from_db()
         self.assertNotEqual(self.member.main_character, self.member.character)
@@ -260,14 +261,14 @@ class CorpMemberTestCase(TestCase):
     def test_alts(self):
         self.assertListEqual(self.member.alts, [])
 
-        character = EveCharacter.objects.create(character_id='2', character_name='other test character', corporation_id='2', corporation_name='test corp', corporation_ticker='TEST')
+        character = EveCharacter.objects.create(character_id=2, character_name='other test character', corporation_id=2, corporation_name='test corp', corporation_ticker='TEST')
         CharacterOwnership.objects.create(character=character, user=self.user, owner_hash='b')
         self.assertIn(character, self.member.alts)
 
     def test_registered(self):
         self.assertFalse(self.member.registered)
         AuthUtils.disconnect_signals()
-        character = EveCharacter.objects.create(character_id='2', character_name='other test character', corporation_id='2', corporation_name='test corp', corporation_ticker='TEST')
+        character = EveCharacter.objects.create(character_id=2, character_name='other test character', corporation_id=2, corporation_name='test corp', corporation_ticker='TEST')
         CharacterOwnership.objects.create(character=character, user=self.user, owner_hash='b')
         self.assertTrue(self.member.registered)
         AuthUtils.connect_signals()

allianceauth/eveonline/migrations/0011_ids_to_integers.py

@@ -0,0 +1,43 @@
+# Generated by Django 2.2.12 on 2020-05-25 02:28
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('eveonline', '0010_alliance_ticker'),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name='eveallianceinfo',
+            name='alliance_id',
+            field=models.PositiveIntegerField(unique=True),
+        ),
+        migrations.AlterField(
+            model_name='eveallianceinfo',
+            name='executor_corp_id',
+            field=models.PositiveIntegerField(),
+        ),
+        migrations.AlterField(
+            model_name='evecharacter',
+            name='alliance_id',
+            field=models.PositiveIntegerField(blank=True, default=None, null=True),
+        ),
+        migrations.AlterField(
+            model_name='evecharacter',
+            name='character_id',
+            field=models.PositiveIntegerField(unique=True),
+        ),
+        migrations.AlterField(
+            model_name='evecharacter',
+            name='corporation_id',
+            field=models.PositiveIntegerField(),
+        ),
+        migrations.AlterField(
+            model_name='evecorporationinfo',
+            name='corporation_id',
+            field=models.PositiveIntegerField(unique=True),
+        ),
+    ]

allianceauth/eveonline/migrations/0012_index_additions.py

@@ -0,0 +1,33 @@
+# Generated by Django 2.2.12 on 2020-05-26 02:09
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('eveonline', '0011_ids_to_integers'),
+    ]
+
+    operations = [
+        migrations.AddIndex(
+            model_name='eveallianceinfo',
+            index=models.Index(fields=['executor_corp_id'], name='eveonline_e_executo_7f3280_idx'),
+        ),
+        migrations.AddIndex(
+            model_name='evecharacter',
+            index=models.Index(fields=['corporation_id'], name='eveonline_e_corpora_cb4cd9_idx'),
+        ),
+        migrations.AddIndex(
+            model_name='evecharacter',
+            index=models.Index(fields=['alliance_id'], name='eveonline_e_allianc_39ee2a_idx'),
+        ),
+        migrations.AddIndex(
+            model_name='evecharacter',
+            index=models.Index(fields=['corporation_name'], name='eveonline_e_corpora_893c60_idx'),
+        ),
+        migrations.AddIndex(
+            model_name='evecharacter',
+            index=models.Index(fields=['alliance_name'], name='eveonline_e_allianc_63fd98_idx'),
+        ),
+    ]

allianceauth/eveonline/models.py

@@ -11,14 +11,17 @@ _DEFAULT_IMAGE_SIZE = 32
 
 
 class EveAllianceInfo(models.Model):
-    alliance_id = models.CharField(max_length=254, unique=True)
+    alliance_id = models.PositiveIntegerField(unique=True)
     alliance_name = models.CharField(max_length=254, unique=True)
     alliance_ticker = models.CharField(max_length=254)
-    executor_corp_id = models.CharField(max_length=254)
+    executor_corp_id = models.PositiveIntegerField()
 
     objects = EveAllianceManager()
     provider = EveAllianceProviderManager()
 
+    class Meta:
+        indexes = [models.Index(fields=['executor_corp_id',])]
+
     def populate_alliance(self):
         alliance = self.provider.get_alliance(self.alliance_id)
         for corp_id in alliance.corp_ids:
@@ -75,7 +78,7 @@ class EveAllianceInfo(models.Model):
 
 
 class EveCorporationInfo(models.Model):
-    corporation_id = models.CharField(max_length=254, unique=True)
+    corporation_id = models.PositiveIntegerField(unique=True)
     corporation_name = models.CharField(max_length=254, unique=True)
     corporation_ticker = models.CharField(max_length=254)
     member_count = models.IntegerField()
@@ -133,18 +136,26 @@ class EveCorporationInfo(models.Model):
 
 
 class EveCharacter(models.Model):
-    character_id = models.CharField(max_length=254, unique=True)
+    character_id = models.PositiveIntegerField(unique=True)
     character_name = models.CharField(max_length=254, unique=True)
-    corporation_id = models.CharField(max_length=254)
+    corporation_id = models.PositiveIntegerField()
     corporation_name = models.CharField(max_length=254)
     corporation_ticker = models.CharField(max_length=5)
-    alliance_id = models.CharField(max_length=254, blank=True, null=True, default='')
+    alliance_id = models.PositiveIntegerField(blank=True, null=True, default=None)
     alliance_name = models.CharField(max_length=254, blank=True, null=True, default='')
     alliance_ticker = models.CharField(max_length=5, blank=True, null=True, default='')
 
     objects = EveCharacterManager()
     provider = EveCharacterProviderManager()
 
+    class Meta:
+        indexes = [
+                    models.Index(fields=['corporation_id',]),
+                    models.Index(fields=['alliance_id',]),
+                    models.Index(fields=['corporation_name',]),
+                    models.Index(fields=['alliance_name',]),
+                  ]
+
     @property
     def alliance(self) -> Union[EveAllianceInfo, None]:
         """

allianceauth/eveonline/tests/test_managers.py

@@ -12,7 +12,7 @@ class EveCharacterProviderManagerTestCase(TestCase):
         expected = Character()
         provider.get_character.return_value = expected
 
-        result = EveCharacter.provider.get_character('1234')
+        result = EveCharacter.provider.get_character(1234)
 
         self.assertEqual(expected, result)
 
@@ -22,30 +22,30 @@ class EveCharacterManagerTestCase(TestCase):
     class TestCharacter(Character):
         @property
         def alliance(self):
-            return Alliance(id='3456', name='Test Alliance')
+            return Alliance(id=3456, name='Test Alliance')
 
         @property
         def corp(self):
             return Corporation(
-                id='2345', 
+                id=2345, 
                 name='Test Corp', 
-                alliance_id='3456', 
-                ticker='0BUGS'
+                alliance_id=3456, 
+                ticker='0BUGS' #lies, blatant lies!
             )
 
     @mock.patch('allianceauth.eveonline.managers.providers.provider')
     def test_create_character(self, provider):
         # Also covers create_character_obj
         expected = self.TestCharacter(
-            id='1234', 
+            id=1234, 
             name='Test Character', 
-            corp_id='2345', 
-            alliance_id='3456'
+            corp_id=2345, 
+            alliance_id=3456
         )
 
         provider.get_character.return_value = expected
 
-        result = EveCharacter.objects.create_character('1234')
+        result = EveCharacter.objects.create_character(1234)
 
         self.assertEqual(result.character_id, expected.id)
         self.assertEqual(result.character_name, expected.name)
@@ -58,22 +58,25 @@ class EveCharacterManagerTestCase(TestCase):
     @mock.patch('allianceauth.eveonline.managers.providers.provider')
     def test_update_character(self, provider):
         # Also covers Model.update_character
-        EveCharacter.objects.create(
-            character_id='1234',
+        existing = EveCharacter.objects.create(
+            character_id=1234,
             character_name='character.name',
-            corporation_id='character.corp.id',
+            corporation_id=23457,
             corporation_name='character.corp.name',
-            corporation_ticker='abc',
-            alliance_id='character.alliance.id',
+            corporation_ticker='cc1',
+            alliance_id=34567,
             alliance_name='character.alliance.name',
         )
 
         expected = self.TestCharacter(
-            id='1234', name='Test Character', corp_id='2345', alliance_id='3456'
+            id=1234, 
+            name='Test Character', 
+            corp_id=2345, 
+            alliance_id=3456
         )
         provider.get_character.return_value = expected
 
-        result = EveCharacter.objects.update_character('1234')
+        result = EveCharacter.objects.update_character(1234)
 
         self.assertEqual(result.character_id, expected.id)
         self.assertEqual(result.character_name, expected.name)
@@ -86,23 +89,23 @@ class EveCharacterManagerTestCase(TestCase):
     def test_get_character_by_id(self):
         EveCharacter.objects.all().delete()
         EveCharacter.objects.create(
-            character_id='1234',
+            character_id=1234,
             character_name='character.name',
-            corporation_id='character.corp.id',
+            corporation_id=2345,
             corporation_name='character.corp.name',
-            corporation_ticker='abc',
-            alliance_id='character.alliance.id',
+            corporation_ticker='cc1',
+            alliance_id=3456,
             alliance_name='character.alliance.name',
         )
 
         # try to get existing character
-        result = EveCharacter.objects.get_character_by_id('1234')
+        result = EveCharacter.objects.get_character_by_id(1234)
 
-        self.assertEqual(result.character_id, '1234')
+        self.assertEqual(result.character_id, 1234)
         self.assertEqual(result.character_name, 'character.name')
 
         # try to get non existing character        
-        self.assertIsNone(EveCharacter.objects.get_character_by_id('9999'))
+        self.assertIsNone(EveCharacter.objects.get_character_by_id(9999))
 
 
 class EveAllianceProviderManagerTestCase(TestCase):
@@ -111,7 +114,7 @@ class EveAllianceProviderManagerTestCase(TestCase):
         expected = Alliance()
         provider.get_alliance.return_value = expected
 
-        result = EveAllianceInfo.provider.get_alliance('1234')
+        result = EveAllianceInfo.provider.get_alliance(1234)
 
         self.assertEqual(expected, result)
 
@@ -127,16 +130,16 @@ class EveAllianceManagerTestCase(TestCase):
     def test_create_alliance(self, provider, populate_alliance):
         # Also covers create_alliance_obj
         expected = self.TestAlliance(
-            id='3456', 
+            id=3456, 
             name='Test Alliance', 
             ticker='TEST',
-            corp_ids=['2345'], 
-            executor_corp_id='2345'
+            corp_ids=[2345], 
+            executor_corp_id=2345
         )
 
         provider.get_alliance.return_value = expected
 
-        result = EveAllianceInfo.objects.create_alliance('3456')
+        result = EveAllianceInfo.objects.create_alliance(3456)
 
         self.assertEqual(result.alliance_id, expected.id)
         self.assertEqual(result.alliance_name, expected.name)
@@ -148,22 +151,22 @@ class EveAllianceManagerTestCase(TestCase):
     def test_update_alliance(self, provider):
         # Also covers Model.update_alliance
         EveAllianceInfo.objects.create(
-            alliance_id='3456',
+            alliance_id=3456,
             alliance_name='alliance.name',
-            alliance_ticker='alliance.ticker',
-            executor_corp_id='alliance.executor_corp_id',
+            alliance_ticker='at1',
+            executor_corp_id=2345,
         )
         expected = self.TestAlliance(
-            id='3456', 
+            id=3456, 
             name='Test Alliance', 
             ticker='TEST',
-            corp_ids=['2345'], 
-            executor_corp_id='2345'
+            corp_ids=[2345], 
+            executor_corp_id=2345
         )
 
         provider.get_alliance.return_value = expected
 
-        result = EveAllianceInfo.objects.update_alliance('3456')
+        result = EveAllianceInfo.objects.update_alliance(3456)
 
         # This is the only thing ever updated in code
         self.assertEqual(result.executor_corp_id, expected.executor_corp_id)
@@ -175,7 +178,7 @@ class EveCorporationProviderManagerTestCase(TestCase):
         expected = Corporation()
         provider.get_corp.return_value = expected
 
-        result = EveCorporationInfo.provider.get_corporation('2345')
+        result = EveCorporationInfo.provider.get_corporation(2345)
 
         self.assertEqual(expected, result)
 
@@ -186,39 +189,39 @@ class EveCorporationManagerTestCase(TestCase):
         @property
         def alliance(self):
             return EveAllianceManagerTestCase.TestAlliance(
-                id='3456', 
+                id=3456, 
                 name='Test Alliance', 
                 ticker='TEST',
-                corp_ids=['2345'], 
-                executor_corp_id='2345'
+                corp_ids=[2345], 
+                executor_corp_id=2345
             )
 
         @property
         def ceo(self):
             return EveCharacterManagerTestCase.TestCharacter(
-                id='1234', 
+                id=1234, 
                 name='Test Character',
-                corp_id='2345', 
-                alliance_id='3456'
+                corp_id=2345, 
+                alliance_id=3456
             )
 
     @mock.patch('allianceauth.eveonline.managers.providers.provider')
     def test_create_corporation(self, provider):
         # Also covers create_corp_obj
         exp_alliance = EveAllianceInfo.objects.create(
-            alliance_id='3456',
+            alliance_id=3456,
             alliance_name='alliance.name',
-            alliance_ticker='alliance.ticker',
-            executor_corp_id='alliance.executor_corp_id',
+            alliance_ticker='99bug',
+            executor_corp_id=2345,
         )
 
         expected = self.TestCorporation(
-            id='2345', 
+            id=2345, 
             name='Test Corp', 
             ticker='0BUGS',
-            ceo_id='1234', 
+            ceo_id=1234, 
             members=1, 
-            alliance_id='3456'
+            alliance_id=3456
         )
 
         provider.get_corp.return_value = expected
@@ -236,17 +239,17 @@ class EveCorporationManagerTestCase(TestCase):
         # variant to test no alliance case
         # Also covers create_corp_obj        
         expected = self.TestCorporation(
-            id='2345', 
+            id=2345, 
             name='Test Corp', 
             ticker='0BUGS',
-            ceo_id='1234', 
+            ceo_id=1234, 
             members=1, 
-            alliance_id='3456'
+            alliance_id=3456
         )
 
         provider.get_corp.return_value = expected
 
-        result = EveCorporationInfo.objects.create_corporation('2345')
+        result = EveCorporationInfo.objects.create_corporation(2345)
 
         self.assertEqual(result.corporation_id, expected.id)
         self.assertEqual(result.corporation_name, expected.name)
@@ -258,27 +261,27 @@ class EveCorporationManagerTestCase(TestCase):
     def test_update_corporation(self, provider):
         # Also covers Model.update_corporation
         exp_alliance = EveAllianceInfo.objects.create(
-            alliance_id='3456',
+            alliance_id=3456,
             alliance_name='alliance.name',
-            alliance_ticker='alliance.ticker',
-            executor_corp_id='alliance.executor_corp_id',
+            alliance_ticker='at1',
+            executor_corp_id=2345,
         )
 
         EveCorporationInfo.objects.create(
-            corporation_id='2345',
+            corporation_id=2345,
             corporation_name='corp.name',
-            corporation_ticker='abc',
+            corporation_ticker='cc1',
             member_count=10,
             alliance=None,
         )
 
         expected = self.TestCorporation(
-            id='2345', 
+            id=2345, 
             name='Test Corp', 
             ticker='0BUGS',
-            ceo_id='1234', 
+            ceo_id=1234, 
             members=1, 
-            alliance_id='3456'
+            alliance_id=3456
         )
 
         provider.get_corp.return_value = expected

allianceauth/eveonline/tests/test_models.py

@@ -15,27 +15,27 @@ class EveCharacterTestCase(TestCase):
         Test that the correct corporation is returned by the corporation property
         """
         character = EveCharacter.objects.create(
-            character_id='1234',
+            character_id=1234,
             character_name='character.name',
-            corporation_id='2345',
+            corporation_id=2345,
             corporation_name='character.corp.name',
-            corporation_ticker='abc',
-            alliance_id='character.alliance.id',
+            corporation_ticker='cc1',
+            alliance_id=12345,
             alliance_name='character.alliance.name',
         )
 
         expected = EveCorporationInfo.objects.create(
-            corporation_id='2345',
+            corporation_id=2345,
             corporation_name='corp.name',
-            corporation_ticker='abc',
+            corporation_ticker='cc1',
             member_count=10,
             alliance=None,
         )
 
         incorrect = EveCorporationInfo.objects.create(
-            corporation_id='9999',
+            corporation_id=9999,
             corporation_name='corp.name1',
-            corporation_ticker='abc1',
+            corporation_ticker='cc11',
             member_count=10,
             alliance=None,
         )
@@ -49,12 +49,12 @@ class EveCharacterTestCase(TestCase):
         object is not in the database
         """
         character = EveCharacter.objects.create(
-            character_id='1234',
+            character_id=1234,
             character_name='character.name',
-            corporation_id='2345',
+            corporation_id=2345,
             corporation_name='character.corp.name',
-            corporation_ticker='abc',
-            alliance_id='character.alliance.id',
+            corporation_ticker='cc1',
+            alliance_id=123456,
             alliance_name='character.alliance.name',
         )
 
@@ -66,27 +66,27 @@ class EveCharacterTestCase(TestCase):
         Test that the correct alliance is returned by the alliance property
         """
         character = EveCharacter.objects.create(
-            character_id='1234',
+            character_id=1234,
             character_name='character.name',
-            corporation_id='2345',
+            corporation_id=2345,
             corporation_name='character.corp.name',
-            corporation_ticker='abc',
-            alliance_id='3456',
+            corporation_ticker='cc1',
+            alliance_id=3456,
             alliance_name='character.alliance.name',
         )
 
         expected = EveAllianceInfo.objects.create(
-            alliance_id='3456',
+            alliance_id=3456,
             alliance_name='alliance.name',
-            alliance_ticker='alliance.ticker',
-            executor_corp_id='alliance.executor_corp_id',
+            alliance_ticker='ac2',
+            executor_corp_id=2345,
         )
 
         incorrect = EveAllianceInfo.objects.create(
-            alliance_id='9001',
+            alliance_id=9001,
             alliance_name='alliance.name1',
-            alliance_ticker='alliance.ticker1',
-            executor_corp_id='alliance.executor_corp_id1',
+            alliance_ticker='ac1',
+            executor_corp_id=2654,
         )
 
         self.assertEqual(character.alliance, expected)
@@ -98,12 +98,12 @@ class EveCharacterTestCase(TestCase):
         object is not in the database
         """
         character = EveCharacter.objects.create(
-            character_id='1234',
+            character_id=1234,
             character_name='character.name',
-            corporation_id='2345',
+            corporation_id=2345,
             corporation_name='character.corp.name',
-            corporation_ticker='abc',
-            alliance_id='3456',
+            corporation_ticker='cc1',
+            alliance_id=3456,
             alliance_name='character.alliance.name',
         )
 
@@ -115,11 +115,11 @@ class EveCharacterTestCase(TestCase):
         Check that None is returned when the character has no alliance
         """
         character = EveCharacter.objects.create(
-            character_id='1234',
+            character_id=1234,
             character_name='character.name',
-            corporation_id='2345',
+            corporation_id=2345,
             corporation_name='character.corp.name',
-            corporation_ticker='abc',
+            corporation_ticker='cc1',
             alliance_id=None,
             alliance_name=None,
         )
@@ -137,12 +137,12 @@ class EveCharacterTestCase(TestCase):
         )
         
         my_character = EveCharacter.objects.create(
-            character_id='1001',
+            character_id=1001,
             character_name='Bruce Wayne',
-            corporation_id='2001',
+            corporation_id=2001,
             corporation_name='Dummy Corp 1',
             corporation_ticker='DC1',
-            alliance_id='3001',
+            alliance_id=3001,
             alliance_name='Dummy Alliance 1',
         )        
         my_updated_character = Character(
@@ -166,9 +166,9 @@ class EveCharacterTestCase(TestCase):
 
     def test_portrait_urls(self):
         x = EveCharacter(
-            character_id='42',
+            character_id=42,
             character_name='character.name',
-            corporation_id='123',
+            corporation_id=123,
             corporation_name='corporation.name',            
             corporation_ticker='ABC',            
         )
@@ -199,9 +199,9 @@ class EveCharacterTestCase(TestCase):
 
     def test_corporation_logo_urls(self):
         x = EveCharacter(
-            character_id='42',
+            character_id=42,
             character_name='character.name',
-            corporation_id='123',
+            corporation_id=123,
             corporation_name='corporation.name',            
             corporation_ticker='ABC',            
         )
@@ -232,9 +232,9 @@ class EveCharacterTestCase(TestCase):
 
     def test_alliance_logo_urls(self):
         x = EveCharacter(
-            character_id='42',
+            character_id=42,
             character_name='character.name',
-            corporation_id='123',
+            corporation_id=123,
             corporation_name='corporation.name',            
             corporation_ticker='ABC',            
         )        
@@ -405,10 +405,10 @@ class EveAllianceTestCase(TestCase):
 
     def test_logo_url(self):
         x = EveAllianceInfo(
-            alliance_id='42',
+            alliance_id=42,
             alliance_name='alliance.name',
             alliance_ticker='ABC',
-            executor_corp_id='123'
+            executor_corp_id=123
         )
         self.assertEqual(
             x.logo_url(),

allianceauth/eveonline/tests/test_tasks.py

@@ -58,25 +58,25 @@ class TestTasks(TestCase):
         EveCharacter.objects.all().delete()
 
         EveCorporationInfo.objects.create(
-            corporation_id='2345',
+            corporation_id=2345,
             corporation_name='corp.name',
             corporation_ticker='corp.ticker',
             member_count=10,
             alliance=None,
         )
         EveAllianceInfo.objects.create(
-            alliance_id='3456',
+            alliance_id=3456,
             alliance_name='alliance.name',
             alliance_ticker='alliance.ticker',
-            executor_corp_id='alliance.executor_corp_id',
+            executor_corp_id='78910',
         )
         EveCharacter.objects.create(
-            character_id='1234',
+            character_id=1234,
             character_name='character.name',
-            corporation_id='character.corp.id',
+            corporation_id=2345,
             corporation_name='character.corp.name',
             corporation_ticker='c.c.t',  # max 5 chars 
-            alliance_id='character.alliance.id',
+            alliance_id=3456,
             alliance_name='character.alliance.name',
         )
 

allianceauth/fleetactivitytracking/auth_hooks.py

@@ -6,7 +6,7 @@ from allianceauth.services.hooks import MenuItemHook, UrlHook
 
 @hooks.register('menu_item_hook')
 def register_menu():
-    return MenuItemHook(_('Fleet Activity Tracking'), 'fa fa-users fa-lightbulb-o fa-fw', 'fatlink:view',
+    return MenuItemHook(_('Fleet Activity Tracking'), 'fas fa-users fa-fw', 'fatlink:view',
                         navactive=['fatlink:'])
 
 

allianceauth/groupmanagement/context_processors.py

@@ -1,5 +0,0 @@
-from allianceauth.groupmanagement.managers import GroupManager
-
-
-def can_manage_groups(request):
-    return {'can_manage_groups': GroupManager.can_manage_groups(request.user)}

allianceauth/groupmanagement/templates/groupmanagement/groupmembers.html

@@ -36,7 +36,7 @@
                                     <tr>                                                                
                                         <td class="text-right">
                                             {% if member.is_leader %}
-                                                <i class="fa fa-star"></i>&nbsp;
+                                                <i class="fas fa-star"></i>&nbsp;
                                             {% endif %}
                                             <img src="{{ member.main_char|character_portrait_url:32 }}" class="img-circle">                                            
                                         </td>
@@ -69,7 +69,7 @@
                                 {% endfor %}
                             </tbody>
                         </table>
-                        <p class="text-muted"><i class="fa fa-star"></i>: Group leader</p>
+                        <p class="text-muted"><i class="fas fa-star"></i>: Group leader</p>
                     </div>
                 {% else %}
                     <div class="alert alert-warning text-center">

allianceauth/groupmanagement/templatetags/groupmanagement.py

@@ -0,0 +1,15 @@
+from django import template
+from django.contrib.auth.models import User
+
+from allianceauth.groupmanagement.managers import GroupManager
+
+
+register = template.Library()
+
+
+@register.filter
+def can_manage_groups(user: User) -> bool:
+    """returns True if the given user can manage groups. Returns False otherwise."""
+    if not isinstance(user, User):
+        return False
+    return GroupManager.can_manage_groups(user)

allianceauth/groupmanagement/tests/test_admin.py

@@ -11,11 +11,7 @@ from allianceauth.eveonline.models import (
     EveCharacter, EveCorporationInfo, EveAllianceInfo
 )
 
-from ..admin import (   
-   HasLeaderFilter,
-   GroupAdmin,   
-   Group
-)
+from ..admin import HasLeaderFilter, GroupAdmin, Group
 from . import get_admin_change_view_url
 
 if 'allianceauth.eveonline.autogroups' in settings.INSTALLED_APPS:
@@ -88,33 +84,33 @@ class TestGroupAdmin(TestCase):
         
         # user 1 - corp and alliance, normal user
         cls.character_1 = EveCharacter.objects.create(
-            character_id='1001',
+            character_id=1001,
             character_name='Bruce Wayne',
-            corporation_id='2001',
+            corporation_id=2001,
             corporation_name='Wayne Technologies',
             corporation_ticker='WT',
-            alliance_id='3001',
+            alliance_id=3001,
             alliance_name='Wayne Enterprises',
             alliance_ticker='WE',
         )
         cls.character_1a = EveCharacter.objects.create(
-            character_id='1002',
+            character_id=1002,
             character_name='Batman',
-            corporation_id='2001',
+            corporation_id=2001,
             corporation_name='Wayne Technologies',
             corporation_ticker='WT',
-            alliance_id='3001',
+            alliance_id=3001,
             alliance_name='Wayne Enterprises',
             alliance_ticker='WE',
         )
         alliance = EveAllianceInfo.objects.create(
-            alliance_id='3001',
+            alliance_id=3001,
             alliance_name='Wayne Enterprises',
             alliance_ticker='WE',            
-            executor_corp_id='2001'
+            executor_corp_id=2001
         )
         EveCorporationInfo.objects.create(
-            corporation_id='2001',
+            corporation_id=2001,
             corporation_name='Wayne Technologies',
             corporation_ticker='WT',            
             member_count=42,
@@ -189,10 +185,10 @@ class TestGroupAdmin(TestCase):
             alliance=None
         )
         EveAllianceInfo.objects.create(
-            alliance_id='3101',
+            alliance_id=3101,
             alliance_name='Lex World Domination',
             alliance_ticker='LWD',
-            executor_corp_id=''
+            executor_corp_id=2101
         )
         cls.user_3 = User.objects.create_user(
             cls.character_3.character_name.replace(' ', '_'),
@@ -219,8 +215,8 @@ class TestGroupAdmin(TestCase):
         """create autogroups for corps and alliances"""
         if _has_auto_groups:
             autogroups_config = AutogroupsConfig(
-                corp_groups = True,
-                alliance_groups = True
+                corp_groups=True,
+                alliance_groups=True
             )
             autogroups_config.save()
             for state in State.objects.all():
@@ -277,7 +273,7 @@ class TestGroupAdmin(TestCase):
 
     if _has_auto_groups:
         @patch(MODULE_PATH + '._has_auto_groups', True)
-        def test_properties_6(self):
+        def test_properties_7(self):
             self._create_autogroups()
             expected = ['Auto Group']
             my_group = Group.objects\
@@ -337,8 +333,8 @@ class TestGroupAdmin(TestCase):
             changelist = my_modeladmin.get_changelist_instance(request)
             queryset = changelist.get_queryset(request)
             expected = Group.objects.exclude(
-                        managedalliancegroup__isnull=True, 
-                        managedcorpgroup__isnull=True
+                managedalliancegroup__isnull=True, 
+                managedcorpgroup__isnull=True
             )
             self.assertSetEqual(set(queryset), set(expected))
          
@@ -394,4 +390,4 @@ class TestGroupAdmin(TestCase):
         c = Client()
         c.login(username='superuser', password='secret')                
         response = c.get(get_admin_change_view_url(self.group_1))
-        self.assertEqual(response.status_code, 200)
+        self.assertEqual(response.status_code, 200)

allianceauth/groupmanagement/tests/test_templatetags.py

@@ -0,0 +1,27 @@
+from unittest.mock import patch
+
+from django.test import TestCase
+from allianceauth.tests.auth_utils import AuthUtils
+
+from ..templatetags.groupmanagement import can_manage_groups
+
+MODULE_PATH = 'allianceauth.groupmanagement.templatetags.groupmanagement'
+
+
+@patch(MODULE_PATH + '.GroupManager.can_manage_groups')
+class TestCanManageGroups(TestCase):
+        
+    def setUp(self):        
+        self.user = AuthUtils.create_user('Bruce Wayne')
+
+    def test_return_normal_result(self, mock_can_manage_groups):
+        mock_can_manage_groups.return_value = True
+
+        self.assertTrue(can_manage_groups(self.user))
+        self.assertTrue(mock_can_manage_groups.called)
+        
+    def test_return_false_if_not_user(self, mock_can_manage_groups):
+        mock_can_manage_groups.return_value = True
+
+        self.assertFalse(can_manage_groups('invalid'))
+        self.assertFalse(mock_can_manage_groups.called)

allianceauth/hrapplications/auth_hooks.py

@@ -8,7 +8,7 @@ class ApplicationsMenu(MenuItemHook):
     def __init__(self):
         MenuItemHook.__init__(self,
                               _('Applications'),
-                              'fa fa-file-o fa-fw',
+                              'far fa-file fa-fw',
                               'hrapplications:index',
                               navactive=['hrapplications:'])
 

allianceauth/optimer/auth_hooks.py

@@ -7,7 +7,7 @@ from . import urls
 class OpTimerboardMenu(MenuItemHook):
     def __init__(self):
         MenuItemHook.__init__(self, _('Fleet Operations'),
-                              'fa fa-exclamation  fa-fw',
+                              'fas fa-exclamation  fa-fw',
                               'optimer:view',
                               navactive=['optimer:'])
 

allianceauth/permissions_tool/auth_hooks.py

@@ -8,7 +8,7 @@ class PermissionsTool(MenuItemHook):
     def __init__(self):
         MenuItemHook.__init__(self,
                               'Permissions Audit',
-                              'fa fa-key fa-id-card',
+                              'fas fa-id-card fa-fw',
                               'permissions_tool:overview',
                               order=400,
                               navactive=['permissions_tool:'])

allianceauth/permissions_tool/tests.py

@@ -41,7 +41,7 @@ class PermissionsToolViewsTestCase(WebTest):
         response_content = response.content.decode('utf-8')
 
         self.assertInHTML('<li><a class="active" href="/permissions/overview/">'
-                          '<i class="fa fa-key fa-id-card"></i> Permissions Audit</a></li>', response_content)
+                          '<i class="fas fa-id-card fa-fw"></i> Permissions Audit</a></li>', response_content)
 
     def test_permissions_overview(self):
         self.app.set_user(self.member)

allianceauth/project_template/project_name/settings/base.py

@@ -103,8 +103,7 @@ TEMPLATES = [
                 'django.template.context_processors.media',
                 'django.template.context_processors.static',
                 'django.template.context_processors.tz',
-                'allianceauth.notifications.context_processors.user_notification_count',
-                'allianceauth.groupmanagement.context_processors.can_manage_groups',
+                'allianceauth.notifications.context_processors.user_notification_count',                
                 'allianceauth.context_processors.auth_settings',
             ],
         },

allianceauth/services/auth_hooks.py

@@ -9,7 +9,7 @@ class Services(MenuItemHook):
     def __init__(self):
         MenuItemHook.__init__(self,
                               _('Services'),
-                              'fa fa-cogs fa-fw',
+                              'fas fa-cogs fa-fw',
                               'services:services', 100)
 
     def render(self, request):

allianceauth/services/modules/discord/auth_hooks.py

@@ -33,7 +33,8 @@ class DiscordService(ServicesHook):
         if self.user_has_account(user):
             logger.debug('Deleting user %s %s account', user, self.name)
             tasks.delete_user.apply_async(
-                kwargs={'user_pk': user.pk}, priority=SINGLE_TASK_PRIORITY
+                kwargs={'user_pk': user.pk, 'notify_user': notify_user}, 
+                priority=SINGLE_TASK_PRIORITY
             )        
     
     def render_services_ctrl(self, request):                
@@ -60,13 +61,21 @@ class DiscordService(ServicesHook):
         )
 
     def service_active_for_user(self, user):
-        return user.has_perm(self.access_perm)
+        has_perms = user.has_perm(self.access_perm)
+        logger.debug("User %s has service permission: %s", user, has_perms)
+        return has_perms
 
     def sync_nickname(self, user):
         logger.debug('Syncing %s nickname for user %s', self.name, user)
         if self.user_has_account(user):
             tasks.update_nickname.apply_async(
-                kwargs={'user_pk': user.pk}, priority=SINGLE_TASK_PRIORITY
+                kwargs={
+                    'user_pk': user.pk,
+                    # since the new nickname is not yet in the DB we need to 
+                    # provide it manually to the task
+                    'nickname': DiscordUser.objects.user_formatted_nick(user)
+                }, 
+                priority=SINGLE_TASK_PRIORITY
             )
 
     def sync_nicknames_bulk(self, users: list):
@@ -84,10 +93,16 @@ class DiscordService(ServicesHook):
         tasks.update_all_groups.delay()
 
     def update_groups(self, user):        
-        logger.debug('Processing %s groups for %s', self.name, user)
-        if self.user_has_account(user):            
+        logger.debug('Processing %s groups for %s', self.name, user)        
+        if self.user_has_account(user):
             tasks.update_groups.apply_async(
-                kwargs={'user_pk': user.pk}, priority=SINGLE_TASK_PRIORITY
+                kwargs={
+                    'user_pk': user.pk,
+                    # since state changes may not yet be in the DB we need to 
+                    # provide the new state name manually to the task
+                    'state_name': user.profile.state.name
+                }, 
+                priority=SINGLE_TASK_PRIORITY
             )
 
     def update_groups_bulk(self, users: list):

allianceauth/services/modules/discord/discord_client/app_settings.py

@@ -6,9 +6,14 @@ DISCORD_API_BASE_URL = clean_setting(
     'DISCORD_API_BASE_URL', 'https://discordapp.com/api/'
 )
 
-# Low level timeout for requests to the Discord API in ms
-DISCORD_API_TIMEOUT = clean_setting(
-    'DISCORD_API_TIMEOUT', 5000
+# Low level connecttimeout for requests to the Discord API in seconds
+DISCORD_API_TIMEOUT_CONNECT = clean_setting(
+    'DISCORD_API_TIMEOUT', 5
+)
+
+# Low level read timeout for requests to the Discord API in seconds
+DISCORD_API_TIMEOUT_READ = clean_setting(
+    'DISCORD_API_TIMEOUT', 30
 )
 
 # Base authorization URL for Discord Oauth

allianceauth/services/modules/discord/discord_client/client.py

@@ -15,7 +15,8 @@ from allianceauth import __title__ as AUTH_TITLE, __url__, __version__
 from .. import __title__
 from .app_settings import (
     DISCORD_API_BASE_URL,
-    DISCORD_API_TIMEOUT, 
+    DISCORD_API_TIMEOUT_CONNECT,
+    DISCORD_API_TIMEOUT_READ,
     DISCORD_DISABLE_ROLE_CREATION,
     DISCORD_GUILD_NAME_CACHE_MAX_AGE,
     DISCORD_OAUTH_BASE_URL, 
@@ -540,7 +541,7 @@ class DiscordClient:
         args = {
             'url': url,
             'headers': headers,
-            'timeout': DISCORD_API_TIMEOUT / 1000
+            'timeout': (DISCORD_API_TIMEOUT_CONNECT, DISCORD_API_TIMEOUT_READ)
         }
         if data:
             args['json'] = data

allianceauth/services/modules/discord/managers.py

@@ -127,9 +127,17 @@ class DiscordUserManager(models.Manager):
             return None
 
     @staticmethod
-    def user_group_names(user: User) -> list:
+    def user_group_names(user: User, state_name: str = None) -> list:
         """returns list of group names plus state the given user is a member of"""
-        return [group.name for group in user.groups.all()] + [user.profile.state.name]
+        if not state_name:
+            state_name = user.profile.state.name
+        group_names = (
+            [group.name for group in user.groups.all()] + [state_name]
+        )
+        logger.debug(
+            "Group names for roles updates of user %s are: %s", user, group_names
+        )
+        return group_names
     
     def user_has_account(self, user: User) -> bool:
         """Returns True if the user has an Discord account, else False
@@ -171,8 +179,15 @@ class DiscordUserManager(models.Manager):
     
     @classmethod
     def server_name(cls):
-        """returns the name of the Discord server"""        
-        return cls._bot_client().guild_name(DISCORD_GUILD_ID)
+        """returns the name of the current Discord server 
+        or an empty string if the name could not be retrieved
+        """
+        try:
+            server_name = cls._bot_client().guild_name(DISCORD_GUILD_ID)
+        except HTTPError:
+            server_name = ""
+
+        return server_name
 
     @staticmethod
     def _bot_client(is_rate_limited: bool = True):

allianceauth/services/modules/discord/models.py

@@ -67,21 +67,25 @@ class DiscordUser(models.Model):
     def __repr__(self):
         return f'{type(self).__name__}(user=\'{self.user}\', uid={self.uid})'
 
-    def update_nickname(self) -> bool:
+    def update_nickname(self, nickname: str = None) -> bool:
         """Update nickname with formatted name of main character
-                
+
+        Params:
+        - nickname: optional nickname to be used instead of user's main
+
         Returns:
         - True on success
         - None if user is no longer a member of the Discord server
         - False on error or raises exception
         """        
-        requested_nick = DiscordUser.objects.user_formatted_nick(self.user)
-        if requested_nick:            
+        if not nickname:
+            nickname = DiscordUser.objects.user_formatted_nick(self.user)
+        if nickname:            
             client = DiscordUser.objects._bot_client()            
             success = client.modify_guild_member(
                 guild_id=DISCORD_GUILD_ID,
                 user_id=self.uid,
-                nick=requested_nick
+                nick=nickname
             )
             if success:
                 logger.info('Nickname for %s has been updated', self.user)
@@ -92,10 +96,13 @@ class DiscordUser(models.Model):
         else:
             return False
 
-    def update_groups(self) -> bool:
+    def update_groups(self, state_name: str = None) -> bool:
         """update groups for a user based on his current group memberships. 
         Will add or remove roles of a user as needed.
         
+        Params:
+        - state_name: optional state name to be used
+
         Returns:
         - True on success
         - None if user is no longer a member of the Discord server
@@ -128,7 +135,9 @@ class DiscordUser(models.Model):
         requested_roles = match_or_create_roles_from_names(
             client=client, 
             guild_id=DISCORD_GUILD_ID, 
-            role_names=DiscordUser.objects.user_group_names(self.user)
+            role_names=DiscordUser.objects.user_group_names(
+                user=self.user, state_name=state_name
+            )
         )
         logger.debug(
             'Requested roles for user %s: %s', self.user, requested_roles.ids()
@@ -144,13 +153,13 @@ class DiscordUser(models.Model):
                 role_ids=list(new_roles.ids())
             )
             if success:
-                logger.info('Groups for %s have been updated', self.user)
+                logger.info('Roles for %s have been updated', self.user)
             else:
-                logger.warning('Failed to update groups for %s', self.user)
+                logger.warning('Failed to update roles for %s', self.user)
             return success
 
         else:
-            logger.info('No need to update groups for user %s', self.user)
+            logger.info('No need to update roles for user %s', self.user)
             return True
 
     def update_username(self) -> bool:

allianceauth/services/modules/discord/tasks.py

@@ -26,25 +26,27 @@ BULK_TASK_PRIORITY = 6
 @shared_task(
     bind=True, name='discord.update_groups', base=QueueOnce, max_retries=None
 )
-def update_groups(self, user_pk: int) -> None:
+def update_groups(self, user_pk: int, state_name: str = None) -> None:
     """Update roles on Discord for given user according to his current groups
     
     Params:
     - user_pk: PK of given user
-    """
-    _task_perform_user_action(self, user_pk, 'update_groups')
+    - state_name: optional state name to be used
+    """    
+    _task_perform_user_action(self, user_pk, 'update_groups', state_name=state_name)
 
 
 @shared_task(
     bind=True, name='discord.update_nickname', base=QueueOnce, max_retries=None
 )
-def update_nickname(self, user_pk: int) -> None:
+def update_nickname(self, user_pk: int, nickname: str = None) -> None:
     """Set nickname on Discord for given user to his main character name
     
     Params:
     - user_pk: PK of given user
+    - nickname: optional nickname to be used instead of user's main
     """
-    _task_perform_user_action(self, user_pk, 'update_nickname')
+    _task_perform_user_action(self, user_pk, 'update_nickname', nickname=nickname)
 
 
 @shared_task(
@@ -75,6 +77,7 @@ def _task_perform_user_action(self, user_pk: int, method: str, **kwargs) -> None
     """perform a user related action incl. managing all exceptions"""
     logger.debug("Starting %s for user with pk %s", method, user_pk)
     user = User.objects.get(pk=user_pk)    
+    # logger.debug("user %s has state %s", user, user.profile.state)
     if DiscordUser.objects.user_has_account(user):
         logger.info("Running %s for user %s", method, user)
         try:

allianceauth/services/modules/discord/templates/services/discord/discord_service_ctrl.html

@@ -28,7 +28,7 @@
         {% endif %}
         {% if request.user.is_superuser %}
             <div class="text-center" style="padding-top:5px;">
-                <a type="button" class="btn btn-default" href="{% url 'discord:add_bot' %}">
+                <a type="button" id="btnLinkDiscordServer" class="btn btn-default" href="{% url 'discord:add_bot' %}">
                     {% trans "Link Discord Server" %}
                 </a>
             </div>

allianceauth/services/modules/discord/tests/test_admin.py

@@ -34,33 +34,33 @@ class TestDataMixin(TestCase):
         
         # user 1 - corp and alliance, normal user
         cls.character_1 = EveCharacter.objects.create(
-            character_id='1001',
+            character_id=1001,
             character_name='Bruce Wayne',
-            corporation_id='2001',
+            corporation_id=2001,
             corporation_name='Wayne Technologies',
             corporation_ticker='WT',
-            alliance_id='3001',
+            alliance_id=3001,
             alliance_name='Wayne Enterprises',
             alliance_ticker='WE',
         )
         cls.character_1a = EveCharacter.objects.create(
-            character_id='1002',
+            character_id=1002,
             character_name='Batman',
-            corporation_id='2001',
+            corporation_id=2001,
             corporation_name='Wayne Technologies',
             corporation_ticker='WT',
-            alliance_id='3001',
+            alliance_id=3001,
             alliance_name='Wayne Enterprises',
             alliance_ticker='WE',
         )
         alliance = EveAllianceInfo.objects.create(
-            alliance_id='3001',
+            alliance_id=3001,
             alliance_name='Wayne Enterprises',
             alliance_ticker='WE',            
-            executor_corp_id='2001'
+            executor_corp_id=2001
         )
         EveCorporationInfo.objects.create(
-            corporation_id='2001',
+            corporation_id=2001,
             corporation_name='Wayne Technologies',
             corporation_ticker='WT',            
             member_count=42,
@@ -141,10 +141,10 @@ class TestDataMixin(TestCase):
             alliance=None
         )
         EveAllianceInfo.objects.create(
-            alliance_id='3101',
+            alliance_id=3101,
             alliance_name='Lex World Domination',
             alliance_ticker='LWD',
-            executor_corp_id=''
+            executor_corp_id=2101
         )
         cls.user_3 = User.objects.create_user(
             cls.character_3.character_name.replace(' ', '_'),
@@ -245,8 +245,8 @@ class TestFilters(TestDataMixin, TestCase):
         filters = changelist.get_filters(request)
         filterspec = filters[0][0]
         expected = [            
-            ('2002', 'Daily Planet'),
-            ('2001', 'Wayne Technologies'),
+            (2002, 'Daily Planet'),
+            (2001, 'Wayne Technologies'),
         ]
         self.assertEqual(filterspec.lookup_choices, expected)
 
@@ -274,7 +274,7 @@ class TestFilters(TestDataMixin, TestCase):
         filters = changelist.get_filters(request)
         filterspec = filters[0][0]
         expected = [
-            ('3001', 'Wayne Enterprises'),
+            (3001, 'Wayne Enterprises'),
         ]
         self.assertEqual(filterspec.lookup_choices, expected)
 

allianceauth/services/modules/discord/tests/test_auth_hooks.py

@@ -3,6 +3,7 @@ from unittest.mock import patch
 from django.test import TestCase, RequestFactory
 from django.test.utils import override_settings
 
+from allianceauth.notifications.models import Notification
 from allianceauth.tests.auth_utils import AuthUtils
 
 from . import TEST_USER_NAME, TEST_USER_ID, add_permissions_to_members, MODULE_PATH
@@ -30,6 +31,7 @@ class TestDiscordService(TestCase):
         self.service = DiscordService
         add_permissions_to_members()
         self.factory = RequestFactory()
+        Notification.objects.all().delete()
 
     def test_service_enabled(self):
         service = self.service()        
@@ -89,16 +91,17 @@ class TestDiscordService(TestCase):
         service = self.service()        
         service.sync_nicknames_bulk([self.member])        
         self.assertTrue(mock_update_nicknames_bulk.delay.called)
-        
+            
     @patch(MODULE_PATH + '.managers.DiscordClient', spec=DiscordClient)
-    def test_delete_user_is_member(self, mock_DiscordClient):        
+    def test_delete_user_is_member(self, mock_DiscordClient): 
         mock_DiscordClient.return_value.remove_guild_member.return_value = True
 
-        service = self.service()        
-        service.delete_user(self.member)
+        service = self.service()
+        service.delete_user(self.member, notify_user=True)
         
         self.assertTrue(mock_DiscordClient.return_value.remove_guild_member.called)
-        self.assertFalse(DiscordUser.objects.filter(user=self.member).exists())
+        self.assertFalse(DiscordUser.objects.filter(user=self.member).exists())        
+        self.assertTrue(Notification.objects.filter(user=self.member).exists())
 
     @patch(MODULE_PATH + '.managers.DiscordClient', spec=DiscordClient)
     def test_delete_user_is_not_member(self, mock_DiscordClient):

allianceauth/services/modules/discord/tests/test_integration.py

@@ -16,9 +16,12 @@ import requests_mock
 from django.contrib.auth.models import Group, User
 from django.core.cache import caches
 from django.shortcuts import reverse
-from django.test import TransactionTestCase
+from django.test import TransactionTestCase, TestCase
 from django.test.utils import override_settings
 
+from allianceauth.authentication.models import State
+from allianceauth.eveonline.models import EveCharacter
+from allianceauth.notifications.models import Notification
 from allianceauth.tests.auth_utils import AuthUtils
 
 from . import (
@@ -43,6 +46,7 @@ from ..models import DiscordUser
 logger = logging.getLogger('allianceauth')
 
 ROLE_MEMBER = create_role(99, 'Member')
+ROLE_BLUE = create_role(98, 'Blue')
 
 # Putting all requests to Discord into objects so we can compare them better
 DiscordRequest = namedtuple('DiscordRequest', ['method', 'url'])
@@ -87,6 +91,16 @@ def clear_cache():
     logger.info('Cache flushed')
 
 
+def reset_testdata():    
+    AuthUtils.disconnect_signals()
+    Group.objects.all().delete()
+    User.objects.all().delete()
+    State.objects.all().delete()
+    EveCharacter.objects.all().delete()
+    AuthUtils.connect_signals()
+    Notification.objects.all().delete()
+
+
 @patch(MODULE_PATH + '.models.DISCORD_GUILD_ID', TEST_GUILD_ID)
 @override_settings(CELERY_ALWAYS_EAGER=True)
 @requests_mock.Mocker()
@@ -96,16 +110,26 @@ class TestServiceFeatures(TransactionTestCase):
     def setUpClass(cls):
         super().setUpClass()
         cls.maxDiff = None
-        
+                
     def setUp(self):
+        """All tests: Given a user with member state, 
+        service permission and active Discord account
+        """
         clear_cache()
-        AuthUtils.disconnect_signals()
-        Group.objects.all().delete()
-        User.objects.all().delete()
-        AuthUtils.connect_signals()
-        self.group_3 = Group.objects.create(name='charlie')        
-        self.user = AuthUtils.create_member(TEST_USER_NAME)
-        AuthUtils.add_main_character_2(
+        reset_testdata()
+        self.group_charlie = Group.objects.create(name='charlie')        
+        
+        # States
+        self.member_state = AuthUtils.get_member_state()
+        self.guest_state = AuthUtils.get_guest_state()
+        self.blue_state = AuthUtils.create_state("Blue", 50)
+        permission = AuthUtils.get_permission_by_name('discord.access_discord')
+        self.member_state.permissions.add(permission)
+        self.blue_state.permissions.add(permission)
+
+        # Test user
+        self.user = AuthUtils.create_user(TEST_USER_NAME)
+        self.main = AuthUtils.add_main_character_2(
             self.user, 
             TEST_MAIN_NAME, 
             TEST_MAIN_ID, 
@@ -113,60 +137,55 @@ class TestServiceFeatures(TransactionTestCase):
             corp_name='test_corp', 
             corp_ticker='TEST',
             disconnect_signals=True
-        )
-        self.discord_user = DiscordUser.objects.create(user=self.user, uid=TEST_USER_ID)
-        add_permissions_to_members()
+        )                
+        self.member_state.member_characters.add(self.main)
         
-    def test_name_of_main_changes(self, requests_mocker):      
-        # modify_guild_member()        
+        # verify user is a member and has an account
+        self.user = User.objects.get(pk=self.user.pk)
+        self.assertEqual(self.user.profile.state, self.member_state)
+        
+        self.discord_user = DiscordUser.objects.create(user=self.user, uid=TEST_USER_ID)
+        self.assertTrue(DiscordUser.objects.user_has_account(self.user))
+        
+    def test_when_name_of_main_changes_then_discord_nick_is_updated(
+        self, requests_mocker
+    ):        
         requests_mocker.patch(modify_guild_member_request.url, status_code=204)
         
         # changing nick to trigger signals
         new_nick = f'Testnick {uuid1().hex}'[:32]
         self.user.profile.main_character.character_name = new_nick
         self.user.profile.main_character.save()
-
-        # Need to have called modify_guild_member two times only
-        # Once for sync nickname
-        # Once for change of main character        
-        requests_made = list()
+        
+        # verify Discord nick was updates
+        nick_updated = False
         for r in requests_mocker.request_history:            
-            requests_made.append(DiscordRequest(r.method, r.url))
+            my_request = DiscordRequest(r.method, r.url)                        
+            if my_request == modify_guild_member_request and "nick" in r.json():
+                nick_updated = True
+                self.assertEqual(r.json()["nick"], new_nick)
+        
+        self.assertTrue(nick_updated)
+        self.assertTrue(DiscordUser.objects.user_has_account(self.user))
 
-        expected = [modify_guild_member_request, modify_guild_member_request]        
-        self.assertListEqual(requests_made, expected)
-
-    def test_name_of_main_changes_but_user_deleted(self, requests_mocker):      
-        # modify_guild_member()        
+    def test_when_name_of_main_changes_and_user_deleted_then_account_is_deleted(
+        self, requests_mocker
+    ):        
         requests_mocker.patch(
             modify_guild_member_request.url, status_code=404, json={'code': 10007}
-        )
-        # remove_guild_member()
+        )        
         requests_mocker.delete(remove_guild_member_request.url, status_code=204)
         
         # changing nick to trigger signals
         new_nick = f'Testnick {uuid1().hex}'[:32]
         self.user.profile.main_character.character_name = new_nick
         self.user.profile.main_character.save()
+        
+        self.assertFalse(DiscordUser.objects.user_has_account(self.user))
 
-        # Need to have called modify_guild_member two times only
-        # Once for sync nickname
-        # Once for change of main character        
-        requests_made = list()
-        for r in requests_mocker.request_history:            
-            requests_made.append(DiscordRequest(r.method, r.url))
-
-        expected = [
-            modify_guild_member_request, 
-            remove_guild_member_request,            
-        ]            
-        self.assertListEqual(requests_made, expected)
-        # self.assertFalse(DiscordUser.objects.user_has_account(self.user))
-
-    def test_name_of_main_changes_but_user_rate_limited(
+    def test_when_name_of_main_changes_and_and_rate_limited_then_dont_call_api(
         self, requests_mocker
-    ):
-        # modify_guild_member()        
+    ):        
         requests_mocker.patch(modify_guild_member_request.url, status_code=204)
         
         # exhausting rate limit
@@ -183,98 +202,232 @@ class TestServiceFeatures(TransactionTestCase):
         self.user.profile.main_character.save()
 
         # should not have called the API
-        requests_made = list()
-        for r in requests_mocker.request_history:            
-            requests_made.append(DiscordRequest(r.method, r.url))
+        requests_made = [
+            DiscordRequest(r.method, r.url) for r in requests_mocker.request_history
+        ]
+                
+        self.assertListEqual(requests_made, list())
         
-        expected = list()  
-        self.assertListEqual(requests_made, expected)
-
-    def test_user_demoted_to_guest(self, requests_mocker):        
-        # remove_guild_member()        
+    def test_when_member_is_demoted_to_guest_then_his_account_is_deleted(
+        self, requests_mocker
+    ):        
+        requests_mocker.patch(modify_guild_member_request.url, status_code=204)
         requests_mocker.delete(remove_guild_member_request.url, status_code=204)
-        self.user.groups.clear()
-
-        requests_made = list()
-        for r in requests_mocker.request_history:            
-            requests_made.append(DiscordRequest(r.method, r.url))
+                
+        # our user is a member and has an account        
+        self.assertTrue(self.user.has_perm('discord.access_discord'))
+                
+        # now we demote him to guest        
+        self.member_state.member_characters.remove(self.main)
         
-        # compare the list of made requests with expected
-        expected = [remove_guild_member_request]
-        self.assertListEqual(requests_made, expected)
+        # verify user is now guest
+        self.user = User.objects.get(pk=self.user.pk)        
+        self.assertEqual(self.user.profile.state, AuthUtils.get_guest_state())
+        
+        # verify user has no longer access to Discord and no account
+        self.assertFalse(self.user.has_perm('discord.access_discord'))
+        self.assertFalse(DiscordUser.objects.user_has_account(self.user))        
+        
+        # verify account was actually deleted from Discord server
+        requests_made = [
+            DiscordRequest(r.method, r.url) for r in requests_mocker.request_history
+        ]                                
+        self.assertIn(remove_guild_member_request, requests_made)
+        
+        # verify user has been notified
+        self.assertTrue(Notification.objects.filter(user=self.user).exists())
+        
+    def test_when_member_changes_to_blue_state_then_roles_are_updated_accordingly(
+        self, requests_mocker
+    ):        
+        # request mocks
+        requests_mocker.get(
+            guild_member_request.url,
+            json={'user': create_user_info(), 'roles': ['3', '13', '99']}
+        )     
+        requests_mocker.get(
+            guild_roles_request.url,
+            json=[
+                ROLE_ALPHA, ROLE_BRAVO, ROLE_CHARLIE, ROLE_MIKE, ROLE_MEMBER, ROLE_BLUE
+            ]
+        )                
+        requests_mocker.post(create_guild_role_request.url, json=ROLE_CHARLIE) 
+        requests_mocker.patch(modify_guild_member_request.url, status_code=204)
+        
+        AuthUtils.disconnect_signals()
+        self.user.groups.add(self.group_charlie)
+        AuthUtils.connect_signals()
 
-    def test_adding_group_to_user_role_exists(self, requests_mocker):
-        # guild_member()                
+        # demote user to blue state
+        self.blue_state.member_characters.add(self.main)
+        self.member_state.member_characters.remove(self.main)
+
+        # verify roles for user where updated        
+        roles_updated = False
+        for r in requests_mocker.request_history:            
+            my_request = DiscordRequest(r.method, r.url)                        
+            if my_request == modify_guild_member_request and "roles" in r.json():
+                roles_updated = True
+                self.assertSetEqual(set(r.json()["roles"]), {3, 13, 98})
+                break
+        
+        self.assertTrue(roles_updated)
+        self.assertTrue(DiscordUser.objects.user_has_account(self.user))
+
+    def test_when_group_added_to_member_and_role_known_then_his_roles_are_updated(
+        self, requests_mocker
+    ):        
         requests_mocker.get(
             guild_member_request.url,
             json={
                 'user': create_user_info(),
-                'roles': ['1', '13', '99']
+                'roles': ['13', '99']
             }
-        )        
-        # guild_roles()        
+        )              
         requests_mocker.get(
             guild_roles_request.url, 
             json=[ROLE_ALPHA, ROLE_BRAVO, ROLE_CHARLIE, ROLE_MIKE, ROLE_MEMBER]
-        )        
-        # create_guild_role()        
-        requests_mocker.post(create_guild_role_request.url, json=ROLE_CHARLIE)
-        # modify_guild_member()                
+        )                
+        requests_mocker.post(create_guild_role_request.url, json=ROLE_CHARLIE)        
         requests_mocker.patch(modify_guild_member_request.url, status_code=204)
                 
         # adding new group to trigger signals
-        self.user.groups.add(self.group_3)        
-        self.user.refresh_from_db()
-        
-        # compare the list of made requests with expected
-        requests_made = list()
+        self.user.groups.add(self.group_charlie)
+                
+        # verify roles for user where updated
+        roles_updated = False
         for r in requests_mocker.request_history:            
-            requests_made.append(DiscordRequest(r.method, r.url))
+            my_request = DiscordRequest(r.method, r.url)                        
+            if my_request == modify_guild_member_request and "roles" in r.json():
+                roles_updated = True
+                self.assertSetEqual(set(r.json()["roles"]), {3, 13, 99})
+                break
+        
+        self.assertTrue(roles_updated)
+        self.assertTrue(DiscordUser.objects.user_has_account(self.user))
 
-        expected = [
-            guild_member_request,
-            guild_roles_request,            
-            modify_guild_member_request
-        ]        
-        self.assertListEqual(requests_made, expected)
-
-    def test_adding_group_to_user_role_does_not_exist(self, requests_mocker):    
-        # guild_member()                
+    def test_when_group_added_to_member_and_role_unknown_then_his_roles_are_updated(
+        self, requests_mocker
+    ):        
         requests_mocker.get(
             guild_member_request.url,
             json={
                 'user': {'id': str(TEST_USER_ID), 'username': TEST_MAIN_NAME},
-                'roles': ['1', '13', '99']
+                'roles': ['13', '99']
             }
-        )        
-        # guild_roles()        
+        )              
         requests_mocker.get(
             guild_roles_request.url, 
             json=[ROLE_ALPHA, ROLE_BRAVO, ROLE_MIKE, ROLE_MEMBER]
-        )        
-        # create_guild_role()        
-        requests_mocker.post(create_guild_role_request.url, json=ROLE_CHARLIE)
-        # modify_guild_member()                
+        )                
+        requests_mocker.post(create_guild_role_request.url, json=ROLE_CHARLIE)        
         requests_mocker.patch(modify_guild_member_request.url, status_code=204)
                 
         # adding new group to trigger signals
-        self.user.groups.add(self.group_3)        
+        self.user.groups.add(self.group_charlie)
         self.user.refresh_from_db()
         
-        # compare the list of made requests with expected
-        requests_made = list()
+        # verify roles for user where updated
+        roles_updated = False
         for r in requests_mocker.request_history:            
-            requests_made.append(DiscordRequest(r.method, r.url))
-
-        expected = [
-            guild_member_request,
-            guild_roles_request,
-            create_guild_role_request,
-            modify_guild_member_request
-        ]        
-        self.assertListEqual(requests_made, expected)
+            my_request = DiscordRequest(r.method, r.url)                        
+            if my_request == modify_guild_member_request and "roles" in r.json():
+                roles_updated = True
+                self.assertSetEqual(set(r.json()["roles"]), {3, 13, 99})
+                break
+        
+        self.assertTrue(roles_updated)
+        self.assertTrue(DiscordUser.objects.user_has_account(self.user))
     
 
+@override_settings(CELERY_ALWAYS_EAGER=True)
+@patch(MODULE_PATH + '.managers.DISCORD_GUILD_ID', TEST_GUILD_ID)
+@patch(MODULE_PATH + '.models.DISCORD_GUILD_ID', TEST_GUILD_ID)
+@requests_mock.Mocker()
+class StateTestCase(TestCase):
+    
+    def setUp(self):        
+        clear_cache()
+        reset_testdata()
+        
+        self.user = AuthUtils.create_user('test_user', disconnect_signals=True)
+        AuthUtils.add_main_character(
+            self.user, 
+            'Perm Test Character', '99', 
+            corp_id='100', 
+            alliance_id='200',
+            corp_name='Perm Test Corp', 
+            alliance_name='Perm Test Alliance'
+        )
+        self.test_character = EveCharacter.objects.get(character_id='99')
+        self.member_state = State.objects.create(
+            name='Test Member',
+            priority=150,
+        )
+        self.access_discord = AuthUtils.get_permission_by_name('discord.access_discord')
+        self.member_state.permissions.add(self.access_discord)
+        self.member_state.member_characters.add(self.test_character)
+    
+    def _add_discord_user(self):
+        self.discord_user = DiscordUser.objects.create(
+            user=self.user, uid="12345678910"
+        )
+
+    def _refresh_user(self):
+        self.user = User.objects.get(pk=self.user.pk)
+
+    def test_perm_changes_to_higher_priority_state_creation(self, requests_mocker):
+        mock_url = DiscordRequest(
+            method='DELETE',
+            url=f'{DISCORD_API_BASE_URL}guilds/{TEST_GUILD_ID}/members/12345678910'
+        )
+        requests_mocker.delete(mock_url.url, status_code=204)
+        self._add_discord_user()
+        self._refresh_user()
+        higher_state = State.objects.create(
+            name='Higher State',
+            priority=200,
+        )
+        self.assertIsNotNone(self.user.discord)
+        higher_state.member_characters.add(self.test_character)
+        self._refresh_user()
+        self.assertEquals(higher_state, self.user.profile.state)
+        with self.assertRaises(DiscordUser.DoesNotExist):
+            self.user.discord
+        higher_state.member_characters.clear()
+        self._refresh_user()
+        self.assertEquals(self.member_state, self.user.profile.state)
+        with self.assertRaises(DiscordUser.DoesNotExist):
+            self.user.discord
+
+    def test_perm_changes_to_lower_priority_state_creation(self, requests_mocker):
+        mock_url = DiscordRequest(
+            method='DELETE',
+            url=f'{DISCORD_API_BASE_URL}guilds/{TEST_GUILD_ID}/members/12345678910'
+        )
+        requests_mocker.delete(mock_url.url, status_code=204)
+        self._add_discord_user()
+        self._refresh_user()
+        lower_state = State.objects.create(
+            name='Lower State',
+            priority=125,
+        )
+        self.assertIsNotNone(self.user.discord)
+        lower_state.member_characters.add(self.test_character)
+        self._refresh_user()
+        self.assertEquals(self.member_state, self.user.profile.state)
+        self.member_state.member_characters.clear()
+        self._refresh_user()
+        self.assertEquals(lower_state, self.user.profile.state)
+        with self.assertRaises(DiscordUser.DoesNotExist):
+            self.user.discord
+        self.member_state.member_characters.add(self.test_character)
+        self._refresh_user()
+        self.assertEquals(self.member_state, self.user.profile.state)
+        with self.assertRaises(DiscordUser.DoesNotExist):
+            self.user.discord
+
+
 @patch(MODULE_PATH + '.managers.DISCORD_GUILD_ID', TEST_GUILD_ID)
 @patch(MODULE_PATH + '.models.DISCORD_GUILD_ID', TEST_GUILD_ID)
 @requests_mock.Mocker()
@@ -282,6 +435,7 @@ class TestUserFeatures(WebTest):
     
     def setUp(self):
         clear_cache()
+        reset_testdata()
         self.member = AuthUtils.create_member(TEST_USER_NAME)
         AuthUtils.add_main_character_2(
             self.member, 
@@ -474,3 +628,24 @@ class TestUserFeatures(WebTest):
                 
         expected = [remove_guild_member_request, guild_infos_request]
         self.assertListEqual(requests_made, expected)
+
+    @patch(MODULE_PATH + '.views.messages')
+    def test_user_add_new_server(self, requests_mocker, mock_messages): 
+        # guild_infos()
+        mock_exception = HTTPError('can not get guild info from Discord API')
+        mock_exception.response = Mock()
+        mock_exception.response.status_code = 440
+        requests_mocker.get(guild_infos_request.url, exc=mock_exception)
+        
+        # login        
+        self.member.is_superuser = True
+        self.member.is_staff = True
+        self.member.save()
+        self.app.set_user(self.member)
+        
+        # click deactivate on the service page
+        response = self.app.get(reverse('services:services'))
+        
+        # check we got can see the page and the "link server" button
+        self.assertEqual(response.status_int, 200)
+        self.assertIsNotNone(response.html.find(id='btnLinkDiscordServer'))

allianceauth/services/modules/discord/tests/test_managers.py

@@ -361,3 +361,26 @@ class TestUserHasAccount(TestCase):
 
     def test_return_false_if_not_called_with_user_object(self):                
         self.assertFalse(DiscordUser.objects.user_has_account('abc'))
+
+
+@patch(MODULE_PATH + '.managers.DiscordClient', spec=DiscordClient)
+class TestServerName(TestCase):
+
+    @classmethod
+    def setUpClass(cls):
+        super().setUpClass()
+        cls.user = AuthUtils.create_user(TEST_USER_NAME)
+    
+    def test_returns_name_when_api_returns_it(self, mock_DiscordClient):
+        server_name = "El Dorado"
+        mock_DiscordClient.return_value.guild_name.return_value = server_name
+
+        self.assertEqual(DiscordUser.objects.server_name(), server_name)
+
+    def test_returns_empty_string_when_api_throws_http_error(self, mock_DiscordClient):
+        mock_exception = HTTPError('Test exception')
+        mock_exception.response = Mock(**{"status_code": 440})        
+        mock_DiscordClient.return_value.guild_name.side_effect = mock_exception
+
+        self.assertEqual(DiscordUser.objects.server_name(), "")
+

allianceauth/services/modules/example/auth_hooks.py

@@ -25,10 +25,10 @@ class ExampleService(ServicesHook):
         :return:
         """
         urls = self.Urls()
-        urls.auth_activate = 'auth_example_activate'
-        urls.auth_deactivate = 'auth_example_deactivate'
-        urls.auth_reset_password = 'auth_example_reset_password'
-        urls.auth_set_password = 'auth_example_set_password'
+        # urls.auth_activate = 'auth_example_activate'
+        # urls.auth_deactivate = 'auth_example_deactivate'
+        # urls.auth_reset_password = 'auth_example_reset_password'        
+        # urls.auth_set_password = 'auth_example_set_password'
         return render_to_string(self.service_ctrl_template, {
             'service_name': self.title,
             'urls': urls,

allianceauth/services/modules/openfire/auth_hooks.py

@@ -76,7 +76,7 @@ class JabberBroadcast(MenuItemHook):
     def __init__(self):
         MenuItemHook.__init__(self,
                               _('Jabber Broadcast'),
-                              'fa fa-lock fa-fw fa-bullhorn',
+                              'fas fa-bullhorn fa-fw',
                               'openfire:broadcast')
 
     def render(self, request):
@@ -89,7 +89,7 @@ class FleetBroadcastFormatter(MenuItemHook):
     def __init__(self):
         MenuItemHook.__init__(self,
                               _('Fleet Broadcast Formatter'),
-                              'fa fa-lock fa-fw fa-space-shuttle',
+                              'fas fa-space-shuttle fa-fw',
                               'services:fleet_format_tool')
 
     def render(self, request):

allianceauth/services/signals.py

@@ -123,17 +123,12 @@ def m2m_changed_state_permissions(sender, instance, action, pk_set, *args, **kwa
             logger.debug("Permission change for state {} was not service permission, ignoring".format(instance))
 
 
-@receiver(state_changed, sender=UserProfile)
+@receiver(state_changed)
 def check_service_accounts_state_changed(sender, user, state, **kwargs):
-    logger.debug("Received state_changed from %s to state %s" % (user, state))
-    service_perms = [svc.access_perm for svc in ServicesHook.get_services()]
-    state_perms = ["{}.{}".format(perm.natural_key()[1], perm.natural_key()[0]) for perm in state.permissions.all()]
-    for perm in service_perms:
-        if perm not in state_perms:
-            for svc in ServicesHook.get_services():
-                if svc.access_perm == perm:
-                    logger.debug("User %s new state %s does not have service %s permission. Checking account." % (user, state, svc))
-                    svc.validate_user(user)
+    logger.debug("Received state_changed from %s to state %s" % (user, state))    
+    for svc in ServicesHook.get_services():
+        svc.validate_user(user)
+        svc.update_groups(user)
 
 
 @receiver(pre_delete, sender=User)
@@ -159,24 +154,37 @@ def disable_services_on_inactive(sender, instance, *args, **kwargs):
 
 
 @receiver(pre_save, sender=UserProfile)
-def process_main_character_change(sender, instance, *args, **kwargs):
-
-    if not instance.pk:  # ignore
-        # new model being created
+def process_main_character_change(sender, instance, *args, **kwargs):    
+    if not instance.pk:
+        # ignore new model being created
         return
     try:
+        logger.debug(
+            "Received pre_save from %s for process_main_character_change", instance
+        )
         old_instance = UserProfile.objects.get(pk=instance.pk)
-        if old_instance.main_character and not instance.main_character:  # lost main char disable services
-            logger.info("Disabling services due to loss of main character for user {0}".format(instance.user))
+        if old_instance.main_character and not instance.main_character:
+            logger.info(
+                "Disabling services due to loss of main character for user %s",
+                instance.user
+            )
             disable_user(instance.user)
-        elif old_instance.main_character is not instance.main_character:  # swapping/changing main character
-            logger.info("Updating Names due to change of main character for user {0}".format(instance.user))
+        elif old_instance.main_character != instance.main_character:              
+            logger.info(
+                "Updating Names due to change of main character for user %s", 
+                instance.user
+            )
             for svc in ServicesHook.get_services():
                 try:
                     svc.validate_user(instance.user)
                     svc.sync_nickname(instance.user)
                 except:
-                    logger.exception('Exception running sync_nickname for services module %s on user %s' % (svc, instance))
+                    logger.exception(
+                        "Exception running sync_nickname for services module %s "
+                        "on user %s", 
+                        svc, 
+                        instance
+                    )
 
     except UserProfile.DoesNotExist:
         pass
@@ -184,8 +192,12 @@ def process_main_character_change(sender, instance, *args, **kwargs):
 
 @receiver(pre_save, sender=EveCharacter)
 def process_main_character_update(sender, instance, *args, **kwargs):
-    try:
+    try:        
         if instance.userprofile:
+            logger.debug(
+                "Received pre_save from %s for process_main_character_update", 
+                instance
+            )
             old_instance = EveCharacter.objects.get(pk=instance.pk)
             if not instance.character_name == old_instance.character_name or \
                not instance.corporation_name == old_instance.corporation_name or \

allianceauth/services/tests/test_signals.py

@@ -1,15 +1,20 @@
+from copy import deepcopy
 from unittest import mock
 
 from django.test import TestCase
 from django.contrib.auth.models import Group, Permission
-from allianceauth.tests.auth_utils import AuthUtils
+
 from allianceauth.authentication.models import State
+from allianceauth.eveonline.models import EveCharacter
+from allianceauth.tests.auth_utils import AuthUtils
 
 
 class ServicesSignalsTestCase(TestCase):
     def setUp(self):
         self.member = AuthUtils.create_user('auth_member', disconnect_signals=True)
-        AuthUtils.add_main_character(self.member, 'Test', '1', '2', 'Test Corp', 'TEST')
+        AuthUtils.add_main_character_2(
+            self.member, 'Test', 1, 2, 'Test Corp', 'TEST'
+        )
         self.none_user = AuthUtils.create_user('none_user', disconnect_signals=True)
 
     @mock.patch('allianceauth.services.signals.transaction')
@@ -46,7 +51,6 @@ class ServicesSignalsTestCase(TestCase):
 
     @mock.patch('allianceauth.services.signals.disable_user')
     def test_pre_delete_user(self, disable_user):
-
         """
         Test that disable_member is called when a user is deleted
         """
@@ -126,7 +130,9 @@ class ServicesSignalsTestCase(TestCase):
         transaction.on_commit = lambda fn: fn()
 
         ct = ContentType.objects.get(app_label='auth', model='permission')
-        perm = Permission.objects.create(name="Test perm", codename="access_testsvc", content_type=ct)
+        perm = Permission.objects.create(
+            name="Test perm", codename="access_testsvc", content_type=ct
+        )
         self.member.user_permissions.add(perm)
 
         # Act, should trigger m2m change
@@ -159,7 +165,9 @@ class ServicesSignalsTestCase(TestCase):
         AuthUtils.connect_signals()
 
         ct = ContentType.objects.get(app_label='auth', model='permission')
-        perm = Permission.objects.create(name="Test perm", codename="access_testsvc", content_type=ct)
+        perm = Permission.objects.create(
+            name="Test perm", codename="access_testsvc", content_type=ct
+        )
         test_state.permissions.add(perm)
 
         # Act, should trigger m2m change
@@ -173,12 +181,12 @@ class ServicesSignalsTestCase(TestCase):
         self.assertEqual(self.member, args[0])
 
     @mock.patch('allianceauth.services.signals.ServicesHook')
-    def test_state_changed_services_valudation(self, services_hook):
-        """
-        Test a user changing state has service accounts validated
+    def test_state_changed_services_validation_and_groups_update(self, services_hook):
+        """Test a user changing state has service accounts validated and groups updated
         """
         svc = mock.Mock()
         svc.validate_user.return_value = None
+        svc.update_groups.return_value = None
         svc.access_perm = 'auth.access_testsvc'
 
         services_hook.get_services.return_value = [svc]
@@ -190,6 +198,65 @@ class ServicesSignalsTestCase(TestCase):
         # Assert
         self.assertTrue(services_hook.get_services.called)
 
-        self.assertTrue(svc.validate_user.called)
+        self.assertTrue(svc.validate_user.called)        
         args, kwargs = svc.validate_user.call_args
-        self.assertEqual(self.member, args[0])
+        self.assertEqual(self.member, args[0])
+        
+        self.assertTrue(svc.update_groups.called)
+        args, kwargs = svc.update_groups.call_args
+        self.assertEqual(self.member, args[0])
+
+
+    @mock.patch('allianceauth.services.signals.ServicesHook')
+    def test_state_changed_services_validation_and_groups_update_1(self, services_hook):
+        """Test a user changing main has service accounts validated and sync updated
+        """
+        svc = mock.Mock()
+        svc.validate_user.return_value = None
+        svc.sync_nickname.return_value = None
+        svc.access_perm = 'auth.access_testsvc'
+
+        services_hook.get_services.return_value = [svc]
+        
+        new_main = EveCharacter.objects.create(
+            character_id=123, 
+            character_name="Alter Ego", 
+            corporation_id=987, 
+            corporation_name="ABC"
+        )
+        self.member.profile.main_character = new_main
+        self.member.profile.save()
+
+        # Assert
+        self.assertTrue(services_hook.get_services.called)
+
+        self.assertTrue(svc.validate_user.called)        
+        args, kwargs = svc.validate_user.call_args
+        self.assertEqual(self.member, args[0])
+        
+        self.assertTrue(svc.sync_nickname.called)
+        args, kwargs = svc.sync_nickname.call_args
+        self.assertEqual(self.member, args[0])
+
+    @mock.patch('allianceauth.services.signals.ServicesHook')
+    def test_state_changed_services_validation_and_groups_update_2(self, services_hook):
+        """Test a user changing main has service does not have accounts validated 
+        and sync updated if the new main is equal to the old main
+        """
+        svc = mock.Mock()
+        svc.validate_user.return_value = None
+        svc.sync_nickname.return_value = None
+        svc.access_perm = 'auth.access_testsvc'
+
+        services_hook.get_services.return_value = [svc]
+        
+        # this creates a clone of the Django object
+        new_main = deepcopy(self.member.profile.main_character)
+        self.assertIsNot(new_main, self.member.profile.main_character)
+        self.member.profile.main_character = new_main
+        self.member.profile.save()
+
+        # Assert
+        self.assertFalse(services_hook.get_services.called)
+        self.assertFalse(svc.validate_user.called)                
+        self.assertFalse(svc.sync_nickname.called)

allianceauth/srp/auth_hooks.py

@@ -7,7 +7,7 @@ from . import urls
 class SrpMenu(MenuItemHook):
     def __init__(self):
         MenuItemHook.__init__(self, _('Ship Replacement'),
-                              'fa fa-money fa-fw',
+                              'far fa-money-bill-alt fa-fw',
                               'srp:management',
                               navactive=['srp:'])
 

allianceauth/srp/templates/srp/data.html

@@ -131,7 +131,7 @@ ESC to cancel{% endblocktrans %}"id="blah"></i></th>
                                             <div class="checkbox">
                                                 <label style="font-size: 1.5em">
                                                     <input type="checkbox" name="{{srpfleetrequest.id}}">
-                                                    <span class="cr"><i class="cr-icon fa fa-check"></i></span>
+                                                    <span class="cr"><i class="cr-icon fas fa-check"></i></span>
                                                 </label>
                                             </div>                            
                                         </td>

allianceauth/templates/allianceauth/admin-status/overview.html

@@ -20,7 +20,7 @@
                 </div>
                 <div class="text-right" style="position:absolute;bottom:5px;right:5px;">
                     <a href="https://gitlab.com/allianceauth/allianceauth/issues"><span class="label" style="background-color:#e65328;">
-                        <i class="fa fa-gitlab" aria-hidden="true"></i> Powered by GitLab</span>
+                        <i class="fab fa-gitlab" aria-hidden="true"></i> Powered by GitLab</span>
                     </a>
                 </div>
             </div>
@@ -36,36 +36,28 @@
                                 {{ current_version }}
                             </p>
                         </li>
-                        <li class="list-group-item list-group-item-{% if latest_major %}success{% else %}danger{% endif %}">
-                            <h5 class="list-group-item-heading">{% trans "Latest Major" %}</h5>
+                        <li class="list-group-item list-group-item-{% if latest_patch %}success{% elif latest_minor %}warning{% else %}danger{% endif %}">
+                            <h5 class="list-group-item-heading">{% trans "Latest Stable" %}</h5>
                             <p class="list-group-item-text">
                                 <a href="https://gitlab.com/allianceauth/allianceauth/tags" style="color:#000">
-                                    <i class="fa fa-gitlab hidden-xs" aria-hidden="true"></i>
-                                    {{ latest_major_version }}
-                                </a>
-                                {% if not latest_major %}<br>{% trans "Update available" %}{% endif %}
-                            </p>
-                        </li>
-                        <li class="list-group-item list-group-item-{% if latest_minor %}success{% else %}danger{% endif %}">
-                            <h5 class="list-group-item-heading">{% trans "Latest Minor" %}</h5>
-                            <p class="list-group-item-text">
-                                <a href="https://gitlab.com/allianceauth/allianceauth/tags" style="color:#000">
-                                    <i class="fa fa-gitlab hidden-xs" aria-hidden="true"></i>
-                                    {{ latest_minor_version }}
-                                </a>
-                                {% if not latest_minor %}<br>{% trans "Update available" %}{% endif %}
-                            </p>
-                        </li>
-                        <li class="list-group-item list-group-item-{% if latest_patch %}success{% else %}warning{% endif %}">
-                            <h5 class="list-group-item-heading">{% trans "Latest Patch" %}</h5>
-                            <p class="list-group-item-text">
-                                <a href="https://gitlab.com/allianceauth/allianceauth/tags" style="color:#000">
-                                    <i class="fa fa-gitlab hidden-xs" aria-hidden="true"></i>
+                                    <i class="fab fa-gitlab hidden-xs" aria-hidden="true"></i>
                                     {{ latest_patch_version }}
                                 </a>
                                 {% if not latest_patch %}<br>{% trans "Update available" %}{% endif %}
                             </p>
                         </li>
+                        {% if latest_beta %}
+                        <li class="list-group-item list-group-item-info">
+                            <h5 class="list-group-item-heading">{% trans "Latest Pre-Release" %}</h5>
+                            <p class="list-group-item-text">
+                                <a href="https://gitlab.com/allianceauth/allianceauth/tags" style="color:#000">
+                                    <i class="fab fa-gitlab hidden-xs" aria-hidden="true"></i>
+                                    {{ latest_beta_version }}
+                                </a>
+                                <br>{% trans "Pre-Release available" %}
+                            </p>
+                        </li>
+                        {% endif %}
                     </ul>
                 </div>
             </div>

allianceauth/templates/allianceauth/side-menu.html

@@ -1,26 +1,28 @@
 {% load i18n %}
 {% load navactive %}
 {% load menu_items %}
+{% load groupmanagement %}
+    
 <div class="col-sm-2 auth-side-navbar" role="navigation">
     <div class="collapse navbar-collapse auth-menus-collapse auth-side-navbar-collapse">
         <ul class="nav nav-pills nav-stacked gray-icon-color" id="side-menu">
             <li>
                 <a class="{% navactive request 'authentication:dashboard' %}"
                    href="{% url 'authentication:dashboard' %}">
-                    <i class="fa fa-dashboard fa-fw"></i> {% trans "Dashboard" %}
+                    <i class="fas fa-tachometer-alt fa-fw"></i> {% trans "Dashboard" %}
                 </a>
             </li>
             <li>
                 <a class="{% navactive request 'groupmanagement:groups' %}" href="{% url 'groupmanagement:groups' %}">
-                    <i class="fa fa-cogs fa-fw fa-sitemap"></i> {% trans "Groups" %}
+                    <i class="fas fa-sitemap fa-fw"></i> {% trans "Groups" %}
                 </a>
             </li>
 
-            {% if can_manage_groups %}
+            {% if request.user|can_manage_groups %}
                 <li>
                     <a class="{% navactive request 'groupmanagement:management groupmanagement:membership groupmanagement:membership_list' %}"
                        href="{% url 'groupmanagement:management' %}">
-                        <i class="fa fa-lock fa-sitemap fa-fw"></i> {% trans "Group Management" %}
+                        <i class="fas fa-sitemap fa-fw"></i> {% trans "Group Management" %}
                     </a>
                 </li>
             {% endif %}

allianceauth/templates/allianceauth/top-menu.html

@@ -28,7 +28,7 @@
                     </li>
                 {% else %}
                     <li><a href="{% url 'notifications:list' %}">
-                        <i class="fa fa-bell-o"></i></a>
+                        <i class="far fa-bell"></i></a>
                     </li>
                 {% endif %}
                 {% if user.is_authenticated %}
@@ -42,7 +42,7 @@
                 {% if user.is_superuser %}
                     <li>
                         <a class="navbar-brand" style="margin-left: -4px;" href="https://allianceauth.readthedocs.io/" target="_blank">
-                            <i class="fa fa-question-circle fa-fw"></i>
+                            <i class="fas fa-question-circle fa-fw"></i>
                         </a>
                     </li>
                 {% endif %}

allianceauth/templates/bundles/fontawesome.html

@@ -1,4 +1,5 @@
 {% load staticfiles %}
 <!-- Font Awesome Bundle -->
-<link href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/4.7.0/css/font-awesome.min.css" rel="stylesheet" type="text/css">
+<link href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/5.13.0/css/all.min.css" rel="stylesheet" type="text/css">
+<link href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/5.13.0/css/v4-shims.min.css" rel="stylesheet" type="text/css">
 <!-- End Font Awesome Bundle -->

allianceauth/templatetags/admin_status.py

@@ -95,7 +95,7 @@ def _current_version_summary() -> dict:
         logger.exception('Error while getting gitlab release tags')
         return {}
         
-    latest_major_version, latest_minor_version, latest_patch_version = \
+    latest_major_version, latest_minor_version, latest_patch_version, latest_beta_version = \
         _latests_versions(tags)    
     current_version = Pep440Version(__version__)
 
@@ -105,15 +105,21 @@ def _current_version_summary() -> dict:
         current_version >= latest_minor_version if latest_minor_version else False
     has_latest_patch = \
         current_version >= latest_patch_version if latest_patch_version else False
+    has_current_beta = \
+        current_version.base_version <= latest_beta_version.base_version \
+            and latest_major_version.base_version <= latest_beta_version.base_version \
+                if latest_beta_version else False
 
     response = {        
         'latest_major': has_latest_major,
         'latest_minor': has_latest_minor,
         'latest_patch': has_latest_patch,
+        'latest_beta': has_current_beta,
         'current_version': str(current_version),
         'latest_major_version': str(latest_major_version),
         'latest_minor_version': str(latest_minor_version),
-        'latest_patch_version': str(latest_patch_version)
+        'latest_patch_version': str(latest_patch_version),
+        'latest_beta_version': str(latest_beta_version)
     }        
     return response
 
@@ -128,14 +134,18 @@ def _latests_versions(tags: list) -> tuple:
     Non-compliant tags will be ignored
     """
     versions = list()
+    betas = list()
     for tag in tags:
         try:
             version = Pep440Version(tag.get('name'))            
         except InvalidVersion:
             pass
         else:
-            if not version.is_prerelease:
+            if version.is_prerelease or version.is_devrelease:
+                betas.append(version)
+            else:
                 versions.append(version)
+
     
     latest_version = latest_patch_version = max(versions)
     latest_major_version = min([
@@ -145,8 +155,8 @@ def _latests_versions(tags: list) -> tuple:
         v for v in versions 
         if v.major == latest_version.major and v.minor == latest_version.minor
     ])
-    
-    return latest_major_version, latest_minor_version, latest_patch_version
+    latest_beta_version = max(betas)
+    return latest_major_version, latest_minor_version, latest_patch_version, latest_beta_version
 
 
 def _fetch_list_from_gitlab(url: str, max_pages: int = MAX_PAGES):

allianceauth/tests/auth_utils.py

@@ -141,12 +141,18 @@ class AuthUtils:
         post_save.connect(check_state_on_character_update, sender=EveCharacter)
 
     @classmethod
-    def add_main_character(cls, user, name, character_id, corp_id='', corp_name='', corp_ticker='', alliance_id='',
+    def add_main_character(cls, user, name, character_id, corp_id=2345, corp_name='', corp_ticker='', alliance_id=None,
                            alliance_name=''):
+        if alliance_id:
+            try:
+                alliance_id = int(alliance_id)
+            except:
+                alliance_id = None
+
         char = EveCharacter.objects.create(
-            character_id=character_id,
+            character_id=int(character_id),
             character_name=name,
-            corporation_id=corp_id,
+            corporation_id=int(corp_id),
             corporation_name=corp_name,
             corporation_ticker=corp_ticker,
             alliance_id=alliance_id,
@@ -160,10 +166,10 @@ class AuthUtils:
         user, 
         name, 
         character_id, 
-        corp_id='', 
+        corp_id=2345, 
         corp_name='', 
         corp_ticker='', 
-        alliance_id='', 
+        alliance_id=None, 
         alliance_name='',
         disconnect_signals=False
     ):
@@ -171,10 +177,16 @@ class AuthUtils:
         if disconnect_signals:
             cls.disconnect_signals()
 
+        if alliance_id:
+            try:
+                alliance_id = int(alliance_id)
+            except:
+                alliance_id = None
+
         char = EveCharacter.objects.create(
-            character_id=character_id,
+            character_id=int(character_id),
             character_name=name,
-            corporation_id=corp_id,
+            corporation_id=int(corp_id),
             corporation_name=corp_name,
             corporation_ticker=corp_ticker,
             alliance_id=alliance_id,

allianceauth/timerboard/auth_hooks.py

@@ -7,7 +7,7 @@ from . import urls
 class TimerboardMenu(MenuItemHook):
     def __init__(self):
         MenuItemHook.__init__(self, 'Structure Timers',
-                              'fa fa-clock-o fa-fw',
+                              'far fa-clock fa-fw',
                               'timerboard:view',
                               navactive=['timerboard:'])
 

docs/contributing/index.md

@@ -0,0 +1,45 @@
+# Contributing
+
+Alliance Auth is developed by the community and we are always looking to welcome new contributors. If you are interested in contributing, here are some ideas where to start:
+
+## Publish a new community app or service
+
+One great way to contribute is to develop and publish your own community app or service for Alliance Auth. By design Auth only comes with some basic features and therefore heavily relies on the community to provide apps to extend Auth with additional features.
+
+To publish your app make sure it can be installed from a public repo or PyPI. Once it's ready, you can inform everybody about your new app by posting it to our [list of community apps](/features/community/index.md).
+
+If you are looking for ideas on what to make, you can check out Auth's [issue list](https://gitlab.com/allianceauth/allianceauth/-/issues?scope=all&utf8=%E2%9C%93&state=opened&label_name[]=enhancement). Many of those issues are feature requests that will probably never make into Auth core, but would be awesome to have as community app or service. You could also ask the other devs on our Discord server for ideas or to help you get a feeling about which new features might be in higher demand than others.
+
+## Help to maintain an existing community app or service
+
+There are quite a few great community apps that need help from additional maintainers. Often the initial author has no time anymore to support his app or would just appreciate some support for working on new features or to fix bugs.
+
+Sometimes original app owners may even be looking to completely hand over their apps to a new owner.
+
+If you are interested to help maintain an existing community app or service you can just start working on open issues and create merge requests. Or just ask other devs on our Discord.
+
+## Help with improving Auth documentation
+
+Auth has an extensive [documentation](https://allianceauth.readthedocs.io/en/latest/), but there are always things to improve and add. If you notice any errors or see something to improve or add please feel free to issue a change for the documentation (via MRs same as code changes).
+
+## Help with support questions on Discord
+
+One of the main functions of the Auth Discord server is to help the community with any support question they may have when installing or running an Auth installation.
+
+Note that you do not need a be part of any official group to become a supporter. Just jump in and help with answering new questions from the community if you know how to help.
+
+## Help to improve Alliance Auth core
+
+Alliance Auth has an issue list, which is usually the basis for all maintenance activities for Auth core. That means that bug fixes and new features are primarily delivered based on existing open issues.
+
+We usually have a long list of open issues and very much welcome every help to fix existing bugs or work on new features for Auth.
+
+Before starting to code on any topic we'd suggest talking to the other devs on Discord to make sure your issue is not already being worked on. Also, some feature request may be better implemented in a community app. Another aspect, which is best clarified by talking with the other devs.
+
+If you like to contribute to Auth core, but are unsure where to start, we have a dedicated label for issues that are suitable for beginners: [beginner friendly](https://gitlab.com/allianceauth/allianceauth/-/issues?label_name%5B%5D=beginner+friendly).
+
+## Additional Resources
+
+For more information on how to create community apps or how to setup a developer environment for Auth, please see our official [developer documentation](/development/index.md).
+
+For getting in touch with other contributors please feel free to join the [Alliance Auth Discord server](https://discord.gg/fjnHAmk).

docs/features/community/index.md

@@ -4,4 +4,4 @@ Another key feature of **Alliance Auth** is that it can be easily extended. Our
 
 Check out the [Community Creations](https://gitlab.com/allianceauth/community-creations) repo for more details.
 
-Or if you have very specific needs you can of course develop your own plugin- apps and services. Please see the [Development](/development/index.md) chapter details.
+Or if you have specific needs you can of course always develop your own plugin- apps and services. Please see the [Development](/development/index.md) chapter for details.

docs/features/services/discord.md

@@ -144,3 +144,11 @@ Name                                Description
 ### "Unknown Error" on Discord site when activating service
 
 This indicates your callback URL doesn't match. Ensure the `DISCORD_CALLBACK_URL` setting exactly matches the URL entered on the Discord developers site. This includes http(s), trailing slash, etc.
+
+### "Add/Remove" Errors in Discord Service
+
+If you are recieving errors in your Notifications after verifying that your settings are all correct try the following:
+
+- Ensure that the bot's role in Discord is at the top of the roles list. Each time you add it to your server you will need to do this again.
+- Make sure that the bot is not trying to modify the Owner of the discord, as it will fail. A holding discord account added with invite link will mitigate this.
+- Make sure that the bot role on discord has all needed permissions, Admin etc., remembering that these will need to be set every time you add the bot to the Discord server.

docs/index.md

@@ -18,4 +18,5 @@ Welcome to the official documentation for **Alliance Auth**!
     support/index
     customizing/index
     development/index
+    contributing/index
 ```

setup.py

@@ -18,9 +18,8 @@ install_requires = [
     'semantic_version',
     'packaging>=20.1,<21',
 
-    'future',
     'redis>=3.3.1,<4.0.0',
-    'celery>=4.3.0,<5.0.0',
+    'celery>=4.3.0,<5.0.0,!=4.4.4',  # 4.4.4 is missing a dependency
     'celery_once',
 
     'django>=2.2.1,<3.0',
@@ -33,7 +32,7 @@ install_requires = [
     'openfire-restapi',
     'sleekxmpp',
 
-    'django-esi>=1.5.0,<2.0'
+    'django-esi>=1.5,<3.0'
 ]
 
 testing_extras = [