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

ledger/models/general.py

@@ -4,18 +4,13 @@ General Model
 
 # Standard Library
 import datetime
-from collections.abc import Callable
 from dataclasses import dataclass
 from typing import Any, NamedTuple
 
-# Third Party
-from aiopenapi3.errors import ContentTypeError, HTTPClientError, HTTPServerError
-
 # Django
 from django.core.validators import MinValueValidator
 from django.db import models
 from django.utils import timezone
-from django.utils.safestring import mark_safe
 from django.utils.translation import gettext_lazy as _
 
 # Alliance Auth
@@ -25,17 +20,18 @@ from allianceauth.eveonline.models import (
     EveCorporationInfo,
 )
 from allianceauth.services.hooks import get_extension_logger
-from esi.errors import TokenError
-from esi.exceptions import HTTPNotModified
-
-# Alliance Auth (External Libs)
-from app_utils.logging import LoggerAddTag
 
 # AA Ledger
 from ledger import __title__, app_settings
+from ledger.helpers.eveonline import (
+    get_alliance_logo_url,
+    get_character_portrait_url,
+    get_corporation_logo_url,
+)
 from ledger.managers.general_manager import EveEntityManager
+from ledger.providers import AppLogger
 
-logger = LoggerAddTag(get_extension_logger(__name__), __title__)
+logger = AppLogger(get_extension_logger(__name__), __title__)
 
 # Permission Manager
 
@@ -57,6 +53,11 @@ class General(models.Model):
 class EveEntity(models.Model):
     """An Eve entity like a corporation or a character"""
 
+    objects: EveEntityManager = EveEntityManager()
+
+    class Meta:
+        default_permissions = ()
+
     CATEGORY_ALLIANCE = "alliance"
     CATEGORY_CHARACTER = "character"
     CATEGORY_CORPORATION = "corporation"
@@ -92,8 +93,6 @@ class EveEntity(models.Model):
     )
     last_update = models.DateTimeField(auto_now=True)
 
-    objects = EveEntityManager()
-
     def __str__(self) -> str:
         return str(self.name)
 
@@ -118,6 +117,41 @@ class EveEntity(models.Model):
         """Return True if entity is a character, else False."""
         return self.category == self.CATEGORY_CHARACTER
 
+    def get_portrait(self, size=64, as_html=False) -> str:
+        """
+        Get the portrait URL for this entity.
+
+        Args:
+            size (int, optional): The size of the portrait.
+            as_html (bool, optional): Whether to return the portrait as an HTML img tag.
+        Returns:
+            str: The URL of the portrait or an HTML img tag.
+        """
+        if self.category == self.CATEGORY_ALLIANCE:
+            return get_alliance_logo_url(
+                alliance_id=self.eve_id,
+                size=size,
+                alliance_name=self.name,
+                as_html=as_html,
+            )
+
+        if self.category == self.CATEGORY_CORPORATION:
+            return get_corporation_logo_url(
+                corporation_id=self.eve_id,
+                size=size,
+                corporation_name=self.name,
+                as_html=as_html,
+            )
+
+        if self.category == self.CATEGORY_CHARACTER:
+            return get_character_portrait_url(
+                character_id=self.eve_id,
+                size=size,
+                character_name=self.name,
+                as_html=as_html,
+            )
+        return ""
+
     def icon_url(self, size=128) -> str:
         """Url to an icon image for this organization."""
         if self.category == self.CATEGORY_ALLIANCE:
@@ -136,9 +170,6 @@ class EveEntity(models.Model):
     def needs_update(self):
         return self.last_update + datetime.timedelta(days=7) < timezone.now()
 
-    class Meta:
-        default_permissions = ()
-
 
 class UpdateSectionResult(NamedTuple):
     """A result of an attempted section update."""
@@ -165,200 +196,12 @@ class _NeedsUpdate:
         return self.section_map.get(section, False)
 
 
-class AuditBase(models.Model):
-    """A base model for audit models."""
+class UpdateStatusBaseModel(models.Model):
+    """A Model to track the status of the last update."""
 
     class Meta:
         abstract = True
-
-    class UpdateStatus(models.TextChoices):
-        DISABLED = "disabled", _("disabled")
-        TOKEN_ERROR = "token_error", _("token error")
-        ERROR = "error", _("error")
-        OK = "ok", _("ok")
-        INCOMPLETE = "incomplete", _("incomplete")
-        IN_PROGRESS = "in_progress", _("in progress")
-
-        def bootstrap_icon(self) -> str:
-            """Return bootstrap corresponding icon class."""
-            update_map = {
-                status: mark_safe(
-                    f"<span class='{self.bootstrap_text_style_class()}' data-tooltip-toggle='ledger-tooltip' title='{self.description()}'>⬤</span>"
-                )
-                for status in [
-                    self.DISABLED,
-                    self.TOKEN_ERROR,
-                    self.ERROR,
-                    self.INCOMPLETE,
-                    self.IN_PROGRESS,
-                    self.OK,
-                ]
-            }
-            return update_map.get(self, "")
-
-        def bootstrap_text_style_class(self) -> str:
-            """Return bootstrap corresponding bootstrap text style class."""
-            update_map = {
-                self.DISABLED: "text-muted",
-                self.TOKEN_ERROR: "text-warning",
-                self.INCOMPLETE: "text-warning",
-                self.IN_PROGRESS: "text-info",
-                self.ERROR: "text-danger",
-                self.OK: "text-success",
-            }
-            return update_map.get(self, "")
-
-        def description(self) -> str:
-            """Return description for an enum object."""
-            update_map = {
-                self.DISABLED: _("Update is disabled"),
-                self.TOKEN_ERROR: _("One section has a token error during update"),
-                self.INCOMPLETE: _("One or more sections have not been updated"),
-                self.IN_PROGRESS: _("Update is in progress"),
-                self.ERROR: _("An error occurred during update"),
-                self.OK: _("Updates completed successfully"),
-            }
-            return update_map.get(self, "")
-
-    def update_section_if_changed(
-        self,
-        section: models.TextChoices,
-        fetch_func: Callable,
-        force_refresh: bool = False,
-    ):
-        """Update the status of a specific section if it has changed."""
-        section = self.UpdateSection(section)
-        try:
-            data = fetch_func(audit=self, force_refresh=force_refresh)
-            logger.debug("%s: Update has changed, section: %s", self, section.label)
-        except HTTPServerError as exc:
-            logger.debug("%s: Update has an HTTP internal server error: %s", self, exc)
-            return UpdateSectionResult(is_changed=False, is_updated=False)
-        except HTTPClientError as exc:
-            error_message = f"{type(exc).__name__}: {str(exc)}"
-            # TODO ADD DISCORD/AUTH NOTIFICATION?
-            logger.error(
-                "%s: %s: Update has Client Error: %s %s",
-                self,
-                section.label,
-                error_message,
-                exc.status_code,
-            )
-            return UpdateSectionResult(
-                is_changed=False,
-                is_updated=False,
-                has_token_error=True,
-                error_message=error_message,
-            )
-        except HTTPNotModified:
-            logger.debug("%s: Update has not changed, section: %s", self, section.label)
-            return UpdateSectionResult(is_changed=False, is_updated=False)
-        except (OSError, ContentTypeError) as exc:
-            logger.info(
-                "%s Update has a %s error, section: %s: %s",
-                self,
-                type(exc).__name__,
-                section.label,
-                exc,
-            )
-            return UpdateSectionResult(is_changed=False, is_updated=False)
-        return UpdateSectionResult(
-            is_changed=True,
-            is_updated=True,
-            data=data,
-        )
-
-    def reset_has_token_error(self) -> None:
-        """Reset the has_token_error flag for this character."""
-        if self.get_status == self.UpdateStatus.TOKEN_ERROR:
-            self.update_status.filter(
-                has_token_error=True,
-            ).update(
-                has_token_error=False,
-            )
-            return True
-        return False
-
-    def reset_update_status(self, section):
-        """Reset the status of a given update section and return it."""
-        update_status_obj = self.update_status.get_or_create(
-            section=section,
-        )[0]
-        update_status_obj.reset()
-        return update_status_obj
-
-    def perform_update_status(
-        self, section, method: Callable, *args, **kwargs
-    ) -> UpdateSectionResult:
-        """Perform update status."""
-        try:
-            result = method(*args, **kwargs)
-        except Exception as exc:
-            error_message = f"{type(exc).__name__}: {str(exc)}"
-            is_token_error = isinstance(exc, (TokenError))
-            logger.error(
-                "%s: %s: Error during update status: %s",
-                self,
-                section.label,
-                error_message,
-                exc_info=not is_token_error,  # do not log token errors
-            )
-
-            # Update the status using the related manager name
-            self.update_status.update_or_create(
-                section=section,
-                defaults={
-                    "is_success": False,
-                    "error_message": error_message,
-                    "has_token_error": is_token_error,
-                    "last_update_at": timezone.now(),
-                },
-            )
-            raise exc
-        return result
-
-    def update_section_log(
-        self,
-        section: models.TextChoices,
-        result: UpdateSectionResult,
-    ) -> None:
-        """Update the status of a specific section."""
-        error_message = result.error_message if result.error_message else ""
-        is_success = not result.has_token_error
-        defaults = {
-            "is_success": is_success,
-            "error_message": error_message,
-            "has_token_error": result.has_token_error,
-            "last_run_finished_at": timezone.now(),
-        }
-        obj: UpdateStatus = self.update_status.update_or_create(
-            section=section,
-            defaults=defaults,
-        )[0]
-        if result.is_updated:
-            obj.last_update_at = obj.last_run_at
-            obj.last_update_finished_at = timezone.now()
-            obj.save()
-        status = "successfully" if is_success else "with errors"
-        logger.info("%s: %s Update run completed %s", self, section.label, status)
-
-    def calc_update_needed(self) -> _NeedsUpdate:
-        """Calculate if an update is needed."""
-        sections_needs_update = {
-            section: True for section in self.UpdateSection.get_sections()
-        }
-        existing_sections: models.QuerySet[UpdateStatus] = self.update_status.all()
-        needs_update = {
-            obj.section: obj.need_update()
-            for obj in existing_sections
-            if obj.section in sections_needs_update
-        }
-        sections_needs_update.update(needs_update)
-        return _NeedsUpdate(section_map=sections_needs_update)
-
-
-class UpdateStatus(models.Model):
-    """A Model to track the status of the last update."""
+        default_permissions = ()
 
     is_success = models.BooleanField(default=None, null=True, db_index=True)
     error_message = models.TextField()
@@ -389,10 +232,6 @@ class UpdateStatus(models.Model):
         help_text="Last update has been successful finished at this time",
     )
 
-    class Meta:
-        abstract = True
-        default_permissions = ()
-
     def need_update(self) -> bool:
         """Check if the update is needed."""
         if not self.is_success or not self.last_update_finished_at:
@@ -424,3 +263,58 @@ class UpdateStatus(models.Model):
         self.last_run_at = timezone.now()
         self.last_run_finished_at = None
         self.save()
+
+
+class WalletJournalEntry(models.Model):
+    amount = models.DecimalField(
+        max_digits=20, decimal_places=2, null=True, default=None
+    )
+    balance = models.DecimalField(
+        max_digits=20, decimal_places=2, null=True, default=None
+    )
+    context_id = models.BigIntegerField(null=True, default=None)
+
+    class ContextType(models.TextChoices):
+        STRUCTURE_ID = "structure_id"
+        STATION_ID = "station_id"
+        MARKET_TRANSACTION_ID = "market_transaction_id"
+        CHARACTER_ID = "character_id"
+        CORPORATION_ID = "corporation_id"
+        ALLIANCE_ID = "alliance_id"
+        EVE_SYSTEM = "eve_system"
+        INDUSTRY_JOB_ID = "industry_job_id"
+        CONTRACT_ID = "contract_id"
+        PLANET_ID = "planet_id"
+        SYSTEM_ID = "system_id"
+        TYPE_ID = "type_id"
+
+    context_id_type = models.CharField(
+        max_length=30, choices=ContextType.choices, null=True, default=None
+    )
+    date = models.DateTimeField()
+    description = models.CharField(max_length=500)
+    first_party = models.ForeignKey(
+        EveEntity,
+        on_delete=models.SET_DEFAULT,
+        default=None,
+        null=True,
+        blank=True,
+        related_name="+",
+    )
+    entry_id = models.BigIntegerField()
+    reason = models.CharField(max_length=500, null=True, default=None)
+    ref_type = models.CharField(max_length=72)
+    second_party = models.ForeignKey(
+        EveEntity,
+        on_delete=models.SET_DEFAULT,
+        default=None,
+        null=True,
+        blank=True,
+        related_name="+",
+    )
+    tax = models.DecimalField(max_digits=20, decimal_places=2, null=True, default=None)
+    tax_receiver_id = models.IntegerField(null=True, default=None)
+
+    class Meta:
+        abstract = True
+        default_permissions = ()

ledger/models/helpers/update_manager.py

@@ -0,0 +1,302 @@
+# Standard Library
+from typing import TYPE_CHECKING, Union
+
+# Django
+from django.db import models
+from django.utils import timezone
+from django.utils.safestring import mark_safe
+from django.utils.translation import gettext_lazy as _
+
+# Alliance Auth
+from allianceauth.services.hooks import get_extension_logger
+from esi.exceptions import HTTPClientError, HTTPNotModified, HTTPServerError
+
+# AA Ledger
+from ledger import __title__
+from ledger.models.general import (
+    UpdateSectionResult,
+    _NeedsUpdate,
+)
+
+if TYPE_CHECKING:
+    # AA Ledger
+    from ledger.models.characteraudit import CharacterOwner, CharacterUpdateStatus
+    from ledger.models.corporationaudit import CorporationOwner, CorporationUpdateStatus
+
+# AA Ledger
+from ledger.providers import AppLogger
+
+logger = AppLogger(get_extension_logger(__name__), __title__)
+
+
+class UpdateStatus(models.TextChoices):
+    DISABLED = "disabled", _("Disabled")
+    TOKEN_ERROR = "token_error", _("Token Error")
+    ERROR = "error", _("Error")
+    OK = "ok", _("OK")
+    INCOMPLETE = "incomplete", _("Incomplete")
+    IN_PROGRESS = "in_progress", _("In Progress")
+
+    def bootstrap_icon(self) -> str:
+        """Return bootstrap corresponding icon class."""
+        update_map = {
+            status: mark_safe(
+                f"<span class='{self.bootstrap_text_style_class()}' data-tooltip-toggle='ledger-tooltip' title='{self.description()}'>⬤</span>"
+            )
+            for status in [
+                self.DISABLED,
+                self.TOKEN_ERROR,
+                self.ERROR,
+                self.INCOMPLETE,
+                self.IN_PROGRESS,
+                self.OK,
+            ]
+        }
+        return update_map.get(self, "")
+
+    def bootstrap_text_style_class(self) -> str:
+        """Return bootstrap corresponding bootstrap text style class."""
+        update_map = {
+            self.DISABLED: "text-muted",
+            self.TOKEN_ERROR: "text-warning",
+            self.INCOMPLETE: "text-warning",
+            self.IN_PROGRESS: "text-info",
+            self.ERROR: "text-danger",
+            self.OK: "text-success",
+        }
+        return update_map.get(self, "")
+
+    def description(self) -> str:
+        """Return description for an enum object."""
+        update_map = {
+            self.DISABLED: _("Update is disabled"),
+            self.TOKEN_ERROR: _("One section has a token error during update"),
+            self.INCOMPLETE: _("One or more sections have not been updated"),
+            self.IN_PROGRESS: _("Update is in progress"),
+            self.ERROR: _("An error occurred during update"),
+            self.OK: _("Updates completed successfully"),
+        }
+        return update_map.get(self, "")
+
+
+class CharacterUpdateSection(models.TextChoices):
+    WALLET_JOURNAL = "wallet_journal", _("Wallet Journal")
+    MINING_LEDGER = "mining_ledger", _("Mining Ledger")
+    PLANETS = "planets", _("Planets")
+    PLANETS_DETAILS = "planets_details", _("Planets Details")
+
+    @classmethod
+    def get_sections(cls) -> list[str]:
+        """Return list of section values."""
+        return [choice.value for choice in cls]
+
+    @property
+    def method_name(self) -> str:
+        """Return method name for this section."""
+        return f"update_{self.value}"
+
+
+class CorporationUpdateSection(models.TextChoices):
+    WALLET_DIVISION_NAMES = "wallet_division_names", _("Divisions Names")
+    WALLET_DIVISION = "wallet_division", _("Divisions")
+    WALLET_JOURNAL = "wallet_journal", _("Wallet Journal")
+
+    @classmethod
+    def get_sections(cls) -> list[str]:
+        """Return list of section values."""
+        return [choice.value for choice in cls]
+
+    @property
+    def method_name(self) -> str:
+        """Return method name for this section."""
+        return f"update_{self.value}"
+
+
+class UpdateManager:
+    """Manager class to handle update operations for CharacterOwner and CorporationOwner.
+    This class provides methods to manage and track update statuses for both character and corporation owners.
+
+    Args:
+        owner (CorporationOwner | CharacterOwner): The owner model (corporation or character)
+        update_section (CorporationUpdateSection | CharacterUpdateSection): The update section class (CorporationUpdateSection or CharacterUpdateSection)
+        update_status (CorporationUpdateStatus | CharacterUpdateStatus): The update status class (CorporationUpdateStatus or CharacterUpdateStatus)
+    """
+
+    def __init__(
+        self,
+        owner: Union["CorporationOwner", "CharacterOwner"],
+        update_section: CorporationUpdateSection | CharacterUpdateSection,
+        update_status: Union["CorporationUpdateStatus", "CharacterUpdateStatus"],
+    ):
+        self.owner = owner
+        self.update_section = update_section
+        self.update_status = update_status
+
+    # Shared methods
+    def calc_update_needed(self) -> _NeedsUpdate:
+        """
+        Calculate which sections need an update and save the results in a _NeedsUpdate object.
+
+        Returns:
+            _NeedsUpdate: An object containing a mapping of sections to their update needs.
+        """
+        sections_needs_update = {
+            section: True for section in self.update_section.get_sections()
+        }
+        existing_sections = self.update_status.objects.filter(owner=self.owner)
+        needs_update = {
+            obj.section: obj.need_update()
+            for obj in existing_sections
+            if obj.section in sections_needs_update
+        }
+        sections_needs_update.update(needs_update)
+        return _NeedsUpdate(section_map=sections_needs_update)
+
+    def reset_update_status(self, section: models.TextChoices):
+        """
+        Create or Reset the update status for a specific section.
+
+        Args:
+            section (models.TextChoices): The section to reset.
+        Returns:
+            UpdateStatus (Object): The reset update status object for the Owner Model.
+        """
+        update_status_obj = self.update_status.objects.get_or_create(
+            owner=self.owner,
+            section=section,
+        )[0]
+        update_status_obj.reset()
+        return update_status_obj
+
+    def reset_has_token_error(self) -> None:
+        """
+        Reset has_token_error for all sections.
+
+        Returns:
+            None
+        """
+        self.update_status.objects.filter(
+            has_token_error=True,
+        ).update(
+            has_token_error=False,
+        )
+
+    def update_section_if_changed(
+        self, section: models.TextChoices, fetch_func, force_refresh: bool = False
+    ):
+        """
+        Handle updating a specific section if there are changes.
+
+        Args:
+            section (models.TextChoices): The section to update.
+            fetch_func (Callable): The function to fetch the data for the section.
+            force_refresh (bool): Whether to force a refresh of the data.
+        Returns:
+            UpdateSectionResult: The result of the update operation.
+        Raises:
+            HTTPClientError: If there is a client error during the fetch.
+            HTTPServerError: If there is a server error during the fetch.
+            HTTPNotModified: If the data has not been modified.
+        """
+        section = self.update_section(section)
+        try:
+            data = fetch_func(owner=self.owner, force_refresh=force_refresh)
+            logger.debug(
+                "%s: Update has changed, section: %s", self.owner, section.label
+            )
+        except HTTPNotModified:
+            logger.debug(
+                "%s: Update has not changed, section: %s", self.owner, section.label
+            )
+            return UpdateSectionResult(is_changed=False, is_updated=False)
+        except HTTPClientError as exc:
+            error_message = f"{type(exc).__name__}: {str(exc)}"
+            logger.error(
+                "%s: %s: Update has Client Error: %s %s",
+                self.owner,
+                section.label,
+                error_message,
+                exc.status_code,
+            )
+            return UpdateSectionResult(
+                is_changed=False,
+                is_updated=False,
+                has_token_error=True,
+                error_message=error_message,
+            )
+        return UpdateSectionResult(
+            is_changed=True,
+            is_updated=True,
+            data=data,
+        )
+
+    def update_section_log(
+        self, section: models.TextChoices, result: UpdateSectionResult
+    ) -> None:
+        """
+        Update the status of a specific section.
+        Args:
+            section (models.TextChoices): The section to update.
+            result (UpdateSectionResult): The result of the update operation.
+        Returns:
+            None
+        """
+        error_message = result.error_message if result.error_message else ""
+        is_success = not result.has_token_error
+        defaults = {
+            "is_success": is_success,
+            "error_message": error_message,
+            "has_token_error": result.has_token_error,
+            "last_run_finished_at": timezone.now(),
+        }
+        obj = self.update_status.objects.update_or_create(
+            owner=self.owner,
+            section=section,
+            defaults=defaults,
+        )[0]
+        if result.is_updated:
+            obj.last_update_at = obj.last_run_at
+            obj.last_update_finished_at = timezone.now()
+            obj.save()
+        status = "successfully" if is_success else "with errors"
+        logger.info("%s: %s Update run completed %s", self.owner, section.label, status)
+
+    def perform_update_status(
+        self, section: models.TextChoices, method, *args, **kwargs
+    ):
+        """
+        Perform update status.
+        Args:
+            section (models.TextChoices): The section to update.
+            method (Callable): The method to perform the update.
+            *args: Positional arguments for the method.
+            **kwargs: Keyword arguments for the method.
+        Returns:
+            Any: The result of the method call.
+        Raises:
+            Exception: Reraises any exception encountered during the method call.
+        """
+        try:
+            result = method(*args, **kwargs)
+        except HTTPServerError as exc:
+            raise exc
+        except Exception as exc:
+            error_message = f"{type(exc).__name__}: {str(exc)}"
+            logger.error(
+                "%s: %s: Error during update status: %s",
+                self.owner,
+                section.label,
+                error_message,
+            )
+            self.update_status.objects.update_or_create(
+                owner=self.owner,
+                section=section,
+                defaults={
+                    "is_success": False,
+                    "error_message": error_message,
+                    "has_token_error": False,
+                    "last_update_at": timezone.now(),
+                },
+            )
+            raise exc
+        return result