aa-killtracker 0.12.0__py3-none-any.whl → 0.12.1__py3-none-any.whl

killtracker/tests/models/test_trackers_2.py

@@ -1,21 +1,14 @@
-import json
 from unittest.mock import patch
 
-import dhooks_lite
-import requests_mock
 from bs4 import BeautifulSoup
 from markdown import markdown
 
-from django.core.cache import cache
 from django.test import TestCase
 from eveuniverse.models import EveConstellation, EveRegion, EveSolarSystem, EveType
 
-from app_utils.json import JSONDateTimeDecoder
 from app_utils.testing import NoSocketsTestCase
 
 from killtracker.core.killmails import Killmail
-from killtracker.exceptions import WebhookTooManyRequests
-from killtracker.models import Webhook
 
 from ..testdata.factories import TrackerFactory
 from ..testdata.helpers import LoadTestDataMixin, load_killmail
@@ -23,47 +16,6 @@ from ..testdata.helpers import LoadTestDataMixin, load_killmail
 MODELS_PATH = "killtracker.models.trackers"
 
 
-class TestWebhookQueue(LoadTestDataMixin, TestCase):
-    @classmethod
-    def setUpClass(cls):
-        super().setUpClass()
-
-    def setUp(self) -> None:
-        self.webhook_1.main_queue.clear()
-        self.webhook_1.error_queue.clear()
-
-    def test_reset_failed_messages(self):
-        message = "Test message"
-        self.webhook_1.error_queue.enqueue(message)
-        self.webhook_1.error_queue.enqueue(message)
-        self.assertEqual(self.webhook_1.error_queue.size(), 2)
-        self.assertEqual(self.webhook_1.main_queue.size(), 0)
-        self.webhook_1.reset_failed_messages()
-        self.assertEqual(self.webhook_1.error_queue.size(), 0)
-        self.assertEqual(self.webhook_1.main_queue.size(), 2)
-
-    def test_discord_message_asjson_normal(self):
-        embed = dhooks_lite.Embed(description="my_description")
-        result = Webhook._discord_message_asjson(
-            content="my_content",
-            username="my_username",
-            avatar_url="my_avatar_url",
-            embeds=[embed],
-        )
-        message_python = json.loads(result, cls=JSONDateTimeDecoder)
-        expected = {
-            "content": "my_content",
-            "embeds": [{"description": "my_description", "type": "rich"}],
-            "username": "my_username",
-            "avatar_url": "my_avatar_url",
-        }
-        self.assertDictEqual(message_python, expected)
-
-    def test_discord_message_asjson_empty(self):
-        with self.assertRaises(ValueError):
-            Webhook._discord_message_asjson("")
-
-
 class TestHasLocalizationClause(LoadTestDataMixin, NoSocketsTestCase):
     def test_has_localization_filter_1(self):
         tracker = TrackerFactory.build(webhook=self.webhook_1, exclude_high_sec=True)
@@ -137,102 +89,6 @@ class TestSaveMethod(LoadTestDataMixin, NoSocketsTestCase):
         self.assertFalse(tracker.color)
 
 
-@requests_mock.Mocker()
-class TestWebhookSendMessage(LoadTestDataMixin, TestCase):
-    def setUp(self) -> None:
-        self.message = Webhook._discord_message_asjson(content="Test message")
-        cache.clear()
-
-    def test_when_send_ok_returns_true(self, requests_mocker):
-        # given
-        requests_mocker.register_uri(
-            "POST",
-            self.webhook_1.url,
-            status_code=200,
-            json={
-                "name": "test webhook",
-                "type": 1,
-                "channel_id": "199737254929760256",
-                "token": "3d89bb7572e0fb30d8128367b3b1b44fecd1726de135cbe28a41f8b2f777c372ba2939e72279b94526ff5d1bd4358d65cf11",
-                "avatar": None,
-                "guild_id": "199737254929760256",
-                "id": "223704706495545344",
-                "application_id": None,
-                "user": {
-                    "username": "test",
-                    "discriminator": "7479",
-                    "id": "190320984123768832",
-                    "avatar": "b004ec1740a63ca06ae2e14c5cee11f3",
-                    "public_flags": 131328,
-                },
-            },
-        )
-        # when
-        response = self.webhook_1.send_message_to_webhook(self.message)
-        # then
-        self.assertTrue(response.status_ok)
-        self.assertTrue(requests_mocker.called)
-
-    def test_when_send_not_ok_returns_false(self, requests_mocker):
-        # given
-        requests_mocker.register_uri("POST", self.webhook_1.url, status_code=404)
-        # when
-        response = self.webhook_1.send_message_to_webhook(self.message)
-        # then
-        self.assertFalse(response.status_ok)
-        self.assertTrue(requests_mocker.called)
-
-    def test_too_many_requests_normal(self, requests_mocker):
-        # given
-        requests_mocker.register_uri(
-            "POST",
-            self.webhook_1.url,
-            status_code=429,
-            json={
-                "global": False,
-                "message": "You are being rate limited.",
-                "retry_after": 2000,
-            },
-            headers={
-                "x-ratelimit-remaining": "5",
-                "x-ratelimit-reset-after": "60",
-                "Retry-After": "2000",
-            },
-        )
-        # when/then
-        try:
-            self.webhook_1.send_message_to_webhook(self.message)
-        except Exception as ex:
-            self.assertIsInstance(ex, WebhookTooManyRequests)
-            self.assertEqual(ex.retry_after, 2002)
-        else:
-            self.fail("Did not raise excepted exception")
-
-        self.assertAlmostEqual(
-            cache.ttl(self.webhook_1._blocked_cache_key()), 2002, delta=5
-        )
-
-    def test_too_many_requests_no_retry_value(self, requests_mocker):
-        # given
-        requests_mocker.register_uri(
-            "POST",
-            self.webhook_1.url,
-            status_code=429,
-            headers={
-                "x-ratelimit-remaining": "5",
-                "x-ratelimit-reset-after": "60",
-            },
-        )
-        # when/then
-        try:
-            self.webhook_1.send_message_to_webhook(self.message)
-        except Exception as ex:
-            self.assertIsInstance(ex, WebhookTooManyRequests)
-            self.assertEqual(ex.retry_after, WebhookTooManyRequests.DEFAULT_RESET_AFTER)
-        else:
-            self.fail("Did not raise excepted exception")
-
-
 @patch(MODELS_PATH + ".Webhook.enqueue_message")
 class TestTrackerGenerateKillmailMessage(LoadTestDataMixin, TestCase):
     def setUp(self) -> None:

killtracker/tests/models/test_webhook.py

@@ -0,0 +1,150 @@
+import json
+
+import dhooks_lite
+import requests_mock
+
+from django.core.cache import cache
+from django.test import TestCase
+
+from app_utils.json import JSONDateTimeDecoder
+
+from killtracker.exceptions import WebhookTooManyRequests
+from killtracker.models import Webhook
+from killtracker.tests.testdata.helpers import LoadTestDataMixin
+
+
+class TestWebhookQueue(LoadTestDataMixin, TestCase):
+    @classmethod
+    def setUpClass(cls):
+        super().setUpClass()
+
+    def setUp(self) -> None:
+        self.webhook_1.main_queue.clear()
+        self.webhook_1.error_queue.clear()
+
+    def test_reset_failed_messages(self):
+        message = "Test message"
+        self.webhook_1.error_queue.enqueue(message)
+        self.webhook_1.error_queue.enqueue(message)
+        self.assertEqual(self.webhook_1.error_queue.size(), 2)
+        self.assertEqual(self.webhook_1.main_queue.size(), 0)
+        self.webhook_1.reset_failed_messages()
+        self.assertEqual(self.webhook_1.error_queue.size(), 0)
+        self.assertEqual(self.webhook_1.main_queue.size(), 2)
+
+    def test_discord_message_asjson_normal(self):
+        embed = dhooks_lite.Embed(description="my_description")
+        result = Webhook._discord_message_asjson(
+            content="my_content",
+            username="my_username",
+            avatar_url="my_avatar_url",
+            embeds=[embed],
+        )
+        message_python = json.loads(result, cls=JSONDateTimeDecoder)
+        expected = {
+            "content": "my_content",
+            "embeds": [{"description": "my_description", "type": "rich"}],
+            "username": "my_username",
+            "avatar_url": "my_avatar_url",
+        }
+        self.assertDictEqual(message_python, expected)
+
+    def test_discord_message_asjson_empty(self):
+        with self.assertRaises(ValueError):
+            Webhook._discord_message_asjson("")
+
+
+@requests_mock.Mocker()
+class TestWebhookSendMessage(LoadTestDataMixin, TestCase):
+    def setUp(self) -> None:
+        self.message = Webhook._discord_message_asjson(content="Test message")
+        cache.clear()
+
+    def test_when_send_ok_returns_true(self, requests_mocker):
+        # given
+        requests_mocker.register_uri(
+            "POST",
+            self.webhook_1.url,
+            status_code=200,
+            json={
+                "name": "test webhook",
+                "type": 1,
+                "channel_id": "199737254929760256",
+                "token": "3d89bb7572e0fb30d8128367b3b1b44fecd1726de135cbe28a41f8b2f777c372ba2939e72279b94526ff5d1bd4358d65cf11",
+                "avatar": None,
+                "guild_id": "199737254929760256",
+                "id": "223704706495545344",
+                "application_id": None,
+                "user": {
+                    "username": "test",
+                    "discriminator": "7479",
+                    "id": "190320984123768832",
+                    "avatar": "b004ec1740a63ca06ae2e14c5cee11f3",
+                    "public_flags": 131328,
+                },
+            },
+        )
+        # when
+        response = self.webhook_1.send_message_to_webhook(self.message)
+        # then
+        self.assertTrue(response.status_ok)
+        self.assertTrue(requests_mocker.called)
+
+    def test_when_send_not_ok_returns_false(self, requests_mocker):
+        # given
+        requests_mocker.register_uri("POST", self.webhook_1.url, status_code=404)
+        # when
+        response = self.webhook_1.send_message_to_webhook(self.message)
+        # then
+        self.assertFalse(response.status_ok)
+        self.assertTrue(requests_mocker.called)
+
+    def test_too_many_requests_normal(self, requests_mocker):
+        # given
+        requests_mocker.register_uri(
+            "POST",
+            self.webhook_1.url,
+            status_code=429,
+            json={
+                "global": False,
+                "message": "You are being rate limited.",
+                "retry_after": 2000,
+            },
+            headers={
+                "x-ratelimit-remaining": "5",
+                "x-ratelimit-reset-after": "60",
+                "Retry-After": "2000",
+            },
+        )
+        # when/then
+        try:
+            self.webhook_1.send_message_to_webhook(self.message)
+        except Exception as ex:
+            self.assertIsInstance(ex, WebhookTooManyRequests)
+            self.assertEqual(ex.retry_after, 2002)
+        else:
+            self.fail("Did not raise excepted exception")
+
+        self.assertAlmostEqual(
+            cache.ttl(self.webhook_1._blocked_cache_key()), 2002, delta=5
+        )
+
+    def test_too_many_requests_no_retry_value(self, requests_mocker):
+        # given
+        requests_mocker.register_uri(
+            "POST",
+            self.webhook_1.url,
+            status_code=429,
+            headers={
+                "x-ratelimit-remaining": "5",
+                "x-ratelimit-reset-after": "60",
+            },
+        )
+        # when/then
+        try:
+            self.webhook_1.send_message_to_webhook(self.message)
+        except Exception as ex:
+            self.assertIsInstance(ex, WebhookTooManyRequests)
+            self.assertEqual(ex.retry_after, WebhookTooManyRequests.DEFAULT_RESET_AFTER)
+        else:
+            self.fail("Did not raise excepted exception")

killtracker/tests/test_admin.py

@@ -1,16 +1,15 @@
 from django.contrib.auth.models import User
+from django.test import TestCase
 from django.urls import reverse
 from django_webtest import WebTest
-from eveuniverse.models import EveType
 
 from allianceauth.eveonline.models import EveCorporationInfo
-from app_utils.testing import create_fake_user
+from app_utils.testdata_factories import UserFactory
 
 from killtracker.models import Tracker, Webhook
 
-from .testdata.factories import TrackerFactory
+from .testdata.factories import TrackerFactory, WebhookFactory
 from .testdata.helpers import LoadTestDataMixin
-from .testdata.load_eveuniverse import load_eveuniverse
 
 
 class TestTrackerChangeList(LoadTestDataMixin, WebTest):
@@ -97,34 +96,6 @@ class TestTrackerValidations(LoadTestDataMixin, WebTest):
         self.assertIn("Please correct the error below", response.text)
         self.assertEqual(Tracker.objects.count(), 0)
 
-    def test_can_not_have_same_options_attacker_alliances(self):
-        form = self._open_page()
-        form["exclude_attacker_alliances"] = [
-            self.alliance_3001.pk,
-            self.alliance_3011.pk,
-        ]
-        form["require_attacker_alliances"] = [self.alliance_3001.pk]
-        response = form.submit()
-
-        # assert results
-        self.assertEqual(response.status_code, 200)
-        self.assertIn("Please correct the error below", response.text)
-        self.assertEqual(Tracker.objects.count(), 0)
-
-    def test_can_not_have_same_options_attacker_corporations(self):
-        form = self._open_page()
-        form["exclude_attacker_corporations"] = [
-            self.corporation_2001.pk,
-            self.corporation_2011.pk,
-        ]
-        form["require_attacker_corporations"] = [self.corporation_2011.pk]
-        response = form.submit()
-
-        # assert results
-        self.assertEqual(response.status_code, 200)
-        self.assertIn("Please correct the error below", response.text)
-        self.assertEqual(Tracker.objects.count(), 0)
-
     def test_min_attackers_must_be_less_than_max_attackers(self):
         form = self._open_page()
         form["require_min_attackers"] = 10
@@ -161,142 +132,32 @@ class TestTrackerValidations(LoadTestDataMixin, WebTest):
         self.assertEqual(Tracker.objects.count(), 0)
 
 
-class TestTrackerChangeForm(WebTest):
+class TestTrackerValidations2(TestCase):
     @classmethod
-    def setUpClass(cls) -> None:
+    def setUpClass(cls):
         super().setUpClass()
-        cls.user = create_fake_user(1001, "Bruce Wayne")
-        cls.user.is_staff = True
-        cls.user.is_superuser = True
-        cls.user.save()
-        load_eveuniverse()
-        cls.npc_type = EveType.objects.get(id=23320)
-
-    def test_do_not_show_npcs_when_not_used_and_not_enabled(self):
-        # given
-        tracker = TrackerFactory()
-        url = reverse("admin:killtracker_tracker_change", args=[tracker.id])
-        self.app.set_user(self.user)
-        # when
-        response = self.app.get(url)
-        # then
-        self.assertEqual(response.status_code, 200)
-        form = response.form
-        require_attackers_ship_types_ids = {
-            int(obj[0]) for obj in form["require_attackers_ship_types"].options
-        }
-        self.assertNotIn(self.npc_type.id, require_attackers_ship_types_ids)
-        require_attackers_ship_groups_ids = {
-            int(obj[0]) for obj in form["require_attackers_ship_groups"].options
-        }
-        self.assertNotIn(self.npc_type.eve_group_id, require_attackers_ship_groups_ids)
-
-    def test_show_npcs_when_in_use(self):
-        # given
-        tracker = TrackerFactory()
-        tracker.require_attackers_ship_types.add(self.npc_type)
-        url = reverse("admin:killtracker_tracker_change", args=[tracker.id])
-        self.app.set_user(self.user)
-        # when
-        response = self.app.get(url)
-        # then
-        self.assertEqual(response.status_code, 200)
-        form = response.form
-        require_attackers_ship_types_ids = {
-            int(obj[0]) for obj in form["require_attackers_ship_types"].options
-        }
-        self.assertIn(self.npc_type.id, require_attackers_ship_types_ids)
-        require_attackers_ship_groups_ids = {
-            int(obj[0]) for obj in form["require_attackers_ship_groups"].options
-        }
-        self.assertIn(self.npc_type.eve_group_id, require_attackers_ship_groups_ids)
+        cls.user = UserFactory(is_staff=True, is_superuser=True)
+        cls.webhook = WebhookFactory()
+        cls.url_add = reverse("admin:killtracker_tracker_add")
+        cls.url_changelist = reverse("admin:killtracker_tracker_changelist")
 
-    def test_show_npcs_when_enabled(self):
+    def test_should_add_new_tracker(self):
         # given
-        tracker = TrackerFactory()
-        tracker.require_attackers_ship_types.add(self.npc_type)
-        url = reverse("admin:killtracker_tracker_change", args=[tracker.id])
-        self.app.set_user(self.user)
-        self.app.session["killtracker_toogle_npc"] = True
-        # when
-        response = self.app.get(url)
-        # then
-        self.assertEqual(response.status_code, 200)
-        form = response.form
-        require_attackers_ship_types_ids = {
-            int(obj[0]) for obj in form["require_attackers_ship_types"].options
-        }
-        self.assertIn(self.npc_type.id, require_attackers_ship_types_ids)
-        require_attackers_ship_groups_ids = {
-            int(obj[0]) for obj in form["require_attackers_ship_groups"].options
+        self.client.force_login(self.user)
+        data = {
+            "name": "Dummy",
+            "webhook": self.webhook.pk,
+            "_save": "Save",
+            "is_enabled": "on",
+            "color": "#000000",
+            "ping_type": "PN",
+            "is_posting_name": "on",
         }
-        self.assertIn(self.npc_type.eve_group_id, require_attackers_ship_groups_ids)
 
-    def test_can_enable_npcs(self):
-        # given
-        tracker = TrackerFactory()
-        url = reverse("admin:killtracker_tracker_change", args=[tracker.id])
-        self.app.set_user(self.user)
-        initial_page = self.app.get(url)
         # when
-        response = initial_page.click(linkid="toogle-npc").follow()
-        # then
-        self.assertEqual(response.status_code, 200)
-        form = response.form
-        require_attackers_ship_types_ids = {
-            int(obj[0]) for obj in form["require_attackers_ship_types"].options
-        }
-        self.assertIn(self.npc_type.id, require_attackers_ship_types_ids)
-        require_attackers_ship_groups_ids = {
-            int(obj[0]) for obj in form["require_attackers_ship_groups"].options
-        }
-        self.assertIn(self.npc_type.eve_group_id, require_attackers_ship_groups_ids)
-
-
-class TestTrackerAddForm(WebTest):
-    @classmethod
-    def setUpClass(cls) -> None:
-        super().setUpClass()
-        cls.user = create_fake_user(1001, "Bruce Wayne")
-        cls.user.is_staff = True
-        cls.user.is_superuser = True
-        cls.user.save()
-        load_eveuniverse()
-        cls.npc_type = EveType.objects.get(id=23320)
+        response = self.client.post(self.url_add, data=data)
 
-    def test_do_not_show_npcs_when_not_enabled(self):
-        # given
-        url = reverse("admin:killtracker_tracker_add")
-        self.app.set_user(self.user)
-        # when
-        response = self.app.get(url)
-        # then
-        self.assertEqual(response.status_code, 200)
-        form = response.form
-        require_attackers_ship_types_ids = {
-            int(obj[0]) for obj in form["require_attackers_ship_types"].options
-        }
-        self.assertNotIn(self.npc_type.id, require_attackers_ship_types_ids)
-        require_attackers_ship_groups_ids = {
-            int(obj[0]) for obj in form["require_attackers_ship_groups"].options
-        }
-        self.assertNotIn(self.npc_type.eve_group_id, require_attackers_ship_groups_ids)
-
-    def test_can_enable_npcs(self):
-        # given
-        url = reverse("admin:killtracker_tracker_add")
-        self.app.set_user(self.user)
-        initial_page = self.app.get(url)
-        # when
-        response = initial_page.click(linkid="toogle-npc").follow()
         # then
-        self.assertEqual(response.status_code, 200)
-        form = response.form
-        require_attackers_ship_types_ids = {
-            int(obj[0]) for obj in form["require_attackers_ship_types"].options
-        }
-        self.assertIn(self.npc_type.id, require_attackers_ship_types_ids)
-        require_attackers_ship_groups_ids = {
-            int(obj[0]) for obj in form["require_attackers_ship_groups"].options
-        }
-        self.assertIn(self.npc_type.eve_group_id, require_attackers_ship_groups_ids)
+        self.assertEqual(response.status_code, 302)
+        self.assertEqual(response.url, self.url_changelist)
+        self.assertTrue(Tracker.objects.filter(name="Dummy").exists())

killtracker/tests/test_integration.py

@@ -19,7 +19,7 @@ PACKAGE_PATH = "killtracker"
 @patch("celery.app.task.Context.called_directly", False)  # make retry work with eager
 @override_settings(CELERY_ALWAYS_EAGER=True)
 @patch(PACKAGE_PATH + ".tasks.is_esi_online", lambda: True)
-@patch(PACKAGE_PATH + ".models.trackers.dhooks_lite.Webhook.execute", spec=True)
+@patch(PACKAGE_PATH + ".models.webhooks.dhooks_lite.Webhook.execute", spec=True)
 @requests_mock.Mocker()
 class TestTasksEnd2End(LoadTestDataMixin, TestCase):
     @classmethod

killtracker/tests/test_tasks.py

@@ -348,7 +348,7 @@ class TestStoreKillmail(TestTrackerBase):
 
 
 @override_settings(CELERY_ALWAYS_EAGER=True, CELERY_EAGER_PROPAGATES_EXCEPTIONS=True)
-@patch("killtracker.models.trackers.dhooks_lite.Webhook.execute", spec=True)
+@patch("killtracker.models.webhooks.dhooks_lite.Webhook.execute", spec=True)
 @patch(MODULE_PATH + ".logger", spec=True)
 class TestSendTestKillmailsToWebhook(TestTrackerBase):
     def setUp(self) -> None:

killtracker/auth_hooks.py

@@ -1,9 +0,0 @@
-from allianceauth import hooks
-from allianceauth.services.hooks import UrlHook
-
-from . import urls
-
-
-@hooks.register("url_hook")
-def register_urls():
-    return UrlHook(urls, "killtracker", r"^killtracker/")

killtracker/templates/admin/killtracker/tracker/change_form.html

@@ -1,16 +0,0 @@
-{% extends "admin/change_form.html" %}
-
-{% block object-tools %}
-    <ul class="object-tools">
-        {% if change %}
-            {% if not is_popup %}
-                {% block object-tools-items %}
-                    {{ block.super }}
-                    {% include "admin/killtracker/tracker/toogle_npc_button.html" %}
-                {% endblock %}
-            {% endif %}
-        {% else %}
-            {% include "admin/killtracker/tracker/toogle_npc_button.html" %}
-        {% endif %}
-    </ul>
-{% endblock %}

killtracker/templates/admin/killtracker/tracker/toogle_npc_button.html

@@ -1,23 +0,0 @@
-{% load i18n %}
-
-<li>
-    {% if not is_using_npc %}
-        <a
-            id="toogle-npc"
-            {% if not change %}
-                href="{% url 'killtracker:admin_killtracker_toogle_npc' %}"
-            {% else %}
-                href="{% url 'killtracker:admin_killtracker_toogle_npc' object_id %}"
-            {% endif %}
-            class="btn"
-            title="Click to toogle">
-            {% if request.session.killtracker_toogle_npc %}
-                {% translate "NPC types: enabled" %}
-            {% else %}
-                {% translate "NPC types: disabled" %}
-            {% endif %}
-        </a>
-    {% else %}
-        <p class="btn">NPC types in use</p>
-    {% endif %}
-</li>

killtracker/urls.py

@@ -1,20 +0,0 @@
-"""Routes for killtracker."""
-
-from django.urls import path
-
-from . import views
-
-app_name = "killtracker"
-
-urlpatterns = [
-    path(
-        "admin_killtracker_toogle_npc/<int:object_id>/",
-        views.admin_killtracker_toogle_npc,
-        name="admin_killtracker_toogle_npc",
-    ),
-    path(
-        "admin_killtracker_toogle_npc/",
-        views.admin_killtracker_toogle_npc,
-        name="admin_killtracker_toogle_npc",
-    ),
-]

killtracker/views.py

@@ -1,27 +0,0 @@
-"""Views for killtracker."""
-
-from typing import Optional
-
-from django.contrib.admin.views.decorators import staff_member_required
-from django.contrib.auth.decorators import login_required
-from django.shortcuts import redirect
-
-from allianceauth.services.hooks import get_extension_logger
-from app_utils.logging import LoggerAddTag
-
-from . import __title__
-from .constants import SESSION_KEY_TOOGLE_NPC
-
-logger = LoggerAddTag(get_extension_logger(__name__), __title__)
-
-
-@login_required
-@staff_member_required
-def admin_killtracker_toogle_npc(request, object_id: Optional[int] = None):
-    """Enable or disable the toogle to show NPC types."""
-    request.session[SESSION_KEY_TOOGLE_NPC] = not request.session.get(
-        SESSION_KEY_TOOGLE_NPC, False
-    )
-    if object_id:
-        return redirect("admin:killtracker_tracker_change", object_id)
-    return redirect("admin:killtracker_tracker_add")