aa-ledger 1.0.4__py3-none-any.whl → 2.0.0__py3-none-any.whl

ledger/api/helpers/planetary_helper.py

@@ -0,0 +1,354 @@
+# Third Party
+from ninja import schema
+
+# Django
+from django.utils.html import format_html
+from django.utils.translation import gettext_lazy as _
+
+# Alliance Auth
+from allianceauth.services.hooks import get_extension_logger
+
+# Alliance Auth (External Libs)
+from eveuniverse.models import EveType
+
+# AA Ledger
+from ledger import __title__
+from ledger.helpers.eveonline import get_icon_render_url
+from ledger.models.planetary import CharacterPlanetDetails
+from ledger.providers import AppLogger
+
+logger = AppLogger(get_extension_logger(__name__), __title__)
+
+
+class ProductSchema(schema.Schema):
+    item_id: int
+    item_name: str
+    item_quantity: int | None = None
+    icon: str | None = None
+
+
+class FactorySchema(schema.Schema):
+    factory_name: str
+    products: list[ProductSchema]
+    is_active: str
+
+
+class ProduceSchema(schema.Schema):
+    factory_name: str
+    input_products: list[ProductSchema]
+    output_product: ProductSchema | None = None
+    is_active: str
+
+
+class StorageSchema(schema.Schema):
+    factory_name: str
+    product: ProductSchema
+
+
+def get_factories_info(planet_details: CharacterPlanetDetails) -> list[FactorySchema]:
+    """
+    Get the factories information for a planet.
+
+    Args:
+        planet_details (CharacterPlanetDetails): The planetary details object.
+    Returns:
+        list[FactorySchema]: A list with the factory information for the Planet.
+    """
+    response_factories_list: list[FactorySchema] = []
+
+    try:
+        factories = planet_details.factories.values()
+    except AttributeError:
+        return response_factories_list
+
+    for factory_info in factories:
+        factory_name = factory_info.get("facility_name") or _("No facility")
+        # Only process Processors
+        if factory_info.get("facility_type") != "Processors":
+            continue
+
+        # Skip if no ressources
+        ressources = factory_info.get("ressources", None) or None
+        if ressources is None:
+            continue
+
+        ressource_types = get_resource_type(ressources)
+        ressource_list = []
+
+        # Build Ressource List from Factories
+        for product in ressource_types.values():
+            product = ProductSchema(
+                item_id=product["item_id"],
+                item_name=product["item_name"],
+                icon=get_icon_render_url(
+                    type_id=product["item_id"],
+                    type_name=product["item_name"],
+                    as_html=True,
+                ),
+            )
+            ressource_list.append(product)
+
+        # Populate Product if exists
+        if factory_info.get("output_product", None) is not None:
+            output_product = ProductSchema(
+                item_id=factory_info["output_product"]["item_id"],
+                item_name=factory_info["output_product"]["item_name"],
+                icon=get_icon_render_url(
+                    type_id=factory_info["output_product"]["item_id"],
+                    type_name=factory_info["output_product"]["item_name"],
+                    as_html=True,
+                ),
+            )
+            ressource_list.append(output_product)
+
+        is_active = factory_info.get("is_active", False)
+
+        response_factories_list.append(
+            FactorySchema(
+                factory_name=factory_name,
+                products=ressource_list,
+                is_active=generate_is_active_icon(is_active),
+            )
+        )
+    return response_factories_list
+
+
+def get_factory_info(planet_details: CharacterPlanetDetails) -> list[FactorySchema]:
+    """
+    Get the factory information for a planet.
+
+    Args:
+        planet_details (CharacterPlanetDetails): The planetary details object.
+    Returns:
+        list[FactorySchema]: A list with the factory information for the Planet.
+    """
+    response_factories_list: list[FactorySchema] = []
+
+    try:
+        factories = planet_details.factories.values()
+    except AttributeError:
+        return response_factories_list
+
+    for factory_info in factories:
+        factory_name = factory_info.get("facility_name") or _("No facility")
+        # Only process Processors
+        if factory_info.get("facility_type") != "Processors":
+            continue
+
+        ressource_types = get_resource_type(factory_info["ressources"])
+        input_products_list = []
+
+        # Build Ressource List from Factories
+        for input_ressource in ressource_types.values():
+            input_ressource = ProductSchema(
+                item_id=input_ressource["item_id"],
+                item_name=input_ressource["item_name"],
+                icon=get_icon_render_url(
+                    type_id=input_ressource["item_id"],
+                    type_name=input_ressource["item_name"],
+                    as_html=True,
+                ),
+            )
+            input_products_list.append(input_ressource)
+
+        output_product = None
+        # Get Output Product if exists
+        if factory_info.get("output_product", None) is not None:
+            output_product = ProductSchema(
+                item_id=factory_info["output_product"]["item_id"],
+                item_name=factory_info["output_product"]["item_name"],
+                icon=get_icon_render_url(
+                    type_id=factory_info["output_product"]["item_id"],
+                    type_name=factory_info["output_product"]["item_name"],
+                    as_html=True,
+                ),
+            )
+
+        is_active = factory_info.get("is_active", False)
+
+        response_factories_list.append(
+            ProduceSchema(
+                factory_name=factory_name,
+                input_products=input_products_list,
+                output_product=output_product,
+                is_active=generate_is_active_icon(is_active),
+            )
+        )
+    return response_factories_list
+
+
+def get_storage_info(planet_details: CharacterPlanetDetails) -> list[StorageSchema]:
+    """
+    Get the storage information for a planet.
+
+    Args:
+        planet_details (CharacterPlanetDetails): The planetary details object.
+    Returns:
+        list[StorageSchema]: A list with the storage information for the Planet.
+    """
+    response_storage_list: list[StorageSchema] = []
+
+    try:
+        factories = planet_details.factories.values()
+    except AttributeError:
+        return response_storage_list
+
+    for factory in factories:
+        factory_name = factory.get("facility_name") or _("No facility")
+
+        # Storage Info
+        storage = factory.get("storage", {}) or {}
+        for type_id, stored in storage.items():
+            # Get Eve Type
+            type_data = EveType.objects.get_or_create_esi(id=type_id)[0]
+
+            # Get Amount if Available
+            amount = (
+                stored.get("amount")
+                or stored.get("quantity")
+                or stored.get("item_quantity")
+                or stored.get("stored")
+                or 0
+            )
+
+            # Store Storage Information
+            response_storage_list.append(
+                StorageSchema(
+                    factory_name=factory_name,
+                    product=ProductSchema(
+                        item_id=type_id,
+                        item_name=type_data.name,
+                        item_quantity=int(amount) if amount is not None else None,
+                        icon=get_icon_render_url(
+                            type_id=type_id, type_name=type_data.name, as_html=True
+                        ),
+                    ),
+                )
+            )
+    return response_storage_list
+
+
+def generate_is_active_icon(is_active: bool) -> str:
+    """
+    Generate an HTML icon representing the active status.
+
+    Args:
+        is_active (bool): The active status.
+    Returns:
+        str: HTML string representing the active status icon.
+    """
+    color = "danger"
+    if is_active:
+        color = "success"
+    return format_html(
+        '<span class="fs-5 text-{}" data-bs-tooltip="aa-ledger" title="{}">⬤</span>',
+        color,
+        _("Active" if is_active else "Inactive"),
+    )
+
+
+def generate_is_notification_icon(is_notification: bool) -> str:
+    """
+    Generate an HTML icon representing the notification status.
+
+    Args:
+        is_notification (bool): The notification status.
+    Returns:
+        str: HTML string representing the notification status icon.
+    """
+    color = "danger"
+    if is_notification:
+        color = "success"
+    return format_html(
+        '<i class="fa-solid fa-bullhorn text-{}" style="margin-left: 5px;" data-bs-tooltip="aa-ledger" title="{}"></i>',
+        color,
+        _("Active" if is_notification else "Inactive"),
+    )
+
+
+def get_resource_type(ressources):
+    """
+    Get the resource types.
+
+    Args:
+        ressources (list): List of resource dictionaries.
+    Returns:
+        dict: Dictionary of unique resource types.
+    """
+    resource_types = {}
+    for ressource in ressources:
+        # Create a new entry if item_id not in resource_types
+        if ressource["item_id"] not in resource_types:
+            resource_types[ressource["item_id"]] = {
+                "item_id": ressource["item_id"],
+                "item_name": ressource["item_name"],
+            }
+    return resource_types
+
+
+def allocate_overall_progress(planet_details: CharacterPlanetDetails) -> float | None:
+    """
+    Calculate the overall progress percentage of all extractors on the planet.
+
+    Args:
+        planet_details (CharacterPlanetDetails): The planetary details object.
+    Returns:
+        float | None: The overall progress percentage, or None if no extractors are present.
+    """
+    progress_sum = 0.0
+    valid_extractors = 0
+
+    try:
+        factories = planet_details.factories.values()
+    except AttributeError:
+        return None
+
+    for factory in factories:
+        extractor = factory.get("extractor", {})
+
+        # Skip if no extractor present
+        if not extractor:
+            continue
+
+        # Get Progress from Extractors
+        progress = extractor.get("progress_percentage")
+        if progress is not None:
+            progress_sum += float(progress)
+            valid_extractors += 1
+            continue
+
+    if valid_extractors == 0:
+        return None
+
+    return round(progress_sum / valid_extractors, 2)
+
+
+def generate_progressbar(percentage: float | None) -> str:
+    """
+    Generate a progress bar based on the percentage.
+
+    This function creates an HTML representation of a progress bar
+    with a colored percentage display.
+
+    Args:
+        percentage (float): The percentage to display in the progress bar.
+    Returns:
+        str: HTML string representing the progress bar.
+    """
+    if percentage is None:
+        return str(_("No active extractors"))
+
+    if percentage > 50:
+        progress_value = f'<span class="text-white)">{percentage}%</span>'
+    else:
+        progress_value = f'<span class="text-dark">{percentage}%</span>'
+
+    progressbar = f"""
+        <div class="progress-outer flex-grow-1 me-2">
+            <div class="progress" style="position: relative;">
+                <div class="progress-bar progress-bar-warning progress-bar-striped active" role="progressbar" style="width: {percentage}%; box-shadow: -1px 3px 5px rgba(0, 180, 231, 0.9);"></div>
+                <div class="fw-bold fs-6 text-center position-absolute top-50 start-50 translate-middle">{progress_value}</div>
+            </div>
+        </div>
+    """
+    return progressbar

ledger/api/planetary.py

@@ -0,0 +1,354 @@
+# Third Party
+from ninja import NinjaAPI, schema
+
+# Django
+from django.core.handlers.wsgi import WSGIRequest
+from django.db.models import Q
+from django.utils.translation import gettext_lazy as _
+
+# Alliance Auth
+from allianceauth.services.hooks import get_extension_logger
+
+# AA Ledger
+from ledger import __title__
+from ledger.api.helpers.core import get_alts_queryset, get_characterowner_or_none
+from ledger.api.helpers.icons import (
+    get_extractor_info_button,
+    get_factory_info_button,
+    get_toggle_notification_button,
+)
+from ledger.api.helpers.planetary_helper import (
+    FactorySchema,
+    ProduceSchema,
+    StorageSchema,
+    allocate_overall_progress,
+    generate_is_active_icon,
+    generate_is_notification_icon,
+    generate_progressbar,
+    get_factories_info,
+    get_factory_info,
+    get_storage_info,
+)
+from ledger.api.schema import (
+    EveTypeSchema,
+    ExtractorSchema,
+    OwnerSchema,
+    PlanetSchema,
+    ProgressBarSchema,
+)
+from ledger.helpers.eveonline import (
+    get_character_portrait_url,
+    get_icon_render_url,
+    get_type_render_url,
+)
+from ledger.models.planetary import CharacterPlanetDetails
+from ledger.providers import AppLogger
+
+logger = AppLogger(get_extension_logger(__name__), __title__)
+
+
+class FactoryDetailsResponse(schema.Schema):
+    owner: OwnerSchema
+    planet: PlanetSchema
+    factories: list[ProduceSchema]
+    storage: list[StorageSchema]
+
+
+class ExtractorDetailsResponse(schema.Schema):
+    owner: OwnerSchema
+    planet: PlanetSchema
+    extractors: list[ExtractorSchema]
+
+
+class PlanetaryDetailsActions(schema.Schema):
+    factory_info_button: str
+    extractor_info_button: str
+    toggle_notification_button: str
+
+
+class PlanetaryDetails(schema.Schema):
+    owner: OwnerSchema
+    planet: PlanetSchema
+    expired: str | bool
+    alarm: str | bool
+    progress_bar: str
+    factories: list[FactorySchema]
+    actions: PlanetaryDetailsActions
+
+
+class PlanetaryApiEndpoints:
+    tags = ["CharacterPlanet"]
+
+    # pylint: disable=too-many-statements
+    def __init__(self, api: NinjaAPI):
+        @api.get(
+            "character/{character_id}/planet/{planet_id}/details/",
+            response={200: list[PlanetaryDetails], 403: str},
+            tags=self.tags,
+        )
+        # pylint: disable=too-many-locals
+        def get_planetarydetails(
+            request: WSGIRequest, character_id: int, planet_id: int
+        ):
+            singleview = request.GET.get("single", False)
+            perm, character = get_characterowner_or_none(request, character_id)
+
+            if not perm:
+                return 403, str(_("Permission Denied"))
+
+            if not singleview:
+                characters = get_alts_queryset(character)
+            else:
+                characters = [character]
+
+            filters = Q(planet__character__in=characters)
+            if not planet_id == 0:
+                filters &= Q(planet__id=planet_id)
+
+            planets_details = CharacterPlanetDetails.objects.filter(filters)
+            response_planetary_details_list: list[PlanetaryDetails] = []
+
+            for details in planets_details:
+                response_factories_list = get_factories_info(planet_details=details)
+
+                response_planetary_details = PlanetaryDetails(
+                    owner=OwnerSchema(
+                        character_id=details.planet.character.eve_character.character_id,
+                        character_name=details.planet.character.eve_character.character_name,
+                        icon=get_character_portrait_url(
+                            character_id=details.planet.character.eve_character.character_id,
+                            character_name=details.planet.character.eve_character.character_name,
+                            as_html=True,
+                        ),
+                    ),
+                    planet=PlanetSchema(
+                        id=details.planet.eve_planet.id,
+                        name=details.planet.eve_planet.name,
+                        type=EveTypeSchema(
+                            id=details.planet.eve_planet.eve_type.id,
+                            name=details.planet.eve_planet.eve_type.name,
+                            icon=get_icon_render_url(
+                                type_id=details.planet.eve_planet.eve_type.id,
+                                type_name=details.planet.eve_planet.eve_type.name,
+                                size=32,
+                                as_html=True,
+                            ),
+                        ),
+                        upgrade_level=details.planet.upgrade_level,
+                        num_pins=details.planet.num_pins,
+                        last_update=details.planet.last_update,
+                    ),
+                    factories=response_factories_list,
+                    expired=generate_is_active_icon(
+                        is_active=not details.is_expired,
+                    ),
+                    alarm=generate_is_notification_icon(
+                        is_notification=details.notification
+                    ),
+                    progress_bar=generate_progressbar(
+                        allocate_overall_progress(details)
+                    ),
+                    actions=PlanetaryDetailsActions(
+                        factory_info_button=get_factory_info_button(
+                            planet_details=details
+                        ),
+                        extractor_info_button=get_extractor_info_button(
+                            planet_details=details
+                        ),
+                        toggle_notification_button=get_toggle_notification_button(
+                            planet_details=details
+                        ),
+                    ),
+                )
+                response_planetary_details_list.append(response_planetary_details)
+            return response_planetary_details_list
+
+        @api.get(
+            "character/{character_id}/planet/{planet_id}/factory/",
+            response={200: FactoryDetailsResponse, 403: dict, 404: dict},
+            tags=self.tags,
+        )
+        def get_factory_details(
+            request: WSGIRequest, character_id: int, planet_id: int
+        ):
+            """
+            Get Factory Information for a character's planet.
+
+            Args:
+                request (WSGIRequest): The HTTP request object.
+                character_id (int): The ID of the character.
+                planet_id (int): The ID of the planet.
+            Returns:
+                dict: Factory details including owner, planet info, factories, and storage.
+            """
+            perm, character = get_characterowner_or_none(request, character_id)
+
+            if not perm:
+                return 403, {"error": _("Permission Denied.")}
+
+            filters = Q(planet__character=character)
+            if planet_id != 0:
+                filters &= Q(planet__id=planet_id)
+
+            planet_details = CharacterPlanetDetails.objects.filter(filters).first()
+
+            if not planet_details:
+                return 403, {"error": _("Planet not found.")}
+
+            response_storage_list = get_storage_info(planet_details=planet_details)
+            response_factories_list = get_factory_info(planet_details=planet_details)
+
+            return FactoryDetailsResponse(
+                owner=OwnerSchema(
+                    character_id=planet_details.planet.character.eve_character.character_id,
+                    character_name=planet_details.planet.character.eve_character.character_name,
+                ),
+                planet=PlanetSchema(
+                    id=planet_details.planet.eve_planet.id,
+                    name=planet_details.planet.eve_planet.name,
+                    type=EveTypeSchema(
+                        id=planet_details.planet.eve_planet.eve_type.id,
+                        name=planet_details.planet.eve_planet.eve_type.name,
+                        icon=get_type_render_url(
+                            type_id=planet_details.planet.eve_planet.eve_type.id,
+                            size=32,
+                            as_html=True,
+                        ),
+                    ),
+                    upgrade_level=planet_details.planet.upgrade_level,
+                    num_pins=planet_details.planet.num_pins,
+                    last_update=planet_details.planet.last_update,
+                ),
+                factories=response_factories_list,
+                storage=response_storage_list,
+            )
+
+        @api.get(
+            "character/{character_id}/planet/{planet_id}/extractor/",
+            response={200: ExtractorDetailsResponse, 403: dict, 404: dict},
+            tags=self.tags,
+        )
+        def get_extractor_details(
+            request: WSGIRequest, character_id: int, planet_id: int
+        ):
+            """
+            Get Extractor Information for a character's planet.
+
+            Args:
+                request (WSGIRequest): The HTTP request object.
+                character_id (int): The ID of the character.
+                planet_id (int): The ID of the planet.
+            Returns:
+                dict: Extractor details including owner, planet info, extractors, and last update.
+            """
+            perm, character = get_characterowner_or_none(request, character_id)
+
+            if not perm:
+                return 403, {"error": _("Permission Denied.")}
+
+            filters = Q(planet__character=character)
+            if not planet_id == 0:
+                filters &= Q(planet__id=planet_id)
+
+            planet_details = CharacterPlanetDetails.objects.filter(filters).first()
+
+            if not planet_details:
+                return 404, {"error": _("Planet not found.")}
+
+            response_extractors: list[ExtractorSchema] = []
+
+            if planet_details.factories:
+                for factory in planet_details.factories.values():
+                    extractor_info = factory.get("extractor", None)
+
+                    # Skip if no extractor info
+                    if not extractor_info:
+                        continue
+
+                    extractor = ExtractorSchema(
+                        item_id=extractor_info["product_type_id"],
+                        item_name=extractor_info["product_type_name"],
+                        icon=get_icon_render_url(
+                            type_id=extractor_info["product_type_id"],
+                            type_name=extractor_info["product_type_name"],
+                            as_html=True,
+                        ),
+                        install_time=extractor_info["install_time"],
+                        expiry_time=extractor_info["expiry_time"],
+                        progress=ProgressBarSchema(
+                            percentage=str(extractor_info["progress_percentage"]),
+                            html=generate_progressbar(
+                                extractor_info["progress_percentage"]
+                            ),
+                        ),
+                    )
+                    response_extractors.append(extractor)
+
+            return ExtractorDetailsResponse(
+                owner=OwnerSchema(
+                    character_id=planet_details.planet.character.eve_character.character_id,
+                    character_name=planet_details.planet.character.eve_character.character_name,
+                ),
+                planet=PlanetSchema(
+                    id=planet_details.planet.eve_planet.id,
+                    name=planet_details.planet.eve_planet.name,
+                    type=EveTypeSchema(
+                        id=planet_details.planet.eve_planet.eve_type.id,
+                        name=planet_details.planet.eve_planet.eve_type.name,
+                        icon=get_type_render_url(
+                            type_id=planet_details.planet.eve_planet.eve_type.id,
+                            size=32,
+                            as_html=True,
+                        ),
+                    ),
+                    upgrade_level=planet_details.planet.upgrade_level,
+                    num_pins=planet_details.planet.num_pins,
+                    last_update=planet_details.planet.last_update,
+                ),
+                extractors=response_extractors,
+            )
+
+        @api.post(
+            "character/{character_id}/planet/{planet_id}/toggle/",
+            response={200: dict, 403: dict, 404: dict},
+            tags=self.tags,
+        )
+        def toggle_planet_notification(
+            request: WSGIRequest, character_id: int, planet_id: int
+        ):
+            """
+            Toggle Notification for a character's planet.
+
+            This endpoint toggles the notification setting for a character's planet.
+            It validates the user's permission and the existence of the planet before performing the toggle action.
+
+            Args:
+                request (WSGIRequest): The HTTP request object.
+                character_id (int): The ID of the character.
+                planet_id (int): The ID of the planet.
+            Returns:
+                dict: A dictionary containing the success status and message.
+            """
+            perm, character = get_characterowner_or_none(request, character_id)
+
+            if not perm:
+                return 403, {"error": _("Permission Denied.")}
+
+            filters = Q(planet__character=character)
+            if not planet_id == 0:
+                filters &= Q(planet__id=planet_id)
+
+            planets = CharacterPlanetDetails.objects.filter(filters)
+
+            if not planets.exists():
+                return 404, {"error": _("Planet not found.")}
+
+            on_count = planets.filter(notification=True).count()
+            off_count = planets.filter(notification=False).count()
+            majority_state = on_count > off_count
+
+            for planet in planets:
+                planet.notification = not majority_state
+                planet.save()
+            msg = _("Notification toggled successfully.")
+            return {"success": True, "message": msg}