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

ledger/models/planetary.py

@@ -5,41 +5,49 @@ Planetary Model
 # Django
 from django.db import models
 from django.utils import timezone
-from django.utils.dateparse import parse_datetime
 from django.utils.translation import gettext_lazy as _
 
 # Alliance Auth
 from allianceauth.services.hooks import get_extension_logger
 
 # Alliance Auth (External Libs)
-from app_utils.logging import LoggerAddTag
-from eveuniverse.models import EvePlanet, EveType
+from eveuniverse.models import EvePlanet
 
 # AA Ledger
 from ledger import __title__
-from ledger.constants import EXTRACTOR_CONTROL_UNIT, P0_PRODUCTS, SPACEPORTS
 from ledger.managers.character_planetary_manager import (
-    PlanetaryDetailsManager,
-    PlanetaryManager,
+    CharacterPlanetManager,
+    PlanetDetailsManager,
 )
-from ledger.models.characteraudit import CharacterAudit, CharacterUpdateStatus
+from ledger.models.characteraudit import CharacterOwner, CharacterUpdateStatus
+from ledger.models.helpers.update_manager import CharacterUpdateSection
+from ledger.providers import AppLogger
 
-logger = LoggerAddTag(get_extension_logger(__name__), __title__)
+logger = AppLogger(get_extension_logger(__name__), __title__)
 
 
 class CharacterPlanet(models.Model):
-    objects = PlanetaryManager()
+    """Model to store the planetary data of a character"""
+
+    objects: CharacterPlanetManager = CharacterPlanetManager()
+
+    class Meta:
+        default_permissions = ()
+        indexes = [
+            models.Index(fields=["character"]),
+            models.Index(fields=["eve_planet"]),
+        ]
 
     id = models.AutoField(primary_key=True)
 
-    planet_name = models.CharField(max_length=100, null=True, default=None)
+    name = models.CharField(max_length=100, null=True, default=None)
 
-    planet = models.ForeignKey(
+    eve_planet = models.ForeignKey(
         EvePlanet, on_delete=models.CASCADE, related_name="ledger_planet"
     )
 
     character = models.ForeignKey(
-        CharacterAudit, on_delete=models.CASCADE, related_name="ledger_character_planet"
+        CharacterOwner, on_delete=models.CASCADE, related_name="ledger_character_planet"
     )
 
     upgrade_level = models.IntegerField(
@@ -50,23 +58,16 @@ class CharacterPlanet(models.Model):
         default=0, help_text=_("Number of pins on the planet")
     )
 
-    class Meta:
-        default_permissions = ()
-        indexes = [
-            models.Index(fields=["character"]),
-            models.Index(fields=["planet"]),
-        ]
-
     def __str__(self):
-        return f"Planet Data: {self.character.eve_character.character_name} - {self.planet.name}"
+        return f"Planet Data: {self.character.eve_character.character_name} - {self.eve_planet.name}"
 
     @property
     def last_update(self) -> timezone.datetime:
         """Return the last update time of the planet."""
         try:
             last_update = CharacterUpdateStatus.objects.get(
-                character=self.character,
-                section=CharacterAudit.UpdateSection.PLANETS,
+                owner=self.character,
+                section=CharacterUpdateSection.PLANETS,
             ).last_update_at
         except CharacterUpdateStatus.DoesNotExist:
             last_update = None
@@ -83,7 +84,13 @@ class CharacterPlanet(models.Model):
 class CharacterPlanetDetails(models.Model):
     """Model to store the details of a planet"""
 
-    objects = PlanetaryDetailsManager()
+    objects: PlanetDetailsManager = PlanetDetailsManager()
+
+    class Meta:
+        default_permissions = ()
+        indexes = [
+            models.Index(fields=["planet"]),
+        ]
 
     id = models.AutoField(primary_key=True)
 
@@ -94,7 +101,7 @@ class CharacterPlanetDetails(models.Model):
     )
 
     character = models.ForeignKey(
-        CharacterAudit,
+        CharacterOwner,
         on_delete=models.CASCADE,
         related_name="ledger_character_planet_details",
     )
@@ -102,196 +109,44 @@ class CharacterPlanetDetails(models.Model):
     links = models.JSONField(null=True, default=None, blank=True)
     pins = models.JSONField(null=True, default=None, blank=True)
     routes = models.JSONField(null=True, default=None, blank=True)
-    facilitys = models.JSONField(null=True, default=None, blank=True)
+    factories = models.JSONField(null=True, default=None, blank=True)
 
     last_alert = models.DateTimeField(null=True, default=None, blank=True)
 
     notification = models.BooleanField(default=False)
     notification_sent = models.BooleanField(default=False)
 
-    class Meta:
-        default_permissions = ()
-        indexes = [
-            models.Index(fields=["planet"]),
-        ]
-
     def __str__(self):
-        return f"Planet Details Data: {self.planet.character.eve_character.character_name} - {self.planet.planet.name}"
-
-    def count_extractors(self):
-        return len(
-            [pin for pin in self.pins if pin.get("type_id") in EXTRACTOR_CONTROL_UNIT]
-        )
-
-    def get_planet_install_date(self):
-        install_times = [
-            pin.get("install_time")
-            for pin in self.pins
-            if pin.get("install_time") and pin["install_time"] != "0"
-        ]
-        if install_times:
-            install = timezone.datetime.fromisoformat(
-                min(install_times).replace("Z", "+00:00")
-            )
-            return install
-        return None
-
-    def get_planet_expiry_date(self):
-        if self.pins is None:
-            return None
-
-        expiry_times = [
-            pin.get("expiry_time")
-            for pin in self.pins
-            if pin.get("expiry_time") and pin["expiry_time"] != "0"
-        ]
-        if expiry_times:
-            alert = timezone.datetime.fromisoformat(
-                min(expiry_times).replace("Z", "+00:00")
-            )
-            return alert
-        return None
-
-    def get_types(self) -> list:
-        """Get the product types of the routes on the planet"""
-        types = []
-        for pin in self.routes:
-            if pin.get("content_type_id") not in types:
-                types.append(pin.get("content_type_id"))
-        return types
-
-    def allocate_products(self) -> dict:
-        """Get the product types on the planet"""
-        product_types = {}
-        for c_type_id in self.routes:
-            type_id = c_type_id.get("content_type_id")
-            if type_id not in P0_PRODUCTS and type_id not in product_types:
-                type_data, _ = EveType.objects.get_or_create_esi(id=type_id)
-                product_types[type_id] = {
-                    "id": type_id,
-                    "name": type_data.name,
-                    "category": type_data.eve_group.name,
-                }
-        return product_types
-
-    def allocate_extracts(self) -> dict:
-        """Get the extractor raw product types on the planet"""
-        product_types = {}
-        for c_type_id in self.routes:
-            type_id = c_type_id.get("content_type_id")
-            if type_id in P0_PRODUCTS and type_id not in product_types:
-                type_data, _ = EveType.objects.get_or_create_esi(id=type_id)
-                product_types[type_id] = {
-                    "id": type_id,
-                    "name": type_data.name,
-                    "category": type_data.eve_group.name,
-                }
-        return product_types
-
-    def allocate_overall_progress(self) -> dict:
-        extractors = self.get_extractors_info()
-
-        if not extractors:
-            return 0
-
-        total_install_time = 0
-        total_expiry_time = 0
-        current_time = timezone.now().timestamp() * 1000  # Current time in milliseconds
-        extractor_count = len(extractors)
-
-        for extractor in extractors.values():
-            if not extractor.get("install_time") or not extractor.get("expiry_time"):
-                continue
-            install_time = (
-                timezone.datetime.fromisoformat(extractor["install_time"]).timestamp()
-                * 1000
-            )
-            expiry_time = (
-                timezone.datetime.fromisoformat(extractor["expiry_time"]).timestamp()
-                * 1000
-            )
-
-            total_install_time += install_time
-            total_expiry_time += expiry_time
-
-        average_install_time = total_install_time / extractor_count
-        average_expiry_time = total_expiry_time / extractor_count
-
-        total_duration = average_expiry_time - average_install_time
-        elapsed_duration = current_time - average_install_time
-        progress_percentage = min(
-            max((elapsed_duration / total_duration) * 100, 0), 100
-        )
-
-        return progress_percentage
-
-    def get_extractors_info(self) -> dict:
-        extractors = {}
-        current_time = timezone.now().timestamp()
-
-        for pin in self.pins:
-            extractor_details = pin.get("extractor_details")
-            if extractor_details and "cycle_time" in extractor_details:
-                type_id = extractor_details.get("product_type_id")
-                type_data, _ = EveType.objects.get_or_create_esi(id=type_id)
-
-                install_time_str = pin.get("install_time")
-                expiry_time_str = pin.get("expiry_time")
-
-                install_time = parse_datetime(install_time_str).timestamp()
-                expiry_time = parse_datetime(expiry_time_str).timestamp()
-
-                # Calculate progress percentage (0-100)
-                if current_time >= expiry_time:
-                    progress_percentage = 100.0
-                else:
-                    progress_percentage = round(
-                        ((current_time - install_time) / (expiry_time - install_time))
-                        * 100,
-                        2,
-                    )
-
-                extractors[pin.get("pin_id")] = {
-                    "install_time": install_time_str,
-                    "expiry_time": expiry_time_str,
-                    "item_id": type_id,
-                    "item_name": type_data.name,
-                    "progress_percentage": progress_percentage,
-                }
-        return extractors
-
-    def get_storage_info(self) -> dict:
-        storage = {}
-        for pin in self.pins:
-            type_id = pin.get("type_id")
-            if type_id in SPACEPORTS:
-                type_data, _ = EveType.objects.get_or_create_esi(id=type_id)
-                contents_info = []
-                for content in pin.get("contents", []):
-                    content_type_id = content.get("type_id")
-                    content_type_data, _ = EveType.objects.get_or_create_esi(
-                        id=content_type_id
-                    )
-                    contents_info.append(
-                        {
-                            "amount": content.get("amount"),
-                            "type_id": content_type_id,
-                            "product_name": content_type_data.name,
-                        }
-                    )
-                storage[pin.get("pin_id")] = {
-                    "facility_id": type_id,
-                    "facility_name": type_data.name,
-                    "contents": contents_info,
-                }
-        return storage
+        return f"Planet Details Data: {self.planet.character.eve_character.character_name} - {self.planet.eve_planet.name}"
 
     @property
     def is_expired(self):
-        expiry_date = self.get_planet_expiry_date()
-        if expiry_date is None:
-            return False
-        return expiry_date < timezone.now()
+        """
+        Return False (not expired) when any extractor is running or when any
+        'Processors' facility has an active resource. Otherwise return True.
+        """
+        # No factories means nothing is running, so expired
+        if not self.factories:
+            return True
+
+        # Check all facilities for running extractors or active processor ressources
+        try:
+            factories = self.factories.values()
+        except AttributeError:
+            return True
+
+        for factory in factories:
+            # Extractor running?
+            extractor = factory.get("extractor", {})
+            if extractor.get("is_running", False):
+                return False
+
+            # Processors: any resource with is_active True?
+            if factory.get("facility_type") == "Processors":
+                for ressource in factory.get("ressources", []) or []:
+                    if ressource.get("is_active", False):
+                        return False
+        return True
 
     @property
     def last_update(self) -> timezone.datetime:
@@ -299,7 +154,7 @@ class CharacterPlanetDetails(models.Model):
         try:
             last_update = CharacterUpdateStatus.objects.get(
                 character=self.character,
-                section=CharacterAudit.UpdateSection.PLANETS_DETAILS,
+                section=CharacterUpdateSection.PLANETS_DETAILS,
             ).last_update_at
         except CharacterUpdateStatus.DoesNotExist:
             last_update = None

ledger/providers.py

@@ -1,6 +1,22 @@
 """Shared ESI client for Ledger."""
 
+# Standard Library
+import logging
+import random
+from contextlib import contextmanager
+from http import HTTPStatus
+
+# Third Party
+from aiopenapi3 import RequestError
+from celery import Task
+
 # Alliance Auth
+from allianceauth.services.hooks import get_extension_logger
+from esi.exceptions import (
+    ESIBucketLimitException,
+    ESIErrorLimitException,
+    HTTPServerError,
+)
 from esi.openapi_clients import ESIClientProvider
 
 # AA Ledger
@@ -24,3 +40,88 @@ esi = ESIClientProvider(
     + __character_operations__
     + __universe_operations__,
 )
+
+
+class AppLogger(logging.LoggerAdapter):
+    """
+    Custom logger adapter that adds a prefix to log messages.
+
+    Taken from the `allianceauth-app-utils` package.
+    Credits to: Erik Kalkoken
+    """
+
+    def __init__(self, my_logger, prefix):
+        """
+        Initializes the AppLogger with a logger and a prefix.
+
+        :param my_logger: Logger instance
+        :type my_logger: logging.Logger
+        :param prefix: Prefix string to add to log messages
+        :type prefix: str
+        """
+
+        super().__init__(my_logger, {})
+
+        self.prefix = prefix
+
+    def process(self, msg, kwargs):
+        """
+        Prepares the log message by adding the prefix.
+
+        :param msg: Original log message
+        :type msg: str
+        :param kwargs: Additional keyword arguments for logging
+        :type kwargs: dict
+        :return: Tuple of modified message and kwargs
+        :rtype: tuple
+        """
+        return f"[{self.prefix}] {msg}", kwargs
+
+
+logger = AppLogger(my_logger=get_extension_logger(__name__), prefix=__title__)
+
+
+@contextmanager
+def retry_task_on_esi_error(task: Task):
+    """Retry Task when a ESI error occurs.
+
+    Taken from the `allianceauth-app-utils` package.
+    Credits to: Erik Kalkoken
+
+    Retries on:
+    - Error limits reached (ESIErrorLimitException)
+    - Rate limit errors (ESIBucketLimitException)
+    - HTTPError with status codes 502, 503, 504 (server errors)
+
+    :param task: Celery Task instance
+    :return: Context manager that retries the task on ESI errors.
+
+    """
+
+    def retry(exc: Exception, retry_after: float, issue: str):
+        backoff_jitter = int(random.uniform(2, 5) ** task.request.retries)
+        countdown = retry_after + backoff_jitter
+        logger.warning(
+            "ESI Error encountered: %s. Retrying after %.2f seconds. Issue: %s",
+            str(exc),
+            countdown,
+            issue,
+        )
+        raise task.retry(countdown=countdown, exc=exc)
+
+    try:
+        yield
+    except ESIErrorLimitException as exc:
+        retry(exc, exc.reset, "ESI Error Limit Reached")
+    except ESIBucketLimitException as exc:
+        retry(exc, exc.reset, f"ESI Bucket Limit Reached for {exc.bucket}")
+    except HTTPServerError as exc:
+        if exc.status_code in [
+            HTTPStatus.BAD_GATEWAY,
+            HTTPStatus.SERVICE_UNAVAILABLE,
+            HTTPStatus.GATEWAY_TIMEOUT,
+        ]:
+            retry(exc, 60, f"ESI seems to be down (HTTP {exc.status_code})")
+        raise exc
+    except RequestError as exc:
+        retry(exc, 60, "Request Error")

ledger/static/ledger/css/{ledger.css → aa-ledger.css}

@@ -11,26 +11,6 @@
         animation-iteration-count: infinite;
     }
 
-    .custom-line {
-        height: 3px;
-        border: none;
-        background: linear-gradient(to right, rgb(0 170 255 / 100%) 0%, rgb(0 170 255 / 0%) 80%, rgb(0 170 255 / 0%) 100%);
-        z-index: 1;
-    }
-
-    /* Style the Image Used to Trigger the Modal */
-    .zoom {
-        opacity: 0.7;
-        border-radius: 10px;
-        cursor: pointer;
-        transition: 0.3s;
-    }
-
-    .zoom:hover {
-        opacity: 1;
-        transform: scale(1.1);
-    }
-
     /* Custom CSS for tab mouseover */
     .nav-tabs .nav-link:hover {
         opacity: 0.8;
@@ -38,10 +18,6 @@
         border-color: white;
     }
 
-    .aa-ledger-modal-header > h5 {
-        border-bottom: 1px solid var(--bs-secondary-bg-subtle);
-    }
-
     .dropdown-scrollable {
         max-height: 200px; /* Adjust the height as needed */
         overflow-y: auto;
@@ -52,10 +28,7 @@
         color: rgb(33 37 41); /* Dark text color */
     }
 
-    .card-ledger {
-        min-width: 1000px;
-    }
-
+    /* Ratting Chart */
     .rattingchart {
         height: 500px;
         margin-left: 50px;
@@ -66,6 +39,59 @@
     .rattingbar {
         height: 500px;
     }
+
+    /* Ratting Table */
+    #ratting {
+        table-layout: fixed;
+        overflow-wrap: break-word;
+    }
+
+    #ratting th,
+    #ratting td {
+        padding: 0.75rem;
+        vertical-align: top;
+    }
+
+    #ratting thead th {
+        text-align: center;
+    }
+
+    #ratting thead th.col-main-character {
+        text-align: left;
+    }
+
+    #ratting tbody td {
+        text-align: right;
+    }
+
+    #ratting tbody td:nth-child(1) {
+        text-align: left;
+    }
+
+    #ratting tfoot th {
+        text-align: right;
+        border-top: 1px solid rgb(222 226 230);
+    }
+
+    #ratting tfoot th:nth-child(1) {
+        text-align: left;
+    }
+
+    .nav-tabs .nav-item .nav-link {
+        opacity: 0.3;
+    }
+
+    .nav-tabs .nav-item .nav-link.active {
+        opacity: 1.0;
+    }
+
+    /* CSV Export Button */
+    .aa-ledger-csv {
+        position: relative;
+        z-index: 1;
+        pointer-events: auto;
+        display: inline-block;
+    }
 }
 
 

ledger/static/ledger/js/aa-ledger.js

@@ -0,0 +1,124 @@
+/* global aaLedgerDefaultSettings, aaLedgerSettingsOverride, objectDeepMerge, bootstrap */
+
+/**
+ * Default settings for aa-ledger
+ * Settings can be overridden by defining aaLedgerSettingsOverride before this script is loaded.
+ */
+const aaLedgerSettings = (typeof aaLedgerSettingsOverride !== 'undefined')
+    ? objectDeepMerge(aaLedgerDefaultSettings, aaLedgerSettingsOverride) // jshint ignore:line
+    : aaLedgerDefaultSettings;
+
+/**
+ * Bootstrap tooltip by (@ppfeufer)
+ *
+ * @param {string} [selector=body] Selector for the tooltip elements, defaults to 'body'
+ *                                 to apply to all elements with the data-bs-tooltip attribute.
+ *                                 Example: 'body', '.my-tooltip-class', '#my-tooltip-id'
+ *                                 If you want to apply it to a specific element, use that element's selector.
+ *                                 If you want to apply it to all elements with the data-bs-tooltip attribute,
+ *                                 use 'body' or leave it empty.
+ * @param {string} [namespace=aa-ledger] Namespace for the tooltip
+ * @param {string} [trigger=hover] Trigger for the tooltip ('hover', 'click', etc.)
+ * @returns {void}
+ */
+const _bootstrapTooltip = ({selector = 'body', namespace = 'aa-ledger', trigger = 'hover'} = {}) => {
+    document.querySelectorAll(`${selector} [data-bs-tooltip="${namespace}"]`)
+        .forEach((tooltipTriggerEl) => {
+            // Dispose existing tooltip instance if it exists
+            const existing = bootstrap.Tooltip.getInstance(tooltipTriggerEl);
+            if (existing) {
+                existing.dispose();
+            }
+
+            // Remove any leftover tooltip elements
+            $('.bs-tooltip-auto').remove();
+
+            // Create new tooltip instance
+            return new bootstrap.Tooltip(tooltipTriggerEl, { trigger });
+        });
+};
+
+const _bootstrapPopOver = ({selector = 'body', namespace = 'aa-ledger', trigger = 'hover'} = {}) => {
+    document.querySelectorAll(`${selector} [data-bs-popover="${namespace}"]`)
+        .forEach((popoverTriggerEl) => {
+            // Dispose existing popover instance if it exists
+            const existing = bootstrap.Popover.getInstance(popoverTriggerEl);
+            if (existing) {
+                existing.dispose();
+            }
+
+            // Remove any leftover popover elements
+            $('.bs-popover-auto').remove();
+
+            // Create new popover instance
+            return new bootstrap.Popover(popoverTriggerEl, { trigger });
+        });
+};
+
+/**
+ * Export HTML table to CSV file (DataTables-only)
+ *
+ * This function exports the contents of a DataTables-enhanced HTML table to a CSV file.
+ *
+ * @param {HTMLElement} table HTML table element enhanced by DataTables
+ * @param {number} columnIndex Index of the column to exclude from export (e.g., actions column)
+ * @param {string} filename Name of the CSV file to be downloaded
+ * @returns {void}
+ */
+const _exportTableToCSV = (dt, columnIndex, filename = 'ledger.csv') => {
+    const csv = [];
+
+    let headerCells = [];
+    // Get header cells from DataTables API
+    try {
+        headerCells = dt.columns().header().toArray();
+    } catch (e) {
+        console.log('Error retrieving DataTables column headers for CSV export:', e);
+    }
+
+    // Determine columns to export (exclude specified column)
+    const colCount = dt.columns().count();
+    let exportColIndexes = [];
+    for (let i = 0; i < colCount; i++) exportColIndexes.push(i);
+    exportColIndexes = exportColIndexes.filter(i => i !== columnIndex);
+
+    // Header row
+    const headerRow = [];
+    for (let ci = 0; ci < exportColIndexes.length; ci++) {
+        const colIndex = exportColIndexes[ci];
+        const cell = headerCells[colIndex];
+        const raw = cell ? (cell.innerText || cell.textContent || '') : '';
+        headerRow.push(raw);
+    }
+    csv.push(headerRow.join(','));
+
+    // Process rows by index and download CSV (use sort cell values)
+    const rowIndexes = dt.rows({ search: 'applied', page: 'all' }).indexes().toArray();
+    for (let ri = 0; ri < rowIndexes.length; ri++) {
+        const rowIndex = rowIndexes[ri];
+        const row = [];
+        for (let k = 0; k < exportColIndexes.length; k++) {
+            const ci = exportColIndexes[k];
+            let raw = '';
+            try {
+                const renderMode = 'sort';
+                raw = dt.cell(rowIndex, ci).render(renderMode);
+            } catch (e) {
+                console.log(`Error retrieving cell data for row ${rowIndex}, column ${ci}:`, e);
+                raw = '';
+            }
+            row.push(raw);
+        }
+        csv.push(row.join(','));
+    }
+
+    // Download CSV file
+    const csvFile = new Blob([csv.join('\n')], { type: 'text/csv' });
+    const downloadLink = document.createElement('a');
+    downloadLink.download = filename;
+    downloadLink.href = window.URL.createObjectURL(csvFile);
+    downloadLink.style.display = 'none';
+    document.body.appendChild(downloadLink);
+    downloadLink.click();
+    document.body.removeChild(downloadLink);
+};