aa-structures 2.2.0__py3-none-any.whl → 2.3.1b1__py3-none-any.whl

structures/managers.py

@@ -1,6 +1,6 @@
 import datetime as dt
 import itertools
-from typing import Optional, Set, Tuple
+from typing import Optional, Set, Tuple, TypeVar
 
 from django.contrib.auth.models import User
 from django.db import models, transaction
@@ -21,6 +21,8 @@ from .webhooks.managers import WebhookBaseManager
 
 logger = LoggerAddTag(get_extension_logger(__name__), __title__)
 
+ModelType = TypeVar("ModelType", bound=models.Model)
+
 
 class EveSovereigntyMapManager(models.Manager):
     def update_from_esi(self):
@@ -53,7 +55,7 @@ class EveSovereigntyMapManager(models.Manager):
                 self.bulk_create(obj_list, batch_size=1000)
 
     def corporation_has_sov(
-        self, eve_solar_system: models.Model, corporation: EveCorporationInfo
+        self, eve_solar_system, corporation: EveCorporationInfo
     ) -> bool:
         """returns true if given corporation has sov in this solar system
         else False
@@ -68,9 +70,7 @@ class EveSovereigntyMapManager(models.Manager):
                 self.solar_system_sov_alliance_id(eve_solar_system) == alliance_id
             )
 
-    def solar_system_sov_alliance_id(
-        self, eve_solar_system: models.Model
-    ) -> Optional[int]:
+    def solar_system_sov_alliance_id(self, eve_solar_system) -> Optional[int]:
         """returns ID of sov owning alliance for this system or None"""
         if not eve_solar_system.is_null_sec:
             return None
@@ -133,7 +133,7 @@ class GeneratedNotificationQuerySet(NotificationBaseQuerySet):
 class GeneratedNotificationManagerBase(NotificationBaseManagerBase):
     def get_or_create_from_structure(
         self, structure: models.Model, notif_type: models.TextChoices
-    ) -> Tuple[models.Model, bool]:
+    ) -> Tuple[ModelType, bool]:
         """Get or create an object from given structure."""
         from .models import NotificationType
 
@@ -142,9 +142,7 @@ class GeneratedNotificationManagerBase(NotificationBaseManagerBase):
 
         return self._get_or_create_tower_reinforced(structure)
 
-    def _get_or_create_tower_reinforced(
-        self, structure: models.Model
-    ) -> Tuple[models.Model, bool]:
+    def _get_or_create_tower_reinforced(self, structure) -> Tuple[ModelType, bool]:
         from .models import NotificationType
 
         if not structure.is_starbase:
@@ -233,7 +231,9 @@ class StructureQuerySet(models.QuerySet):
         )
 
     # TODO: Add specific tests
-    def visible_for_user(self, user: User, tags: list = None) -> models.QuerySet:
+    def visible_for_user(
+        self, user: User, tags: Optional[list] = None
+    ) -> models.QuerySet:
         if user.has_perm("structures.view_all_structures"):
             structures_query = self.select_related_defaults()
             if tags:
@@ -247,7 +247,7 @@ class StructureQuerySet(models.QuerySet):
             ):
                 corporation_ids = {
                     character_ownership.character.corporation_id
-                    for character_ownership in user.character_ownerships.all()
+                    for character_ownership in user.character_ownerships.all()  # type: ignore
                 }
                 corporations = list(
                     EveCorporationInfo.objects.select_related("alliance").filter(
@@ -462,7 +462,7 @@ class StructureTagManager(models.Manager):
                 return self.update_or_create_for_space_type(solar_system)
         return None, None
 
-    def update_or_create_for_space_type(self, solar_system: object) -> tuple:
+    def update_or_create_for_space_type(self, solar_system) -> tuple:
         from .models import EveSpaceType
 
         space_type = EveSpaceType.from_solar_system(solar_system)

structures/models/notifications.py

@@ -1,7 +1,7 @@
 """Notification related models."""
 
 import math
-from typing import Optional, Tuple, Union
+from typing import List, Optional, Set, Tuple, Union
 
 import dhooks_lite
 import yaml
@@ -177,11 +177,11 @@ class NotificationType(models.TextChoices):
     )
 
     @classproperty
-    def esi_notifications(cls) -> set:
-        return set(cls.values) - cls.generated_notifications
+    def esi_notifications(cls) -> Set["NotificationType"]:
+        return set(cls.values) - cls.generated_notifications  # type: ignore
 
     @classproperty
-    def generated_notifications(cls) -> set:
+    def generated_notifications(cls) -> Set["NotificationType"]:
         return {
             cls.STRUCTURE_JUMP_FUEL_ALERT,
             cls.STRUCTURE_REFUELED_EXTRA,
@@ -190,7 +190,7 @@ class NotificationType(models.TextChoices):
         }
 
     @classproperty
-    def webhook_defaults(cls) -> list:
+    def webhook_defaults(cls) -> List["NotificationType"]:
         """List of default notifications for new webhooks."""
         return [
             cls.STRUCTURE_ANCHORING,
@@ -212,7 +212,7 @@ class NotificationType(models.TextChoices):
         ]
 
     @classproperty
-    def relevant_for_timerboard(cls) -> set:
+    def relevant_for_timerboard(cls) -> Set["NotificationType"]:
         """Notification types that can create timers."""
         return {
             cls.STRUCTURE_LOST_SHIELD,
@@ -225,7 +225,7 @@ class NotificationType(models.TextChoices):
         }
 
     @classproperty
-    def relevant_for_alliance_level(cls) -> set:
+    def relevant_for_alliance_level(cls) -> Set["NotificationType"]:
         """Notification types that require the alliance level flag."""
         return {
             # billing
@@ -239,7 +239,7 @@ class NotificationType(models.TextChoices):
             cls.SOV_STRUCTURE_REINFORCED,
             cls.SOV_STRUCTURE_DESTROYED,
             cls.SOV_ALL_CLAIM_LOST_MSG,
-            cls.SOV_ALL_ANCHORING_MSG,
+            # cls.SOV_ALL_ANCHORING_MSG, # This notif is not broadcasted to all corporations
             # wars
             cls.WAR_ALLY_JOINED_WAR_AGGRESSOR_MSG,
             cls.WAR_ALLY_JOINED_WAR_AllY_MSG,
@@ -255,7 +255,7 @@ class NotificationType(models.TextChoices):
         }
 
     @classproperty
-    def relevant_for_moonmining(cls) -> set:
+    def relevant_for_moonmining(cls) -> Set["NotificationType"]:
         """Notification types about moon mining."""
         return {
             cls.MOONMINING_EXTRACTION_STARTED,
@@ -266,7 +266,7 @@ class NotificationType(models.TextChoices):
         }
 
     @classproperty
-    def structure_related(cls) -> set:
+    def structure_related(cls) -> Set["NotificationType"]:
         """Notification types that are related to a structure."""
         return {
             cls.STRUCTURE_ONLINE,
@@ -298,18 +298,18 @@ class NotificationType(models.TextChoices):
         }
 
     @classproperty
-    def relevant_for_forwarding(cls) -> set:
+    def relevant_for_forwarding(cls) -> Set["NotificationType"]:
         """Notification types that are forwarded to Discord."""
-        my_set = set(cls.values_enabled)
+        my_set = set(cls.values_enabled)  # type: ignore
         # if STRUCTURES_NOTIFICATION_DISABLE_ESI_FUEL_ALERTS:
         #     my_set.discard(cls.STRUCTURE_FUEL_ALERT)
         #     my_set.discard(cls.TOWER_RESOURCE_ALERT_MSG)
         return my_set
 
     @classproperty
-    def values_enabled(cls) -> set:
+    def values_enabled(cls) -> Set["NotificationType"]:
         """Values of enabled notif types only."""
-        my_set = set(cls.values)
+        my_set = set(cls.values)  # type: ignore
         if not STRUCTURES_FEATURE_REFUELED_NOTIFICATIONS:
             my_set.discard(cls.STRUCTURE_REFUELED_EXTRA)
             my_set.discard(cls.TOWER_REFUELED_EXTRA)
@@ -514,10 +514,13 @@ class NotificationBase(models.Model):
     def relevant_webhooks(self) -> models.QuerySet:
         """Determine relevant webhooks matching this notification type."""
         if not self.is_structure_related:
-            structures_qs = None
+            structures_qs = Structure.objects.none()
         else:
             structures_qs = self.calc_related_structures()
-        if structures_qs and structures_qs.filter(webhooks__isnull=False).count() == 1:
+        if (
+            structures_qs.exists()
+            and structures_qs.filter(webhooks__isnull=False).count() == 1
+        ):
             webhooks_qs = structures_qs.first().webhooks.filter(
                 notification_types__contains=self.notif_type, is_active=True
             )
@@ -631,7 +634,7 @@ class NotificationBase(models.Model):
 
     def _generate_embed(
         self, language_code: Optional[str]
-    ) -> Tuple[dhooks_lite.Embed, Webhook.PingType]:
+    ) -> Tuple[dhooks_lite.Embed, Optional[Webhook.PingType]]:
         """Generates a Discord embed for this notification."""
         from ..core.notification_embeds import NotificationBaseEmbed
 

structures/models/owners.py

@@ -905,9 +905,7 @@ class Owner(models.Model):
         names = {x["item_id"]: x["name"] for x in names_data}
         return names
 
-    def _update_starbase_detail(
-        self, structure: object, token: Token
-    ) -> StarbaseDetail:
+    def _update_starbase_detail(self, structure, token: Token) -> StarbaseDetail:
         """Update detail for the starbase from ESI."""
         operation = esi.client.Corporation.get_corporations_corporation_id_starbases_starbase_id(
             corporation_id=structure.owner.corporation.corporation_id,

structures/models/structures.py

@@ -1009,7 +1009,7 @@ class StarbaseDetail(models.Model):
     def __str__(self) -> str:
         return str(self.structure)
 
-    def calc_fuel_expires(self) -> dt.datetime:
+    def calc_fuel_expires(self) -> Optional[dt.datetime]:
         """Estimate when fuel will expire for this starbase.
 
         Estimate will vary due to server caching of remaining fuel blocks.

structures/tests/core/test_notification_embeds.py

@@ -8,13 +8,30 @@ from eveuniverse.models import EveEntity
 
 from app_utils.testing import NoSocketsTestCase, create_user_from_evecharacter
 
-from ...core import notification_embeds as ne
-from ...models.notifications import Notification, NotificationType, Structure, Webhook
+from structures.core import notification_embeds as ne
+from structures.core.notification_embeds import (
+    NotificationBaseEmbed,
+    NotificationTowerReinforcedExtra,
+)
+from structures.models.notifications import (
+    Notification,
+    NotificationType,
+    Structure,
+    Webhook,
+)
+
 from ..testdata.factories import (
     create_notification,
     create_owner_from_user,
     create_starbase,
 )
+from ..testdata.factories_2 import (
+    EveEntityAllianceFactory,
+    GeneratedNotificationFactory,
+    NotificationFactory,
+    OwnerFactory,
+    WebhookFactory,
+)
 from ..testdata.helpers import (
     create_structures,
     load_entities,
@@ -27,6 +44,16 @@ from ..testdata.load_eveuniverse import load_eveuniverse
 MODULE_PATH = "structures.core.notification_embeds"
 
 
+class TestBilType(TestCase):
+    def test_should_create_from_valid_id(self):
+        self.assertEqual(ne.BillType.to_enum(7), ne.BillType.INFRASTRUCTURE_HUB)
+
+    def test_should_create_from_invalid_id(self):
+        for bill_id in range(7):
+            with self.subTest(bill_id=bill_id):
+                self.assertEqual(ne.BillType.to_enum(bill_id), ne.BillType.UNKNOWN)
+
+
 class TestNotificationEmbeds(TestCase):
     @classmethod
     def setUpClass(cls):
@@ -35,10 +62,6 @@ class TestNotificationEmbeds(TestCase):
         create_structures()
         _, cls.owner = set_owner_character(character_id=1001)
         load_notification_entities(cls.owner)
-        cls.webhook = Webhook.objects.create(
-            name="Test", url="http://www.example.com/dummy/"
-        )
-        cls.owner.webhooks.add(cls.webhook)
 
     def test_should_create_obj_from_notification(self):
         # given
@@ -59,6 +82,40 @@ class TestNotificationEmbeds(TestCase):
             "notif_type='MoonminingExtractionFinished'))",
         )
 
+    def test_should_raise_exception_for_unsupported_notif_types(self):
+        # given
+        notification = Notification.objects.create(
+            notification_id=666,
+            owner=self.owner,
+            sender=EveEntity.objects.get(id=2001),
+            timestamp=now(),
+            notif_type="XXXUnsupportedNotificationTypeXXX",
+            last_updated=now(),
+        )
+        # when / then
+        with self.assertRaises(NotImplementedError):
+            ne.NotificationBaseEmbed.create(notification)
+
+    def test_should_require_notification_for_init(self):
+        with self.assertRaises(TypeError):
+            ne.NotificationBaseEmbed(notification="dummy")
+
+    def test_should_require_notification_for_factory(self):
+        with self.assertRaises(TypeError):
+            ne.NotificationBaseEmbed.create(notification="dummy")
+
+
+class TestNotificationEmbedsGenerate(TestCase):
+    @classmethod
+    def setUpClass(cls):
+        super().setUpClass()
+        load_eveuniverse()
+        create_structures()
+        _, cls.owner = set_owner_character(character_id=1001)
+        load_notification_entities(cls.owner)
+        cls.webhook = WebhookFactory()
+        cls.owner.webhooks.add(cls.webhook)
+
     def test_should_generate_embed_from_notification(self):
         # given
         notification = Notification.objects.get(notification_id=1000000403)
@@ -116,36 +173,6 @@ class TestNotificationEmbeds(TestCase):
                 types_tested.add(notification.notif_type)
         self.assertSetEqual(NotificationType.esi_notifications, types_tested)
 
-    def test_should_raise_exception_for_unsupported_notif_types(self):
-        # given
-        notification = Notification.objects.create(
-            notification_id=666,
-            owner=self.owner,
-            sender=EveEntity.objects.get(id=2001),
-            timestamp=now(),
-            notif_type="XXXUnsupportedNotificationTypeXXX",
-            last_updated=now(),
-        )
-        # when / then
-        with self.assertRaises(NotImplementedError):
-            ne.NotificationBaseEmbed.create(notification)
-
-    def test_should_require_notification_for_init(self):
-        with self.assertRaises(TypeError):
-            ne.NotificationBaseEmbed(notification="dummy")
-
-    def test_should_require_notification_for_factory(self):
-        with self.assertRaises(TypeError):
-            ne.NotificationBaseEmbed.create(notification="dummy")
-
-    def test_should_not_allow_generating_embed_for_base_class(self):
-        # given
-        notification = Notification.objects.get(notification_id=1000000403)
-        notification_embed = ne.NotificationBaseEmbed(notification=notification)
-        # when
-        with self.assertRaises(ValueError):
-            notification_embed.generate_embed()
-
     def test_should_set_ping_everyone_for_color_danger(self):
         # given
         notification = Notification.objects.get(notification_id=1000000513)
@@ -269,3 +296,65 @@ class TestNotificationEmbedsClasses(NoSocketsTestCase):
         # then
         description = markdown_to_plain(discord_embed.description)
         self.assertIn("is running out of fuel in 2 hours", description)
+
+
+class TestGeneratedNotification(NoSocketsTestCase):
+    @classmethod
+    def setUpClass(cls):
+        super().setUpClass()
+        load_eveuniverse()
+
+    def test_should_create_tower_reinforced_embed(self):
+        # given
+        notif = GeneratedNotificationFactory()
+        # when
+        obj = NotificationBaseEmbed.create(notif)
+        # then
+        self.assertIsInstance(obj, NotificationTowerReinforcedExtra)
+
+    def test_should_generate_embed(self):
+        # given
+        notif = GeneratedNotificationFactory()
+        embed = NotificationBaseEmbed.create(notif)
+        # when
+        obj = embed.generate_embed()
+        # then
+        self.assertIsInstance(obj, dhooks_lite.Embed)
+        starbase = notif.structures.first()
+        self.assertIn(starbase.name, obj.description)
+
+
+class TestEveNotificationEmbeds(NoSocketsTestCase):
+    @classmethod
+    def setUpClass(cls):
+        super().setUpClass()
+        load_eveuniverse()
+        cls.owner = OwnerFactory()
+
+    def test_should_create_sov_embed(self):
+        # given
+        notif = NotificationFactory(
+            owner=self.owner,
+            sender=EveEntityAllianceFactory(),
+            notif_type=NotificationType.SOV_ENTOSIS_CAPTURE_STARTED,
+            text_from_dict={"solarSystemID": 30000474, "structureTypeID": 32226},
+        )
+        embed = NotificationBaseEmbed.create(notif)
+        # when
+        obj = embed.generate_embed()
+        # then
+        self.assertIsInstance(obj, dhooks_lite.Embed)
+
+    def test_should_create_sov_embed_without_sender(self):
+        # given
+        notif = NotificationFactory(
+            owner=self.owner,
+            sender=None,
+            notif_type=NotificationType.SOV_ENTOSIS_CAPTURE_STARTED,
+            text_from_dict={"solarSystemID": 30000474, "structureTypeID": 32226},
+        )
+        embed = NotificationBaseEmbed.create(notif)
+        # when
+        obj = embed.generate_embed()
+        # then
+        self.assertIsInstance(obj, dhooks_lite.Embed)

structures/tests/models/test_notifications_1.py

@@ -121,47 +121,73 @@ class TestNotificationFilterForAllianceLevel(NoSocketsTestCase):
         # given
         self.owner.is_alliance_main = False
         self.owner.save()
-        notif = self.owner.notification_set.get(notification_id=1000000509)
+        notifs = self.owner.notification_set.exclude(
+            notif_type__in=NotificationType.relevant_for_alliance_level
+        )
         # when/then
-        self.assertFalse(notif.filter_for_alliance_level())
+        for notif in notifs:
+            with self.subTest(notif=str(notif)):
+                self.assertFalse(notif.filter_for_alliance_level())
 
     def test_should_not_filter_non_alliance_notifications_2(self):
         # given
         self.owner.is_alliance_main = True
         self.owner.save()
-        notif = self.owner.notification_set.get(notification_id=1000000509)
+        notifs = self.owner.notification_set.exclude(
+            notif_type__in=NotificationType.relevant_for_alliance_level
+        )
         # when/then
-        self.assertFalse(notif.filter_for_alliance_level())
+        for notif in notifs:
+            with self.subTest(notif=str(notif)):
+                self.assertFalse(notif.filter_for_alliance_level())
 
     def test_should_filter_alliance_notifications(self):
         # given
         self.owner.is_alliance_main = False
         self.owner.save()
-        notif = self.owner.notification_set.get(notification_id=1000000803)
+        notifs = self.owner.notification_set.filter(
+            notif_type__in=NotificationType.relevant_for_alliance_level
+        )
         # when/then
-        self.assertTrue(notif.filter_for_alliance_level())
+        for notif in notifs:
+            with self.subTest(notif=str(notif)):
+                self.assertTrue(notif.filter_for_alliance_level())
 
     def test_should_not_filter_alliance_notifications_1(self):
         # given
         self.owner.is_alliance_main = True
         self.owner.save()
+        notifs = self.owner.notification_set.filter(
+            notif_type__in=NotificationType.relevant_for_alliance_level
+        )
         # when/then
-        notif = self.owner.notification_set.get(notification_id=1000000803)
-        self.assertFalse(notif.filter_for_alliance_level())
+        for notif in notifs:
+            with self.subTest(notif=str(notif)):
+                self.assertFalse(notif.filter_for_alliance_level())
 
     def test_should_not_filter_alliance_notifications_2(self):
         # given
         self.owner.is_alliance_main = True
         self.owner.save()
-        notif = self.owner.notification_set.get(notification_id=1000000803)
-        self.assertFalse(notif.filter_for_alliance_level())
+        notifs = self.owner.notification_set.filter(
+            notif_type__in=NotificationType.relevant_for_alliance_level
+        )
+        # when/then
+        for notif in notifs:
+            with self.subTest(notif=str(notif)):
+                self.assertFalse(notif.filter_for_alliance_level())
 
     def test_should_not_filter_alliance_notifications_3(self):
         # given
         _, owner = set_owner_character(character_id=1102)  # corp with no alliance
         load_notification_entities(owner)
-        notif = owner.notification_set.get(notification_id=1000000803)
-        self.assertFalse(notif.filter_for_alliance_level())
+        notifs = self.owner.notification_set.filter(
+            notif_type__in=NotificationType.relevant_for_alliance_level
+        )
+        # when/then
+        for notif in notifs:
+            with self.subTest(notif=str(notif)):
+                self.assertFalse(notif.filter_for_alliance_level())
 
 
 class TestNotificationCreateFromStructure(NoSocketsTestCase):