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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: aa-structures
-Version: 2.10.0
+Version: 2.12.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.12.0}/structures/__init__.py

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

{aa_structures-2.10.0 → aa_structures-2.12.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.12.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.12.0}/structures/core/notification_embeds/main.py

@@ -10,6 +10,8 @@ import dhooks_lite
 from django.conf import settings
 from django.utils.translation import gettext as _
 
+from allianceauth.services.hooks import get_extension_logger
+from app_utils.logging import LoggerAddTag
 from app_utils.urls import reverse_absolute, static_file_absolute_url
 
 from structures import __title__
@@ -19,6 +21,8 @@ from structures.models.notifications import Notification, NotificationBase, Webh
 
 from .helpers import target_datetime_formatted
 
+logger = LoggerAddTag(get_extension_logger(__name__), __title__)
+
 
 class NotificationBaseEmbed:
     """Base class for all notification embeds.
@@ -141,6 +145,20 @@ class NotificationBaseEmbed:
             footer_text += f" #{my_text}"
         footer_icon_url = footer_icon_url if is_absolute_url(footer_icon_url) else None
         footer = dhooks_lite.Footer(text=footer_text, icon_url=footer_icon_url)
+        max_description = dhooks_lite.Embed.MAX_DESCRIPTION
+        if self._description and len(self._description) > max_description:
+            logger.warning(
+                "%s: Description of notification is too long: %s",
+                self,
+                self._description,
+            )
+            self._description = self._description[:max_description]
+        max_title = dhooks_lite.Embed.MAX_TITLE
+        if self._title and len(self._title) > max_title:
+            logger.warning(
+                "%s: Title of notification is too long: %s", self, self._title
+            )
+            self._title = self._title[:max_title]
         return dhooks_lite.Embed(
             author=author,
             color=self._color,

{aa_structures-2.10.0 → aa_structures-2.12.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.12.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.12.0}/structures/models/notifications.py

@@ -410,11 +410,15 @@ class NotificationBase(models.Model):
         try:
             embed, ping_type = self._generate_embed(webhook.language_code)
         except OSError as ex:
-            logger.warning("%s: Failed to generate embed: %s", self, ex, exc_info=True)
+            logger.error("%s: Failed to generate embed: %s", self, ex, exc_info=True)
             return False
 
         content = self._create_content_with_pings(webhook, ping_type)
         content += self._add_discord_group_pings(webhook)
+        max_content = dhooks_lite.Webhook.MAX_CHARACTERS
+        if content and len(content) > max_content:
+            logger.error("%s: Content of notification is too long: %s", self, content)
+            return False
 
         username, avatar_url = self._gen_avatar()
         new_queue_size = webhook.send_message(

{aa_structures-2.10.0 → aa_structures-2.12.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.12.0}/structures/tests/core/notification_embeds/test_main.py

@@ -240,6 +240,26 @@ class TestNotificationEmbedsGenerate(TestCase):
         self.assertEqual(discord_embed.footer.text, "Structures")
         self.assertIn("structures_logo.png", discord_embed.footer.icon_url)
 
+    def test_should_not_break_with_too_large_description(self):
+        # given
+        notification = Notification.objects.get(notification_id=1000000403)
+        notification_embed = NotificationBaseEmbed.create(notification)
+        notification_embed._description = "x" * 2049
+        # when
+        discord_embed = notification_embed.generate_embed()
+        # then
+        self.assertIsInstance(discord_embed, dhooks_lite.Embed)
+
+    def test_should_not_break_with_too_large_title(self):
+        # given
+        notification = Notification.objects.get(notification_id=1000000403)
+        notification_embed = NotificationBaseEmbed.create(notification)
+        notification_embed._title = "x" * 257
+        # when
+        discord_embed = notification_embed.generate_embed()
+        # then
+        self.assertIsInstance(discord_embed, dhooks_lite.Embed)
+
 
 class TestNotificationEmbedsClasses(NoSocketsTestCase):
     @classmethod

{aa_structures-2.10.0 → aa_structures-2.12.0}/structures/tests/models/test_notifications_discord.py

@@ -33,6 +33,7 @@ if "discord" in app_labels():
             super().setUpClass()
             load_eveuniverse()
             load_eve_entities()
+
             cls.group_1 = Group.objects.create(name="Dummy Group 1")
             cls.group_2 = Group.objects.create(name="Dummy Group 2")
             cls.owner = OwnerFactory()
@@ -140,3 +141,23 @@ if "discord" in app_labels():
             self.assertTrue(mock_import_discord.called)
             _, kwargs = mock_send_message.call_args
             self.assertFalse(re.search(r"(<@&\d+>)", kwargs["content"]))
+
+        def test_should_abort_when_content_is_too_large(
+            self, mock_send_message, mock_import_discord
+        ):
+            # given
+            mock_send_message.return_value = 1
+            mock_import_discord.return_value.objects.group_to_role.side_effect = (
+                self._my_group_to_role
+            )
+            webhook = WebhookFactory()
+            for i in range(286):
+                group = Group.objects.create(name=f"Group {i+1}")
+                webhook.ping_groups.add(group)
+            obj = clone_notification(
+                Notification.objects.get(notification_id=1000000509)
+            )
+            # when
+            result = obj.send_to_webhook(webhook)
+            # then
+            self.assertFalse(result)