aa-structures 2.10.0__tar.gz → 2.11.0__tar.gz

{aa_structures-2.10.0 → aa_structures-2.11.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: aa-structures
-Version: 2.10.0
+Version: 2.11.0
 Summary: App for managing Eve Online structures with Alliance Auth.
 Author-email: Erik Kalkoken <kalkoken87@gmail.com>
 Requires-Python: >=3.8

{aa_structures-2.10.0 → aa_structures-2.11.0}/structures/__init__.py

@@ -3,5 +3,5 @@
 # pylint: disable = invalid-name
 default_app_config = "structures.apps.StructuresConfig"
 
-__version__ = "2.10.0"
+__version__ = "2.11.0"
 __title__ = "Structures"

{aa_structures-2.10.0 → aa_structures-2.11.0}/structures/admin.py

@@ -348,6 +348,29 @@ class OwnerCharacterAdminInline(admin.TabularInline):
         return False
 
 
+class DisabledCharactersFilter(admin.SimpleListFilter):
+    title = _("has disabled characters")
+    parameter_name = "has_disabled_characters"
+
+    def lookups(self, request, model_admin):
+        return (
+            ("yes", _("yes")),
+            ("no", _("no")),
+        )
+
+    def queryset(self, request, queryset):
+        """Return the filtered queryset"""
+        if self.value() == "yes":
+            return queryset.annotate_characters_count().filter(
+                characters_disabled_count__gt=0
+            )
+        if self.value() == "no":
+            return queryset.annotate_characters_count().filter(
+                characters_disabled_count=0
+            )
+        return queryset
+
+
 @admin.register(Owner)
 class OwnerAdmin(admin.ModelAdmin):
     list_display = (
@@ -364,6 +387,7 @@ class OwnerAdmin(admin.ModelAdmin):
     list_filter = (
         "is_active",
         "is_up",
+        DisabledCharactersFilter,
         ("corporation__alliance", admin.RelatedOnlyFieldListFilter),
         "has_default_pings_enabled",
         "is_alliance_main",
@@ -376,6 +400,7 @@ class OwnerAdmin(admin.ModelAdmin):
         "fetch_notifications",
         "deactivate_owners",
         "activate_owners",
+        "reset_characters",
     )
     inlines = (OwnerCharacterAdminInline,)
     filter_horizontal = ("ping_groups", "webhooks")
@@ -485,9 +510,13 @@ class OwnerAdmin(admin.ModelAdmin):
     def has_add_permission(self, request):
         return False
 
-    @admin.display(ordering="characters_count_2", description=_("characters"))
-    def _characters(self, obj: Owner) -> int:
-        return obj.characters_count_2
+    @admin.display(ordering="characters_enabled_count", description=_("characters"))
+    def _characters(self, obj: Owner) -> str:
+        enabled = obj.characters_enabled_count
+        disabled = obj.characters_disabled_count
+        if not disabled:
+            return enabled
+        return f"{enabled} ({disabled})"
 
     @admin.display(description=_("default pings"), boolean=True)
     def _has_default_pings_enabled(self, obj: Owner):
@@ -549,6 +578,16 @@ class OwnerAdmin(admin.ModelAdmin):
         queryset.update(is_active=False)
         self.message_user(request, _("Deactivated %d owners") % queryset.count())
 
+    @admin.action(description=_("Reset disabled characters for selected owners"))
+    def reset_characters(self, request, queryset):
+        owner_pks = queryset.values_list("pk", flat=True)
+        OwnerCharacter.objects.filter(
+            owner__pk__in=list(owner_pks), is_enabled=False
+        ).update(is_enabled=True, disabled_reason="", error_count=0)
+        self.message_user(
+            request, _("Characters have been reset for %d owners") % len(owner_pks)
+        )
+
     @admin.action(description=_("Update all from EVE server for selected owners"))
     def update_all(self, request, queryset):
         for obj in queryset:
@@ -631,7 +670,7 @@ class OwnerAdmin(admin.ModelAdmin):
     def _assets_last_update_fresh(self, obj: Owner) -> bool:
         return obj.is_assets_sync_fresh
 
-    @admin.action(description=_("structures Count"))
+    @admin.display(description=_("structures Count"))
     def _structures_count(self, obj: Owner) -> int:
         return obj.structures.count()
 

{aa_structures-2.10.0 → aa_structures-2.11.0}/structures/app_settings.py

@@ -55,7 +55,7 @@ STRUCTURES_FEATURE_STARBASES = clean_setting("STRUCTURES_FEATURE_STARBASES", Tru
 STRUCTURES_ESI_DIRECTOR_ERROR_MAX_RETRIES = clean_setting(
     "STRUCTURES_ESI_DIRECTOR_ERROR_MAX_RETRIES", 3
 )
-"""Max retries before a character is deleted when ESI claims the character
+"""Max retries before a character is disabled when ESI claims the character
 is not a director (Since this sometimes is reported wrongly by ESI).
 """
 

{aa_structures-2.10.0 → aa_structures-2.11.0}/structures/managers.py

@@ -181,14 +181,27 @@ GeneratedNotificationManager = GeneratedNotificationManagerBase.from_queryset(
 
 class OwnerQuerySet(models.QuerySet):
     def annotate_characters_count(self) -> models.QuerySet:
-        """Add character count annotation."""
-        return self.annotate(
-            characters_count_2=Count(
+        """Add character count annotations."""
+        qs = self.annotate(
+            characters_enabled_count=Count(
+                "characters",
+                filter=Q(
+                    characters__character_ownership__isnull=False,
+                    characters__is_enabled=True,
+                ),
+                distinct=True,
+            )
+        ).annotate(
+            characters_disabled_count=Count(
                 "characters",
-                filter=Q(characters__character_ownership__isnull=False),
+                filter=Q(
+                    characters__character_ownership__isnull=False,
+                    characters__is_enabled=False,
+                ),
                 distinct=True,
             )
         )
+        return qs
 
     def structures_last_updated(self) -> Optional[dt.datetime]:
         """Date/time when structures were last updated for any of the active owners."""

aa_structures-2.11.0/structures/migrations/0006_add_ownercharacter_disabled.py

@@ -0,0 +1,27 @@
+# Generated by Django 4.0.10 on 2024-06-23 14:26
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("structures", "0005_add_notification_types"),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name="ownercharacter",
+            name="disabled_reason",
+            field=models.TextField(default=""),
+        ),
+        migrations.AddField(
+            model_name="ownercharacter",
+            name="is_enabled",
+            field=models.BooleanField(
+                default=True,
+                help_text="Disabled characters are not used for syncing owners",
+                verbose_name="is enabled",
+            ),
+        ),
+    ]

{aa_structures-2.10.0 → aa_structures-2.11.0}/structures/models/owners.py

@@ -338,12 +338,15 @@ class Owner(models.Model):
                 f"Character {character_ownership.character} does not belong "
                 "to owner corporation."
             )
-        obj, _ = self.characters.get_or_create(character_ownership=character_ownership)
+        obj: OwnerCharacter = self.characters.get_or_create(
+            character_ownership=character_ownership
+        )[0]
+        obj.reset()
         return obj
 
-    def characters_count(self) -> int:
+    def valid_characters_count(self) -> int:
         """Count of valid owner characters."""
-        return self.characters.count()
+        return self.characters.filter(is_enabled=True).count()
 
     def has_sov(self, eve_solar_system: EveSolarSystem) -> bool:
         """Determine whether this owner has sov in the given solar system."""
@@ -351,42 +354,31 @@ class Owner(models.Model):
             eve_solar_system=eve_solar_system, corporation=self.corporation
         )
 
-    def delete_character(
+    def disable_character(
         self,
         character: "OwnerCharacter",
-        error: str,
-        level: str = "warning",
+        reason: str,
         max_allowed_errors: int = 0,
     ) -> None:
-        """Delete character and notify it's owner and admin about the reason
+        """Disable character and notify it's owner and admins about it.
 
         Args:
-        - character: Character this error refers to
-        - error: Error text
-        - level: context level for the notification
-        - max_error: how many errors are permitted before character is deleted
+        - character: Character to disable
+        - reason: User friendly reason for the deletion
+        - max_allowed_errors: Maximum number of allowed errors for this type of error
         """
         if character.error_count < max_allowed_errors:
-            logger.warning(
-                (
-                    "%s: Character encountered an error and will be deleted "
-                    "if this occurs more often (%d/%d): %s"
-                ),
-                character,
-                character.error_count + 1,
-                max_allowed_errors,
-                error,
-            )
-            with transaction.atomic():
-                character.error_count = F("error_count") + 1
-                character.save(update_fields=["error_count"])
+            character.increase_error_count()
             return
 
-        title = f"{__title__}: {self}: Invalid character has been removed"
+        character.disable(reason)
+
+        title = f"{__title__}: {self}: Character has been disabled"
+        level = "warning"
         message = (
-            f"{character.character_ownership}: {error}\n"
-            "The character has been removed. "
-            "Please add a new character to restore the previous service level."
+            f"{character.character_ownership}: {reason}\n"
+            "This character caused too many errors and has been disabled. "
+            "Administrator action is required to resolve this issue."
         )
         notify(
             user=character.character_ownership.user,
@@ -394,15 +386,44 @@ class Owner(models.Model):
             message=message,
             level=level,
         )
-        if self.characters.count() == 1:
+        if not self.valid_characters_count():
             message += (
                 " This owner has no configured characters anymore "
                 "and it's services are now down."
             )
             level = "danger"
+
         notify_admins(title=f"FYI: {title}", message=message, level=level)
+
+    def delete_character(self, character: "OwnerCharacter", reason: str) -> None:
+        """Delete character and notify it's owner and admin about the reason
+
+        Args:
+        - character: Character this error refers to
+        - reason: User friendly reason for the deletion
+        """
         character.delete()
 
+        title = f"{__title__}: {self}: Invalid character has been removed"
+        level = "warning"
+        message = (
+            f"{character.character_ownership}: {reason}\n"
+            "Your character is no longer valid for syncing this owner and has been removed. "
+        )
+        notify(
+            user=character.character_ownership.user,
+            title=title,
+            message=message,
+            level=level,
+        )
+        if not self.valid_characters_count():
+            message += (
+                " This owner has no valid characters anymore "
+                "and it's services are now down."
+            )
+            level = "danger"
+        notify_admins(title=f"FYI: {title}", message=message, level=level)
+
     def _rotate_character(
         self,
         character: "OwnerCharacter",
@@ -421,7 +442,7 @@ class Owner(models.Model):
         )
         try:
             minimum_time_between_rotations = max(
-                rotate_characters.esi_cache_duration / self.characters.count(),
+                rotate_characters.esi_cache_duration / self.valid_characters_count(),
                 60,
             )
         except ZeroDivisionError:
@@ -453,14 +474,18 @@ class Owner(models.Model):
             if rotate_characters
             else "notifications_last_used_at"
         )
-        for character in self.characters.order_by(order_by_last_used):
+        enabled_characters: models.QuerySet[OwnerCharacter] = self.characters.filter(
+            is_enabled=True
+        ).order_by(order_by_last_used)
+        for character in enabled_characters:
             if (
                 character.character_ownership.character.corporation_id
                 != self.corporation.corporation_id
             ):
+                corporation_name = self.corporation.corporation_name
                 self.delete_character(
                     character=character,
-                    error="Character does no longer belong to the owner's corporation.",
+                    reason=f"Character is no longer a member of {corporation_name}",
                 )
                 continue
 
@@ -469,17 +494,17 @@ class Owner(models.Model):
             ):
                 self.delete_character(
                     character=character,
-                    error="Character does not have sufficient permission to sync.",
+                    reason="Character no longer has permission to sync",
                 )
                 continue
 
             token = character.valid_token()
             if not token:
-                self.delete_character(
-                    character=character,
-                    error="Character has no valid token for sync.",
+                self.disable_character(
+                    character=character, reason="No valid token found for character"
                 )
                 continue
+
             found_character = character
             break  # leave the for loop if we have found a valid token
 
@@ -797,6 +822,13 @@ class Owner(models.Model):
 
         Return True when successful, else False.
         """
+        try:
+            character: OwnerCharacter = self.characters.get(
+                character_ownership__character__character_id=token.character_id
+            )
+        except ObjectDoesNotExist:
+            return False
+
         structures = []
         try:
             starbases_data = (
@@ -824,21 +856,11 @@ class Owner(models.Model):
                 self._store_raw_data("starbases", structures)
 
         except HTTPForbidden:
-            try:
-                character = self.characters.get(
-                    character_ownership__character__character_id=token.character_id
-                )
-            except ObjectDoesNotExist:
-                pass
-            else:
-                self.delete_character(
-                    character=character,
-                    error=(
-                        "Character is not a director or CEO and therefore "
-                        "can not fetch starbases."
-                    ),
-                    max_allowed_errors=STRUCTURES_ESI_DIRECTOR_ERROR_MAX_RETRIES,
-                )
+            self.disable_character(
+                character=character,
+                reason=("This character is not a director or CEO"),
+                max_allowed_errors=STRUCTURES_ESI_DIRECTOR_ERROR_MAX_RETRIES,
+            )
             return False
 
         except OSError as ex:
@@ -849,6 +871,7 @@ class Owner(models.Model):
             structures_qs=self.structures.filter_starbases(),
             new_structures=structures,
         )
+        character.reset_error_counter()
         return True
 
     def _store_updates_for_starbases(self, token, structures):
@@ -1337,6 +1360,12 @@ class OwnerCharacter(models.Model):
         verbose_name=_("error count"),
         help_text="Count of ESI errors which happened with this character.",
     )
+    is_enabled = models.BooleanField(
+        default=True,
+        verbose_name=_("is enabled"),
+        help_text=_("Disabled characters are not used for syncing owners"),
+    )
+    disabled_reason = models.TextField(default="")
     created_at = models.DateTimeField(auto_now_add=True)
 
     class Meta:
@@ -1369,3 +1398,27 @@ class OwnerCharacter(models.Model):
             .require_valid()
             .first()
         )
+
+    def reset(self) -> None:
+        """Resets a disabled owner character."""
+        self.is_enabled = True
+        self.disabled_reason = ""
+        self.error_count = 0
+        self.save()
+
+    def reset_error_counter(self) -> None:
+        """Reset the error counter"""
+        self.error_count = 0
+        self.save(update_fields=["error_count"])
+
+    def disable(self, reason: str = "") -> None:
+        """Disables a character."""
+        self.is_enabled = False
+        self.disabled_reason = reason
+        self.save()
+
+    def increase_error_count(self):
+        """Increase error count of this character by one."""
+        with transaction.atomic():
+            self.error_count = F("error_count") + 1
+            self.save(update_fields=["error_count"])

{aa_structures-2.10.0 → aa_structures-2.11.0}/structures/tests/models/test_owners_1.py

@@ -318,20 +318,21 @@ class TestOwnerFetchToken(NoSocketsTestCase):
         self.assertTrue(mock_notify.called)
         self.assertEqual(owner.characters.count(), 0)
 
-    def test_raise_error_when_token_not_found_and_delete_character(
+    def test_raise_error_when_no_valid_token_found_and_disable_character(
         self, mock_notify_admins, mock_notify
     ):
         # given
-        character = EveCharacterFactory()
-        user = UserMainDefaultOwnerFactory(main_character__character=character)
-        owner = OwnerFactory(user=user, characters=[character])
-        user.token_set.first().scopes.clear()
+        eve_character = EveCharacterFactory()
+        user = UserMainDefaultOwnerFactory(main_character__character=eve_character)
+        owner = OwnerFactory(user=user, characters=[eve_character])
+        user.token_set.first().scopes.clear()  # token no longer valid
         # when/then
         with self.assertRaises(TokenError):
             owner.fetch_token()
+        character = owner.characters.first()
+        self.assertFalse(character.is_enabled)
         self.assertTrue(mock_notify_admins.called)
         self.assertTrue(mock_notify.called)
-        self.assertEqual(owner.characters.count(), 0)
 
     def test_raise_error_when_character_no_longer_a_corporation_member_and_delete_it(
         self, mock_notify_admins, mock_notify
@@ -351,37 +352,7 @@ class TestOwnerFetchToken(NoSocketsTestCase):
         self.assertTrue(mock_notify.called)
         self.assertEqual(owner.characters.count(), 0)
 
-    def test_should_delete_invalid_characters_and_return_token_from_valid_char(
-        self, mock_notify_admins, mock_notify
-    ):
-        # given
-        character_1 = EveCharacterFactory()
-        user = UserMainDefaultOwnerFactory(main_character__character=character_1)
-        owner = OwnerFactory(
-            user=user,
-            characters=[character_1],
-            characters__notifications_last_used_at=dt.datetime(
-                2021, 1, 1, 1, 2, tzinfo=utc
-            ),
-        )
-        character_2 = EveCharacterFactory()
-        OwnerCharacterFactory(
-            owner=owner,
-            eve_character=character_2,
-            notifications_last_used_at=dt.datetime(2021, 1, 1, 1, 1, tzinfo=utc),
-        )
-
-        # when
-        token = owner.fetch_token()
-
-        # then
-        self.assertIsInstance(token, Token)
-        self.assertEqual(token.user, user)
-        self.assertTrue(mock_notify_admins.called)
-        self.assertTrue(mock_notify.called)
-        self.assertEqual(owner.characters.count(), 1)
-
-    def test_should_rotate_through_characters_for_notification(
+    def test_should_rotate_through_enabled_characters_for_notification(
         self, mock_notify_admins, mock_notify
     ):
         # given
@@ -398,6 +369,9 @@ class TestOwnerFetchToken(NoSocketsTestCase):
             owner=owner,
             notifications_last_used_at=dt.datetime(2021, 1, 1, 3, 0, tzinfo=utc),
         )
+        OwnerCharacterFactory(
+            owner=owner, is_enabled=False
+        )  # this one should be ignore
         tokens_received = []
 
         # when
@@ -493,6 +467,36 @@ class TestOwnerFetchToken(NoSocketsTestCase):
             ],
         )
 
+    def test_should_delete_invalid_characters_and_return_token_from_valid_char(
+        self, mock_notify_admins, mock_notify
+    ):
+        # given
+        character_1 = EveCharacterFactory()
+        user = UserMainDefaultOwnerFactory(main_character__character=character_1)
+        owner = OwnerFactory(
+            user=user,
+            characters=[character_1],
+            characters__notifications_last_used_at=dt.datetime(
+                2021, 1, 1, 1, 2, tzinfo=utc
+            ),
+        )
+        character_2 = EveCharacterFactory()  # invalid, because of different corporation
+        OwnerCharacterFactory(
+            owner=owner,
+            eve_character=character_2,
+            notifications_last_used_at=dt.datetime(2021, 1, 1, 1, 1, tzinfo=utc),
+        )
+
+        # when
+        token = owner.fetch_token()
+
+        # then
+        self.assertIsInstance(token, Token)
+        self.assertEqual(token.user, user)
+        self.assertTrue(mock_notify_admins.called)
+        self.assertTrue(mock_notify.called)
+        self.assertEqual(owner.characters.count(), 1)
+
 
 class TestOwnerCharacters(NoSocketsTestCase):
     @classmethod
@@ -500,12 +504,6 @@ class TestOwnerCharacters(NoSocketsTestCase):
         super().setUpClass()
         cls.owner = OwnerFactory()
 
-    def test_should_return_str(self):
-        # given
-        character = OwnerCharacterFactory(owner=self.owner)
-        # when/then
-        self.assertTrue(str(character))
-
     def test_should_add_new_character(self):
         # given
         character = EveCharacterFactory(corporation=self.owner.corporation)
@@ -546,22 +544,35 @@ class TestOwnerCharacters(NoSocketsTestCase):
         with self.assertRaises(ValueError):
             self.owner.add_character(character_ownership)
 
-    def test_should_count_characters(self):
+    def test_should_count_enabled_characters_only(self):
         # given
-        OwnerCharacterFactory(owner=self.owner)
+        OwnerCharacterFactory(owner=self.owner, is_enabled=False)
         # when
-        result = self.owner.characters_count()
+        result = self.owner.valid_characters_count()
         # then
-        self.assertEqual(result, 2)
+        self.assertEqual(result, 1)
 
     def test_should_count_characters_when_empty(self):
         # given
         owner = OwnerFactory(characters=False)
         # when
-        result = owner.characters_count()
+        result = owner.valid_characters_count()
         # then
         self.assertEqual(result, 0)
 
+    def test_should_reset_character_when_re_adding(self):
+        # given
+        character: OwnerCharacter = self.owner.characters.first()
+        character.is_enabled = False
+        character.disabled_reason = "some reason"
+        character.save()
+        # when
+        self.owner.add_character(character.character_ownership)
+        # then
+        character.refresh_from_db()
+        self.assertTrue(character.is_enabled)
+        self.assertFalse(character.disabled_reason)
+
 
 @patch(MODULE_PATH + ".notify", spec=True)
 @patch(MODULE_PATH + ".notify_admins", spec=True)
@@ -577,7 +588,7 @@ class TestOwnerDeleteCharacter(NoSocketsTestCase):
         user = character.character_ownership.user
 
         # when
-        self.owner.delete_character(character=character, error="dummy error")
+        self.owner.delete_character(character=character, reason="dummy error")
 
         # then
         self.assertEqual(self.owner.characters.count(), 0)
@@ -591,18 +602,50 @@ class TestOwnerDeleteCharacter(NoSocketsTestCase):
         self.assertEqual(kwargs["user"], user)
         self.assertEqual(kwargs["level"], "warning")
 
-    def test_should_not_delete_when_errors_are_allowed(
+
+@patch(MODULE_PATH + ".notify", spec=True)
+@patch(MODULE_PATH + ".notify_admins", spec=True)
+class TestOwnerDisableCharacters(NoSocketsTestCase):
+    @classmethod
+    def setUpClass(cls):
+        super().setUpClass()
+        cls.owner = OwnerFactory(characters=False)
+
+    def test_should_disable_character_and_notify(self, mock_notify_admins, mock_notify):
+        # given
+        character = OwnerCharacterFactory(owner=self.owner)
+        user = character.character_ownership.user
+
+        # when
+        self.owner.disable_character(character=character, reason="dummy error")
+
+        # then
+        character.refresh_from_db()
+        self.assertFalse(character.is_enabled)
+        self.assertTrue(character.disabled_reason)
+        self.assertTrue(mock_notify_admins.called)
+        _, kwargs = mock_notify_admins.call_args
+        self.assertIn("dummy error", kwargs["message"])
+        self.assertEqual(kwargs["level"], "danger")
+        self.assertTrue(mock_notify.called)
+        _, kwargs = mock_notify.call_args
+        self.assertIn("dummy error", kwargs["message"])
+        self.assertEqual(kwargs["user"], user)
+        self.assertEqual(kwargs["level"], "warning")
+
+    def test_should_not_disable_when_error_counter_above_zero(
         self, mock_notify_admins, mock_notify
     ):
         # given
         character = OwnerCharacterFactory(owner=self.owner)
 
         # when
-        self.owner.delete_character(
-            character=character, error="dummy error", max_allowed_errors=1
+        self.owner.disable_character(
+            character=character, reason="dummy error", max_allowed_errors=1
         )
         # then
         character.refresh_from_db()
+        self.assertTrue(character.is_enabled)
         self.assertEqual(character.error_count, 1)
         self.assertFalse(mock_notify_admins.called)
         self.assertFalse(mock_notify.called)