aa-killtracker 0.14.0__py3-none-any.whl → 0.16.0__py3-none-any.whl

{aa_killtracker-0.14.0.dist-info → aa_killtracker-0.16.0.dist-info}/METADATA

@@ -1,7 +1,7 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: aa-killtracker
-Version: 0.14.0
-Summary: "An app for running killmail trackers with Alliance Auth and Discord.
+Version: 0.16.0
+Summary: An app for running killmail trackers with Alliance Auth and Discord.
 Author-email: Erik Kalkoken <kalkoken87@gmail.com>
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
@@ -19,6 +19,7 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Topic :: Internet :: WWW/HTTP
 Classifier: Topic :: Internet :: WWW/HTTP :: Dynamic Content
+License-File: LICENSE
 Requires-Dist: allianceauth-app-utils>=1.19.0
 Requires-Dist: allianceauth>=3
 Requires-Dist: dacite
@@ -90,6 +91,8 @@ And here is how posted killmails look on Discord:
 
 2. Killtracker needs the app [django-eveuniverse](https://gitlab.com/ErikKalkoken/django-eveuniverse) to function. Please make sure it is installed, before continuing.
 
+3. Killtracker will generate a lot of tasks. For optimal performance we recommend a threads-based configuration of your celery workers. Please see [this guide](https://aa-memberaudit.readthedocs.io/en/latest/operations.html#configuring-celery-workers) for details.
+
 ### Step 2 - Install app
 
 Make sure you are in the virtual environment (venv) of your Alliance Auth installation. Then install the newest release from PyPI:
@@ -179,6 +182,8 @@ To test that your webhook works correctly you can send a test notification.
 
 Next you can create your trackers under **Tracker**. Make sure you link each tracker to the right webhook. Once you save a tracker that is **enabled** it will start working.
 
+>**Hint**:<br>A common mistake is to set both attacker alliance and victim alliance to your alliance in the same tracker. This will only match awox kills though, which is usually not what you want. Instead create separate trackers to capture kills and losses for your alliance.
+
 As final test that your setup is correct you may want to create a "Catch all" tracker. for that just create a new tracker without any conditions and it will forward all killmails to your Discord channel as they are received.
 
 Congratulations you are now ready to use killtracker!

{aa_killtracker-0.14.0.dist-info → aa_killtracker-0.16.0.dist-info}/RECORD

@@ -1,5 +1,5 @@
-killtracker/__init__.py,sha256=qmlkoj0QbgRePuQ6rH64unfUejmQPj_Ebs9EzZSrYAs,356
-killtracker/admin.py,sha256=CHudWND2slzqCt046xdf2lzhFaAuEsNKiF7ptaXm1wQ,13696
+killtracker/__init__.py,sha256=rJv9uVGH-1GPu-1zVtAt6rCtJD7KpgmLO2CZcFWboSg,355
+killtracker/admin.py,sha256=s_O86Ct4prno0cQJE8otumCEqgkZ7H3Q_GFptEOTI_c,14103
 killtracker/app_settings.py,sha256=aN93musXOQ0AAVVWz67oSy9ryEiNXrcCCz6G2NlJ5QQ,3608
 killtracker/apps.py,sha256=CfmDvqVXmoy6sumpjXKldhSlJt5xDiQW3XLBfCqH3-c,307
 killtracker/constants.py,sha256=W7-VARE3B4_sdzV_9k7qunUzlxTcdSAeSp_ZJVnbUhw,2514
@@ -10,7 +10,7 @@ killtracker/providers.py,sha256=smkZe_rKHkZeWFzJ0RhIhJVcbrZUpLYR5fKCge-dpXY,348
 killtracker/tasks.py,sha256=u_ZAOEeFZWW6qpWcB0HCzgbN0VjA1ZZDHdKPJGHKl0U,7884
 killtracker/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 killtracker/core/discord_messages.py,sha256=mOKiMWq-3WnaSUFbfgVmlkAedGTZ7OWcVxLp7n58-Z0,14132
-killtracker/core/killmails.py,sha256=V8mXnp0rVqS3EcHgwU4BWq_h900B0dfGbdgAqvPOTSI,20306
+killtracker/core/killmails.py,sha256=v7ciMSPHyIg4L4d-Q8UECuqJShfxfd3g_sdfRnKKSPY,20499
 killtracker/management/commands/killtracker_load_eve.py,sha256=5P2wr6LU-EMl9_gG-DKP2yw3eFXOU7ApeuGAWEbvCKk,1159
 killtracker/migrations/0001_initial_new.py,sha256=WszI5DmNFtk45IZ2Zul3_Ak-VXmye9ffJKFAsGIxoXA,27818
 killtracker/migrations/0001_squashed_all.py,sha256=KXwOcRayjGGGmleg7-aTcXeIi-92Mn4BaGkEY3iE9Vc,26221
@@ -18,6 +18,7 @@ killtracker/migrations/0002_fix_webhook_notes_field.py,sha256=c_Uymy3K_NSwuZzoKZ
 killtracker/migrations/0002_tracker_require_attackers_weapon_groups_and_more.py,sha256=zLBGMxzxha4cq9SX3yKuJA6y7yGQJ7B0TB3G9MtUfFI,1184
 killtracker/migrations/0003_add_state_clauses.py,sha256=J0AwRYrmiSAmkpui-p637k_aVa404ED2nvw_mVEsY7g,1663
 killtracker/migrations/0003_optimize_tracker_form.py,sha256=Q_5ArFB1mxCShgoV3CwpSAgP7DM2xR9Vr_fo92MozH0,3623
+killtracker/migrations/0004_add_faction_clauses.py,sha256=w6LIodDScd-CWGVPs8pyV1kTWszj74w6CSQC6--bHlI,2433
 killtracker/migrations/0004_django4_update.py,sha256=fOgbzWr6gMZWYr9Q-Ozg9mHxeUxY1VhuqBvyXv60pAg,7542
 killtracker/migrations/0005_add_final_blow_clause_and_more.py,sha256=XvaXUChQkcARcP-o8xTQ1inbc5l9IiAmUXuWY1UqzGQ,15550
 killtracker/migrations/0006_evetypeplus.py,sha256=SpaxJKA5mwnELVtUPFmDcp5Ws1CVono5Fzn2ZuiTZfg,569
@@ -27,7 +28,7 @@ killtracker/migrations/0009_remove_old_models.py,sha256=bDIz0hywpFKbHYhdXFXzra5D
 killtracker/migrations/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 killtracker/models/__init__.py,sha256=WL6VD9MK7EsZot_RLPz0nX8WxJkp7RtQpw_mYpnVqu8,188
 killtracker/models/killmails.py,sha256=CCdrHkwUSoTOGqavG-TpMxDRleF9UEacOTui8v3-VT8,5181
-killtracker/models/trackers.py,sha256=2ShkcH8CPix0EszHg-jxZZaJSM5iZUfjPWBEPxIPoOw,28791
+killtracker/models/trackers.py,sha256=t3pm29UW_0JqBgHbU0Xx1qgLyft7_EjNtKCJ37OM_fE,31188
 killtracker/models/webhooks.py,sha256=hh1mYE4pBU26YFawkv1z-j4uyX8aT25B0crOTsocSSY,8268
 killtracker/static/killtracker/killtracker_logo.png,sha256=3jc9zmYHqP60Np5piP5RfkX0_II-315DNjZ4FRGbqKc,74625
 killtracker/static/killtracker/zkb_icon.png,sha256=wuVfgyTbTs9qS4KGbDAH3Q9KVPgHqYV5eaVrjEmTjsE,328
@@ -41,10 +42,10 @@ killtracker/tests/test_tasks.py,sha256=ZDoCUBd-1kSOKrvSeTrlDaSGFmzHieT5ef0iBz6nr
 killtracker/tests/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 killtracker/tests/core/test_discord_messages_1.py,sha256=1cYpj4E9pNqQOeE7yWeV1mme-JYGIHfSIibOauEHi88,3101
 killtracker/tests/core/test_discord_messages_2.py,sha256=AppA_FUFQA5I35UKjaEwn_ZQcnscqillR1SIo1unwJg,4774
-killtracker/tests/core/test_killmails.py,sha256=GdU5glj9as4l17GQpzZvNCaXzLM2fP2LLhbF7JOUogU,14148
+killtracker/tests/core/test_killmails.py,sha256=OFV6EbERi0UyMzXblLsNoJrPbLSIgtA27Wt9vGwOYd8,14349
 killtracker/tests/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 killtracker/tests/models/test_killmails.py,sha256=0ytwIGbTPb1OTzmK8B9VnR1ylxMuaYtp2tvCXzNOwNc,8293
-killtracker/tests/models/test_trackers_1.py,sha256=h9RNQ8h4bCf_LsbyO-wycbFn3WcmADZS4qnmo2B1RMo,35242
+killtracker/tests/models/test_trackers_1.py,sha256=_ARZKBrQz0QF6_OZEOFOsTqNdfflz7wWenAT-T35nqU,42771
 killtracker/tests/models/test_trackers_2.py,sha256=FmtaWBjV32NlIjYPaG5Kh87oES5ChoDMVJ4ol2uWopE,5404
 killtracker/tests/models/test_webhook.py,sha256=E4BgmQw9mI5ZenV6ncYHbBonlEeWvvdilAS8IKFkbjw,5246
 killtracker/tests/testdata/__init__.py,sha256=9aQhf8V-DseZMWjJ_QMXOba6CypoHFSVpYRZEUh-oFc,212
@@ -53,13 +54,13 @@ killtracker/tests/testdata/evealliances.json,sha256=i6udrtUnWQjn71Iw17WWz9Eb1fdG
 killtracker/tests/testdata/evecorporations.json,sha256=Hk4WuplZl69rQcquOU-15lgUyvHRMZW0fnYfKz8oeWw,1229
 killtracker/tests/testdata/eveentities.json,sha256=0yStlAMEhednEiMKvKOYFsyRovtsGxw6IpWAyvnQXv4,1459
 killtracker/tests/testdata/eveuniverse.json,sha256=JagrJ-asKlkxrqj3dtAth6d5bhIpeEmlvBHgXjLTMSI,36117
-killtracker/tests/testdata/factories.py,sha256=xCspEV2hC5f5hwaIELFEtF6Y6mrtt36MxaXKJPdVTtc,10390
+killtracker/tests/testdata/factories.py,sha256=WqmIthF6kgrdQrV5CSlub4hBYo42lC_8UORzZ8sGAp0,11019
 killtracker/tests/testdata/helpers.py,sha256=5T35ITnh16pTswR1O4t4IdVSpokC3x8_Me_vk3CgBB8,4741
 killtracker/tests/testdata/killmails.json,sha256=HKfpXQJ_ikymBSewh4wWixYpLwC3kNBqi04cCms1AjA,45366
 killtracker/tests/testdata/load_eveuniverse.py,sha256=FitVc12E_ob56ezK5Y1q07Kbyc7N8poHiCNaLRGU4Jg,388
 killtracker/tools/drop_tables_killtracker.sql,sha256=fJrGY23NKRunpYC3hI-klFkWub4sBuhfP8TaT__zjPg,1726
-killtracker/tools/generate_conditions_text.py,sha256=CiXBtaH2KY6JHpuxNlGmxLI6GsvxKKBX5xhXsSz3Rno,768
-aa_killtracker-0.14.0.dist-info/LICENSE,sha256=XZiwB_S_40_HhnvLg5xvtBb3g1oGjPrk0rpFwk8iInE,1070
-aa_killtracker-0.14.0.dist-info/WHEEL,sha256=EZbGkh7Ie4PoZfRQ8I0ZuP9VklN_TvcZ6DSE5Uar4z4,81
-aa_killtracker-0.14.0.dist-info/METADATA,sha256=3RNa9LwqMBs6kQUdcSusm5qm883oTXuz1z1brXzRxqA,13380
-aa_killtracker-0.14.0.dist-info/RECORD,,
+killtracker/tools/generate_conditions_text.py,sha256=LxAtTQIX-IbuqaNDMV1XHhq5AbrrlwxLWgXa1M7DWQo,767
+aa_killtracker-0.16.0.dist-info/licenses/LICENSE,sha256=XZiwB_S_40_HhnvLg5xvtBb3g1oGjPrk0rpFwk8iInE,1070
+aa_killtracker-0.16.0.dist-info/WHEEL,sha256=G2gURzTEtmeR8nrdXUJfNiB3VYVxigPQ-bEQujpNiNs,82
+aa_killtracker-0.16.0.dist-info/METADATA,sha256=Oklfjd1Nn8qBPS33Smq7i5jGPyNgQon-aZQZH62BD4E,13946
+aa_killtracker-0.16.0.dist-info/RECORD,,

{aa_killtracker-0.14.0.dist-info → aa_killtracker-0.16.0.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: flit 3.9.0
+Generator: flit 3.12.0
 Root-Is-Purelib: true
 Tag: py3-none-any

killtracker/__init__.py

@@ -1,9 +1,9 @@
-""""An app for running killmail trackers with Alliance Auth and Discord."""
+"""An app for running killmail trackers with Alliance Auth and Discord."""
 
 # pylint: disable = invalid-name
 default_app_config = "killtracker.apps.KillmailsConfig"
 
-__version__ = "0.14.0"
+__version__ = "0.16.0"
 __title__ = "Killtracker"
 
 APP_NAME = "aa-killtracker"

killtracker/admin.py

@@ -101,13 +101,17 @@ class TrackerAdmin(admin.ModelAdmin):
         "require_constellations",
         "require_solar_systems",
         "exclude_attacker_alliances",
-        "exclude_attacker_corporations",
+        "exclude_victim_alliances",
+        "require_victim_alliances",
         "require_attacker_alliances",
+        "exclude_attacker_corporations",
         "require_attacker_corporations",
-        "require_victim_alliances",
-        "exclude_victim_alliances",
-        "require_victim_corporations",
         "exclude_victim_corporations",
+        "require_victim_corporations",
+        "exclude_attacker_factions",
+        "require_attacker_factions",
+        "exclude_victim_factions",
+        "require_victim_factions",
         "require_attackers_ship_types",
         "require_attackers_ship_groups",
         "require_attackers_weapon_groups",
@@ -118,6 +122,7 @@ class TrackerAdmin(admin.ModelAdmin):
     filter_horizontal = (
         "exclude_attacker_states",
         "require_attacker_states",
+        "exclude_victim_states",
         "require_victim_states",
         "ping_groups",
     )
@@ -154,28 +159,33 @@ class TrackerAdmin(admin.ModelAdmin):
             },
         ),
         (
-            "Organizations",
+            "Attackers",
             {
                 "fields": (
-                    "exclude_attacker_alliances",
-                    "exclude_attacker_corporations",
                     "require_attacker_alliances",
+                    "exclude_attacker_alliances",
                     "require_attacker_corporations",
+                    "exclude_attacker_corporations",
+                    "require_attacker_factions",
+                    "exclude_attacker_factions",
+                    "require_attacker_states",
+                    "exclude_attacker_states",
                     "require_attacker_organizations_final_blow",
-                    "require_victim_alliances",
-                    "exclude_victim_alliances",
-                    "require_victim_corporations",
-                    "exclude_victim_corporations",
                 ),
             },
         ),
         (
-            "Auth State",
+            "Victims",
             {
                 "fields": (
-                    "exclude_attacker_states",
-                    "require_attacker_states",
+                    "require_victim_alliances",
+                    "exclude_victim_alliances",
+                    "require_victim_corporations",
+                    "exclude_victim_corporations",
+                    "require_victim_factions",
+                    "exclude_victim_factions",
                     "require_victim_states",
+                    "exclude_victim_states",
                 ),
             },
         ),

killtracker/core/killmails.py

@@ -38,7 +38,7 @@ from killtracker.providers import esi
 
 logger = LoggerAddTag(get_extension_logger(__name__), __title__)
 
-ZKB_REDISQ_URL = "https://redisq.zkillboard.com/listen.php"
+ZKB_REDISQ_URL = "https://zkillredisq.stream/listen.php"
 ZKB_API_URL = "https://zkillboard.com/api/"
 ZKB_KILLMAIL_BASEURL = "https://zkillboard.com/kill/"
 REQUESTS_TIMEOUT = (5, 30)
@@ -97,6 +97,7 @@ class KillmailAttacker(_KillmailCharacter):
 @dataclass
 class KillmailPosition(_KillmailBase):
     "A position for a killmail."
+
     x: Optional[float] = None
     y: Optional[float] = None
     z: Optional[float] = None
@@ -182,6 +183,10 @@ class Killmail(_KillmailBase):
         """Return distinct character IDs of all attackers."""
         return {obj.character_id for obj in self.attackers if obj.character_id}
 
+    def attackers_distinct_faction_ids(self) -> Set[int]:
+        """Return distinct faction IDs of all attackers."""
+        return {obj.faction_id for obj in self.attackers if obj.faction_id}
+
     def attackers_ship_type_ids(self) -> List[int]:
         """Returns ship type IDs of all attackers with duplicates."""
         return [obj.ship_type_id for obj in self.attackers if obj.ship_type_id]

killtracker/migrations/0004_add_faction_clauses.py

@@ -0,0 +1,69 @@
+# Generated by Django 4.0.10 on 2024-07-04 12:40
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+    dependencies = [
+        ("authentication", "0021_alter_userprofile_language"),
+        ("eveonline", "0017_alliance_and_corp_names_are_not_unique"),
+        ("killtracker", "0003_optimize_tracker_form"),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name="tracker",
+            name="exclude_attacker_factions",
+            field=models.ManyToManyField(
+                blank=True,
+                default=None,
+                help_text="Exclude killmails with attackers from one of these factions. ",
+                related_name="+",
+                to="eveonline.evefactioninfo",
+            ),
+        ),
+        migrations.AddField(
+            model_name="tracker",
+            name="exclude_victim_factions",
+            field=models.ManyToManyField(
+                blank=True,
+                default=None,
+                help_text="Exclude killmails where the victim belongs to one of these factions. ",
+                related_name="+",
+                to="eveonline.evefactioninfo",
+            ),
+        ),
+        migrations.AddField(
+            model_name="tracker",
+            name="exclude_victim_states",
+            field=models.ManyToManyField(
+                blank=True,
+                default=None,
+                help_text="Exclude killmails where the victim belongs to one of these Auth states. ",
+                related_name="+",
+                to="authentication.state",
+            ),
+        ),
+        migrations.AddField(
+            model_name="tracker",
+            name="require_attacker_factions",
+            field=models.ManyToManyField(
+                blank=True,
+                default=None,
+                help_text="Only include killmails with attackers from one of these factions. ",
+                related_name="+",
+                to="eveonline.evefactioninfo",
+            ),
+        ),
+        migrations.AddField(
+            model_name="tracker",
+            name="require_victim_factions",
+            field=models.ManyToManyField(
+                blank=True,
+                default=None,
+                help_text="Only include killmails where the victim belongs to one of these factions. ",
+                related_name="+",
+                to="eveonline.evefactioninfo",
+            ),
+        ),
+    ]

killtracker/models/trackers.py

@@ -17,7 +17,11 @@ from eveuniverse.models import (
 )
 
 from allianceauth.authentication.models import State
-from allianceauth.eveonline.models import EveAllianceInfo, EveCorporationInfo
+from allianceauth.eveonline.models import (
+    EveAllianceInfo,
+    EveCorporationInfo,
+    EveFactionInfo,
+)
 from allianceauth.services.hooks import get_extension_logger
 from app_utils.logging import LoggerAddTag
 
@@ -170,6 +174,25 @@ class Tracker(models.Model):
         blank=True,
         help_text="Only include killmails with attackers from one of these alliances. ",
     )
+    require_victim_alliances = models.ManyToManyField(
+        EveAllianceInfo,
+        related_name="+",
+        default=None,
+        blank=True,
+        help_text=(
+            "Only include killmails where the victim belongs "
+            "to one of these alliances. "
+        ),
+    )
+    exclude_victim_alliances = models.ManyToManyField(
+        EveAllianceInfo,
+        related_name="+",
+        default=None,
+        blank=True,
+        help_text=(
+            "Exclude killmails where the victim belongs to one of these alliances. "
+        ),
+    )
     exclude_attacker_corporations = models.ManyToManyField(
         EveCorporationInfo,
         related_name="+",
@@ -196,6 +219,25 @@ class Tracker(models.Model):
             "has the final blow."
         ),
     )
+    require_victim_corporations = models.ManyToManyField(
+        EveCorporationInfo,
+        related_name="+",
+        default=None,
+        blank=True,
+        help_text=(
+            "Only include killmails where the victim belongs "
+            "to one of these corporations. "
+        ),
+    )
+    exclude_victim_corporations = models.ManyToManyField(
+        EveCorporationInfo,
+        related_name="+",
+        default=None,
+        blank=True,
+        help_text=(
+            "Exclude killmails where the victim belongs to one of these corporations. "
+        ),
+    )
     exclude_attacker_states = models.ManyToManyField(
         State,
         related_name="+",
@@ -216,52 +258,58 @@ class Tracker(models.Model):
             "to users with these Auth states. "
         ),
     )
-    require_victim_alliances = models.ManyToManyField(
-        EveAllianceInfo,
+    exclude_victim_states = models.ManyToManyField(
+        State,
         related_name="+",
         default=None,
         blank=True,
         help_text=(
-            "Only include killmails where the victim belongs "
-            "to one of these alliances. "
+            "Exclude killmails where the victim belongs to one of these Auth states. "
         ),
     )
-    exclude_victim_alliances = models.ManyToManyField(
-        EveAllianceInfo,
+    require_victim_states = models.ManyToManyField(
+        State,
         related_name="+",
         default=None,
         blank=True,
         help_text=(
-            "Exclude killmails where the victim belongs to one of these alliances. "
+            "Only include killmails where the victim characters belong "
+            "to users with these Auth states. "
         ),
     )
-    require_victim_corporations = models.ManyToManyField(
-        EveCorporationInfo,
+    exclude_attacker_factions = models.ManyToManyField(
+        EveFactionInfo,
+        related_name="+",
+        default=None,
+        blank=True,
+        help_text="Exclude killmails with attackers from one of these factions. ",
+    )
+    require_attacker_factions = models.ManyToManyField(
+        EveFactionInfo,
         related_name="+",
         default=None,
         blank=True,
         help_text=(
-            "Only include killmails where the victim belongs "
-            "to one of these corporations. "
+            "Only include killmails with attackers from one of these factions. "
         ),
     )
-    exclude_victim_corporations = models.ManyToManyField(
-        EveCorporationInfo,
+    require_victim_factions = models.ManyToManyField(
+        EveFactionInfo,
         related_name="+",
         default=None,
         blank=True,
         help_text=(
-            "Exclude killmails where the victim belongs to one of these corporations. "
+            "Only include killmails where the victim belongs "
+            "to one of these factions. "
         ),
     )
-    require_victim_states = models.ManyToManyField(
-        State,
+    exclude_victim_factions = models.ManyToManyField(
+        EveFactionInfo,
         related_name="+",
         default=None,
         blank=True,
         help_text=(
-            "Only include killmails where the victim characters belong "
-            "to users with these Auth states. "
+            "Exclude killmails where the victim belongs to one of these factions. "
         ),
     )
     identify_fleets = models.BooleanField(
@@ -506,6 +554,7 @@ class Tracker(models.Model):
             is_matching = self._match_value(killmail, is_matching)
             is_matching, jumps, distance = self._match_geography(killmail, is_matching)
             is_matching = self._match_attackers(killmail, is_matching)
+            is_matching = self._match_states(killmail, is_matching)
             is_matching, matching_ship_type_ids = self._match_attacker_ships(
                 killmail, is_matching, matching_ship_type_ids
             )
@@ -641,6 +690,16 @@ class Tracker(models.Model):
                 corporation_id__in=killmail.attackers_distinct_corporation_ids()
             ).exists()
 
+        if is_matching and self.require_attacker_factions.exists():
+            is_matching = self.require_attacker_factions.filter(
+                faction_id__in=killmail.attackers_distinct_faction_ids()
+            ).exists()
+
+        if is_matching and self.exclude_attacker_factions.exists():
+            is_matching = self.exclude_attacker_factions.exclude(
+                faction_id__in=killmail.attackers_distinct_faction_ids()
+            ).exists()
+
         if is_matching:
             if self.require_attacker_organizations_final_blow:
                 attacker_final_blow = killmail.attacker_final_blow()
@@ -668,6 +727,9 @@ class Tracker(models.Model):
                         corporation_id__in=killmail.attackers_distinct_corporation_ids()
                     ).exists()
 
+        return is_matching
+
+    def _match_states(self, killmail: Killmail, is_matching: bool) -> bool:
         if is_matching and self.require_attacker_states.exists():
             is_matching = User.objects.filter(
                 profile__state__in=list(self.require_attacker_states.all()),
@@ -684,6 +746,14 @@ class Tracker(models.Model):
                 ),
             ).exists()
 
+        if is_matching and self.require_victim_states.exists():
+            is_matching = User.objects.filter(
+                profile__state__in=list(self.require_victim_states.all()),
+                character_ownerships__character__character_id=(
+                    killmail.victim.character_id
+                ),
+            ).exists()
+
         return is_matching
 
     def _match_attacker_ships(
@@ -765,12 +835,14 @@ class Tracker(models.Model):
                 corporation_id=killmail.victim.corporation_id
             ).exists()
 
-        if is_matching and self.require_victim_states.exists():
-            is_matching = User.objects.filter(
-                profile__state__in=list(self.require_victim_states.all()),
-                character_ownerships__character__character_id=(
-                    killmail.victim.character_id
-                ),
+        if is_matching and self.require_victim_factions.exists():
+            is_matching = self.require_victim_factions.filter(
+                faction_id=killmail.victim.faction_id
+            ).exists()
+
+        if is_matching and self.exclude_victim_factions.exists():
+            is_matching = self.exclude_victim_factions.exclude(
+                faction_id=killmail.victim.faction_id
             ).exists()
 
         return is_matching

killtracker/tests/core/test_killmails.py

@@ -262,6 +262,12 @@ class TestKillmailBasics(NoSocketsTestCase):
         # then
         self.assertSetEqual(set(result), {3001})
 
+    def test_should_return_attacker_faction_ids(self):
+        # when
+        result = self.killmail.attackers_distinct_faction_ids()
+        # then
+        self.assertSetEqual(set(result), {500001})
+
     def test_should_return_attacker_corporation_ids(self):
         # when
         result = self.killmail.attackers_distinct_corporation_ids()

killtracker/tests/models/test_trackers_1.py

@@ -14,19 +14,25 @@ from eveuniverse.models import (
     EveType,
 )
 
-from allianceauth.eveonline.models import EveAllianceInfo, EveCorporationInfo
+from allianceauth.eveonline.models import EveAllianceInfo
 from allianceauth.tests.auth_utils import AuthUtils
 from app_utils.esi_testing import BravadoOperationStub
+from app_utils.testdata_factories import (
+    EveAllianceInfoFactory,
+    EveCorporationInfoFactory,
+)
 from app_utils.testing import NoSocketsTestCase, add_character_to_user_2
 
 from killtracker.constants import EveGroupId
 from killtracker.core.killmails import Killmail, _EntityCount
 from killtracker.models import Tracker
 from killtracker.tests.testdata.factories import (
+    EveFactionInfoFactory,
     KillmailAttackerFactory,
     KillmailFactory,
     KillmailVictimFactory,
     TrackerFactory,
+    WebhookFactory,
 )
 from killtracker.tests.testdata.helpers import LoadTestDataMixin, load_killmail
 
@@ -175,66 +181,6 @@ class TestTrackerCalculate(LoadTestDataMixin, NoSocketsTestCase):
         expected = {10000102, 10000103}
         self.assertSetEqual(results, expected)
 
-    def test_can_filter_attacker_alliance(self):
-        killmail_ids = {10000001, 10000002, 10000003, 10000004, 10000005}
-        tracker = TrackerFactory(webhook=self.webhook_1)
-        tracker.exclude_attacker_alliances.add(
-            EveAllianceInfo.objects.get(alliance_id=3001)
-        )
-        results = self._matching_killmail_ids(tracker, killmail_ids)
-        expected = {10000005}
-        self.assertSetEqual(results, expected)
-
-    def test_can_filter_attacker_corporation(self):
-        killmail_ids = {10000003, 10000004, 10000005}
-        tracker = TrackerFactory(webhook=self.webhook_1)
-        tracker.exclude_attacker_corporations.add(
-            EveCorporationInfo.objects.get(corporation_id=2001)
-        )
-        results = self._matching_killmail_ids(tracker, killmail_ids)
-        expected = {10000005}
-        self.assertSetEqual(results, expected)
-
-    def test_can_required_attacker_alliance(self):
-        killmail_ids = {10000001, 10000002, 10000003, 10000004, 10000005}
-        tracker = TrackerFactory(webhook=self.webhook_1)
-        tracker.require_attacker_alliances.add(
-            EveAllianceInfo.objects.get(alliance_id=3011)
-        )
-        results = self._matching_killmail_ids(tracker, killmail_ids)
-        expected = {10000005}
-        self.assertSetEqual(results, expected)
-
-    def test_can_required_attacker_corporation(self):
-        killmail_ids = {10000003, 10000004, 10000005}
-        tracker = TrackerFactory(webhook=self.webhook_1)
-        tracker.require_attacker_corporations.add(
-            EveCorporationInfo.objects.get(corporation_id=2011)
-        )
-        results = self._matching_killmail_ids(tracker, killmail_ids)
-        expected = {10000005}
-        self.assertSetEqual(results, expected)
-
-    def test_can_required_victim_alliances(self):
-        killmail_ids = {10000001, 10000002, 10000003, 10000004, 10000005}
-        tracker = TrackerFactory(webhook=self.webhook_1)
-        tracker.require_victim_alliances.add(
-            EveAllianceInfo.objects.get(alliance_id=3001)
-        )
-        results = self._matching_killmail_ids(tracker, killmail_ids)
-        expected = {10000005}
-        self.assertSetEqual(results, expected)
-
-    def test_can_required_victim_corporation(self):
-        killmail_ids = {10000003, 10000004, 10000005}
-        tracker = TrackerFactory(webhook=self.webhook_1)
-        tracker.require_victim_corporations.add(
-            EveCorporationInfo.objects.get(corporation_id=2001)
-        )
-        results = self._matching_killmail_ids(tracker, killmail_ids)
-        expected = {10000005}
-        self.assertSetEqual(results, expected)
-
     def test_can_filter_nullsec_and_attacker_alliance(self):
         killmail_ids = {10000001, 10000002, 10000003, 10000004, 10000005}
         tracker = TrackerFactory(exclude_null_sec=True, webhook=self.webhook_1)
@@ -371,205 +317,443 @@ class TestTrackerCalculate(LoadTestDataMixin, NoSocketsTestCase):
 
 
 class TestTrackerCalculate2(LoadTestDataMixin, NoSocketsTestCase):
-    def test_should_accept_with_require_attacker_alliances(self):
-        attacker = KillmailAttackerFactory(alliance_id=3011)
+    def test_should_deny_when_value_is_below_minimum(self):
+        killmail = KillmailFactory(zkb__total_value=50_000_000)
+        tracker = TrackerFactory(require_min_value=51, webhook=self.webhook_1)
+        # when
+        result = tracker.process_killmail(killmail)
+        # then
+        self.assertIsNone(result)
+
+    def test_should_threat_no_value_as_zero(self):
+        killmail = KillmailFactory(zkb__total_value=None)
+        tracker = TrackerFactory(require_min_value=51, webhook=self.webhook_1)
+        # when
+        result = tracker.process_killmail(killmail)
+        # then
+        self.assertIsNone(result)
+
+    def test_should_accept_with_require_attacker_weapon_group(self):
+        attacker = KillmailAttackerFactory(weapon_type_id=2977)
         killmail = KillmailFactory(attackers=[attacker])
         tracker = TrackerFactory(webhook=self.webhook_1)
-        tracker.require_attacker_alliances.add(
-            EveAllianceInfo.objects.get(alliance_id=3011)
+        tracker.require_attackers_weapon_groups.add(
+            EveGroup.objects.get(id=EveGroupId.PROJECTILE_WEAPON)
         )
         # when
         result = tracker.process_killmail(killmail)
         # then
-        self.assertIsNotNone(result)
+        self.assertEqual(killmail.id, result.id)
 
-    def test_should_deny_with_require_attacker_alliances(self):
-        attacker = KillmailAttackerFactory(alliance_id=3010)
+    def test_should_deny_with_require_attacker_weapon_group(self):
+        attacker = KillmailAttackerFactory(weapon_type_id=2488)
         killmail = KillmailFactory(attackers=[attacker])
         tracker = TrackerFactory(webhook=self.webhook_1)
-        tracker.require_attacker_alliances.add(
-            EveAllianceInfo.objects.get(alliance_id=3011)
+        tracker.require_attackers_weapon_groups.add(
+            EveGroup.objects.get(id=EveGroupId.PROJECTILE_WEAPON)
         )
         # when
         result = tracker.process_killmail(killmail)
         # then
         self.assertIsNone(result)
 
-    def test_should_accept_with_require_attacker_corporations(self):
-        attacker = KillmailAttackerFactory(corporation_id=2011)
+    def test_should_accept_with_require_attacker_weapon_type(self):
+        attacker = KillmailAttackerFactory(weapon_type_id=2977)
         killmail = KillmailFactory(attackers=[attacker])
         tracker = TrackerFactory(webhook=self.webhook_1)
-        tracker.require_attacker_corporations.add(
-            EveCorporationInfo.objects.get(corporation_id=2011)
-        )
+        tracker.require_attackers_weapon_types.add(EveType.objects.get(id=2977))
         # when
         result = tracker.process_killmail(killmail)
         # then
-        self.assertIsNotNone(result)
+        self.assertEqual(killmail.id, result.id)
 
-    def test_should_deny_with_require_attacker_corporations(self):
-        attacker = KillmailAttackerFactory(corporation_id=2001)
+    def test_should_deny_with_require_attacker_weapon_type(self):
+        attacker = KillmailAttackerFactory(weapon_type_id=2488)
         killmail = KillmailFactory(attackers=[attacker])
         tracker = TrackerFactory(webhook=self.webhook_1)
-        tracker.require_attacker_corporations.add(
-            EveCorporationInfo.objects.get(corporation_id=2011)
+        tracker.require_attackers_weapon_types.add(EveType.objects.get(id=2977))
+        # when
+        result = tracker.process_killmail(killmail)
+        # then
+        self.assertIsNone(result)
+
+
+class TestTrackerCalculateAlliances(NoSocketsTestCase):
+    @classmethod
+    def setUpClass(cls):
+        super().setUpClass()
+        cls.alliance_1 = EveAllianceInfoFactory()
+        cls.alliance_2 = EveAllianceInfoFactory()
+        cls.webhook = WebhookFactory()
+
+    def test_should_accept_with_require_attacker_alliances(self):
+        attacker = KillmailAttackerFactory(alliance_id=self.alliance_1.alliance_id)
+        killmail = KillmailFactory(attackers=[attacker])
+        tracker = TrackerFactory(webhook=self.webhook)
+        tracker.require_attacker_alliances.add(self.alliance_1)
+        # when
+        result = tracker.process_killmail(killmail)
+        # then
+        self.assertIsNotNone(result)
+
+    def test_should_deny_with_require_attacker_alliances(self):
+        attacker = KillmailAttackerFactory(alliance_id=self.alliance_2.alliance_id)
+        killmail = KillmailFactory(attackers=[attacker])
+        tracker = TrackerFactory(webhook=self.webhook)
+        tracker.require_attacker_alliances.add(self.alliance_1)
+        # when
+        result = tracker.process_killmail(killmail)
+        # then
+        self.assertIsNone(result)
+
+    def test_should_accept_with_exclude_attacker_alliances(self):
+        attacker = KillmailAttackerFactory(alliance_id=self.alliance_2.alliance_id)
+        killmail = KillmailFactory(attackers=[attacker])
+        tracker = TrackerFactory(webhook=self.webhook)
+        tracker.exclude_attacker_alliances.add(self.alliance_1)
+        # when
+        result = tracker.process_killmail(killmail)
+        # then
+        self.assertIsNotNone(result)
+
+    def test_should_deny_with_exclude_attacker_alliances(self):
+        attacker = KillmailAttackerFactory(alliance_id=self.alliance_1.alliance_id)
+        killmail = KillmailFactory(attackers=[attacker])
+        tracker = TrackerFactory(webhook=self.webhook)
+        tracker.exclude_attacker_alliances.add(self.alliance_1)
+        # when
+        result = tracker.process_killmail(killmail)
+        # then
+        self.assertIsNone(result)
+
+    def test_should_accept_when_required_attacker_alliance_has_final_blow(self):
+        attacker = KillmailAttackerFactory(
+            alliance_id=self.alliance_1.alliance_id, is_final_blow=True
+        )
+        killmail = KillmailFactory(attackers=[attacker])
+        tracker = TrackerFactory(
+            require_attacker_organizations_final_blow=True, webhook=self.webhook
+        )
+        tracker.require_attacker_alliances.add(self.alliance_1)
+        # when
+        result = tracker.process_killmail(killmail)
+        # then
+        self.assertIsNotNone(result)
+
+    def test_should_deny_when_required_attacker_alliance_has_not_final_blow(self):
+        attacker_1 = KillmailAttackerFactory(
+            alliance_id=self.alliance_1.alliance_id, is_final_blow=False
         )
+        attacker_2 = KillmailAttackerFactory(
+            alliance_id=self.alliance_2.alliance_id, is_final_blow=True
+        )
+        killmail = KillmailFactory(attackers=[attacker_1, attacker_2])
+        tracker = TrackerFactory(
+            require_attacker_organizations_final_blow=True, webhook=self.webhook
+        )
+        tracker.require_attacker_alliances.add(self.alliance_1)
         # when
         result = tracker.process_killmail(killmail)
         # then
         self.assertIsNone(result)
 
-    def test_should_deny_with_exclude_victim_corporation(self):
-        victim = KillmailVictimFactory(corporation_id=2001)
+    def test_should_deny_with_require_victim_alliance(self):
+        victim = KillmailVictimFactory(alliance_id=self.alliance_2.alliance_id)
         killmail = KillmailFactory(victim=victim)
-        tracker = TrackerFactory(webhook=self.webhook_1)
-        tracker.exclude_victim_corporations.add(
-            EveCorporationInfo.objects.get(corporation_id=2001)
-        )
+        tracker = TrackerFactory(webhook=self.webhook)
+        tracker.require_victim_alliances.add(self.alliance_1)
         # when
         result = tracker.process_killmail(killmail)
         # then
         self.assertIsNone(result)
 
-    def test_should_accept_with_exclude_victim_corporation(self):
-        victim = KillmailVictimFactory(corporation_id=2002)
+    def test_should_accept_with_require_victim_alliance(self):
+        victim = KillmailVictimFactory(alliance_id=self.alliance_1.alliance_id)
         killmail = KillmailFactory(victim=victim)
-        tracker = TrackerFactory(webhook=self.webhook_1)
-        tracker.exclude_victim_corporations.add(
-            EveCorporationInfo.objects.get(corporation_id=2001)
-        )
+        tracker = TrackerFactory(webhook=self.webhook)
+        tracker.require_victim_alliances.add(self.alliance_1)
         # when
         result = tracker.process_killmail(killmail)
         # then
         self.assertIsNotNone(result)
 
     def test_should_deny_with_exclude_victim_alliance(self):
-        victim = KillmailVictimFactory(alliance_id=3001)
+        victim = KillmailVictimFactory(alliance_id=self.alliance_1.alliance_id)
         killmail = KillmailFactory(victim=victim)
-        tracker = TrackerFactory(webhook=self.webhook_1)
-        tracker.exclude_victim_alliances.add(
-            EveAllianceInfo.objects.get(alliance_id=3001)
-        )
+        tracker = TrackerFactory(webhook=self.webhook)
+        tracker.exclude_victim_alliances.add(self.alliance_1)
         # when
         result = tracker.process_killmail(killmail)
         # then
         self.assertIsNone(result)
 
     def test_should_accept_with_exclude_victim_alliance(self):
-        victim = KillmailVictimFactory(alliance_id=3002)
+        victim = KillmailVictimFactory(alliance_id=self.alliance_2.alliance_id)
         killmail = KillmailFactory(victim=victim)
-        tracker = TrackerFactory(webhook=self.webhook_1)
-        tracker.exclude_victim_alliances.add(
-            EveAllianceInfo.objects.get(alliance_id=3001)
-        )
+        tracker = TrackerFactory(webhook=self.webhook)
+        tracker.exclude_victim_alliances.add(self.alliance_1)
         # when
         result = tracker.process_killmail(killmail)
         # then
         self.assertIsNotNone(result)
 
-    def test_should_accept_when_attacker_alliance_has_final_blow(self):
-        attacker = KillmailAttackerFactory(alliance_id=3011, is_final_blow=True)
+
+class TestTrackerCalculateCorporations(NoSocketsTestCase):
+    @classmethod
+    def setUpClass(cls):
+        super().setUpClass()
+        cls.corporation_1 = EveCorporationInfoFactory()
+        cls.corporation_2 = EveCorporationInfoFactory()
+        cls.webhook = WebhookFactory()
+
+    def test_should_accept_with_require_attacker_corporations(self):
+        attacker = KillmailAttackerFactory(
+            corporation_id=self.corporation_1.corporation_id
+        )
         killmail = KillmailFactory(attackers=[attacker])
-        tracker = TrackerFactory(
-            require_attacker_organizations_final_blow=True, webhook=self.webhook_1
+        tracker = TrackerFactory(webhook=self.webhook)
+        tracker.require_attacker_corporations.add(self.corporation_1)
+        # when
+        result = tracker.process_killmail(killmail)
+        # then
+        self.assertIsNotNone(result)
+
+    def test_should_deny_with_require_attacker_corporations(self):
+        attacker = KillmailAttackerFactory(
+            corporation_id=self.corporation_2.corporation_id
         )
-        tracker.require_attacker_alliances.add(
-            EveAllianceInfo.objects.get(alliance_id=3011)
+        killmail = KillmailFactory(attackers=[attacker])
+        tracker = TrackerFactory(webhook=self.webhook)
+        tracker.require_attacker_corporations.add(self.corporation_1)
+        # when
+        result = tracker.process_killmail(killmail)
+        # then
+        self.assertIsNone(result)
+
+    def test_should_accept_with_exclude_attacker_corporations(self):
+        attacker = KillmailAttackerFactory(
+            corporation_id=self.corporation_2.corporation_id
         )
+        killmail = KillmailFactory(attackers=[attacker])
+        tracker = TrackerFactory(webhook=self.webhook)
+        tracker.exclude_attacker_corporations.add(self.corporation_1)
         # when
         result = tracker.process_killmail(killmail)
         # then
         self.assertIsNotNone(result)
 
-    def test_should_accept_when_attacker_corporation_has_final_blow(self):
-        attacker = KillmailAttackerFactory(corporation_id=2011, is_final_blow=True)
+    def test_should_deny_with_exclude_attacker_corporations(self):
+        attacker = KillmailAttackerFactory(
+            corporation_id=self.corporation_1.corporation_id
+        )
         killmail = KillmailFactory(attackers=[attacker])
-        tracker = TrackerFactory(
-            require_attacker_organizations_final_blow=True, webhook=self.webhook_1
+        tracker = TrackerFactory(webhook=self.webhook)
+        tracker.exclude_attacker_corporations.add(self.corporation_1)
+        # when
+        result = tracker.process_killmail(killmail)
+        # then
+        self.assertIsNone(result)
+
+    def test_should_accept_when_required_attacker_corporation_has_final_blow(self):
+        attacker = KillmailAttackerFactory(
+            corporation_id=self.corporation_1.corporation_id, is_final_blow=True
         )
-        tracker.require_attacker_corporations.add(
-            EveCorporationInfo.objects.get(corporation_id=2011)
+        killmail = KillmailFactory(attackers=[attacker])
+        tracker = TrackerFactory(
+            require_attacker_organizations_final_blow=True, webhook=self.webhook
         )
+        tracker.require_attacker_corporations.add(self.corporation_1)
         # when
         result = tracker.process_killmail(killmail)
         # then
         self.assertIsNotNone(result)
 
-    def test_should_deny_when_attacker_corporation_has_not_has_final_blow(self):
-        attacker_1 = KillmailAttackerFactory(corporation_id=2011, is_final_blow=False)
-        attacker_2 = KillmailAttackerFactory(corporation_id=2001, is_final_blow=True)
+    def test_should_deny_when_required_attacker_corporation_has_not_has_final_blow(
+        self,
+    ):
+        attacker_1 = KillmailAttackerFactory(
+            corporation_id=self.corporation_1.corporation_id, is_final_blow=False
+        )
+        attacker_2 = KillmailAttackerFactory(
+            corporation_id=self.corporation_2.corporation_id, is_final_blow=True
+        )
         killmail = KillmailFactory(attackers=[attacker_1, attacker_2])
         tracker = TrackerFactory(
-            require_attacker_organizations_final_blow=True, webhook=self.webhook_1
-        )
-        tracker.require_attacker_corporations.add(
-            EveCorporationInfo.objects.get(corporation_id=2011)
+            require_attacker_organizations_final_blow=True, webhook=self.webhook
         )
+        tracker.require_attacker_corporations.add(self.corporation_1)
         # when
         result = tracker.process_killmail(killmail)
         # then
         self.assertIsNone(result)
 
-    def test_should_deny_when_value_is_below_minimum(self):
-        killmail = KillmailFactory(zkb__total_value=50_000_000)
-        tracker = TrackerFactory(require_min_value=51, webhook=self.webhook_1)
+    def test_should_deny_with_require_victim_corporation(self):
+        victim = KillmailVictimFactory(corporation_id=self.corporation_2.corporation_id)
+        killmail = KillmailFactory(victim=victim)
+        tracker = TrackerFactory(webhook=self.webhook)
+        tracker.require_victim_corporations.add(self.corporation_1)
         # when
         result = tracker.process_killmail(killmail)
         # then
         self.assertIsNone(result)
 
-    def test_should_threat_no_value_as_zero(self):
-        killmail = KillmailFactory(zkb__total_value=None)
-        tracker = TrackerFactory(require_min_value=51, webhook=self.webhook_1)
+    def test_should_accept_with_require_victim_corporation(self):
+        victim = KillmailVictimFactory(corporation_id=self.corporation_1.corporation_id)
+        killmail = KillmailFactory(victim=victim)
+        tracker = TrackerFactory(webhook=self.webhook)
+        tracker.require_victim_corporations.add(self.corporation_1)
+        # when
+        result = tracker.process_killmail(killmail)
+        # then
+        self.assertIsNotNone(result)
+
+    def test_should_deny_with_exclude_victim_corporation(self):
+        victim = KillmailVictimFactory(corporation_id=self.corporation_1.corporation_id)
+        killmail = KillmailFactory(victim=victim)
+        tracker = TrackerFactory(webhook=self.webhook)
+        tracker.exclude_victim_corporations.add(self.corporation_1)
         # when
         result = tracker.process_killmail(killmail)
         # then
         self.assertIsNone(result)
 
-    def test_should_accept_with_require_attacker_weapon_group(self):
-        attacker = KillmailAttackerFactory(weapon_type_id=2977)
+    def test_should_accept_with_exclude_victim_corporation(self):
+        victim = KillmailVictimFactory(corporation_id=self.corporation_2.corporation_id)
+        killmail = KillmailFactory(victim=victim)
+        tracker = TrackerFactory(webhook=self.webhook)
+        tracker.exclude_victim_corporations.add(self.corporation_1)
+        # when
+        result = tracker.process_killmail(killmail)
+        # then
+        self.assertIsNotNone(result)
+
+
+class TestTrackerCalculateFactions(NoSocketsTestCase):
+    @classmethod
+    def setUpClass(cls):
+        super().setUpClass()
+        cls.faction_1 = EveFactionInfoFactory()
+        cls.faction_2 = EveFactionInfoFactory()
+        cls.webhook = WebhookFactory()
+
+    def test_should_accept_with_require_attacker_factions(self):
+        attacker = KillmailAttackerFactory(faction_id=self.faction_1.faction_id)
         killmail = KillmailFactory(attackers=[attacker])
-        tracker = TrackerFactory(webhook=self.webhook_1)
-        tracker.require_attackers_weapon_groups.add(
-            EveGroup.objects.get(id=EveGroupId.PROJECTILE_WEAPON)
-        )
+        tracker = TrackerFactory(webhook=self.webhook)
+        tracker.require_attacker_factions.add(self.faction_1)
         # when
         result = tracker.process_killmail(killmail)
         # then
-        self.assertEqual(killmail.id, result.id)
+        self.assertIsNotNone(result)
 
-    def test_should_deny_with_require_attacker_weapon_group(self):
-        attacker = KillmailAttackerFactory(weapon_type_id=2488)
+    def test_should_deny_with_require_attacker_factions(self):
+        attacker = KillmailAttackerFactory(faction_id=self.faction_1.faction_id)
         killmail = KillmailFactory(attackers=[attacker])
-        tracker = TrackerFactory(webhook=self.webhook_1)
-        tracker.require_attackers_weapon_groups.add(
-            EveGroup.objects.get(id=EveGroupId.PROJECTILE_WEAPON)
-        )
+        tracker = TrackerFactory(webhook=self.webhook)
+        tracker.require_attacker_factions.add(self.faction_2)
         # when
         result = tracker.process_killmail(killmail)
         # then
         self.assertIsNone(result)
 
-    def test_should_accept_with_require_attacker_weapon_type(self):
-        attacker = KillmailAttackerFactory(weapon_type_id=2977)
+    def test_should_accept_with_exclude_attacker_factions(self):
+        attacker = KillmailAttackerFactory(faction_id=self.faction_1.faction_id)
         killmail = KillmailFactory(attackers=[attacker])
-        tracker = TrackerFactory(webhook=self.webhook_1)
-        tracker.require_attackers_weapon_types.add(EveType.objects.get(id=2977))
+        tracker = TrackerFactory(webhook=self.webhook)
+        tracker.exclude_attacker_factions.add(self.faction_2)
         # when
         result = tracker.process_killmail(killmail)
         # then
-        self.assertEqual(killmail.id, result.id)
+        self.assertIsNotNone(result)
 
-    def test_should_deny_with_require_attacker_weapon_type(self):
-        attacker = KillmailAttackerFactory(weapon_type_id=2488)
+    def test_should_deny_with_exclude_attacker_factions(self):
+        attacker = KillmailAttackerFactory(faction_id=self.faction_1.faction_id)
         killmail = KillmailFactory(attackers=[attacker])
-        tracker = TrackerFactory(webhook=self.webhook_1)
-        tracker.require_attackers_weapon_types.add(EveType.objects.get(id=2977))
+        tracker = TrackerFactory(webhook=self.webhook)
+        tracker.exclude_attacker_factions.add(self.faction_1)
+        # when
+        result = tracker.process_killmail(killmail)
+        # then
+        self.assertIsNone(result)
+
+    def test_should_accept_with_require_victim_factions(self):
+        victim = KillmailVictimFactory(faction_id=self.faction_1.faction_id)
+        killmail = KillmailFactory(victim=victim)
+        tracker = TrackerFactory(webhook=self.webhook)
+        tracker.require_victim_factions.add(self.faction_1)
+        # when
+        result = tracker.process_killmail(killmail)
+        # then
+        self.assertIsNotNone(result)
+
+    def test_should_deny_with_require_victim_factions(self):
+        victim = KillmailVictimFactory(faction_id=self.faction_1.faction_id)
+        killmail = KillmailFactory(victim=victim)
+        tracker = TrackerFactory(webhook=self.webhook)
+        tracker.require_victim_factions.add(self.faction_2)
         # when
         result = tracker.process_killmail(killmail)
         # then
         self.assertIsNone(result)
 
+    def test_should_accept_with_exclude_victim_factions(self):
+        victim = KillmailVictimFactory(faction_id=self.faction_1.faction_id)
+        killmail = KillmailFactory(victim=victim)
+        tracker = TrackerFactory(webhook=self.webhook)
+        tracker.exclude_victim_factions.add(self.faction_2)
+        # when
+        result = tracker.process_killmail(killmail)
+        # then
+        self.assertIsNotNone(result)
+
+    def test_should_deny_with_exclude_victim_factions(self):
+        victim = KillmailVictimFactory(faction_id=self.faction_1.faction_id)
+        killmail = KillmailFactory(victim=victim)
+        tracker = TrackerFactory(webhook=self.webhook)
+        tracker.exclude_victim_factions.add(self.faction_1)
+        # when
+        result = tracker.process_killmail(killmail)
+        # then
+        self.assertIsNone(result)
+
+
+# class TestTrackerCalculateStates(NoSocketsTestCase):
+#     @classmethod
+#     def setUpClass(cls):
+#         super().setUpClass()
+#         cls.user = UserMainFactory()
+#         cls.corporation_1 = EveCorporationInfoFactory()
+#         cls.state_1 = AuthUtils.create_state("state_1", priority=200)
+#         cls.state_1.member_corporations.add(cls.corporation_1)
+#         cls.corporation_2 = EveCorporationInfoFactory()
+#         cls.state_2 = AuthUtils.create_state("state_2", priority=150)
+#         cls.state_2.member_corporations.add(cls.corporation_2)
+#         cls.webhook = WebhookFactory()
+
+#     def test_should_accept_with_require_attacker_states(self):
+#         attacker = KillmailAttackerFactory(
+#             corporation_id=self.corporation_1.corporation_id
+#         )
+#         killmail = KillmailFactory(attackers=[attacker])
+#         tracker = TrackerFactory(webhook=self.webhook)
+#         tracker.require_attacker_states.add(self.state_1)
+#         # when
+#         result = tracker.process_killmail(killmail)
+#         # then
+#         self.assertIsNotNone(result)
+
+#     def test_should_deny_with_require_attacker_states(self):
+#         attacker = KillmailAttackerFactory(
+#             corporation_id=self.corporation_2.corporation_id
+#         )
+#         killmail = KillmailFactory(attackers=[attacker])
+#         tracker = TrackerFactory(webhook=self.webhook)
+#         tracker.require_attacker_states.add(self.state_1)
+#         # when
+#         result = tracker.process_killmail(killmail)
+#         # then
+#         self.assertIsNotNone(result)
+
 
 @patch(MODELS_PATH + ".trackers.EveSolarSystem.jumps_to")
 class TestTrackerCalculateTrackerInfo(LoadTestDataMixin, NoSocketsTestCase):

killtracker/tests/testdata/factories.py

@@ -6,9 +6,12 @@ from typing import Generic, Set, TypeVar
 import factory
 import factory.fuzzy
 
+from django.db.models import Max
 from django.utils.timezone import now
 from eveuniverse.models import EveEntity
 
+from allianceauth.eveonline.models import EveFactionInfo
+
 from killtracker.app_settings import KILLTRACKER_KILLMAIL_MAX_AGE_FOR_TRACKER
 from killtracker.constants import EveCategoryId
 from killtracker.core.killmails import (
@@ -111,6 +114,26 @@ class BaseMetaFactory(Generic[T], factory.base.FactoryMetaClass):
         return super().__call__(*args, **kwargs)
 
 
+class EveFactionInfoFactory(
+    factory.django.DjangoModelFactory, metaclass=BaseMetaFactory[EveFactionInfo]
+):
+    """Generate an EveFactionInfo object."""
+
+    class Meta:
+        model = EveFactionInfo
+        django_get_or_create = ("faction_id", "faction_name")
+
+    faction_name = factory.Faker("catch_phrase")
+
+    @factory.lazy_attribute
+    def faction_id(self):
+        last_id = (
+            EveFactionInfo.objects.aggregate(Max("faction_id"))["faction_id__max"]
+            or 500_000
+        )
+        return last_id + 1
+
+
 class KillmailCharacterFactory(
     factory.Factory, metaclass=BaseMetaFactory[_KillmailCharacter]
 ):

killtracker/tools/generate_conditions_text.py

@@ -1,5 +1,5 @@
 # flake8: noqa
-""" this generated the list of current tracker conditions for the documentation"""
+"""this generated the list of current tracker conditions for the documentation"""
 
 # init and setup django project
 import inspect