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

fleetfinder/views.py

@@ -12,15 +12,18 @@ 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.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 +31,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):
@@ -66,8 +103,13 @@ def ajax_dashboard(request) -> JsonResponse:  # pylint: disable=too-many-locals
 
     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))
+        Fleet.objects.filter(
+            Q(groups__group__in=groups)
+            | Q(groups__isnull=True)
+            | Q(fleet_commander__in=user_characters)
+        )
         .distinct()
         .order_by("name")
     )
@@ -144,26 +186,30 @@ def create_fleet(request, token):
     :return:
     """
 
-    context = {}
-
-    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
+    # 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)
 
-            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)
+
+        error_message = _(
+            f"<h4>Error!</h4><p>There was an error creating the fleet: {error_detail}</p>"
+        )
+
+        messages.error(request, mark_safe(error_message))
 
-        logger.info(msg=f"Fleet created by {request.user}")
+        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 +229,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 +253,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 +315,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", []),
+    }
+
+    logger.debug(f"Form data for fleet creation: {form_data}")
+
+    try:
+        _edit_or_create_fleet(**form_data)
+    except HTTPNotFound as ex:
+        logger.debug(f"ESI returned 404 for fleet creation: {ex}", exc_info=True)
 
-            messages.error(request=request, message=mark_safe(s=error_message))
+        esi_error = ex.swagger_result.get("error", "Unknown error")
+        error_message = _(
+            f"<h4>Error!</h4><p>ESI returned the following error: {esi_error}</p>"
+        )
 
-            if request.POST.get(key="origin", default="") == "edit":
-                return redirect(to="fleetfinder:dashboard")
+        messages.error(request, mark_safe(error_message))
+    except ValueError as ex:
+        logger.debug(f"Value error during 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,
-                }
+        error_message = _(
+            f"<h4>Error!</h4><p>There was an error creating the fleet: {ex}</p>"
+        )
 
-                return redirect(to="fleetfinder:create_fleet")
+        messages.error(request, mark_safe(error_message))
 
-    return redirect(to="fleetfinder:dashboard")
+    return redirect("fleetfinder:dashboard")
 
 
 @login_required()
@@ -331,12 +445,12 @@ def ajax_fleet_details(
 
     fleet = get_fleet_composition(fleet_id)
 
-    data = {"fleet_member": [], "fleet_composition": []}
-
-    for member in fleet.fleet:
-        data["fleet_member"].append(member)
-
-    for ship, number in fleet.aggregate.items():
-        data["fleet_composition"].append({"ship_type_name": ship, "number": number})
+    data = {
+        "fleet_member": list(fleet.fleet),
+        "fleet_composition": [
+            {"ship_type_name": ship, "number": number}
+            for ship, number in fleet.aggregate.items()
+        ],
+    }
 
     return JsonResponse(data=data, safe=False)