aa-structures 2.10.0__py3-none-any.whl → 2.12.0__py3-none-any.whl

{aa_structures-2.10.0.dist-info → aa_structures-2.12.0.dist-info}/METADATA

@@ -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.dist-info → aa_structures-2.12.0.dist-info}/RECORD

@@ -1,12 +1,12 @@
-structures/__init__.py,sha256=uMpmaP4VBhwkpAgLo3BXo4Hx7Rw_4RLMyB7jScq_qO8,204
-structures/admin.py,sha256=cn6AtcSDI6bJROhBnvE2iQwOkm1t3NVabrpTVphxbTk,38662
-structures/app_settings.py,sha256=7BFWl1Q4tqTuj3CV6BmEctIFKJx9QIUfm2tjKzme2jM,6526
+structures/__init__.py,sha256=CxjO-itYCGXfwByFQ-cKfhmKWBvz2Lygf1fchGS8_nU,204
+structures/admin.py,sha256=TYWGPou4s-mgspoGaZSiZu2nxBeNzidL_DcJTv7JGJI,40068
+structures/app_settings.py,sha256=7I_6VC7YecCxnSgtyNQa9h1Zdwb11qJhrNaBLgyA5m0,6527
 structures/apps.py,sha256=MNZH9l3qWCwuS7OGiKGkBVrDzKoOFlqwDdEgyEFzxVA,195
 structures/auth_hooks.py,sha256=nRbrixFkAE5gphDokB1E8xhH8FY2VtXVwu0XMmSGBAw,1013
 structures/constants.py,sha256=R7sC5esaWJayJpTDbug7dTKxkkXDKXQ-U6M9Qb0GH5s,967
 structures/forms.py,sha256=kXs-SGIIj-D9xtFCILKe_PMRU4eHl3-HLNWRhaZKmnQ,391
 structures/helpers.py,sha256=_dw7j7yobpcV70VwWxoQiptk69b3ksvaDlRQKHg8Kmg,2344
-structures/managers.py,sha256=Th_nPY8GNcdBPqqfqjtTriYdsZWFAWknbNqI8QG17vo,19225
+structures/managers.py,sha256=5hejDjWN3ZPZqvSGNf9HXtbtpWX9d75Ygc9FXrO0Np4,19638
 structures/providers.py,sha256=9QYHd8X5HwBhrbgbX3LUrXXV1KGM3hFhcxK6qIJjJtg,317
 structures/tasks.py,sha256=INZ3soMYHYfxrQsyTO-ozoxbVX6lpMnF3AUo8ybWIoA,9083
 structures/urls.py,sha256=An5v27AD_NXMNL66cMVtQNci1C_Aqry32rrvDkMpgYo,1467
@@ -20,7 +20,7 @@ structures/core/notification_embeds/__init__.py,sha256=30cpjKLZ5_OFtXDACDcjvWQAY
 structures/core/notification_embeds/billing_embeds.py,sha256=d9XkTyYH7U3UDZaqXu0WoN0wvlrT2S68Rfn2jEpVtM4,5164
 structures/core/notification_embeds/corporate_embeds.py,sha256=mfm6dDrgzupyRZ9TZGXML-UGoY_PymNj9LuR8EthdDA,6098
 structures/core/notification_embeds/helpers.py,sha256=0SlrLLFyV0IrdOYfIOLQs0xZgzK8bO7Iroqh7dZnm98,2974
-structures/core/notification_embeds/main.py,sha256=N-l9PJYxgsBvcPOG1WQ2OgxC6hCAQnxgx2V1gWUsSMc,15233
+structures/core/notification_embeds/main.py,sha256=P8Ajvd9j4SUBpZde2IOejFUV5bEXMUWU4lolNjkrxWQ,16048
 structures/core/notification_embeds/moonmining_embeds.py,sha256=5OJtfwoLE18mB62iwyHTcMo9eOPBC2vQFSjQlDnTcTY,7130
 structures/core/notification_embeds/orbital_embeds.py,sha256=ovAnTqrc2X0s-HhQS-UleI8J5-gJEO361HYJzcoAdeQ,2864
 structures/core/notification_embeds/sov_embeds.py,sha256=_r4U5zN3MfEag9FCeN0my2d4qfMBUwYUGWW-oGftjn8,8901
@@ -57,11 +57,12 @@ structures/migrations/0002_remove_eveuniverse_relation_names.py,sha256=yXOFSolB0
 structures/migrations/0003_add_localization_and_unique_key.py,sha256=ZxJMfUtgUH2W8Z0zbN-iqMzjC3-1pvsbywJFyFMxWGA,44042
 structures/migrations/0004_improve_localization.py,sha256=R29j2Ki9I_yOvEQTxEu_zMnZrR7JkSGpmvMTpp9XjqM,14014
 structures/migrations/0005_add_notification_types.py,sha256=aIgNZN4Gsvh9GiJ0i4XmXopT0qqjZTQrdVjZaVIJKP8,7087
+structures/migrations/0006_add_ownercharacter_disabled.py,sha256=yfcuwWHdSoF7HTEzdtQ1bGhI-K78SxCeE3g3z6UjbqI,726
 structures/migrations/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 structures/models/__init__.py,sha256=Da0-Z4BtsZ_mlnI6XtyvoE0UtTuOA0psGCuVhVPVKrM,916
 structures/models/eveuniverse.py,sha256=vTIfzZL9guEDuZHQvRdG6pI4zSEdMqfVE-2SkHdqbRo,2213
-structures/models/notifications.py,sha256=tznJo2prNjhk9C7S4cDrQxftIvuLcidB6vSkvFfb4mw,35146
-structures/models/owners.py,sha256=8tw8mR2ti9MpPs5ajeV5AONY53cvO5XnucrfIOQXEA4,53953
+structures/models/notifications.py,sha256=HwQc-ChdP0ULuJgxUym9_CBsCWCmcHT7whlk9tB2vzw,35364
+structures/models/owners.py,sha256=8VDRL1fPep0TN6Nv5MJg1NC6_2V6bMJd6f-eda4-PJg,55697
 structures/models/structures_1.py,sha256=e1sI-2zMSKcPi2PyYA--fcc8rn-yQwODzlUHKjeWgLI,29778
 structures/models/structures_2.py,sha256=g5Pct5jNmZC-n7fnpLs5UyiP9JLrGdI1vjYucHTV_wQ,10371
 structures/static/structures/css/global.css,sha256=R4LEH9PwLoN77qkqBK7u2y_vzRC3fq8X_zKnAW7yhiA,1165
@@ -156,10 +157,10 @@ structures/templates/structures/templatetags/list_title.html,sha256=C2NWwo27TGfG
 structures/templatetags/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 structures/templatetags/structures.py,sha256=vSt5AnfYuo11q1SxiskT4oshSMsZ9ZgM0nYpYiMl8bA,1637
 structures/tests/__init__.py,sha256=9MrJzKr8DdsQY3-79v188pTpwqT4TDQ46vKnBJAGqic,75
-structures/tests/test_admin.py,sha256=_kV4giMVn-Pp77er0V5Pu10eBBohzT_oEdnl6D6q5bM,24333
+structures/tests/test_admin.py,sha256=cb_AbOanp31k-oZhaUXCqnlkUu87EgNddq_VQKbB_Dk,26839
 structures/tests/test_helpers.py,sha256=BQC-4H-9-v5qW4nugqy0bkxuGlA3UO2clYY2lI2LjoY,4893
 structures/tests/test_managers_1.py,sha256=ruKq5VRYHdStDQe3uzVhcxF0seQQfmdudJEUYXzi8bY,34539
-structures/tests/test_managers_2.py,sha256=COF4DO67ejHueNwmVj5mtj9ps-FCq9uJQYTmWwpQW7Y,2942
+structures/tests/test_managers_2.py,sha256=FISr_NT1Qnu9j1JYYTceNsUk8k9rfCTKwjKi5WUVbPs,3025
 structures/tests/test_tasks.py,sha256=reL1rPv_kvTgsC4lq5SXulkbEHaJrw5B1-hFI4tiDWY,17269
 structures/tests/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 structures/tests/core/test_notification_structuretimers.py,sha256=OvldjgIHmRVsqoC9C6VJRqwS9WeRFMgpyutRc69PjAU,10857
@@ -170,7 +171,7 @@ structures/tests/core/test_sovereignty.py,sha256=SGgNw6NxmaU3jV-EDhKJRLfHnRnqDCw
 structures/tests/core/test_starbases.py,sha256=Q3EZVIKZGzxUUvvn0TvZYOL9YQ-baiTRTT83xWqTAhQ,3186
 structures/tests/core/notification_embeds/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 structures/tests/core/notification_embeds/test_helpers.py,sha256=HG20TC8Bz7NqpaQWo6uvrsxfNIwTL2Zi_NRkh3UyN2Y,1776
-structures/tests/core/notification_embeds/test_main.py,sha256=vTDByjxxVCA6KMcr5XH4f4QsMgcDI_YDd-fjZfHztng,13808
+structures/tests/core/notification_embeds/test_main.py,sha256=rSUm8dGsddjnX_OUwtCh-wd5UhJ6ttTsfxc1soAoDv8,14667
 structures/tests/integration/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 structures/tests/integration/test_tasks.py,sha256=s6hL5UBotDmhLq7NUiOad72W-S_18u_yAHiLWVryVi8,23617
 structures/tests/integration/test_views.py,sha256=SkbIposTUjo0nujHL4WEaZO7nY1Bfuvm805H39XUv-g,4361
@@ -179,19 +180,20 @@ structures/tests/models/test_eveuniverse.py,sha256=bQ1upOLfoivfaa9KCrzjWvSH_EvL2
 structures/tests/models/test_notifications_1.py,sha256=xVX4an54sZM8WLUdsAGUG2Nb4Rl7W5FBzhI0hBhJo5g,30300
 structures/tests/models/test_notifications_2.py,sha256=wBoB6lHMK4yrd63DSkZ570yXW6coevDtI0pl1ttgB1o,31989
 structures/tests/models/test_notifications_3.py,sha256=u11s0k9EmtFgL3kyb4zDyLVliQLOps701ZgEA2T2i0Y,7257
-structures/tests/models/test_notifications_discord.py,sha256=9_42lcrb2lUUMRqgdRJAub9cJ4QZI71OyoORwK0LEvg,5551
-structures/tests/models/test_owners_1.py,sha256=Xpac4P0xpJUmU8Jz5Ebxu0oSvhGcaW9a6UI7Jxhgmz4,22600
+structures/tests/models/test_notifications_discord.py,sha256=6maDXjl2C5yH2XRgsvMtb3P-tfOdZLQDaksffiqS8OM,6312
+structures/tests/models/test_owners_1.py,sha256=o8AJasQ0-Pdb0FRFZcmNcMGjaIk8fH3OZIZw4paJiDw,24433
 structures/tests/models/test_owners_2.py,sha256=gkTXpSibPWs1XfZtPvyeEvVebyYZcKERD9GQSYSClYk,21911
 structures/tests/models/test_owners_3.py,sha256=cpDkfFkVvC1v4uuXha1vGUmWZ163huYTUDuZyed9Rdc,16947
-structures/tests/models/test_owners_4.py,sha256=1tLHxeQTE4RacEdckwwQCocWyy0tVYuDDrHnHtQTNlA,18831
+structures/tests/models/test_owners_4.py,sha256=_VP4QsPYGwBnn_bVN4aNX2ZVeJzMAzWObZrgCJkOPgY,19496
 structures/tests/models/test_owners_5.py,sha256=lTSfVY3rPOLyF-IhlKPT4mbRqvuN_NA-kyU0Vzzp9qY,31607
+structures/tests/models/test_owners_6.py,sha256=R9UE2QGwiGTWLHzzOZwGQPWJrAPwIIl7UwrHH-ki4Ak,940
 structures/tests/models/test_structures.py,sha256=6HktwBOsmRtRq5MnRlZnvNixUsWUpRni_XnPjNpMN0Y,41469
 structures/tests/testdata/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 structures/tests/testdata/create_eveuniverse.py,sha256=E-Fh-dmuHmLZcqgK2U6mwt9W6dI7H99bG7DaETfcVQY,2129
 structures/tests/testdata/entities.json,sha256=kmcmmbHG_igHwvkpAJGHQEztEXjlo8McDuojpEBmgqU,32147
 structures/tests/testdata/esi_data.json,sha256=DX47oSlRZIPxlPueMfiNElbZbAip2cp3LAUmv8GAPJ0,13864
 structures/tests/testdata/eveuniverse.json,sha256=Z8_EXOF8XNvls9RfBYIHhoNX0rj0NqcjInTU6tZuwhI,993284
-structures/tests/testdata/factories.py,sha256=I-NQI9c6yakWzvYWg48QyX3-6h2bxoymcvPM0RyiEJw,24718
+structures/tests/testdata/factories.py,sha256=KNXxOad44DKD0luQ7QS0DepnCr1S_Z6qwfiXnNDy10I,24774
 structures/tests/testdata/generate_notifications.py,sha256=nE077mVHVmOVudKIGMtHUfBIcV5Ch5Z0IngD1gp5yQk,5746
 structures/tests/testdata/generate_notifications_2.py,sha256=mdoGXd9vgy_opmrwTr9MfGe-QieHV4BHtRA7VFzxFKM,1413
 structures/tests/testdata/generate_structures.py,sha256=4p2ypDj-goniBnraTP2KfWzEX3YLj0qhKPNTfCXy05g,9134
@@ -203,14 +205,14 @@ structures/tests/views/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3
 structures/tests/views/test_public.py,sha256=FTaT3VUOnoT4t9rCCTCGyDrberpa8CRJHsXuqAw2PQE,1372
 structures/tests/views/test_service_status.py,sha256=mWkP13HnKRa3ltsZ2FKJuZRJjvYic9wjgQ1J3qA8n-k,4197
 structures/tests/views/test_statistics.py,sha256=MHt31AIX9_jt8-yP8XsbsiRRUKEtY8mQJbk11saFYZc,2626
-structures/tests/views/test_structures.py,sha256=dspLWOORWZyhgZRD8OtqZtG2kL4kN7JEFTI1v4l7I9U,25971
+structures/tests/views/test_structures.py,sha256=4DrURs32GvbMnXXJm1dC1ZhsDVhJ50iKyiqTRyyRe70,28284
 structures/tests/views/utils.py,sha256=0ALPjL8d0vcIWa_Pl4_gDl1qtBp71oDqyZLJyvDj-Uc,247
 structures/views/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 structures/views/common.py,sha256=Z_hcpEpkGrhwFdMAAMON_DqsfQ_lMyRwOMl5ROo_aSk,818
 structures/views/public.py,sha256=-Tel-poYKZTy8eQllhsWUxVf7HYBuCfeL9JWlbKhs7s,3035
 structures/views/statistics.py,sha256=7jj8b9ATsYwE7Cg6gMp-bYx29nV43GdWYun9WBggGkM,4709
 structures/views/status.py,sha256=gcahbk6dPIZDqkaNHDAsEHyDWLzicTK18Fom0A6xx3c,718
-structures/views/structures.py,sha256=hw4Rjr6O_fK7dvdgtZGP9r3DExkfEwCPixeoEBK5KNU,22548
+structures/views/structures.py,sha256=E1ssnqr2zp0rLQ3txIa6XkcX3NStNjMkuQM4iNjt6yw,22560
 structures/webhooks/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 structures/webhooks/core.py,sha256=mP25MbQG8Yv2YayDFcR6x2V30eqXhR2q5u4SRefblf4,6573
 structures/webhooks/managers.py,sha256=L3G3AmsyDeif_lfpWshmAxQ61UGJ9w8i9lZaF2jbOtQ,1117
@@ -218,7 +220,7 @@ structures/webhooks/models.py,sha256=kUkt9rnRQIJIrU9Bjcs34rvkb-TMbUubHdn-kny08kI
 structures/webhooks/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 structures/webhooks/tests/test_core.py,sha256=4NcEAQgK2KhQkFOxYh2ad0S-qUWh1DNGDmLo5Mo5opI,6762
 structures/webhooks/tests/test_utils.py,sha256=ekADFv0JOEtXeqdiejbeqrABO__Q1flJHzVieQ7L9e0,459
-aa_structures-2.10.0.dist-info/LICENSE,sha256=XZiwB_S_40_HhnvLg5xvtBb3g1oGjPrk0rpFwk8iInE,1070
-aa_structures-2.10.0.dist-info/WHEEL,sha256=EZbGkh7Ie4PoZfRQ8I0ZuP9VklN_TvcZ6DSE5Uar4z4,81
-aa_structures-2.10.0.dist-info/METADATA,sha256=fc6JHf4tNiaFaCZmiZZRD71A0Q2BMEjAjuIQNHmwicI,5972
-aa_structures-2.10.0.dist-info/RECORD,,
+aa_structures-2.12.0.dist-info/LICENSE,sha256=XZiwB_S_40_HhnvLg5xvtBb3g1oGjPrk0rpFwk8iInE,1070
+aa_structures-2.12.0.dist-info/WHEEL,sha256=EZbGkh7Ie4PoZfRQ8I0ZuP9VklN_TvcZ6DSE5Uar4z4,81
+aa_structures-2.12.0.dist-info/METADATA,sha256=E2IAO0tGX_bRqM9r1ryldZsIGyv22TLHn8tMs8zQ2zs,5972
+aa_structures-2.12.0.dist-info/RECORD,,

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"

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()
 

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).
 """
 

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,

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."""

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",
+            ),
+        ),
+    ]

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(

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"])

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

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)

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)

structures/tests/models/test_owners_4.py

@@ -7,7 +7,7 @@ from app_utils.esi_testing import EsiClientStub, EsiEndpoint
 from app_utils.testing import NoSocketsTestCase
 
 from structures.constants import EveCorporationId
-from structures.models import StarbaseDetail, Structure
+from structures.models import OwnerCharacter, StarbaseDetail, Structure
 from structures.tests.testdata.factories import (
     EveEntityCorporationFactory,
     OwnerFactory,
@@ -353,12 +353,13 @@ class TestUpdateStarbasesEsi(NoSocketsTestCase):
         owner.refresh_from_db()
         self.assertFalse(owner.is_structure_sync_fresh)
         self.assertTrue(mock_notify)
-        character = owner.characters.first()
+        character: OwnerCharacter = owner.characters.first()
         self.assertEqual(character.error_count, 1)
+        self.assertTrue(character.is_enabled)
 
     @patch(MODULE_PATH + ".STRUCTURES_ESI_DIRECTOR_ERROR_MAX_RETRIES", 3)
     @patch(MODULE_PATH + ".notify", spec=True)
-    def test_should_remove_character_when_not_director_while_updating_starbases(
+    def test_should_disable_character_when_not_director_while_updating_starbases(
         self, mock_notify, mock_esi
     ):
         # given
@@ -369,7 +370,7 @@ class TestUpdateStarbasesEsi(NoSocketsTestCase):
         )
         mock_esi.client = self.esi_client_stub.replace_endpoints([new_endpoint])
         owner = OwnerFactory(user=self.user, structures_last_update_at=None)
-        character = owner.characters.first()
+        character: OwnerCharacter = owner.characters.first()
         character.error_count = 3
         character.save()
         # when
@@ -378,7 +379,22 @@ class TestUpdateStarbasesEsi(NoSocketsTestCase):
         owner.refresh_from_db()
         self.assertFalse(owner.is_structure_sync_fresh)
         self.assertTrue(mock_notify)
-        self.assertNotIn(character, owner.characters.all())
+        character.refresh_from_db()
+        self.assertFalse(character.is_enabled)
+
+    def test_should_reset_error_count_for_character_when_successful(self, mock_esi):
+        # given
+        mock_esi.client = self.esi_client_stub
+        owner = OwnerFactory(user=self.user, structures_last_update_at=None)
+        character: OwnerCharacter = owner.characters.first()
+        character.error_count = 3
+        character.save()
+        # when
+        owner.update_structures_esi()
+        # then
+        character.refresh_from_db()
+        self.assertTrue(character.is_enabled)
+        self.assertEqual(character.error_count, 0)
 
     def test_should_remove_old_starbases(self, mock_esi):
         # given

structures/tests/models/test_owners_6.py

@@ -0,0 +1,31 @@
+from app_utils.testing import NoSocketsTestCase
+
+from structures.tests.testdata.factories import OwnerCharacterFactory, OwnerFactory
+
+MODULE_PATH = "structures.models.owners"
+
+
+class TestOwnerCharacter(NoSocketsTestCase):
+    @classmethod
+    def setUpClass(cls):
+        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_can_reset_character(self):
+        # given
+        character = OwnerCharacterFactory(
+            owner=self.owner, is_enabled=False, disabled_reason="reason", error_count=42
+        )
+        # when
+        character.reset()
+        # then
+        character.refresh_from_db()
+        self.assertTrue(character.is_enabled)
+        self.assertFalse(character.disabled_reason)
+        self.assertFalse(character.error_count)

structures/tests/test_admin.py

@@ -32,6 +32,7 @@ from .testdata.factories import (
     EveCorporationInfoFactory,
     FuelAlertConfigFactory,
     NotificationFactory,
+    OwnerCharacterFactory,
     OwnerFactory,
     PocoFactory,
     StarbaseFactory,
@@ -261,6 +262,7 @@ class TestNotificationAdmin(TestCase):
         )
         # when
         result = self.modeladmin._structures(obj)
+        # then
         self.assertIsNone(result)
 
     # FIXME: Does not seam to work with special prefetch list
@@ -356,6 +358,52 @@ class TestNotificationAdmin(TestCase):
         self.assertSetEqual(set(queryset), set(expected))
 
 
+class TestNotificationAdminWebhooks(TestCase):
+    @classmethod
+    def setUpClass(cls):
+        super().setUpClass()
+        cls.factory = RequestFactory()
+        load_eveuniverse()
+        cls.modeladmin = NotificationAdmin(model=Notification, admin_site=AdminSite())
+        cls.user = SuperuserFactory()
+
+    def test_should_return_name_of_owner_webhook(self):
+        # given
+        owner = OwnerFactory(webhooks__name="Alpha")
+        obj = NotificationFactory(
+            owner=owner, notif_type=NotificationType.STRUCTURE_LOST_SHIELD
+        )
+        obj2 = self.modeladmin.get_queryset(MockRequest(user=self.user)).get(pk=obj.pk)
+        # when
+        result = self.modeladmin._webhooks(obj2)
+        # then
+        self.assertEqual("Alpha", result)
+
+    def test_should_report_missing_webhook(self):
+        # given
+        owner = OwnerFactory(webhooks=False)
+        obj = NotificationFactory(
+            owner=owner, notif_type=NotificationType.STRUCTURE_LOST_SHIELD
+        )
+        obj2 = self.modeladmin.get_queryset(MockRequest(user=self.user)).get(pk=obj.pk)
+        # when
+        result = self.modeladmin._webhooks(obj2)
+        # then
+        self.assertIn("Not configured", result)
+
+    def test_should_report_when_webhooks_not_configured_for_this_notif_type(self):
+        # given
+        owner = OwnerFactory()
+        obj = NotificationFactory(
+            owner=owner, notif_type=NotificationType.SOV_ENTOSIS_CAPTURE_STARTED
+        )
+        obj2 = self.modeladmin.get_queryset(MockRequest(user=self.user)).get(pk=obj.pk)
+        # when
+        result = self.modeladmin._webhooks(obj2)
+        # then
+        self.assertIn("Not configured", result)
+
+
 class TestOwnerAdmin(TestCase):
     @classmethod
     def setUpClass(cls):
@@ -420,6 +468,23 @@ class TestOwnerAdmin(TestCase):
         self.assertEqual(mock_task.delay.call_count, 1)
         self.assertTrue(mock_message_user.called)
 
+    @patch(MODULE_PATH + ".OwnerAdmin.message_user", spec=True)
+    def test_action_reset_characters(self, mock_message_user):
+        # given
+        owner_1 = OwnerFactory(characters=False)
+        character_1 = OwnerCharacterFactory(owner=owner_1, is_enabled=False)
+        owner_2 = OwnerFactory(characters=False)
+        character_2 = OwnerCharacterFactory(owner=owner_2, is_enabled=False)
+        # when
+        queryset = Owner.objects.filter(pk=owner_1.pk)
+        self.modeladmin.reset_characters(MockRequest(self.user), queryset)
+        # then
+        self.assertTrue(mock_message_user.called)
+        character_1.refresh_from_db()
+        self.assertTrue(character_1.is_enabled)
+        character_2.refresh_from_db()
+        self.assertFalse(character_2.is_enabled)
+
     def test_should_return_empty_turnaround_times(self):
         # given
         obj = OwnerFactory()

structures/tests/test_managers_2.py

@@ -60,12 +60,13 @@ class TestOwnerManager(NoSocketsTestCase):
     def test_should_annotate_characters_count(self):
         # given
         owner = OwnerFactory()  # 1st character automatically created
-        OwnerCharacterFactory(owner=owner)  # 2nd character added
+        OwnerCharacterFactory(owner=owner, is_enabled=False)  # 2nd character added
         # when
         result = Owner.objects.annotate_characters_count()
         # then
         obj = result.get(pk=owner.pk)
-        self.assertEqual(obj.characters_count_2, 2)
+        self.assertEqual(obj.characters_enabled_count, 1)
+        self.assertEqual(obj.characters_disabled_count, 1)
 
     def test_should_return_when_structures_where_last_updated_for_several_owners(self):
         # given

structures/tests/testdata/factories.py

@@ -203,9 +203,7 @@ class OwnerFactory(factory.django.DjangoModelFactory, metaclass=BaseMetaFactory[
     def characters(
         obj, create: bool, extracted: Optional[List[EveCharacter]], **kwargs
     ):
-        """
-        Set extracted to False to skip creating characters.
-        """
+        # Set characters=False to skip creating characters.
         if not create or extracted is False:
             return
 
@@ -222,7 +220,8 @@ class OwnerFactory(factory.django.DjangoModelFactory, metaclass=BaseMetaFactory[
 
     @factory.post_generation
     def webhooks(obj, create, extracted, **kwargs):
-        if not create:
+        # Set webhooks=False to skip creating characters.
+        if not create or extracted is False:
             return
 
         if extracted:

structures/tests/views/test_structures.py

@@ -8,14 +8,13 @@ from django.urls import reverse
 from django.utils.dateparse import parse_datetime
 from django.utils.timezone import now
 
+from allianceauth.eveonline.models import EveCharacter
 from app_utils.testdata_factories import UserMainFactory
 from app_utils.testing import json_response_to_python
 
 import structures.views.status
 from structures.models import Owner, Structure
-from structures.views import structures
-
-from ..testdata.factories import (
+from structures.tests.testdata.factories import (
     EveCharacterFactory,
     JumpGateFactory,
     OwnerFactory,
@@ -27,7 +26,9 @@ from ..testdata.factories import (
     UserMainDefaultOwnerFactory,
     WebhookFactory,
 )
-from ..testdata.load_eveuniverse import load_eveuniverse
+from structures.tests.testdata.load_eveuniverse import load_eveuniverse
+from structures.views import structures
+
 from .utils import json_response_to_dict
 
 VIEWS_PATH = "structures.views.structures"
@@ -527,7 +528,7 @@ class TestAddStructureOwner(TestCase):
         cls.factory = RequestFactory()
         load_eveuniverse()
         cls.user = UserMainDefaultOwnerFactory()
-        cls.character = cls.user.profile.main_character
+        cls.character: EveCharacter = cls.user.profile.main_character
         cls.character_ownership = cls.character.character_ownership
 
     def _add_structure_owner_view(self, token=None, user=None):
@@ -656,6 +657,58 @@ class TestAddStructureOwner(TestCase):
         )
         self.assertTrue(owner.is_active)
 
+    @patch(VIEWS_PATH + ".STRUCTURES_ADMIN_NOTIFICATIONS_ENABLED", False)
+    @patch(VIEWS_PATH + ".tasks.update_all_for_owner")
+    @patch(VIEWS_PATH + ".notify_admins")
+    @patch(VIEWS_PATH + ".messages")
+    def test_can_readd_same_character(
+        self, mock_messages, mock_notify_admins, mock_update_all_for_owner
+    ):
+        # given
+        owner = OwnerFactory(characters=[self.character])
+        owner_character = owner.characters.first()
+        # when
+        response = self._add_structure_owner_view(user=self.user)
+        # then
+        self.assertEqual(response.status_code, 302)
+        self.assertEqual(response.url, reverse("structures:index"))
+        owner.refresh_from_db()
+        character_ownerships = set(
+            owner.characters.values_list("character_ownership", flat=True)
+        )
+        self.assertSetEqual(
+            {self.character_ownership.pk, owner_character.character_ownership.pk},
+            character_ownerships,
+        )
+
+    # @patch(VIEWS_PATH + ".STRUCTURES_ADMIN_NOTIFICATIONS_ENABLED", False)
+    # @patch(VIEWS_PATH + ".tasks.update_all_for_owner")
+    # @patch(VIEWS_PATH + ".notify_admins")
+    # @patch(VIEWS_PATH + ".messages")
+    # def test_should_reenable_character_when_re_adding(
+    #     self, mock_messages, mock_notify_admins, mock_update_all_for_owner
+    # ):
+    #     # given
+    #     owner = OwnerFactory(characters=[self.character])
+    #     owner_character: OwnerCharacter = owner.characters.first()
+    #     owner_character.is_enabled = False
+    #     owner_character.save()
+    #     # when
+    #     response = self._add_structure_owner_view(user=self.user)
+    #     # then
+    #     self.assertEqual(response.status_code, 302)
+    #     self.assertEqual(response.url, reverse("structures:index"))
+    #     owner.refresh_from_db()
+    #     character_ownerships = set(
+    #         owner.characters.values_list("character_ownership", flat=True)
+    #     )
+    #     self.assertSetEqual(
+    #         {self.character_ownership.pk, owner_character.character_ownership.pk},
+    #         character_ownerships,
+    #     )
+    #     owner_character.refresh_from_db()
+    #     self.assertTrue(owner_character.is_enabled)
+
 
 class TestStructureFittingModal(TestCase):
     @classmethod

structures/views/structures.py

@@ -630,7 +630,7 @@ def add_structure_owner(request: HttpRequest, token: Token):
                 % {
                     "corporation": owner,
                     "character": token_char,
-                    "characters_count": owner.characters_count(),
+                    "characters_count": owner.valid_characters_count(),
                 }
             ),
         )
@@ -646,7 +646,7 @@ def add_structure_owner(request: HttpRequest, token: Token):
                         "character": token_char,
                         "corporation": owner,
                         "user": request.user.username,
-                        "characters_count": owner.characters_count(),
+                        "characters_count": owner.valid_characters_count(),
                     },
                     title=_("%s: Character added to: %s") % (__title__, owner),
                 )