aa-fleetfinder 2.6.0__py3-none-any.whl → 2.7.0__py3-none-any.whl

fleetfinder/views.py

@@ -2,25 +2,33 @@
 Views
 """
 
+# Standard Library
+import json
+
 # Third Party
 from bravado.exception import HTTPNotFound
 
 # Django
 from django.contrib import messages
 from django.contrib.auth.decorators import login_required, permission_required
+from django.core.handlers.wsgi import WSGIRequest
 from django.db.models import Q
 from django.http import JsonResponse
 from django.shortcuts import redirect, render
 from django.urls import reverse
+from django.utils import timezone
+from django.utils.functional import Promise
 from django.utils.safestring import mark_safe
 from django.utils.translation import gettext_lazy as _
 
 # Alliance Auth
 from allianceauth.eveonline.evelinks.eveimageserver import character_portrait_url
 from allianceauth.eveonline.models import EveCharacter
+from allianceauth.framework.api.user import get_all_characters_from_user
 from allianceauth.groupmanagement.models import AuthGroup
 from allianceauth.services.hooks import get_extension_logger
 from esi.decorators import token_required
+from esi.models import Token
 
 # Alliance Auth (External Libs)
 from app_utils.logging import LoggerAddTag
@@ -28,11 +36,45 @@ from app_utils.logging import LoggerAddTag
 # AA Fleet Finder
 from fleetfinder import __title__
 from fleetfinder.models import Fleet
-from fleetfinder.tasks import get_fleet_composition, open_fleet, send_fleet_invitation
+from fleetfinder.providers import esi
+from fleetfinder.tasks import get_fleet_composition, send_fleet_invitation
 
 logger = LoggerAddTag(my_logger=get_extension_logger(name=__name__), prefix=__title__)
 
 
+@login_required()
+@permission_required(perm="fleetfinder.access_fleetfinder")
+def _get_and_validate_fleet(token: Token, character_id: int) -> tuple:
+    """
+    Get fleet information and validate fleet commander permissions
+
+    :param token: Token object containing the access token
+    :type token: Token
+    :param character_id: The character ID of the fleet commander
+    :type character_id: int
+    :return: Tuple containing the fleet result, fleet commander, and fleet ID
+    :rtype: tuple
+    """
+
+    fleet_result = esi.client.Fleets.get_characters_character_id_fleet(
+        character_id=token.character_id, token=token.valid_access_token()
+    ).result()
+
+    logger.debug(f"Fleet result: {fleet_result}")
+
+    fleet_commander = EveCharacter.objects.get(character_id=token.character_id)
+    fleet_id = fleet_result.get("fleet_id")
+    fleet_boss_id = fleet_result.get("fleet_boss_id")
+
+    if not fleet_id:
+        raise ValueError(f"No fleet found for {fleet_commander.character_name}")
+
+    if fleet_boss_id != character_id:
+        raise ValueError(f"{fleet_commander.character_name} is not the fleet boss")
+
+    return fleet_result
+
+
 @login_required()
 @permission_required(perm="fleetfinder.access_fleetfinder")
 def dashboard(request):
@@ -64,55 +106,100 @@ def ajax_dashboard(request) -> JsonResponse:  # pylint: disable=too-many-locals
     :return:
     """
 
-    data = []
-    groups = request.user.groups.all()
-    fleets = (
-        Fleet.objects.filter(Q(groups__group__in=groups) | Q(groups__isnull=True))
-        .distinct()
-        .order_by("name")
-    )
+    def _create_button_style_link(
+        url: str, fa_icon_class: str, btn_title: str | Promise, btn_modifier_class: str
+    ) -> str:
+        """
+        Helper function to create a button HTML string
+        This function generates an HTML anchor tag styled as a button with an icon.
+
+        :param url: The URL the button should link to
+        :type url: str
+        :param fa_icon_class: The Font Awesome class for the icon to be displayed
+        :type fa_icon_class: str
+        :param btn_title: The title attribute for the button, typically a translation string
+        :type btn_title: str | Promise
+        :param btn_modifier_class: The Bootstrap modifier class for the button styling
+        :type btn_modifier_class: str
+        :return: An HTML string representing the button
+        :rtype: str
+        """
+
+        return (
+            f'<a href="{url}" class="btn btn-sm {btn_modifier_class} ms-1" '
+            f'data-bs-tooltip="aa-fleetfinder" title="{btn_title}">'
+            f'<i class="{fa_icon_class}"></i></a>'
+        )
 
-    for fleet in fleets:
-        fleet_commander_name = fleet.fleet_commander.character_name
-        fleet_commander_portrait_url = character_portrait_url(
+    def _get_fleet_commander_information(fleet: Fleet) -> tuple[str, str]:
+        """
+        Helper function to get the fleet commander's HTML representation
+        This function retrieves the fleet commander's name and portrait URL,
+        and returns an HTML string with the portrait image and name.
+
+        :param fleet: The Fleet object containing the fleet commander's information
+        :type fleet: Fleet
+        :return: A tuple containing the HTML string for the fleet commander and the name for sorting
+        :rtype: tuple[str, str]
+        """
+
+        commander_name = fleet.fleet_commander.character_name
+        portrait_url = character_portrait_url(
             character_id=fleet.fleet_commander.character_id, size=32
         )
-        fleet_commander_portrait = (
+        portrait_img = (
             '<img class="rounded eve-character-portrait" '
-            f'src="{fleet_commander_portrait_url}" '
-            f'alt="{fleet_commander_name}" loading="lazy">'
+            f'src="{portrait_url}" alt="{commander_name}" loading="lazy">'
         )
-        fleet_commander_html = fleet_commander_portrait + fleet_commander_name
 
-        button_join_url = reverse(
-            viewname="fleetfinder:join_fleet", args=[fleet.fleet_id]
-        )
-        button_join_text = _("Join fleet")
-        button_join = (
-            f'<a href="{button_join_url}" '
-            f'class="btn btn-sm btn-primary">{button_join_text}</a>'
+        return portrait_img + commander_name, commander_name
+
+    data = []
+    groups = request.user.groups.all()
+    user_characters = get_all_characters_from_user(user=request.user)
+    fleets = (
+        Fleet.objects.filter(
+            Q(groups__group__in=groups)
+            | Q(groups__isnull=True)
+            | Q(fleet_commander__in=user_characters)
         )
+        .distinct()
+        .order_by("name")
+    )
 
-        button_details = ""
-        button_edit = ""
+    can_manage_fleets = request.user.has_perm("fleetfinder.manage_fleets")
 
-        if request.user.has_perm(perm="fleetfinder.manage_fleets"):
-            button_details_url = reverse(
-                viewname="fleetfinder:fleet_details", args=[fleet.fleet_id]
-            )
-            button_details_text = _("View fleet details")
-            button_details = (
-                f'<a href="{button_details_url}" '
-                f'class="btn btn-sm btn-primary">{button_details_text}</a>'
-            )
+    for fleet in fleets:
+        fleet_commander_html, fleet_commander_name = _get_fleet_commander_information(
+            fleet
+        )
 
-            button_edit_url = reverse(
-                viewname="fleetfinder:edit_fleet", args=[fleet.fleet_id]
+        # Create buttons
+        buttons = [
+            _create_button_style_link(
+                reverse("fleetfinder:join_fleet", args=[fleet.fleet_id]),
+                "fa-solid fa-right-to-bracket",
+                _("Join fleet"),
+                "btn-success",
             )
-            button_edit_text = _("Edit fleet advert")
-            button_edit = (
-                f'<a href="{button_edit_url}" '
-                f'class="btn btn-sm btn-primary">{button_edit_text}</a>'
+        ]
+
+        if can_manage_fleets:
+            buttons.extend(
+                [
+                    _create_button_style_link(
+                        reverse("fleetfinder:fleet_details", args=[fleet.fleet_id]),
+                        "fa-solid fa-eye",
+                        _("View fleet details"),
+                        "btn-info",
+                    ),
+                    _create_button_style_link(
+                        reverse("fleetfinder:edit_fleet", args=[fleet.fleet_id]),
+                        "fa-solid fa-pen-to-square",
+                        _("Edit fleet advert"),
+                        "btn-warning",
+                    ),
+                ]
             )
 
         data.append(
@@ -123,9 +210,7 @@ def ajax_dashboard(request) -> JsonResponse:  # pylint: disable=too-many-locals
                 },
                 "fleet_name": fleet.name,
                 "created_at": fleet.created_at,
-                "join": button_join,
-                "details": button_details,
-                "edit": button_edit,
+                "actions": "".join(buttons),
             }
         )
 
@@ -144,26 +229,30 @@ def create_fleet(request, token):
     :return:
     """
 
-    context = {}
+    # Validate the token and check if the character is in a fleet and is the fleet boss
+    try:
+        _get_and_validate_fleet(token, token.character_id)
+    except (HTTPNotFound, ValueError) as ex:
+        logger.debug(f"Error during fleet creation: {ex}", exc_info=True)
 
-    if request.method == "POST":
-        auth_groups = AuthGroup.objects.filter(internal=False).all()
-
-        if "modified_fleet_data" in request.session:
-            context["motd"] = request.session["modified_fleet_data"].get("motd", "")
-            context["name"] = request.session["modified_fleet_data"].get("name", "")
-            context["groups"] = request.session["modified_fleet_data"].get("groups", "")
-            context["is_free_move"] = request.session["modified_fleet_data"].get(
-                "free_move", ""
-            )
-            context["character_id"] = token.character_id
-            context["auth_groups"] = auth_groups
-
-            del request.session["modified_fleet_data"]
+        if isinstance(ex, HTTPNotFound):
+            error_detail = ex.swagger_result["error"]
         else:
-            context = {"character_id": token.character_id, "auth_groups": auth_groups}
+            error_detail = str(ex)
 
-        logger.info(msg=f"Fleet created by {request.user}")
+        error_message = _(
+            f"<h4>Error!</h4><p>There was an error creating the fleet: {error_detail}</p>"
+        )
+
+        messages.error(request, mark_safe(error_message))
+
+        return redirect("fleetfinder:dashboard")
+
+    if request.method != "POST":
+        return redirect("fleetfinder:dashboard")
+
+    auth_groups = AuthGroup.objects.filter(internal=False)
+    context = {"character_id": token.character_id, "auth_groups": auth_groups}
 
     return render(
         request=request,
@@ -183,7 +272,22 @@ def edit_fleet(request, fleet_id):
     :return:
     """
 
-    fleet = Fleet.objects.get(fleet_id=fleet_id)
+    try:
+        fleet = Fleet.objects.get(fleet_id=fleet_id)
+    except Fleet.DoesNotExist:
+        logger.debug(f"Fleet with ID {fleet_id} does not exist.")
+
+        messages.error(
+            request,
+            mark_safe(
+                _(
+                    "<h4>Error!</h4><p>Fleet does not exist or is no longer available.</p>"
+                )
+            ),
+        )
+
+        return redirect("fleetfinder:dashboard")
+
     auth_groups = AuthGroup.objects.filter(internal=False)
 
     context = {
@@ -192,6 +296,8 @@ def edit_fleet(request, fleet_id):
         "fleet": fleet,
     }
 
+    logger.debug("Context for fleet edit: %s", context)
+
     logger.info(msg=f"Fleet {fleet_id} edit view by {request.user}")
 
     return render(
@@ -252,46 +358,97 @@ def save_fleet(request):
     :return:
     """
 
-    if request.method == "POST":
-        free_move = request.POST.get(key="free_move", default=False)
-
-        if free_move == "on":
-            free_move = True
-
-        motd = request.POST.get(key="motd", default="")
-        name = request.POST.get(key="name", default="")
-        groups = request.POST.getlist(key="groups", default=[])
-
-        try:
-            open_fleet(
-                character_id=request.POST["character_id"],
-                motd=motd,
-                free_move=free_move,
-                name=name,
-                groups=groups,
-            )
-        except HTTPNotFound as ex:
-            esi_error_message = ex.swagger_result["error"]
-            error_message = _(
-                f"<h4>Error!</h4><p>ESI returned the following error: {esi_error_message}</p>"
-            )
+    def _edit_or_create_fleet(
+        character_id: int,
+        free_move: bool,
+        name: str,
+        groups: list,
+        motd: str = None,  # pylint: disable=unused-argument
+    ) -> None:
+        """
+        Edit or create a fleet from a fleet in EVE Online
+
+        :param character_id: The character ID of the fleet commander
+        :type character_id: int
+        :param free_move: Whether the fleet is free move or not
+        :type free_move: bool
+        :param name: Name of the fleet
+        :type name: str
+        :param groups: Groups that are allowed to access the fleet
+        :type groups: list[AuthGroup]
+        :param motd: Message of the Day for the fleet
+        :type motd: str
+        :return: None
+        :rtype: None
+        """
+
+        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 = _get_and_validate_fleet(token, character_id)
+        fleet_commander = EveCharacter.objects.get(character_id=character_id)
+        fleet_id = fleet_result.get("fleet_id")
+
+        fleet, created = Fleet.objects.get_or_create(
+            fleet_id=fleet_id,
+            defaults={
+                "created_at": timezone.now(),
+                # "motd": motd,
+                "is_free_move": free_move,
+                "fleet_commander": fleet_commander,
+                "name": name,
+            },
+        )
+
+        if not created:
+            fleet.is_free_move = free_move
+            fleet.name = name
+            fleet.save()
+
+        fleet.groups.set(groups)
+
+        esi.client.Fleets.put_fleets_fleet_id(
+            fleet_id=fleet_id,
+            token=token.valid_access_token(),
+            # new_settings={"is_free_move": free_move, "motd": motd},
+            new_settings={"is_free_move": free_move},
+        ).result()
+
+    if request.method != "POST":
+        return redirect("fleetfinder:dashboard")
+
+    # Extract form data
+    form_data = {
+        "character_id": int(request.POST["character_id"]),
+        "free_move": request.POST.get("free_move") == "on",
+        # "motd": request.POST.get("motd", ""),
+        "name": request.POST.get("name", ""),
+        "groups": request.POST.getlist("groups", []),
+    }
 
-            messages.error(request=request, message=mark_safe(s=error_message))
+    logger.debug(f"Form data for fleet creation: {form_data}")
 
-            if request.POST.get(key="origin", default="") == "edit":
-                return redirect(to="fleetfinder:dashboard")
+    try:
+        _edit_or_create_fleet(**form_data)
+    except HTTPNotFound as ex:
+        logger.debug(f"ESI returned 404 for fleet creation: {ex}", exc_info=True)
 
-            if request.POST.get(key="origin", default="") == "create":
-                request.session["modified_fleet_data"] = {
-                    "motd": motd,
-                    "name": name,
-                    "free_move": free_move,
-                    "groups": groups,
-                }
+        esi_error = ex.swagger_result.get("error", "Unknown error")
+        error_message = _(
+            f"<h4>Error!</h4><p>ESI returned the following error: {esi_error}</p>"
+        )
+
+        messages.error(request, mark_safe(error_message))
+    except ValueError as ex:
+        logger.debug(f"Value error during fleet creation: {ex}", exc_info=True)
 
-                return redirect(to="fleetfinder:create_fleet")
+        error_message = _(
+            f"<h4>Error!</h4><p>There was an error creating the fleet: {ex}</p>"
+        )
 
-    return redirect(to="fleetfinder:dashboard")
+        messages.error(request, mark_safe(error_message))
+
+    return redirect("fleetfinder:dashboard")
 
 
 @login_required()
@@ -319,8 +476,7 @@ def fleet_details(request, fleet_id):
 @login_required()
 @permission_required(perm="fleetfinder.manage_fleets")
 def ajax_fleet_details(
-    request,  # pylint: disable=unused-argument
-    fleet_id,
+    request, fleet_id  # pylint: disable=unused-argument
 ) -> JsonResponse:
     """
     Ajax :: Fleet Details
@@ -331,12 +487,69 @@ def ajax_fleet_details(
 
     fleet = get_fleet_composition(fleet_id)
 
-    data = {"fleet_member": [], "fleet_composition": []}
+    data = {
+        "fleet_member": list(fleet.fleet),
+        "fleet_composition": [
+            {"ship_type_name": ship, "number": number}
+            for ship, number in fleet.aggregate.items()
+        ],
+    }
 
-    for member in fleet.fleet:
-        data["fleet_member"].append(member)
+    return JsonResponse(data=data, safe=False)
 
-    for ship, number in fleet.aggregate.items():
-        data["fleet_composition"].append({"ship_type_name": ship, "number": number})
 
-    return JsonResponse(data=data, safe=False)
+@login_required()
+@permission_required(perm="fleetfinder.manage_fleets")
+def ajax_fleet_kick_member(request: WSGIRequest, fleet_id: int) -> JsonResponse:
+    """
+    Ajax :: Kick member from fleet
+
+    :param request: WSGIRequest object containing the request data
+    :type request: WSGIRequest
+    :param fleet_id: The ID of the fleet from which to kick a member
+    :type fleet_id: int
+    :return: JsonResponse indicating success or failure of the operation
+    :rtype: JsonResponse
+    """
+
+    if request.method != "POST":
+        return JsonResponse(
+            data={"success": False, "error": _("Method not allowed")}, status=405
+        )
+
+    try:
+        fleet = Fleet.objects.get(fleet_id=fleet_id)
+        data = json.loads(request.body)
+        member_id = data.get("memberId")
+
+        if not member_id:
+            return JsonResponse(
+                data={"success": False, "error": _("Member ID required")}, status=400
+            )
+
+        logger.debug(f"Request data for kicking member: {data}")
+
+        token = Token.get_token(
+            character_id=fleet.fleet_commander.character_id,
+            scopes=["esi-fleets.write_fleet.v1"],
+        )
+
+        esi.client.Fleets.delete_fleets_fleet_id_members_member_id(
+            fleet_id=fleet_id,
+            member_id=member_id,
+            token=token.valid_access_token(),
+        ).result()
+
+        return JsonResponse(data={"success": True}, status=200)
+    except Fleet.DoesNotExist:
+        return JsonResponse(
+            data={"success": False, "error": _("Fleet not found")}, status=404
+        )
+    except (json.JSONDecodeError, ValueError):
+        return JsonResponse(
+            data={"success": False, "error": _("Invalid request data")}, status=400
+        )
+    except HTTPNotFound:
+        return JsonResponse(
+            data={"success": False, "error": _("Member not found in fleet")}, status=404
+        )