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

ledger/managers/character_journal_manager.py

@@ -1,4 +1,5 @@
 # Standard Library
+from decimal import Decimal
 from typing import TYPE_CHECKING
 
 # Django
@@ -10,15 +11,13 @@ from django.db.models.functions import Coalesce
 from allianceauth.services.hooks import get_extension_logger
 from esi.errors import TokenError
 
-# Alliance Auth (External Libs)
-from app_utils.logging import LoggerAddTag
-
 # AA Ledger
 from ledger import __title__
 from ledger.app_settings import LEDGER_BULK_BATCH_SIZE
 from ledger.decorators import log_timing
 from ledger.helpers.ref_type import RefTypeManager
-from ledger.providers import esi
+from ledger.models.helpers.update_manager import CharacterUpdateSection
+from ledger.providers import AppLogger, esi
 
 if TYPE_CHECKING:
     # Alliance Auth
@@ -26,12 +25,15 @@ if TYPE_CHECKING:
 
     # AA Ledger
     from ledger.models.characteraudit import (
-        CharacterAudit,
+        CharacterOwner,
+    )
+    from ledger.models.characteraudit import (
+        CharacterWalletJournalEntry as CharacterWalletJournalEntryContext,
     )
     from ledger.models.general import UpdateSectionResult
 
 
-logger = LoggerAddTag(get_extension_logger(__name__), __title__)
+logger = AppLogger(get_extension_logger(__name__), __title__)
 
 
 class CharWalletIncomeFilter(models.QuerySet):
@@ -60,308 +62,244 @@ class CharWalletIncomeFilter(models.QuerySet):
             )
         )
 
-    def annotate_mission_income(self) -> models.QuerySet:
-        return self.annotate(
-            mission_income=Coalesce(
-                Sum(
-                    "amount",
-                    filter=Q(ref_type__in=RefTypeManager.MISSION_REWARD, amount__gt=0),
-                ),
-                Value(0),
-                output_field=DecimalField(),
-            )
-        )
 
-    def annotate_incursion_income(self) -> models.QuerySet:
+class CharWalletOutSideFilter(CharWalletIncomeFilter):
+    def annotate_miscellaneous(self) -> models.QuerySet:
         return self.annotate(
-            incursion_income=Coalesce(
+            miscellaneous=Coalesce(
                 Sum(
                     "amount",
-                    filter=Q(ref_type__in=RefTypeManager.INCURSION, amount__gt=0),
+                    filter=Q(
+                        ref_type__in=RefTypeManager.ledger_ref_types(), amount__gt=0
+                    ),
                 ),
                 Value(0),
                 output_field=DecimalField(),
             )
         )
 
-    # Trading - Income
-    def annotate_market_income(self) -> models.QuerySet:
+    def annotate_costs(self) -> models.QuerySet:
         return self.annotate(
-            market_income=Coalesce(
+            costs=Coalesce(
                 Sum(
                     "amount",
-                    filter=Q(ref_type__in=RefTypeManager.MARKET, amount__gt=0),
+                    filter=Q(
+                        ref_type__in=RefTypeManager.ledger_ref_types(), amount__lt=0
+                    ),
                 ),
                 Value(0),
                 output_field=DecimalField(),
             )
         )
 
-    def annotate_contract_income(self) -> models.QuerySet:
-        contract_types = list(RefTypeManager.CONTRACT) + list(
-            RefTypeManager.CORPORATION_CONTRACT
-        )
-        return self.annotate(
-            contract_income=Coalesce(
-                Sum(
-                    "amount",
-                    filter=Q(ref_type__in=contract_types, amount__gt=0),
-                ),
-                Value(0),
-                output_field=DecimalField(),
-            )
-        )
 
-    def annotate_donation_income(self, exclude: list = None) -> models.QuerySet:
-        if exclude is None:
-            exclude = []
+class CharWalletCostQueryFilter(CharWalletOutSideFilter):
+    pass
 
-        return self.annotate(
-            donation_income=Coalesce(
-                Sum(
-                    "amount",
-                    filter=Q(ref_type__in=RefTypeManager.DONATION, amount__gt=0)
-                    & ~Q(first_party_id__in=exclude),
-                ),
-                Value(0),
-                output_field=DecimalField(),
-            )
-        )
 
-    def annotate_insurance_income(self) -> models.QuerySet:
-        return self.annotate(
-            insurance_income=Coalesce(
-                Sum(
-                    "amount",
-                    filter=Q(ref_type__in=RefTypeManager.INSURANCE, amount__gt=0),
-                ),
-                Value(0),
-                output_field=DecimalField(),
-            )
+# pylint: disable=used-before-assignment
+class CharWalletQuerySet(CharWalletCostQueryFilter):
+    def aggregate_bounty(self) -> dict:
+        """Aggregate bounty income."""
+        return Decimal(
+            self.filter(ref_type__in=RefTypeManager.BOUNTY_PRIZES).aggregate(
+                total_bounty=Coalesce(
+                    Sum("amount"), Value(0), output_field=DecimalField()
+                )
+            )["total_bounty"]
         )
 
-    def annotate_milestone_income(self) -> models.QuerySet:
-        return self.annotate(
-            milestone_income=Coalesce(
-                Sum(
-                    "amount",
-                    filter=Q(
-                        ref_type__in=RefTypeManager.MILESTONE_REWARD, amount__gt=0
-                    ),
-                ),
-                Value(0),
-                output_field=DecimalField(),
-            )
+    def aggregate_ess(self) -> dict:
+        """Aggregate ESS income."""
+        return Decimal(
+            self.filter(ref_type__in=RefTypeManager.ESS_TRANSFER).aggregate(
+                total_ess=Coalesce(Sum("amount"), Value(0), output_field=DecimalField())
+            )["total_ess"]
         )
 
-    def annotate_daily_goal_income(self) -> models.QuerySet:
-        """Annotate daily goal income."""
-        return self.annotate(
-            daily_goal_income=Coalesce(
-                Sum(
-                    "amount",
-                    filter=Q(
-                        ref_type__in=RefTypeManager.DAILY_GOAL_REWARD, amount__gt=0
-                    ),
-                ),
-                Value(0),
-                output_field=DecimalField(),
-            )
-        )
+    def aggregate_costs(self, first_party=None, second_party=None) -> dict:
+        """
+        Aggregate costs.
+
+        Args:
+            first_party (int | list[int], optional): Filter by first party ID(s).
+            second_party (int | list[int], optional): Filter by second party ID(s).
+        Returns:
+            dict: Aggregated total costs.
+        """
+        qs = self
+        cost_types = RefTypeManager.ledger_ref_types()
 
+        if first_party is not None:
+            if isinstance(first_party, int):
+                first_party = [first_party]
+            qs = qs.filter(first_party__in=first_party)
 
-class CharWalletOutSideFilter(CharWalletIncomeFilter):
-    def annotate_miscellaneous(self) -> models.QuerySet:
-        return self.annotate(
-            miscellaneous=Coalesce(
-                Sum(
-                    "amount",
-                    filter=Q(ref_type__in=RefTypeManager.all_ref_types(), amount__gt=0),
-                ),
-                Value(0),
-                output_field=DecimalField(),
-            )
-        )
+        if second_party is not None:
+            if isinstance(second_party, int):
+                second_party = [second_party]
+            qs = qs.filter(Q(ref_type__in=cost_types))
+        else:
+            qs = qs.filter(Q(ref_type__in=cost_types))
 
-    def annotate_miscellaneous_exclude_donations(self, exclude=None) -> models.QuerySet:
-        """Allow excluding donations by first_party_id from the miscellaneous sum."""
-        # Normalize single int to list for compatibility with Q lookups
-        if isinstance(exclude, int):
-            exclude = [exclude]
+        qs = qs.filter(amount__lt=0)
+        return Decimal(
+            qs.aggregate(
+                total_costs=Coalesce(
+                    Sum("amount"), Value(0), output_field=DecimalField()
+                )
+            )["total_costs"]
+        )
 
-        # Ensure we have a mutable list (remove may not exist on other iterables)
-        all_types = RefTypeManager.all_ref_types()
-        donation_types = RefTypeManager.DONATION
+    def aggregate_miscellaneous(self, first_party=None, second_party=None) -> dict:
+        """
+        Aggregate miscellaneous income.
+
+        Args:
+            first_party (int | list[int], optional): Filter by first party ID(s).
+            second_party (int | list[int], optional): Filter by second party ID(s).
+        Returns:
+            dict: Aggregated total miscellaneous income.
+        """
+        qs = self
 
-        if exclude is not None:
-            try:
-                all_types.remove("player_donation")
-            except ValueError:
-                pass
+        misc_types = RefTypeManager.ledger_ref_types()
 
-        # Base filter: all reference types and only positive amounts (income)
-        filter_q = Q(ref_type__in=all_types, amount__gt=0)
+        if first_party is not None:
+            if isinstance(first_party, int):
+                first_party = [first_party]
+            qs = qs.filter(Q(ref_type__in=misc_types))
+        else:
+            qs = qs.filter(Q(ref_type__in=misc_types))
 
-        if exclude:
-            filter_q = filter_q & ~(
-                Q(ref_type__in=donation_types) & Q(first_party_id__in=exclude)
-            )
+        if second_party is not None:
+            if isinstance(second_party, int):
+                second_party = [second_party]
+            qs = qs.filter(second_party__in=second_party)
 
-        return self.annotate(
-            miscellaneous=Coalesce(
-                Sum(
-                    "amount",
-                    filter=filter_q,
-                ),
-                Value(0),
-                output_field=DecimalField(),
-            )
+        qs = qs.filter(amount__gt=0)
+        return Decimal(
+            qs.aggregate(
+                total_misc=Coalesce(
+                    Sum("amount"), Value(0), output_field=DecimalField()
+                )
+            )["total_misc"]
         )
 
-    def annotate_costs(self) -> models.QuerySet:
-        return self.annotate(
-            costs=Coalesce(
-                Sum(
-                    "amount",
-                    filter=Q(ref_type__in=RefTypeManager.all_ref_types(), amount__lt=0),
-                ),
-                Value(0),
-                output_field=DecimalField(),
-            )
-        )
+    def aggregate_ref_type(
+        self,
+        ref_type: list,
+        first_party=None,
+        second_party=None,
+        income: bool = False,
+    ) -> dict:
+        """Aggregate income by ref_type."""
+        qs = self.filter(ref_type__in=ref_type)
 
+        if first_party is not None:
+            if isinstance(first_party, int):
+                first_party = [first_party]
+            qs = qs.filter(first_party__in=first_party)
 
-class CharWalletCostQueryFilter(CharWalletOutSideFilter):
-    # Costs
-    def annotate_contract_cost(self) -> models.QuerySet:
-        return self.annotate(
-            contract_cost=Coalesce(
-                Sum(
-                    "amount",
-                    filter=Q(ref_type__in=RefTypeManager.CONTRACT, amount__lt=0),
-                ),
-                Value(0),
-                output_field=DecimalField(),
-            )
-        )
+        if second_party is not None:
+            if isinstance(second_party, int):
+                second_party = [second_party]
+            qs = qs.filter(second_party__in=second_party)
 
-    def annotate_market_cost(self) -> models.QuerySet:
-        return self.annotate(
-            market_cost=Coalesce(
-                Sum(
-                    "amount",
-                    filter=Q(ref_type__in=RefTypeManager.MARKET, amount__lt=0),
-                ),
-                Value(0),
-                output_field=DecimalField(),
-            )
-        )
+        if income:
+            qs = qs.filter(amount__gt=0)
+        else:
+            qs = qs.filter(amount__lt=0)
 
-    def annotate_asset_cost(self) -> models.QuerySet:
-        return self.annotate(
-            asset_cost=Coalesce(
-                Sum(
-                    "amount",
-                    filter=Q(ref_type__in=RefTypeManager.ASSETS, amount__lt=0),
-                ),
-                Value(0),
-                output_field=DecimalField(),
-            )
+        return Decimal(
+            qs.aggregate(
+                total=Coalesce(Sum("amount"), Value(0), output_field=DecimalField())
+            )["total"]
         )
 
-    def annotate_traveling_cost(self) -> models.QuerySet:
-        return self.annotate(
-            traveling_cost=Coalesce(
-                Sum(
-                    "amount",
-                    filter=Q(ref_type__in=RefTypeManager.TRAVELING, amount__lt=0),
-                ),
-                Value(0),
-                output_field=DecimalField(),
-            )
-        )
 
-    def annotate_production_cost(self) -> models.QuerySet:
-        return self.annotate(
-            production_cost=Coalesce(
-                Sum(
-                    "amount",
-                    filter=Q(ref_type__in=RefTypeManager.PRODUCTION, amount__lt=0),
-                ),
-                Value(0),
-                output_field=DecimalField(),
-            )
-        )
+class CharWalletManager(models.Manager["CharacterWalletJournalEntryContext"]):
+    def get_queryset(self) -> CharWalletQuerySet:
+        return CharWalletQuerySet(self.model, using=self._db)
 
-    def annotate_skill_cost(self) -> models.QuerySet:
-        return self.annotate(
-            skill_cost=Coalesce(
-                Sum(
-                    "amount",
-                    filter=Q(ref_type__in=RefTypeManager.SKILL, amount__lt=0),
-                ),
-                Value(0),
-                output_field=DecimalField(),
-            )
-        )
+    # pylint: disable=duplicate-code
+    def annotate_bounty_income(self) -> models.QuerySet:
+        """Annotate bounty income."""
+        return self.get_queryset().annotate_bounty_income()
 
-    def annotate_insurance_cost(self) -> models.QuerySet:
-        return self.annotate(
-            insurance_cost=Coalesce(
-                Sum(
-                    "amount",
-                    filter=Q(ref_type__in=RefTypeManager.INSURANCE, amount__lt=0),
-                ),
-                Value(0),
-                output_field=DecimalField(),
-            )
-        )
+    # pylint: disable=duplicate-code
+    def annotate_ess_income(self) -> models.QuerySet:
+        """Annotate ess income."""
+        return self.get_queryset().annotate_ess_income()
 
-    def annotate_planetary_cost(self) -> models.QuerySet:
-        return self.annotate(
-            planetary_cost=Coalesce(
-                Sum(
-                    "amount",
-                    filter=Q(ref_type__in=RefTypeManager.PLANETARY, amount__lt=0),
-                ),
-                Value(0),
-                output_field=DecimalField(),
-            )
+    # pylint: disable=duplicate-code
+    def annotate_miscellaneous(self) -> models.QuerySet:
+        """Annotate miscellaneous income."""
+        return self.get_queryset().annotate_miscellaneous()
+
+    # pylint: disable=duplicate-code
+    def annotate_costs(self) -> models.QuerySet:
+        """Annotate costs."""
+        return self.get_queryset().annotate_costs()
+
+    # pylint: disable=duplicate-code
+    def aggregate_bounty(self) -> dict:
+        """Aggregate bounty income."""
+        return self.get_queryset().aggregate_bounty()
+
+    # pylint: disable=duplicate-code
+    def aggregate_ess(self) -> dict:
+        """Aggregate ess income."""
+        return self.get_queryset().aggregate_ess()
+
+    # pylint: disable=duplicate-code
+    def aggregate_costs(self, first_party=None, second_party=None) -> dict:
+        """Aggregate costs."""
+        return self.get_queryset().aggregate_costs(
+            first_party=first_party, second_party=second_party
         )
 
-    def annotate_lp_cost(self) -> models.QuerySet:
-        return self.annotate(
-            lp_cost=Coalesce(
-                Sum(
-                    "amount",
-                    filter=Q(ref_type__in=RefTypeManager.LP, amount__lt=0),
-                ),
-                Value(0),
-                output_field=DecimalField(),
-            )
+    # pylint: disable=duplicate-code
+    def aggregate_miscellaneous(self, first_party=None, second_party=None) -> dict:
+        """Aggregate miscellaneous income."""
+        return self.get_queryset().aggregate_miscellaneous(
+            first_party=first_party, second_party=second_party
         )
 
+    # pylint: disable=duplicate-code
+    def aggregate_ref_type(
+        self,
+        ref_type: list,
+        first_party=None,
+        second_party=None,
+        income: bool = False,
+    ) -> dict:
+        """Aggregate income by ref_type."""
+        return self.get_queryset().aggregate_ref_type(
+            ref_type=ref_type,
+            first_party=first_party,
+            second_party=second_party,
+            income=income,
+        )
 
-# pylint: disable=used-before-assignment
-class CharWalletQuerySet(CharWalletCostQueryFilter):
     @log_timing(logger)
     def update_or_create_esi(
-        self, character: "CharacterAudit", force_refresh: bool = False
+        self, owner: "CharacterOwner", force_refresh: bool = False
     ) -> "UpdateSectionResult":
         """Update or Create a wallet journal entry from ESI data."""
-        return character.update_section_if_changed(
-            section=character.UpdateSection.WALLET_JOURNAL,
+        return owner.update_manager.update_section_if_changed(
+            section=CharacterUpdateSection.WALLET_JOURNAL,
             fetch_func=self._fetch_esi_data,
             force_refresh=force_refresh,
         )
 
-    def _fetch_esi_data(self, audit: "CharacterAudit", force_refresh: bool) -> None:
+    def _fetch_esi_data(self, owner: "CharacterOwner", force_refresh: bool) -> None:
         """Fetch wallet journal entries from ESI data."""
         req_scopes = ["esi-wallet.read_character_wallet.v1"]
-        token = audit.get_token(scopes=req_scopes)
+        token = owner.get_token(scopes=req_scopes)
 
         operation = esi.client.Wallet.GetCharactersCharacterIdWalletJournal(
-            character_id=audit.eve_character.character_id,
+            character_id=owner.eve_character.character_id,
             token=token,
         )
 
@@ -369,12 +307,12 @@ class CharWalletQuerySet(CharWalletCostQueryFilter):
             force_refresh=force_refresh,
         )
 
-        self._update_or_create_objs(character=audit, objs=journal_items)
+        self._update_or_create_objs(character=owner, objs=journal_items)
 
     @transaction.atomic()
     def _update_or_create_objs(
         self,
-        character: "CharacterAudit",
+        character: "CharacterOwner",
         objs: list["CharactersCharacterIdWalletJournalGetItem"],
     ) -> None:
         """Update or Create wallet journal entries from objs data."""
@@ -425,113 +363,3 @@ class CharWalletQuerySet(CharWalletCostQueryFilter):
             self.bulk_create(items, batch_size=LEDGER_BULK_BATCH_SIZE)
         else:
             raise TokenError("ESI Fail")
-
-    def aggregate_bounty(self) -> dict:
-        """Aggregate bounty income."""
-        return self.filter(ref_type__in=RefTypeManager.BOUNTY_PRIZES).aggregate(
-            total_bounty=Coalesce(Sum("amount"), Value(0), output_field=DecimalField())
-        )["total_bounty"]
-
-    def aggregate_ess(self) -> dict:
-        """Aggregate ESS income."""
-        return self.filter(ref_type__in=RefTypeManager.ESS_TRANSFER).aggregate(
-            total_ess=Coalesce(Sum("amount"), Value(0), output_field=DecimalField())
-        )["total_ess"]
-
-    def aggregate_costs(self, first_party=None, second_party=None) -> dict:
-        """Aggregate costs. first_party wird für donation exkludiert."""
-        qs = self
-        cost_types = RefTypeManager.all_ref_types()
-        donation_types = RefTypeManager.DONATION
-
-        if first_party is not None:
-            if isinstance(first_party, int):
-                first_party = [first_party]
-            qs = qs.filter(first_party__in=first_party)
-
-        if second_party is not None:
-            if isinstance(second_party, int):
-                second_party = [second_party]
-            # Exclude: alle donation mit first_party_id in Liste, Rest wie gehabt
-            qs = qs.exclude(
-                Q(ref_type__in=donation_types, first_party_id__in=second_party)
-            )
-            qs = qs.filter(Q(ref_type__in=cost_types))
-        else:
-            qs = qs.filter(Q(ref_type__in=cost_types))
-
-        qs = qs.filter(amount__lt=0)
-        return qs.aggregate(
-            total_costs=Coalesce(Sum("amount"), Value(0), output_field=DecimalField())
-        )["total_costs"]
-
-    def aggregate_miscellaneous(self, first_party=None, second_party=None) -> dict:
-        """Aggregate miscellaneous income. first_party wird nur für donation angewandt."""
-        qs = self
-
-        misc_types = RefTypeManager.all_ref_types()
-        donation_types = RefTypeManager.DONATION
-
-        if first_party is not None:
-            if isinstance(first_party, int):
-                first_party = [first_party]
-            # Exclude: alle donation mit first_party_id in Liste, Rest wie gehabt
-            qs = qs.exclude(
-                Q(ref_type__in=donation_types, first_party_id__in=first_party)
-            )
-            qs = qs.filter(Q(ref_type__in=misc_types))
-        else:
-            qs = qs.filter(Q(ref_type__in=misc_types))
-
-        if second_party is not None:
-            if isinstance(second_party, int):
-                second_party = [second_party]
-            qs = qs.filter(second_party__in=second_party)
-
-        qs = qs.filter(amount__gt=0)
-        return qs.aggregate(
-            total_misc=Coalesce(Sum("amount"), Value(0), output_field=DecimalField())
-        )["total_misc"]
-
-    # pylint: disable=too-many-positional-arguments
-    def aggregate_ref_type(
-        self,
-        ref_type: list,
-        first_party=None,
-        second_party=None,
-        exclude=None,
-        income: bool = False,
-    ) -> dict:
-        """Aggregate income by ref_type."""
-        qs = self.filter(ref_type__in=ref_type)
-
-        if first_party is not None:
-            if isinstance(first_party, int):
-                first_party = [first_party]
-            qs = qs.filter(first_party__in=first_party)
-
-        if second_party is not None:
-            if isinstance(second_party, int):
-                second_party = [second_party]
-            qs = qs.filter(second_party__in=second_party)
-
-        if exclude is not None:
-            if isinstance(exclude, int):
-                exclude = [exclude]
-            qs = qs.exclude(first_party__in=exclude)
-
-        if income:
-            qs = qs.filter(amount__gt=0)
-        else:
-            qs = qs.filter(amount__lt=0)
-
-        return qs.aggregate(
-            total=Coalesce(Sum("amount"), Value(0), output_field=DecimalField())
-        )["total"]
-
-
-class CharWalletManagerBase(models.Manager):
-    pass
-
-
-CharWalletManager = CharWalletManagerBase.from_queryset(CharWalletQuerySet)