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

ledger/managers/character_mining_manager.py

@@ -19,14 +19,14 @@ from django.utils import timezone
 from allianceauth.services.hooks import get_extension_logger
 
 # Alliance Auth (External Libs)
-from app_utils.logging import LoggerAddTag
 from eveuniverse.models import EveSolarSystem, EveType
 
 # AA Ledger
 from ledger import __title__
-from ledger.app_settings import LEDGER_PRICE_PERCENTAGE
+from ledger.app_settings import LEDGER_BULK_BATCH_SIZE, LEDGER_PRICE_PERCENTAGE
 from ledger.decorators import log_timing
-from ledger.providers import esi
+from ledger.models.helpers.update_manager import CharacterUpdateSection
+from ledger.providers import AppLogger, esi
 
 if TYPE_CHECKING:
     # Alliance Auth
@@ -34,11 +34,14 @@ if TYPE_CHECKING:
 
     # AA Ledger
     from ledger.models.characteraudit import (
-        CharacterAudit,
+        CharacterMiningLedger as MiningLedgerContext,
+    )
+    from ledger.models.characteraudit import (
+        CharacterOwner,
     )
     from ledger.models.general import UpdateSectionResult
 
-logger = LoggerAddTag(get_extension_logger(__name__), __title__)
+logger = AppLogger(get_extension_logger(__name__), __title__)
 
 
 def require_valid_price_percentage(func):
@@ -52,7 +55,7 @@ def require_valid_price_percentage(func):
     return wrapper
 
 
-class CharacterMiningLedgerEntryQueryset(models.QuerySet):
+class CharacterMiningLedgerEntryQueryset(models.QuerySet["MiningLedgerContext"]):
     @require_valid_price_percentage
     def annotate_pricing(self) -> models.QuerySet:
         """Annotate price and total columns."""
@@ -143,46 +146,74 @@ class CharacterMiningLedgerEntryQueryset(models.QuerySet):
         )
 
 
-class CharacterMiningLedgerEntryManagerBase(models.Manager):
+class CharacterMiningLedgerEntryManager(models.Manager["MiningLedgerContext"]):
+    def get_queryset(self) -> CharacterMiningLedgerEntryQueryset:
+        return CharacterMiningLedgerEntryQueryset(self.model, using=self._db)
+
+    @require_valid_price_percentage
+    def annotate_pricing(self) -> models.QuerySet:
+        """Annotate price and total columns."""
+        return self.get_queryset().annotate_pricing()
+
+    def annotate_mining(self, with_period: bool = False) -> models.QuerySet:
+        """Annotate mining columns."""
+        return self.get_queryset().annotate_mining(with_period=with_period)
+
+    def aggregate_mining(self):
+        """Aggregate mining amounts."""
+        return self.get_queryset().aggregate_mining()
+
+    def aggregate_amounts_information_modal(
+        self, amounts: defaultdict, chars_list: list, filter_date: timezone.datetime
+    ) -> dict:
+        """Generate data template for the ledger character information view."""
+        return self.get_queryset().aggregate_amounts_information_modal(
+            amounts, chars_list, filter_date
+        )
+
+    def annotate_billboard(self, chars_list: list) -> models.QuerySet:
+        """Annotate billboard columns."""
+        return self.get_queryset().annotate_billboard(chars_list)
+
     @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 mining ledger entry from ESI data."""
-        return character.update_section_if_changed(
-            section=character.UpdateSection.MINING_LEDGER,
+        return owner.update_manager.update_section_if_changed(
+            section=CharacterUpdateSection.MINING_LEDGER,
             fetch_func=self._fetch_esi_data,
             force_refresh=force_refresh,
         )
 
     def _fetch_esi_data(
-        self, audit: "CharacterAudit", force_refresh: bool = False
+        self, owner: "CharacterOwner", force_refresh: bool = False
     ) -> None:
         """Fetch mining ledger entries from ESI data."""
         req_scopes = ["esi-industry.read_character_mining.v1"]
-        token = audit.get_token(scopes=req_scopes)
+        token = owner.get_token(scopes=req_scopes)
 
         # Make the ESI request
         operation = esi.client.Industry.GetCharactersCharacterIdMining(
-            character_id=audit.eve_character.character_id,
+            character_id=owner.eve_character.character_id,
             token=token,
         )
 
         mining_items = operation.results(force_refresh=force_refresh)
 
         # Process and update or create mining ledger entries
-        self._update_or_create_objs(audit, mining_items)
+        self._update_or_create_objs(owner=owner, objs=mining_items)
 
     @transaction.atomic()
     def _update_or_create_objs(
         self,
-        character: "CharacterAudit",
+        owner: "CharacterOwner",
         objs: list["CharactersCharacterIdMiningGetItem"],
     ) -> None:
         """Update or Create mining ledger entries from objs data."""
         existings_pks = set(
             self.filter(
-                character=character,
+                character=owner,
                 date__gte=timezone.now() - timezone.timedelta(days=30),
             ).values_list("id", flat=True)
         )
@@ -194,9 +225,9 @@ class CharacterMiningLedgerEntryManagerBase(models.Manager):
         for entry in objs:
             type_ids.add(entry.type_id)
             system_ids.add(entry.solar_system_id)
-            pk = self.model.create_primary_key(character.pk, entry)
+            pk = self.model.create_primary_key(owner.pk, entry)
             _e = self.model(
-                character=character,
+                character=owner,
                 id=pk,
                 date=entry.date,
                 type_id=entry.type_id,
@@ -213,19 +244,23 @@ class CharacterMiningLedgerEntryManagerBase(models.Manager):
         EveSolarSystem.objects.bulk_get_or_create_esi(ids=list(system_ids))
 
         if new_events:
-            self.bulk_create(new_events, ignore_conflicts=True)
+            self.bulk_create(
+                new_events, batch_size=LEDGER_BULK_BATCH_SIZE, ignore_conflicts=True
+            )
 
         if old_events:
-            self.bulk_update(old_events, fields=["quantity"])
+            self.bulk_update(
+                old_events, fields=["quantity"], batch_size=LEDGER_BULK_BATCH_SIZE
+            )
 
-        self._update_mining_price(character)
+        self._update_mining_price(owner=owner)
 
-    def _update_mining_price(self, character: "CharacterAudit") -> None:
+    def _update_mining_price(self, owner: "CharacterOwner") -> None:
         """Update prices for mining ledger entries."""
         # Update EveMarketPrice on a Daily basis
         self.model.update_evemarket_price()
 
-        mining_ledger = character.mining_ledger.filter(price_per_unit__isnull=True)
+        mining_ledger = owner.mining_ledger.filter(price_per_unit__isnull=True)
         logger.debug(
             f"Checking {mining_ledger.count()} mining ledger entries for missing prices."
         )
@@ -238,13 +273,12 @@ class CharacterMiningLedgerEntryManagerBase(models.Manager):
                 updated_entries.append(entry)
 
         if updated_entries:
-            self.bulk_update(updated_entries, fields=["price_per_unit"])
+            self.bulk_update(
+                updated_entries,
+                fields=["price_per_unit"],
+                batch_size=LEDGER_BULK_BATCH_SIZE,
+            )
 
         logger.debug(
-            f"Updated prices for {len(updated_entries)}({character.character_name}) mining ledger entries."
+            f"Updated prices for {len(updated_entries)}({owner.character_name}) mining ledger entries."
         )
-
-
-CharacterMiningLedgerEntryManager = CharacterMiningLedgerEntryManagerBase.from_queryset(
-    CharacterMiningLedgerEntryQueryset
-)