aa-intel-tool 2.10.0__py3-none-any.whl → 2.11.0__py3-none-any.whl

aa_intel_tool/tests/test_parser_module_feetcomp.py

@@ -0,0 +1,230 @@
+# Standard Library
+from unittest.mock import MagicMock, patch
+
+# AA Intel Tool
+from aa_intel_tool.exceptions import ParserError
+from aa_intel_tool.parser.module.fleetcomp import get_fleet_composition, parse
+from aa_intel_tool.tests import BaseTestCase
+
+
+class TestParse(BaseTestCase):
+    def test_raises_error_when_fleetcomp_module_is_disabled(self):
+        """
+        Test that ParserError is raised when the fleet composition module is disabled.
+
+        :return:
+        :rtype:
+        """
+
+        with patch(
+            "aa_intel_tool.app_settings.AppSettings.INTELTOOL_ENABLE_MODULE_FLEETCOMP",
+            False,
+        ):
+            with self.assertRaises(ParserError):
+                parse(scan_data=[])
+
+    def test_returns_empty_data_for_empty_scan(self):
+        """
+        Test that an empty scan returns empty parsed data.
+
+        :return:
+        :rtype:
+        """
+
+        with patch(
+            "aa_intel_tool.app_settings.AppSettings.INTELTOOL_ENABLE_MODULE_FLEETCOMP",
+            True,
+        ):
+            with patch(
+                "aa_intel_tool.parser.module.fleetcomp.safe_scan_to_db"
+            ) as mock_safe_scan:
+                mock_safe_scan.return_value = {}
+
+                result = parse(scan_data=[])
+
+                self.assertEqual(result, {})
+
+    def test_parses_valid_scan_data_correctly(self):
+        """
+        Test that valid scan data is parsed correctly.
+
+        :return:
+        :rtype:
+        """
+
+        scan_data = [
+            "Rounon Dax\tJita\tOmen\tCruiser\tFleet Commander (Boss)\t5 - 5 - 5",
+            "Arodem Artemis\tPerimeter\tLeopard\tShuttle\tSquad Member\t0 - 0 - 5\tWing 1 / Squad 1",
+        ]
+        with patch(
+            "aa_intel_tool.app_settings.AppSettings.INTELTOOL_ENABLE_MODULE_FLEETCOMP",
+            True,
+        ):
+            with patch(
+                "aa_intel_tool.parser.module.fleetcomp.EveEntity.objects.fetch_by_names_esi"
+            ) as mock_fetch:
+                mock_qs = MagicMock()
+                mock_qs.filter.return_value = mock_qs
+                mock_qs.__iter__.return_value = iter([])
+                mock_fetch.return_value = mock_qs
+                with patch(
+                    "aa_intel_tool.parser.module.fleetcomp.safe_scan_to_db"
+                ) as mock_safe_scan:
+                    mock_safe_scan.return_value = {"parsed": "data"}
+                    result = parse(scan_data=scan_data)
+                    self.assertEqual(result, {"parsed": "data"})
+
+    def tst_handles_duplicate_pilot_entries_in_scan(self):
+        scan_data = [
+            "Arodem Artemis\tPerimeter\tLeopard\tShuttle\tSquad Member\t0 - 0 - 5\tWing 1 / Squad 1",
+            "Arodem Artemis\tPerimeter\tLeopard\tShuttle\tSquad Member\t0 - 0 - 5\tWing 1 / Squad 1",
+        ]
+        with patch(
+            "aa_intel_tool.app_settings.AppSettings.INTELTOOL_ENABLE_MODULE_FLEETCOMP",
+            True,
+        ):
+            with patch(
+                "aa_intel_tool.parser.module.fleetcomp.safe_scan_to_db"
+            ) as mock_safe_scan:
+                mock_safe_scan.return_value = {"parsed": "data"}
+                result = parse(scan_data=scan_data)
+                self.assertEqual(result, {"parsed": "data"})
+
+
+class TestGetFleetComposition(BaseTestCase):
+    """
+    Testing the get_fleet_composition function
+    """
+
+    def test_returns_correct_fleet_composition_for_valid_data(self):
+        """
+        Test that the fleet composition is returned correctly for valid data.
+
+        :return:
+        :rtype:
+        """
+
+        pilots = {
+            "Pilot1": {"ship": "Omen"},
+            "Pilot2": {"ship": "Zealot"},
+        }
+        ships = {
+            "class": {"Omen": {"count": 1}, "Zealot": {"count": 1}},
+            "type": {"Cruiser": {"count": 1}, "Heavy Assault Cruiser": {"count": 1}},
+        }
+
+        ship1 = MagicMock()
+        ship1.id = 1
+        ship1.name = "Omen"
+        ship1.eve_group__id = 10
+        ship1.eve_group__name = "Cruiser"
+        ship1.mass = 1000
+
+        ship2 = MagicMock()
+        ship2.id = 2
+        ship2.name = "Zealot"
+        ship2.eve_group__id = 20
+        ship2.eve_group__name = "Heavy Assault Cruiser"
+        ship2.mass = 500
+
+        with (
+            patch(
+                "aa_intel_tool.parser.module.fleetcomp.EveEntity.objects.fetch_by_names_esi"
+            ) as mock_fetch,
+            patch(
+                "aa_intel_tool.parser.module.fleetcomp.EveType.objects.bulk_get_or_create_esi"
+            ) as mock_bulk,
+            patch(
+                "aa_intel_tool.parser.module.fleetcomp._get_character_info"
+            ) as mock_get_character_info,
+        ):
+            mock_fetch.return_value.filter.return_value.values_list.return_value = [
+                1,
+                2,
+            ]
+            mock_bulk.return_value.values_list.return_value = [ship1, ship2]
+            mock_get_character_info.return_value = [
+                MagicMock(
+                    character_name="Pilot1",
+                    character_id=1001,
+                    portrait_url_32="portrait1.png",
+                ),
+                MagicMock(
+                    character_name="Pilot2",
+                    character_id=1002,
+                    portrait_url_32="portrait2.png",
+                ),
+            ]
+
+            result = get_fleet_composition(pilots=pilots, ships=ships)
+
+            self.assertEqual(len(result["classes"]), 2)
+            self.assertEqual(len(result["types"]), 2)
+            self.assertEqual(len(result["pilots"]), 2)
+
+    def test_handles_empty_pilots_and_ships(self):
+        """
+        Test that empty pilots and ships return empty fleet composition.
+        :return:
+        :rtype:
+        """
+
+        pilots = {}
+        ships = {"class": {}, "type": {}}
+
+        with (
+            patch(
+                "aa_intel_tool.parser.module.fleetcomp.EveEntity.objects.fetch_by_names_esi"
+            ) as mock_fetch,
+            patch(
+                "aa_intel_tool.parser.module.fleetcomp.EveType.objects.bulk_get_or_create_esi"
+            ) as mock_bulk,
+            patch(
+                "aa_intel_tool.parser.module.fleetcomp._get_character_info"
+            ) as mock_get_character_info,
+        ):
+            mock_fetch.return_value.filter.return_value.values_list.return_value = []
+            mock_bulk.return_value.values_list.return_value = []
+            mock_get_character_info.return_value = []
+
+            result = get_fleet_composition(pilots=pilots, ships=ships)
+
+            self.assertEqual(result["classes"], [])
+            self.assertEqual(result["types"], [])
+            self.assertEqual(result["pilots"], [])
+
+    def test_raises_error_for_missing_ship_class_in_pilots(self):
+        """
+        Test that an error is raised when a ship class in pilots is missing.
+
+        :return:
+        :rtype:
+        """
+
+        pilots = {"Pilot1": {"ship": "Unknown"}}
+        ships = {"class": {}, "type": {}}
+        mock_ship_class_details = []
+
+        with (
+            patch(
+                "aa_intel_tool.parser.module.fleetcomp.EveEntity.objects.fetch_by_names_esi"
+            ) as mock_fetch,
+            patch(
+                "aa_intel_tool.parser.module.fleetcomp.EveType.objects.bulk_get_or_create_esi"
+            ) as mock_bulk,
+            patch(
+                "aa_intel_tool.parser.module.fleetcomp._get_character_info"
+            ) as mock_get_character_info,
+        ):
+            mock_fetch.return_value.filter.return_value.values_list.return_value = []
+            mock_bulk.return_value.values_list.return_value = mock_ship_class_details
+            mock_get_character_info.return_value = [
+                MagicMock(
+                    character_name="Pilot1",
+                    character_id=1001,
+                    portrait_url_32="portrait1.png",
+                )
+            ]
+
+            with self.assertRaises(StopIteration):
+                get_fleet_composition(pilots=pilots, ships=ships)

aa_intel_tool/tests/test_tasks.py

@@ -0,0 +1,56 @@
+"""
+Unit tests for the tasks in aa_intel_tool.
+"""
+
+# Standard Library
+from datetime import timedelta
+from unittest.mock import patch
+
+# Django
+from django.utils.timezone import now
+
+# AA Intel Tool
+from aa_intel_tool.tasks import housekeeping
+from aa_intel_tool.tests import BaseTestCase
+
+
+class TestHousekeeping(BaseTestCase):
+    """
+    Tests for the housekeeping task
+    """
+
+    def test_removes_scans_older_than_retention_time(self):
+        """
+        Test that scans older than the retention time are removed.
+
+        :return:
+        :rtype:
+        """
+
+        with (
+            patch("aa_intel_tool.tasks.AppSettings.INTELTOOL_SCAN_RETENTION_TIME", 7),
+            patch("aa_intel_tool.tasks.Scan.objects.filter") as mock_filter,
+        ):
+            housekeeping()
+            mock_filter.assert_called_once()
+            called_kwargs = mock_filter.call_args.kwargs
+            created_lte = called_kwargs.get("created__lte")
+            expected = now() - timedelta(days=7)
+
+            self.assertTrue(abs(created_lte - expected) < timedelta(seconds=1))
+            mock_filter.return_value.delete.assert_called_once()
+
+    def test_does_not_remove_scans_when_retention_time_is_zero(self):
+        """
+        Test that no scans are removed when retention time is set to zero.
+
+        :return:
+        :rtype:
+        """
+
+        with (
+            patch("aa_intel_tool.tasks.AppSettings.INTELTOOL_SCAN_RETENTION_TIME", 0),
+            patch("aa_intel_tool.tasks.Scan.objects.filter") as mock_filter,
+        ):
+            housekeeping()
+            mock_filter.assert_not_called()

aa_intel_tool/tests/test_views_ajax.py

@@ -0,0 +1,72 @@
+"""
+Tests for the AJAX views in aa_intel_tool.views.ajax.
+"""
+
+# Standard Library
+from http import HTTPStatus
+from unittest.mock import Mock, patch
+
+# Django
+from django.test import RequestFactory
+from django.urls import reverse
+
+# AA Intel Tool
+from aa_intel_tool.models import ScanData
+from aa_intel_tool.tests import BaseTestCase
+from aa_intel_tool.views.ajax import get_scan_data
+
+
+class TestGetScanData(BaseTestCase):
+    """
+    Tests for the get_scan_data AJAX view
+    """
+
+    def test_returns_processed_data_for_valid_scan_hash_and_section(self):
+        """
+        Testing return of processed data for valid scan hash and section
+
+        :return:
+        :rtype:
+        """
+
+        rf = RequestFactory()
+        request = rf.get(
+            reverse(
+                "aa_intel_tool:ajax_get_scan_data",
+                kwargs={"scan_hash": "valid-hash", "scan_section": "valid-section"},
+            )
+        )
+
+        with patch("aa_intel_tool.views.ajax.ScanData.objects.filter") as mock_filter:
+            mock_scan_data = Mock()
+            mock_scan_data.processed_data = {"key": "value"}
+            mock_filter.return_value.get.return_value = mock_scan_data
+
+            response = get_scan_data(request, "valid-hash", "valid-section")
+
+            self.assertEqual(response.status_code, HTTPStatus.OK)
+            self.assertJSONEqual(response.content, {"key": "value"})
+
+    def test_returns_empty_dict_when_scan_data_does_not_exist(self):
+        """
+        Testing return of empty dict when scan data does not exist
+
+        :return:
+        :rtype:
+        """
+
+        rf = RequestFactory()
+        request = rf.get(
+            reverse(
+                "aa_intel_tool:ajax_get_scan_data",
+                kwargs={"scan_hash": "invalid-hash", "scan_section": "invalid-section"},
+            )
+        )
+
+        with patch("aa_intel_tool.views.ajax.ScanData.objects.filter") as mock_filter:
+            mock_filter.return_value.get.side_effect = ScanData.DoesNotExist
+
+            response = get_scan_data(request, "invalid-hash", "invalid-section")
+
+            self.assertEqual(response.status_code, HTTPStatus.OK)
+            self.assertJSONEqual(response.content, {})

aa_intel_tool/tests/test_views_general.py

@@ -0,0 +1,240 @@
+"""
+Tests for the general views of the AA Intel Tool application.
+"""
+
+# Standard Library
+from http import HTTPStatus
+from unittest.mock import Mock, patch
+
+# Django
+from django.contrib.messages import get_messages
+from django.contrib.messages.storage.fallback import FallbackStorage
+from django.contrib.sessions.middleware import SessionMiddleware
+from django.test import RequestFactory
+
+# AA Intel Tool
+from aa_intel_tool.exceptions import ParserError
+from aa_intel_tool.models import Scan
+from aa_intel_tool.tests import BaseTestCase
+from aa_intel_tool.views import general as general_view
+
+
+class TestViewIndex(BaseTestCase):
+    """
+    Tests for the index view
+    """
+
+    def test_redirects_to_scan_view_on_valid_form_submission_direct_call(self):
+        """
+        Testing redirection to scan view on valid form submission
+
+        :return:
+        :rtype:
+        """
+
+        form_data = {"eve_intel": "valid intel data"}
+        rf = RequestFactory()
+        request = rf.post("/intel/", data=form_data)
+
+        with (
+            patch("aa_intel_tool.views.general.IntelForm") as mock_form,
+            patch("aa_intel_tool.views.general.parse_intel") as mock_parse,
+        ):
+            mock_form.return_value.is_valid.return_value = True
+            mock_form.return_value.cleaned_data = form_data
+            mock_parse.return_value = "valid_scan_hash"
+
+            response = general_view.index(request)
+
+            self.assertEqual(response.status_code, HTTPStatus.FOUND)
+            self.assertEqual(response["Location"], "/intel/scan/valid_scan_hash/")
+
+    def test_shows_error_message_on_parser_error_direct_call(self):
+        """
+        Testing error message on parser error during form submission
+
+        :return:
+        :rtype:
+        """
+
+        form_data = {"eve_intel": "invalid intel data"}
+        rf = RequestFactory()
+        request = rf.post("/intel/", data=form_data)
+
+        middleware = SessionMiddleware(lambda req: None)
+        middleware.process_request(request)
+        request.session.save()
+        request._messages = FallbackStorage(request)
+
+        with (
+            patch("aa_intel_tool.views.general.IntelForm") as mock_form,
+            patch("aa_intel_tool.views.general.parse_intel") as mock_parse,
+        ):
+            mock_form.return_value.is_valid.return_value = True
+            mock_form.return_value.cleaned_data = form_data
+            mock_parse.side_effect = ParserError("Parsing failed")
+
+            response = general_view.index(request)
+
+            self.assertEqual(response.status_code, HTTPStatus.FOUND)
+
+            messages = [str(m) for m in get_messages(request)]
+
+            # ensure the general parse-failure message is present
+            self.assertTrue(
+                any("The provided data could not be parsed." in m for m in messages),
+                f"messages were: {messages}",
+            )
+            # ensure the exception detail is included somewhere
+            self.assertTrue(
+                any("Parsing failed" in m for m in messages),
+                f"messages were: {messages}",
+            )
+
+    def test_shows_error_message_on_unexpected_exception_direct_call(self):
+        """
+        Testing error message on unexpected exception during form submission
+
+        :return:
+        :rtype:
+        """
+
+        form_data = {"eve_intel": "unexpected error data"}
+        rf = RequestFactory()
+        request = rf.post("/intel/", data=form_data)
+
+        middleware = SessionMiddleware(lambda req: None)
+        middleware.process_request(request)
+        request.session.save()
+        request._messages = FallbackStorage(request)
+
+        with (
+            patch("aa_intel_tool.views.general.IntelForm") as mock_form,
+            patch("aa_intel_tool.views.general.parse_intel") as mock_parse,
+        ):
+            mock_form.return_value.is_valid.return_value = True
+            mock_form.return_value.cleaned_data = form_data
+            mock_parse.side_effect = Exception("Unexpected error")
+
+            response = general_view.index(request)
+
+            self.assertEqual(response.status_code, HTTPStatus.FOUND)
+
+            messages = [str(m) for m in get_messages(request)]
+
+            self.assertTrue(
+                any(
+                    "Something unexpected happened" in m or "(System Error)" in m
+                    for m in messages
+                ),
+                f"messages were: {messages}",
+            )
+            self.assertTrue(
+                any("Unexpected error" in m for m in messages),
+                f"messages were: {messages}",
+            )
+
+    def test_renders_blank_form_on_get_request_direct_call(self):
+        """
+        Testing rendering of blank form on GET request
+
+        :return:
+        :rtype:
+        """
+
+        rf = RequestFactory()
+        request = rf.get("/intel/")
+
+        response = general_view.index(request)
+
+        self.assertEqual(response.status_code, HTTPStatus.OK)
+        self.assertIn("<form", response.content.decode("utf-8"))
+
+
+class TestViewScan(BaseTestCase):
+    """
+    Tests for the scan view
+    """
+
+    def test_shows_error_message_when_scan_does_not_exist(self):
+        """
+        Testing error message when scan does not exist
+
+        :return:
+        :rtype:
+        """
+
+        rf = RequestFactory()
+        request = rf.get("/intel/scan/nonexistent-scan-hash/")
+
+        middleware = SessionMiddleware(lambda req: None)
+        middleware.process_request(request)
+        request.session.save()
+
+        request._messages = FallbackStorage(request)
+        with patch("aa_intel_tool.views.general.Scan.objects.exclude") as mock_exclude:
+            mock_exclude.return_value.get.side_effect = Scan.DoesNotExist
+
+            response = general_view.scan(request, scan_hash="nonexistent-scan-hash")
+
+            self.assertEqual(response.status_code, HTTPStatus.FOUND)
+
+            messages = [str(m) for m in get_messages(request)]
+
+            self.assertTrue(
+                any(
+                    "The scan you were looking for could not be found." in m
+                    for m in messages
+                ),
+                f"messages were: {messages}",
+            )
+
+    def test_renders_correct_template_for_supported_scan_type(self):
+        """
+        Testing rendering of correct template for supported scan type
+
+        :return:
+        :rtype:
+        """
+
+        rf = RequestFactory()
+        request = rf.get("/intel/scan/supported-scan-hash/")
+
+        middleware = SessionMiddleware(lambda req: None)
+        middleware.process_request(request)
+        request.session.save()
+        request._messages = FallbackStorage(request)
+
+        with patch("aa_intel_tool.views.general.Scan.objects.exclude") as mock_exclude:
+            mock_scan = Mock()
+            mock_scan.scan_type = "supported_type"
+            mock_scan.created = "2023-01-01"
+            mock_scan.raw_data = "raw intel data"
+            mock_exclude.return_value.get.return_value = mock_scan
+
+            # dummy response that mimics a rendered template response
+            dummy_response = Mock()
+            dummy_response.status_code = HTTPStatus.OK
+            dummy_response.templates = [
+                type("T", (), {"name": "supported_template.html"})()
+            ]
+
+            with (
+                patch(
+                    "aa_intel_tool.views.general.SUPPORTED_INTEL_TYPES",
+                    {
+                        "supported_type": {
+                            "name": "Supported Type",
+                            "template": "supported_template.html",
+                        }
+                    },
+                ),
+                patch(
+                    "aa_intel_tool.views.general.render", return_value=dummy_response
+                ) as mock_render,
+            ):
+                response = general_view.scan(request, scan_hash="supported-scan-hash")
+
+                self.assertEqual(response.status_code, HTTPStatus.OK)
+                self.assertTemplateUsed(response, "supported_template.html")
+                mock_render.assert_called_once()

aa_intel_tool/urls.py

@@ -9,7 +9,7 @@ from django.urls import include, path
 from aa_intel_tool.constants import INTERNAL_URL_PREFIX
 from aa_intel_tool.views import ajax, general
 
-app_name: str = "aa_intel_tool"
+app_name: str = "aa_intel_tool"  # pylint: disable=invalid-name
 
 
 app_urls = [

aa_intel_tool/views/general.py

@@ -50,16 +50,24 @@ def index(request: WSGIRequest) -> HttpResponse:
             # Catching our own parser exceptions
             except ParserError as exc:
                 exception_caught = True
-                errormessage = _("The provided data could not be parsed.") + f" ({exc})"
-                messages.error(request=request, message=errormessage)
+
+                messages.error(
+                    request=request,
+                    message=_("The provided data could not be parsed. ({exc})").format(
+                        exc=exc
+                    ),
+                )
 
             # Catching every other exception we can't think of (hopefully)
             except Exception as exc:  # pylint: disable=broad-exception-caught
                 exception_caught = True
-                errormessage = (
-                    _("(System Error) Something unexpected happened.") + f" ({exc})"
+
+                messages.error(
+                    request=request,
+                    message=_(
+                        "(System Error) Something unexpected happened. ({exc})"
+                    ).format(exc=exc),
                 )
-                messages.error(request=request, message=errormessage)
 
             if exception_caught:
                 return redirect(to="aa_intel_tool:intel_tool_index")

{aa_intel_tool-2.10.0.dist-info → aa_intel_tool-2.11.0.dist-info}/METADATA

@@ -1,13 +1,15 @@
 Metadata-Version: 2.4
 Name: aa-intel-tool
-Version: 2.10.0
+Version: 2.11.0
 Summary: A simple parser for D-Scans and more for Alliance Auth
 Project-URL: Changelog, https://github.com/ppfeufer/aa-intel-tool/blob/master/CHANGELOG.md
+Project-URL: Codecov, https://codecov.io/gh/ppfeufer/aa-intel-tool
+Project-URL: Discord, https://discord.gg/fjnHAmk
 Project-URL: Documentation, https://github.com/ppfeufer/aa-intel-tool/blob/master/README.md
-Project-URL: Donations, https://ko-fi.com/ppfeufer
-Project-URL: Homepage, https://github.com/ppfeufer/aa-intel-tool
-Project-URL: Source, https://github.com/ppfeufer/aa-intel-tool.git
+Project-URL: Donation, https://ko-fi.com/ppfeufer
+Project-URL: GitHub, https://github.com/ppfeufer/aa-intel-tool
 Project-URL: Tracker, https://github.com/ppfeufer/aa-intel-tool/issues
+Project-URL: Translation, https://weblate.ppfeufer.de/projects/alliance-auth-apps/aa-intel-tool/
 Author-email: Peter Pfeufer <develop@ppfeufer.de>
 License:                     GNU GENERAL PUBLIC LICENSE
                                 Version 3, 29 June 2007
@@ -699,7 +701,7 @@ Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Internet :: WWW/HTTP
 Classifier: Topic :: Internet :: WWW/HTTP :: Dynamic Content
-Requires-Python: >=3.10
+Requires-Python: <3.14,>=3.10
 Requires-Dist: allianceauth-app-utils>=1.19.1
 Requires-Dist: allianceauth<5,>=4.10
 Requires-Dist: django-eveuniverse>=1.3
@@ -976,7 +978,7 @@ Please make sure to read the [Contribution Guidelines].\
 [badge: license]: https://img.shields.io/github/license/ppfeufer/aa-intel-tool "License"
 [badge: pre-commit]: https://img.shields.io/badge/pre--commit-enabled-brightgreen?logo=pre-commit&logoColor=white "pre-commit"
 [badge: pre-commit.ci status]: https://results.pre-commit.ci/badge/github/ppfeufer/aa-intel-tool/master.svg "pre-commit.ci status"
-[badge: support discord]: https://img.shields.io/discord/790364535294132234?label=discord "Support Discord"
+[badge: support discord]: https://img.shields.io/discord/399006117012832262?label=discord "Support Discord"
 [badge: supported django versions]: https://img.shields.io/pypi/djversions/aa-intel-tool?label=django "Supported Django Versions"
 [badge: supported python versions]: https://img.shields.io/pypi/pyversions/aa-intel-tool "Supported Python Versions"
 [badge: translation status]: https://weblate.ppfeufer.de/widget/alliance-auth-apps/aa-intel-tool/svg-badge.svg "Translation Status"
@@ -991,5 +993,5 @@ Please make sure to read the [Contribution Guidelines].\
 [image: fleet composition module]: https://raw.githubusercontent.com/ppfeufer/aa-intel-tool/master/docs/images/presentation/fleet-composition.jpg "Fleet Composition Module"
 [ppfeufer on ko-fi]: https://ko-fi.com/ppfeufer "Buy Me a Coffee!"
 [pre-commit.ci status]: https://results.pre-commit.ci/latest/github/ppfeufer/aa-intel-tool/master "pre-commit.ci"
-[support discord]: https://discord.gg/zmh52wnfvM "Alliance Auth Community Apps Support Discord"
+[support discord]: https://discord.gg/fjnHAmk "Alliance Auth Support Discord"
 [weblate engage]: https://weblate.ppfeufer.de/engage/alliance-auth-apps/ "Weblate Translations"