aa-fleetfinder 2.5.1__py3-none-any.whl → 2.6.1__py3-none-any.whl

fleetfinder/tasks.py

@@ -14,7 +14,6 @@ from celery import shared_task
 from django.utils import timezone
 
 # Alliance Auth
-from allianceauth.eveonline.models import EveCharacter
 from allianceauth.services.hooks import get_extension_logger
 from allianceauth.services.tasks import QueueOnce
 from esi.models import Token
@@ -148,10 +147,13 @@ def _get_fleet_aggregate(fleet_infos):
     for member in fleet_infos:
         type_ = member.get("ship_type_name")
 
-        if type_ in counts:
-            counts[type_] += 1
-        else:
-            counts[type_] = 1
+        if type_ and isinstance(type_, str) and type_.strip():
+            type_ = type_.strip()  # Normalize ship type name
+
+            if type_ in counts:
+                counts[type_] += 1
+            else:
+                counts[type_] = 1
 
     return counts
 
@@ -187,110 +189,56 @@ def _check_for_esi_fleet(fleet: Fleet):
     return False
 
 
-def _process_fleet(fleet: Fleet):
+def _process_fleet(fleet: Fleet) -> None:
     """
     Processing a fleet
 
-    :param fleet:
-    :type fleet:
-    :return:
-    :rtype:
+    :param fleet: Fleet object to process
+    :type fleet: Fleet
+    :return: None
+    :rtype: None
     """
 
-    fleet_id = fleet.fleet_id
-    fleet_name = fleet.name
-    fleet_commander = fleet.fleet_commander
-
     logger.info(
-        f'Processing information for fleet "{fleet_name}" '
-        f"of {fleet_commander} (ESI ID: {fleet_id})"
+        f'Processing information for fleet "{fleet.name}" '
+        f"of {fleet.fleet_commander} (ESI ID: {fleet.fleet_id})"
     )
 
     # Check if there is a fleet
     esi_fleet = _check_for_esi_fleet(fleet=fleet)
-    if esi_fleet and fleet.fleet_id == esi_fleet["fleet"]["fleet_id"]:
-        try:
-            fleet_from_esi = esi.client.Fleets.get_characters_character_id_fleet(
-                character_id=fleet.fleet_commander.character_id,
-                token=esi_fleet["token"].valid_access_token(),
-            ).result()
-        except HTTPNotFound:
-            _esi_fleet_error_handling(
-                fleet=fleet, error_key=Fleet.EsiError.NOT_IN_FLEET
-            )
-        except Exception:  # pylint: disable=broad-exception-caught
-            _esi_fleet_error_handling(fleet=fleet, error_key=Fleet.EsiError.NO_FLEET)
-
-        # We have a valid fleet result from ESI
-        else:
-            if fleet_id == fleet_from_esi["fleet_id"]:
-                # Check if we deal with the fleet boss here
-                try:
-                    _ = esi.client.Fleets.get_fleets_fleet_id_members(
-                        fleet_id=fleet_from_esi["fleet_id"],
-                        token=esi_fleet["token"].valid_access_token(),
-                    ).result()
-                except Exception:  # pylint: disable=broad-exception-caught
-                    _esi_fleet_error_handling(
-                        fleet=fleet, error_key=Fleet.EsiError.NOT_FLEETBOSS
-                    )
-            else:
-                _esi_fleet_error_handling(
-                    fleet=fleet, error_key=Fleet.EsiError.FC_CHANGED_FLEET
-                )
-
-
-@shared_task
-def open_fleet(character_id, motd, free_move, name, groups):
-    """
-    Open a fleet
-
-    :param character_id:
-    :param motd:
-    :param free_move:
-    :param name:
-    :param groups:
-    :return:
-    """
-
-    required_scopes = ["esi-fleets.read_fleet.v1", "esi-fleets.write_fleet.v1"]
-    token = Token.get_token(character_id=character_id, scopes=required_scopes)
 
-    fleet_result = esi.client.Fleets.get_characters_character_id_fleet(
-        character_id=token.character_id, token=token.valid_access_token()
-    ).result()
-    fleet_id = fleet_result.pop("fleet_id")
-    fleet_role = fleet_result.pop("role")
-
-    if fleet_id is None or fleet_role is None or fleet_role != "fleet_commander":
+    if not esi_fleet:
         return
 
-    fleet_commander = EveCharacter.objects.get(character_id=token.character_id)
-
-    fleet = Fleet(
-        fleet_id=fleet_id,
-        created_at=timezone.now(),
-        motd=motd,
-        is_free_move=free_move,
-        fleet_commander=fleet_commander,
-        name=name,
-    )
-    fleet.save()
-    fleet.groups.set(groups)
+    # Fleet IDs don't match, FC changed fleets
+    if fleet.fleet_id != esi_fleet["fleet"]["fleet_id"]:
+        _esi_fleet_error_handling(
+            fleet=fleet, error_key=Fleet.EsiError.FC_CHANGED_FLEET
+        )
+        return
 
-    esi_fleet = {"is_free_move": free_move, "motd": motd}
-    esi.client.Fleets.put_fleets_fleet_id(
-        fleet_id=fleet_id, token=token.valid_access_token(), new_settings=esi_fleet
-    ).result()
+    # Check if we deal with the fleet boss here
+    try:
+        _ = esi.client.Fleets.get_fleets_fleet_id_members(
+            fleet_id=fleet.fleet_id,
+            token=esi_fleet["token"].valid_access_token(),
+        ).result()
+    except Exception:  # pylint: disable=broad-exception-caught
+        _esi_fleet_error_handling(fleet=fleet, error_key=Fleet.EsiError.NOT_FLEETBOSS)
 
 
 @shared_task
-def send_fleet_invitation(character_ids, fleet_id):
+def send_fleet_invitation(fleet_id: int, character_ids: list) -> None:
     """
-    Send a fleet invitation through the eve client
-
-    :param character_ids:
-    :param fleet_id:
+    Send fleet invitations to characters through ESI
+    This task sends fleet invitations to a list of character IDs using the ESI API.
+
+    :param fleet_id: The ID of the fleet to which invitations are sent
+    :type fleet_id: int
+    :param character_ids: List of character IDs to invite to the fleet
+    :type character_ids: list[int]
+    :return: None
+    :rtype: None
     """
 
     required_scopes = ["esi-fleets.write_fleet.v1"]
@@ -298,95 +246,118 @@ def send_fleet_invitation(character_ids, fleet_id):
     fleet_commander_token = Token.get_token(
         character_id=fleet.fleet_commander.character_id, scopes=required_scopes
     )
-    _processes = []
 
     with ThreadPoolExecutor(max_workers=50) as ex:
-        for _character_id in character_ids:
-            _processes.append(
-                ex.submit(
-                    _send_invitation,
-                    character_id=_character_id,
-                    fleet_commander_token=fleet_commander_token,
-                    fleet_id=fleet_id,
-                )
+        futures = [
+            ex.submit(
+                _send_invitation,
+                character_id=character_id,
+                fleet_commander_token=fleet_commander_token,
+                fleet_id=fleet_id,
             )
+            for character_id in character_ids
+        ]
 
-    for item in as_completed(_processes):
-        _ = item.result()
+        for future in as_completed(futures):
+            future.result()  # This will raise any exceptions that occurred
 
 
 @shared_task(**{**TASK_DEFAULT_KWARGS}, **{"base": QueueOnce})
-def check_fleet_adverts():
+def check_fleet_adverts() -> None:
     """
-    Scheduled task :: Check for fleets adverts
+    Check all registered fleets and process them
+
+    :return: None
+    :rtype: None
     """
 
     fleets = Fleet.objects.all()
-    fleet_count = fleets.count()
 
-    processing_text = "Processing..." if fleet_count > 0 else "Nothing to do..."
+    if not fleets.exists():
+        logger.info("No registered fleets found. Nothing to do...")
 
-    logger.info(msg=f"{fleet_count} registered fleets found. {processing_text}")
+        return
 
-    if fleet_count > 0:
-        # Abort if ESI seems to be offline or above the error limit
-        if not fetch_esi_status().is_ok:
-            logger.warning(
-                msg="ESI doesn't seem to be available at this time. Aborting."
-            )
+    logger.info(f"Processing {fleets.count()} registered fleets...")
 
-            return
+    # Abort if ESI seems to be offline or above the error limit
+    if not fetch_esi_status().is_ok:
+        logger.warning("ESI doesn't seem to be available at this time. Aborting.")
 
-        for fleet in fleets:
-            _process_fleet(fleet=fleet)
+        return
+
+    for fleet in fleets:
+        _process_fleet(fleet=fleet)
 
 
 @shared_task
-def get_fleet_composition(fleet_id):
+def get_fleet_composition(fleet_id: int) -> FleetViewAggregate | None:
     """
-    Getting the fleet composition
+    Get the composition of a fleet by its ID
+    This task retrieves the composition of a fleet using its ESI ID.
 
-    :param fleet_id:
-    :return:
+    :param fleet_id: The ESI ID of the fleet to retrieve
+    :type fleet_id:  int
+    :return: FleetViewAggregate containing fleet members and aggregate data
+    :rtype: FleetViewAggregate | None
     """
 
-    required_scopes = ["esi-fleets.read_fleet.v1", "esi-fleets.write_fleet.v1"]
-    fleet = Fleet.objects.get(fleet_id=fleet_id)
-    token = Token.get_token(
-        character_id=fleet.fleet_commander.character_id, scopes=required_scopes
+    try:
+        fleet = Fleet.objects.get(fleet_id=fleet_id)
+    except Fleet.DoesNotExist:
+        logger.error(f"Fleet with ID {fleet_id} not found")
+
+        return None
+
+    logger.info(
+        f'Getting fleet composition for fleet "{fleet.name}" '
+        f"of {fleet.fleet_commander.character_name} (ESI ID: {fleet_id})"
     )
-    fleet_infos = esi.client.Fleets.get_fleets_fleet_id_members(
-        fleet_id=fleet_id, token=token.valid_access_token()
-    ).result()
 
-    characters = {}
-    systems = {}
-    ship_type = {}
+    required_scopes = ["esi-fleets.read_fleet.v1"]
 
-    for member in fleet_infos:
-        characters[member["character_id"]] = ""
-        systems[member["solar_system_id"]] = ""
-        ship_type[member["ship_type_id"]] = ""
+    try:
+        token = Token.get_token(
+            character_id=fleet.fleet_commander.character_id, scopes=required_scopes
+        )
 
-    ids = []
-    ids.extend(list(characters.keys()))
-    ids.extend(list(systems.keys()))
-    ids.extend(list(ship_type.keys()))
+        fleet_infos = esi.client.Fleets.get_fleets_fleet_id_members(
+            fleet_id=fleet_id, token=token.valid_access_token()
+        ).result()
 
-    ids_to_name = esi.client.Universe.post_universe_names(ids=ids).result()
+        # Get all unique IDs and fetch names in one call
+        all_ids = {
+            item_id
+            for member in fleet_infos
+            for item_id in [
+                member["character_id"],
+                member["solar_system_id"],
+                member["ship_type_id"],
+            ]
+        }
+
+        ids_to_name = esi.client.Universe.post_universe_names(
+            ids=list(all_ids)
+        ).result()
 
-    for member in fleet_infos:
-        index_character = [x["id"] for x in ids_to_name].index(member["character_id"])
-        member["character_name"] = ids_to_name[index_character]["name"]
+        # Create a lookup dictionary for names
+        name_lookup = {item["id"]: item["name"] for item in ids_to_name}
+
+        # Add names to fleet members
+        for member in fleet_infos:
+            member.update(
+                {
+                    "character_name": name_lookup[member["character_id"]],
+                    "solar_system_name": name_lookup[member["solar_system_id"]],
+                    "ship_type_name": name_lookup[member["ship_type_id"]],
+                }
+            )
 
-        index_solar_system = [x["id"] for x in ids_to_name].index(
-            member["solar_system_id"]
-        )
-        member["solar_system_name"] = ids_to_name[index_solar_system]["name"]
+        aggregate = _get_fleet_aggregate(fleet_infos=fleet_infos)
 
-        index_ship_type = [x["id"] for x in ids_to_name].index(member["ship_type_id"])
-        member["ship_type_name"] = ids_to_name[index_ship_type]["name"]
+        return FleetViewAggregate(fleet=fleet_infos, aggregate=aggregate)
 
-    aggregate = _get_fleet_aggregate(fleet_infos=fleet_infos)
+    except Exception as e:  # pylint: disable=broad-exception-caught
+        logger.error(f"Failed to get fleet composition for fleet {fleet_id}: {e}")
 
-    return FleetViewAggregate(fleet=fleet_infos, aggregate=aggregate)
+        return None

fleetfinder/templates/fleetfinder/dashboard.html

@@ -51,52 +51,57 @@
             const DATETIME_FORMAT = 'YYYY-MM-DD, HH:mm';
             const table_fleet_overview = $('#table_available-fleets');
 
-            const fleetfinderFleetsTable = table_fleet_overview.DataTable({
-                language: {
-                    url: '{{ DT_LANG_PATH }}'
-                },
-                ajax: {
-                    url: "{% url 'fleetfinder:ajax_dashboard' %}",
-                    dataSrc: '',
-                    cache: false
-                },
-                columns: [
-                    {
-                        data: 'fleet_commander',
-                        render: {
-                            _: 'html',
-                            sort: 'sort'
-                        }
-                    },
-                    {data: 'fleet_name'},
-                    {
-                        data: 'created_at',
-                    },
-                    {data: 'join'},
-                    {% if perms.fleetfinder.manage_fleets %}
-                        {data: 'details'},
-                        {data: 'edit'},
-                    {% endif %}
-                ],
-                columnDefs: [
-                    {
-                        targets: 2,
-                        render: DataTable.render.date(DATETIME_FORMAT)
-                    },
-                    {
-                        orderable: false,
-                        targets: [3]
-                    },
-                    {% if perms.fleetfinder.manage_fleets %}
-                        {
-                            orderable: false,
-                            targets: [4, 5]
+            /**
+             * Initialize the datatable for fleet overview
+             */
+            fetchGet({url: '{% url "fleetfinder:ajax_dashboard" %}'})
+                .then((data) => {
+                    table_fleet_overview.DataTable({
+                        language: {
+                            url: '{{ DT_LANG_PATH }}'
                         },
-                    {% endif %}
-                ],
-                order: [[0, 'asc']],
-                paging: false
-            });
+                        data: data,
+                        columns: [
+                            {
+                                data: 'fleet_commander',
+                                render: {
+                                    _: 'html',
+                                    sort: 'sort'
+                                }
+                            },
+                            {data: 'fleet_name'},
+                            {
+                                data: 'created_at',
+                            },
+                            {data: 'join'},
+                            {% if perms.fleetfinder.manage_fleets %}
+                                {data: 'details'},
+                                {data: 'edit'},
+                            {% endif %}
+                        ],
+                        columnDefs: [
+                            {
+                                targets: 2,
+                                render: DataTable.render.date(DATETIME_FORMAT)
+                            },
+                            {
+                                orderable: false,
+                                targets: [3]
+                            },
+                            {% if perms.fleetfinder.manage_fleets %}
+                                {
+                                    orderable: false,
+                                    targets: [4, 5]
+                                },
+                            {% endif %}
+                        ],
+                        order: [[0, 'asc']],
+                        paging: false
+                    });
+                })
+                .catch((error) => {
+                    console.error('Error fetching fleet data:', error);
+                });
 
             /**
              * Refresh the datatable information every 30 seconds
@@ -108,7 +113,7 @@
              * reload datatable "fleetfinderFleetsTable"
              */
             const reloadDataTable = () => {
-                let dt = Date.now() - expectedReloadDatatable; // The drift (positive for overshooting)
+                const dt = Date.now() - expectedReloadDatatable; // The drift (positive for overshooting)
 
                 if (dt > intervalReloadDatatable) {
                     // Something awful happened. Maybe the browser (tab) was inactive?
@@ -120,7 +125,15 @@
                     );
                 }
 
-                fleetfinderFleetsTable.ajax.reload();
+                fetchGet({url: '{% url "fleetfinder:ajax_dashboard" %}'})
+                    .then((newData) => {
+                        const dataTable = table_fleet_overview.DataTable();
+
+                        dataTable.clear().rows.add(newData).draw();
+                    })
+                    .catch((error) => {
+                        console.error('Error fetching updated data:', error);
+                    });
 
                 expectedReloadDatatable += intervalReloadDatatable;
 

fleetfinder/templates/fleetfinder/fleet-details.html

@@ -78,7 +78,10 @@
             const tabe_fleet_composition = $('#table_fleet_composition');
 
             const populateDatatables = () => {
-                $.get('{% url "fleetfinder:ajax_fleet_details" fleet_id %}', (data) => {
+                fetchGet({
+                    url: '{% url "fleetfinder:ajax_fleet_details" fleet_id %}'
+                })
+                .then((data) => {
                     table_fleet_members.DataTable({
                         language: {
                             url: '{{ DT_LANG_PATH }}'
@@ -106,6 +109,9 @@
                         ],
                         order: [[1, 'desc']]
                     });
+                })
+                .catch((error) => {
+                    console.error('Error fetching fleet details:', error);
                 });
             };
 

fleetfinder/templates/fleetfinder/partials/body/form-fleet-details.html

@@ -33,16 +33,16 @@
         </p>
     </div>
 
-    <div class="mb-3">
-        <label for="motd" class="control-label">{% translate "Fleet MOTD" %}</label>
-
-        <div>
-            <textarea class="form-control" name="motd" id="motd" rows="10">{% if motd %}{{ motd }}{% endif %}</textarea>
-        </div>
-    </div>
+{#    <div class="mb-3">#}
+{#        <label for="motd" class="control-label">{% translate "Fleet MOTD" %}</label>#}
+{##}
+{#        <div>#}
+{#            <textarea class="form-control" name="motd" id="motd" rows="10">{% if motd %}{{ motd }}{% endif %}</textarea>#}
+{#        </div>#}
+{#    </div>#}
 
     <div class="mb-3">
-        <input type="checkbox" style="margin-right: 5px;" class="form-check-input" name="free_move" id="free_move" {% if is_free_move %}checked{% endif %}>
+        <input type="checkbox" style="margin-right: 5px;" class="form-check-input" name="free_move" id="free_move" {% if fleet.is_free_move %}checked{% endif %}>
         <label for="free_move" class="form-check-label">{% translate "Enable free move" %}</label>
     </div>
 

fleetfinder/tests/test_tasks.py

@@ -0,0 +1,140 @@
+"""
+Tests for the fleetfinder.tasks module.
+"""
+
+# Standard Library
+from unittest import TestCase
+from unittest.mock import Mock, patch
+
+# AA Fleet Finder
+from fleetfinder.tasks import (
+    _get_fleet_aggregate,
+    check_fleet_adverts,
+)
+
+
+class TestGetFleetAggregate(TestCase):
+    """
+    Tests for the _get_fleet_aggregate function.
+    """
+
+    def test_returns_correct_counts_for_valid_fleet_infos(self):
+        """
+        Test that _get_fleet_aggregate returns correct counts for valid fleet_infos.
+
+        :return:
+        :rtype:
+        """
+
+        fleet_infos = [
+            {"ship_type_name": "Cruiser"},
+            {"ship_type_name": "Cruiser"},
+            {"ship_type_name": "Battleship"},
+        ]
+
+        result = _get_fleet_aggregate(fleet_infos)
+
+        assert result == {"Cruiser": 2, "Battleship": 1}
+
+    def test_returns_empty_dict_for_empty_fleet_infos(self):
+        """
+        Test that _get_fleet_aggregate returns an empty dictionary for empty fleet_infos.
+
+        :return:
+        :rtype:
+        """
+
+        fleet_infos = []
+
+        result = _get_fleet_aggregate(fleet_infos)
+
+        assert result == {}
+
+    def test_returns_only_valid_ship_type_names(self):
+        """
+        Test that _get_fleet_aggregate returns only valid ship type names.
+
+        :return:
+        :rtype:
+        """
+
+        fleet_infos = [
+            {"ship_type_name": "Cruiser"},
+            {},
+            {"ship_type_name": None},
+            {"ship_type_name": "Battleship"},
+            {"other_key": "Frigate"},
+        ]
+
+        result = _get_fleet_aggregate(fleet_infos)
+
+        assert result == {"Cruiser": 1, "Battleship": 1}
+
+
+class TestCheckFleetAdvert(TestCase):
+    """
+    Tests for the check_fleet_adverts function.
+    """
+
+    @patch("fleetfinder.models.Fleet.objects.all")
+    @patch("fleetfinder.tasks.fetch_esi_status")
+    def test_processes_registered_fleets_when_available(
+        self, mock_fetch_esi_status, mock_fleet_objects
+    ):
+        """
+        Test that check_fleet_adverts processes registered fleets when ESI is available.
+
+        :param mock_fetch_esi_status:
+        :type mock_fetch_esi_status:
+        :param mock_fleet_objects:
+        :type mock_fleet_objects:
+        :return:
+        :rtype:
+        """
+
+        mock_fetch_esi_status.return_value.is_ok = True
+        mock_fleet_objects.return_value.exists.return_value = True
+        mock_fleet_objects.return_value.count.return_value = 2
+        mock_fleet_objects.return_value.__iter__.return_value = iter([Mock(), Mock()])
+
+        check_fleet_adverts()
+
+        mock_fleet_objects.return_value.__iter__.assert_called_once()
+        mock_fetch_esi_status.assert_called_once()
+
+    @patch("fleetfinder.models.Fleet.objects.all")
+    @patch("fleetfinder.tasks.fetch_esi_status")
+    def test_logs_no_registered_fleets_when_none_exist(
+        self, mock_fetch_esi_status, mock_fleet_objects
+    ):
+        """
+        Test that check_fleet_adverts logs a message when no registered fleets exist.
+
+        :param mock_fetch_esi_status:
+        :type mock_fetch_esi_status:
+        :param mock_fleet_objects:
+        :type mock_fleet_objects:
+        :return:
+        :rtype:
+        """
+
+        mock_fetch_esi_status.return_value.is_ok = True
+        mock_fleet_objects.return_value.exists.return_value = False
+
+        check_fleet_adverts()
+
+        mock_fleet_objects.return_value.exists.assert_called_once()
+        mock_fetch_esi_status.assert_not_called()
+
+    @patch("fleetfinder.models.Fleet.objects.all")
+    @patch("fleetfinder.tasks.fetch_esi_status")
+    def test_aborts_processing_when_esi_is_unavailable(
+        self, mock_fetch_esi_status, mock_fleet_objects
+    ):
+        mock_fetch_esi_status.return_value.is_ok = False
+        mock_fleet_objects.return_value.exists.return_value = True
+
+        check_fleet_adverts()
+
+        mock_fetch_esi_status.assert_called_once()
+        mock_fleet_objects.return_value.__iter__.assert_not_called()