wbportfolio 1.52.0__py2.py3-none-any.whl → 1.59.4__py2.py3-none-any.whl

wbportfolio/serializers/rebalancing.py

@@ -49,7 +49,7 @@ class RebalancerModelSerializer(wb_serializers.ModelSerializer):
             "computed_str",
             "_rebalancing_model",
             "rebalancing_model",
-            "approve_trade_proposal_automatically",
+            "apply_order_proposal_automatically",
             "activation_date",
             "frequency",
             "frequency_repr",

wbportfolio/serializers/signals.py

@@ -84,7 +84,7 @@ def transactions_resources(sender, serializer, instance, request, user, **kwargs
     additional_resources = dict()
     portfolio = instance.primary_portfolio
     if portfolio:
-        if portfolio.transactions.exists() and user.profile.is_internal:
+        if portfolio.trades.exists() and user.profile.is_internal:
             additional_resources["portfolio_subscriptionsredemptions"] = (
                 f'{reverse("wbportfolio:portfolio-trade-list", args=[portfolio.id], request=request)}?is_customer_trade=True'
             )
@@ -92,17 +92,6 @@ def transactions_resources(sender, serializer, instance, request, user, **kwargs
                 f'{reverse("wbportfolio:portfolio-trade-list", args=[portfolio.id], request=request)}?is_customer_trade=False'
             )
 
-            additional_resources["portfolio_transactions"] = reverse(
-                "wbportfolio:portfolio-transaction-list", args=[portfolio.id], request=request
-            )
-            if PortfolioRole.is_portfolio_manager(user.profile, portfolio=portfolio):
-                additional_resources["portfolio_fees"] = reverse(
-                    "wbportfolio:portfolio-fees-list", args=[portfolio.id], request=request
-                )
-                additional_resources["portfolio_aggregatedfees"] = reverse(
-                    "wbportfolio:portfolio-feesaggregated-list", args=[portfolio.id], request=request
-                )
-
     return additional_resources
 
 
@@ -130,6 +119,14 @@ def product_resources(sender, serializer, instance, request, user, **kwargs):
             args=[instance.id],
             request=request,
         )
+    if instance.fees.exists() and PortfolioRole.is_portfolio_manager(user.profile, instrument=instance):
+        additional_resources["product_fees"] = reverse(
+            "wbportfolio:product-fees-list", args=[instance.id], request=request
+        )
+        additional_resources["product_aggregatedfees"] = reverse(
+            "wbportfolio:product-feesaggregated-list", args=[instance.id], request=request
+        )
+
     return additional_resources
 
 

wbportfolio/serializers/transactions/__init__.py

@@ -1,4 +1,3 @@
-from .trade_proposals import TradeProposalModelSerializer, ReadOnlyTradeProposalModelSerializer
 from .claim import (
     ClaimAccountSerializer,
     ClaimAPIModelSerializer,
@@ -9,16 +8,8 @@ from .claim import (
     NegativeTermimalAccountPerProductModelSerializer,
 )
 from .dividends import DividendModelSerializer, DividendRepresentationSerializer
-from .expiry import ExpiryModelSerializer, ExpiryRepresentationSerializer
 from .fees import FeesModelSerializer, FeesRepresentationSerializer
 from .trades import (
     TradeModelSerializer,
-    TradeProposalRepresentationSerializer,
-    TradeRepresentationSerializer,
-    TradeTradeProposalModelSerializer,
-    ReadOnlyTradeTradeProposalModelSerializer,
-)
-from .transactions import (
-    TransactionModelSerializer,
-    TransactionRepresentationSerializer,
+    TradeRepresentationSerializer
 )

wbportfolio/serializers/transactions/claim.py

@@ -49,8 +49,8 @@ class ClaimAPIModelSerializer(serializers.ModelSerializer):
             if "isin" in request.data:
                 try:
                     data["product"] = Product.objects.get(isin=request.data["isin"])
-                except Product.DoesNotExist:
-                    raise ValidationError({"isin": "A product with this ISIN does not exist."})
+                except Product.DoesNotExist as e:
+                    raise ValidationError({"isin": "A product with this ISIN does not exist."}) from e
         if trade := data.get("trade", None):
             if not trade.is_claimable:
                 raise ValidationError({"trade": "Only a claimable trade can be selected"})

wbportfolio/serializers/transactions/dividends.py

@@ -1,18 +1,46 @@
-from wbportfolio.models import DividendTransaction
+from wbcore import serializers as wb_serializers
+from wbcore.contrib.currency.serializers import CurrencyRepresentationSerializer
+from wbfdm.serializers import InvestableUniverseRepresentationSerializer
 
-from .transactions import (
-    TransactionModelSerializer,
-    TransactionRepresentationSerializer,
-)
+from wbportfolio.models import DividendTransaction
+from wbportfolio.serializers import PortfolioRepresentationSerializer
 
 
-class DividendRepresentationSerializer(TransactionRepresentationSerializer):
+class DividendRepresentationSerializer(wb_serializers.RepresentationSerializer):
     class Meta:
         model = DividendTransaction
-        fields = TransactionRepresentationSerializer.Meta.fields
+        fields = ("id", "value_date")
+
+
+class DividendModelSerializer(wb_serializers.ModelSerializer):
+    _portfolio = PortfolioRepresentationSerializer(source="portfolio")
+    _underlying_instrument = InvestableUniverseRepresentationSerializer(source="underlying_instrument")
+    _currency = CurrencyRepresentationSerializer(source="currency")
 
+    total_value = wb_serializers.DecimalField(max_digits=14, decimal_places=2, read_only=True, required=False)
+    total_value_fx_portfolio = wb_serializers.DecimalField(
+        max_digits=14, decimal_places=2, read_only=True, required=False
+    )
+    total_value_gross = wb_serializers.DecimalField(max_digits=14, decimal_places=2, read_only=True, required=False)
+    total_value_gross_fx_portfolio = wb_serializers.DecimalField(
+        max_digits=14, decimal_places=2, read_only=True, required=False
+    )
 
-class DividendModelSerializer(TransactionModelSerializer):
     class Meta:
         model = DividendTransaction
-        fields = TransactionModelSerializer.Meta.fields
+        fields = (
+            "id",
+            "value_date",
+            "record_date",
+            "ex_date",
+            "portfolio",
+            "underlying_instrument",
+            "currency",
+            "_portfolio",
+            "_underlying_instrument",
+            "_currency",
+            "total_value",
+            "total_value_fx_portfolio",
+            "total_value_gross",
+            "total_value_gross_fx_portfolio",
+        )

wbportfolio/serializers/transactions/fees.py

@@ -1,20 +1,28 @@
 from wbcore import serializers as wb_serializers
+from wbcore.contrib.currency.serializers import CurrencyRepresentationSerializer
 
 from wbportfolio.models import Fees
+from wbportfolio.serializers.products import ProductRepresentationSerializer
 
-from .transactions import (
-    TransactionModelSerializer,
-    TransactionRepresentationSerializer,
-)
 
+class FeesRepresentationSerializer(wb_serializers.RepresentationSerializer):
+    _detail = wb_serializers.HyperlinkField(reverse_name="wbportfolio:fees-detail")
 
-class FeesRepresentationSerializer(TransactionRepresentationSerializer):
     class Meta:
         model = Fees
-        fields = ("transaction_subtype",) + TransactionRepresentationSerializer.Meta.fields
+        fields = ("transaction_subtype", "total_value", "_detail")
 
 
-class FeesModelSerializer(TransactionModelSerializer):
+class FeesModelSerializer(wb_serializers.ModelSerializer):
+    _product = ProductRepresentationSerializer(source="product")
+    _currency = CurrencyRepresentationSerializer(source="currency")
+    total_value_fx_portfolio = wb_serializers.DecimalField(
+        max_digits=14, decimal_places=2, read_only=True, required=False
+    )
+    total_value_gross_fx_portfolio = wb_serializers.DecimalField(
+        max_digits=14, decimal_places=2, read_only=True, required=False
+    )
+
     @wb_serializers.register_resource()
     def additional_resources(self, instance, request, user):
         if (view := request.parser_context.get("view")) and view.is_manager and instance.import_source:
@@ -23,11 +31,32 @@ class FeesModelSerializer(TransactionModelSerializer):
 
     class Meta:
         model = Fees
-        decorators = TransactionModelSerializer.Meta.decorators
+        decorators = {
+            "total_value": wb_serializers.decorator(
+                decorator_type="text", position="left", value="{{_currency.symbol}}"
+            ),
+            "total_value_fx_portfolio": wb_serializers.decorator(
+                position="left", value="{{_portfolio.currency_symbol}}"
+            ),
+            "total_value_gross": wb_serializers.decorator(
+                decorator_type="text", position="left", value="{{_currency.symbol}}"
+            ),
+            "total_value_gross_fx_portfolio": wb_serializers.decorator(
+                position="left", value="{{_portfolio.currency_symbol}}"
+            ),
+        }
         fields = (
+            "id",
             "_additional_resources",
             "transaction_subtype",
             "calculated",
             "fee_date",
-            "linked_product",
-        ) + TransactionModelSerializer.Meta.fields
+            "product",
+            "currency",
+            "_product",
+            "_currency",
+            "total_value",
+            "total_value_fx_portfolio",
+            "total_value_gross",
+            "total_value_gross_fx_portfolio",
+        )

wbportfolio/serializers/transactions/trades.py

@@ -1,23 +1,19 @@
 from datetime import timedelta
 from decimal import Decimal
 
-from rest_framework import serializers
 from rest_framework.reverse import reverse
 from wbcore import serializers as wb_serializers
-from wbcore.metadata.configs.display.list_display import BaseTreeGroupLevelOption
-from wbfdm.models import Instrument
-from wbfdm.serializers import InvestableInstrumentRepresentationSerializer
-from wbfdm.serializers.instruments.instruments import CompanyRepresentationSerializer, SecurityRepresentationSerializer
+from wbcore.contrib.currency.serializers import CurrencyRepresentationSerializer
+from wbfdm.serializers.instruments.instruments import (
+    InvestableUniverseRepresentationSerializer,
+)
 
-from wbportfolio.models import PortfolioRole, Trade, TradeProposal
+from wbportfolio.models import PortfolioRole, Trade
 from wbportfolio.models.transactions.claim import Claim
 from wbportfolio.serializers.custodians import CustodianRepresentationSerializer
 from wbportfolio.serializers.registers import RegisterRepresentationSerializer
 
-from .transactions import (
-    TransactionModelSerializer,
-    TransactionRepresentationSerializer,
-)
+from .. import PortfolioRepresentationSerializer
 
 
 class CopyClaimRepresentationSerializer(wb_serializers.RepresentationSerializer):
@@ -39,21 +35,23 @@ class CopyClaimRepresentationSerializer(wb_serializers.RepresentationSerializer)
         )
 
 
-class TradeProposalRepresentationSerializer(wb_serializers.RepresentationSerializer):
-    _detail = wb_serializers.HyperlinkField(reverse_name="wbportfolio:tradeproposal-detail")
-
-    class Meta:
-        model = TradeProposal
-        fields = ("id", "trade_date", "status", "_detail")
-
-
-class TradeRepresentationSerializer(TransactionRepresentationSerializer):
+class TradeRepresentationSerializer(wb_serializers.RepresentationSerializer):
     _detail = wb_serializers.HyperlinkField(reverse_name="wbportfolio:trade-detail")
-    diff_shares = wb_serializers.DecimalField(max_digits=15, decimal_places=4)
+    diff_shares = wb_serializers.DecimalField(max_digits=15, decimal_places=4, read_only=True)
+    total_value = wb_serializers.DecimalField(max_digits=14, decimal_places=2, read_only=True, required=False)
 
     class Meta:
         model = Trade
-        fields = ("claimed_shares", "diff_shares", "bank", "shares") + TransactionRepresentationSerializer.Meta.fields
+        fields = (
+            "id",
+            "transaction_date",
+            "total_value",
+            "_detail",
+            "claimed_shares",
+            "diff_shares",
+            "bank",
+            "shares",
+        )
 
 
 class TradeClaimRepresentationSerializer(TradeRepresentationSerializer):
@@ -78,7 +76,11 @@ class TradeClaimRepresentationSerializer(TradeRepresentationSerializer):
         return {}
 
 
-class TradeModelSerializer(TransactionModelSerializer):
+class TradeModelSerializer(wb_serializers.ModelSerializer):
+    _portfolio = PortfolioRepresentationSerializer(source="portfolio")
+    _underlying_instrument = InvestableUniverseRepresentationSerializer(source="underlying_instrument")
+    _currency = CurrencyRepresentationSerializer(source="currency")
+
     marked_for_deletion = wb_serializers.BooleanField(required=False, read_only=True)
     marked_as_internal = wb_serializers.BooleanField()
 
@@ -91,6 +93,19 @@ class TradeModelSerializer(TransactionModelSerializer):
     completely_claimed = wb_serializers.BooleanField(required=False, read_only=True, default=Decimal(0.0))
     completely_claimed_if_approved = wb_serializers.BooleanField(required=False, read_only=True, default=Decimal(0.0))
 
+    total_value = wb_serializers.DecimalField(max_digits=14, decimal_places=2, read_only=True, required=False)
+    total_value_fx_portfolio = wb_serializers.DecimalField(
+        max_digits=14, decimal_places=2, read_only=True, required=False
+    )
+    total_value_gross = wb_serializers.DecimalField(max_digits=14, decimal_places=2, read_only=True, required=False)
+    total_value_gross_fx_portfolio = wb_serializers.DecimalField(
+        max_digits=14, decimal_places=2, read_only=True, required=False
+    )
+    external_id = wb_serializers.CharField(required=False, read_only=True)
+    value_date = wb_serializers.DateField(required=False, read_only=True)
+    total_value_usd = wb_serializers.FloatField(default=0, read_only=True, label="Total Value ($)")
+    total_value_gross_usd = wb_serializers.FloatField(default=0, read_only=True, label="Total Value Gross ($)")
+
     # We commented it because people needs to filter with lookup equals onto these fields
     # shares = wb_serializers.DecimalField(max_digits=16, decimal_places=2)
     # price = wb_serializers.DecimalField(max_digits=16, decimal_places=2)
@@ -127,7 +142,24 @@ class TradeModelSerializer(TransactionModelSerializer):
 
     class Meta:
         model = Trade
-        decorators = TransactionModelSerializer.Meta.decorators
+        decorators = {
+            "total_value": wb_serializers.decorator(
+                decorator_type="text", position="left", value="{{_currency.symbol}}"
+            ),
+            "total_value_gross": wb_serializers.decorator(
+                decorator_type="text", position="left", value="{{_currency.symbol}}"
+            ),
+            "total_value_usd": wb_serializers.decorator(decorator_type="text", position="left", value="{{$}}"),
+            "total_value_gross_usd": wb_serializers.decorator(decorator_type="text", position="left", value="{{$}}"),
+            "total_value_fx_portfolio": wb_serializers.decorator(
+                position="left", value="{{_portfolio.currency_symbol}}"
+            ),
+            "total_value_gross_fx_portfolio": wb_serializers.decorator(
+                position="left", value="{{_portfolio.currency_symbol}}"
+            ),
+            # "total_value_fx_portfolio": wb_serializers.decorator(decorator_type="text", position="left", value="{{_portfolio.currency_symbol}}}"),
+            # "total_value_gross_fx_portfolio": wb_serializers.decorator(decorator_type="text", position="left", value="{{_portfolio.currency_symbol}}"),
+        }
         read_only_fields = (
             "id",
             "shares",
@@ -145,9 +177,6 @@ class TradeModelSerializer(TransactionModelSerializer):
             "marked_for_deletion",
             "_claims",
             "claims",
-            "transaction_type",
-            "transaction_url_type",
-            "transaction_underlying_type",
             "portfolio",
             "_portfolio",
             "underlying_instrument",
@@ -185,9 +214,6 @@ class TradeModelSerializer(TransactionModelSerializer):
             "marked_for_deletion",
             "_claims",
             "claims",
-            "transaction_type",
-            "transaction_url_type",
-            "transaction_underlying_type",
             "portfolio",
             "_portfolio",
             "underlying_instrument",
@@ -213,131 +239,3 @@ class TradeModelSerializer(TransactionModelSerializer):
             "_internal_trade",
             "_additional_resources",
         )
-
-
-class GetSecurityDefault:
-    requires_context = True
-
-    def __call__(self, serializer_instance):
-        try:
-            instance = serializer_instance.view.get_object()
-            return instance.underlying_instrument.parent or instance.underlying_instrument
-        except Exception:
-            return None
-
-
-class GetCompanyDefault:
-    requires_context = True
-
-    def __call__(self, serializer_instance):
-        try:
-            instance = serializer_instance.view.get_object()
-            security = instance.underlying_instrument.parent or instance.underlying_instrument
-            return security.parent or security
-        except Exception:
-            return None
-
-
-class TradeTradeProposalModelSerializer(TradeModelSerializer):
-    underlying_instrument_isin = wb_serializers.CharField(read_only=True)
-    underlying_instrument_ticker = wb_serializers.CharField(read_only=True)
-    underlying_instrument_refinitiv_identifier_code = wb_serializers.CharField(read_only=True)
-    underlying_instrument_instrument_type = wb_serializers.CharField(read_only=True)
-
-    company = wb_serializers.PrimaryKeyRelatedField(
-        queryset=Instrument.objects.filter(level=0),
-        required=False,
-        read_only=lambda view: not view.new_mode,
-        default=GetCompanyDefault(),
-    )
-    _company = CompanyRepresentationSerializer(source="company", required=False)
-
-    security = wb_serializers.PrimaryKeyRelatedField(
-        queryset=Instrument.objects.filter(is_security=True),
-        required=False,
-        read_only=lambda view: not view.new_mode,
-        default=GetSecurityDefault(),
-    )
-    _security = SecurityRepresentationSerializer(
-        source="security",
-        optional_get_parameters={"company": "parent"},
-        depends_on=[{"field": "company", "options": {}}],
-        required=False,
-    )
-    underlying_instrument = wb_serializers.PrimaryKeyRelatedField(
-        queryset=Instrument.objects.all(), label="Quote", read_only=lambda view: not view.new_mode
-    )
-    _underlying_instrument = InvestableInstrumentRepresentationSerializer(
-        source="underlying_instrument",
-        optional_get_parameters={"security": "parent"},
-        depends_on=[{"field": "security", "options": {}}],
-        tree_config=BaseTreeGroupLevelOption(clear_filter=True, filter_key="parent"),
-    )
-
-    status = wb_serializers.ChoiceField(default=Trade.Status.DRAFT, choices=Trade.Status.choices)
-    target_weight = wb_serializers.DecimalField(max_digits=16, decimal_places=6, required=False, default=0)
-    effective_weight = wb_serializers.DecimalField(read_only=True, max_digits=16, decimal_places=6, default=0)
-    effective_shares = wb_serializers.DecimalField(read_only=True, max_digits=16, decimal_places=6, default=0)
-    target_shares = wb_serializers.DecimalField(read_only=True, max_digits=16, decimal_places=6, default=0)
-
-    def validate(self, data):
-        data.pop("company", None)
-        data.pop("security", None)
-        if self.instance and "underlying_instrument" in data:
-            raise serializers.ValidationError(
-                {
-                    "underlying_instrument": "You cannot modify the underlying instrument other than creating a new entry"
-                }
-            )
-        effective_weight = self.instance._effective_weight if self.instance else Decimal(0.0)
-        weighting = data.get("weighting", self.instance.weighting if self.instance else Decimal(0.0))
-        if (target_weight := data.pop("target_weight", None)) is not None:
-            weighting = target_weight - effective_weight
-        if weighting >= 0:
-            data["transaction_subtype"] = "BUY"
-        else:
-            data["transaction_subtype"] = "SELL"
-        data["weighting"] = weighting
-        return super().validate(data)
-
-    class Meta:
-        model = Trade
-        percent_fields = ["effective_weight", "target_weight", "weighting"]
-        read_only_fields = (
-            "transaction_subtype",
-            "shares",
-            # "underlying_instrument",
-            # "_underlying_instrument",
-            "shares",
-            "effective_shares",
-            "target_shares",
-        )
-        fields = (
-            "id",
-            "shares",
-            "underlying_instrument_isin",
-            "underlying_instrument_ticker",
-            "underlying_instrument_refinitiv_identifier_code",
-            "underlying_instrument_instrument_type",
-            "company",
-            "_company",
-            "security",
-            "_security",
-            "underlying_instrument",
-            "_underlying_instrument",
-            "transaction_subtype",
-            "status",
-            "comment",
-            "effective_weight",
-            "target_weight",
-            "weighting",
-            "trade_proposal",
-            "order",
-            "effective_shares",
-            "target_shares",
-        )
-
-
-class ReadOnlyTradeTradeProposalModelSerializer(TradeTradeProposalModelSerializer):
-    class Meta(TradeTradeProposalModelSerializer.Meta):
-        read_only_fields = TradeTradeProposalModelSerializer.Meta.fields

wbportfolio/tasks.py

@@ -1,12 +1,12 @@
 from contextlib import suppress
 from datetime import date, timedelta
 
+from celery import shared_task
 from django.db.models import ProtectedError, Q
+from tqdm import tqdm
+from wbfdm.models import Controversy, Instrument
 
-from wbportfolio.models import Portfolio, Trade
-from wbportfolio.models.products import Product, update_outstanding_shares_as_task
-
-from .fdm.tasks import *  # noqa
+from wbportfolio.models import AssetPosition, Portfolio, Product, Trade
 
 
 @shared_task(queue="portfolio")
@@ -15,7 +15,7 @@ def daily_active_product_task(today: date | None = None):
         today = date.today()
     qs = Product.active_objects.all()
     for product in tqdm(qs, total=qs.count()):
-        update_outstanding_shares_as_task(product.id)
+        product.update_outstanding_shares()
         product.check_and_notify_product_termination_on_date(today)
 
 
@@ -49,3 +49,41 @@ def update_preferred_classification_per_instrument_and_portfolio_as_task():
 # - propagate (or update) t-2 asset positions into t-1
 # - Synchronize wbportfolio at t-1
 # - Compute Instrument Price estimate at t-1
+
+
+@shared_task(queue="portfolio")
+def synchronize_portfolio_controversies():
+    active_portfolios = Portfolio.objects.filter_active_and_tracked()
+    qs = (
+        AssetPosition.objects.filter(portfolio__in=active_portfolios)
+        .values("underlying_instrument")
+        .distinct("underlying_instrument")
+    )
+    objs = {}
+    securities = Instrument.objects.filter(id__in=qs.values("underlying_instrument"))
+    securities_mapping = {security.id: security.get_root() for security in securities}
+    for controversy in securities.dl.esg_controversies():
+        instrument = securities_mapping[controversy["instrument_id"]]
+        obj = Controversy.dict_to_model(controversy, instrument)
+        objs[obj.external_id] = obj
+
+    Controversy.objects.bulk_create(
+        objs.values(),
+        update_fields=[
+            "instrument",
+            "headline",
+            "description",
+            "source",
+            "direct_involvement",
+            "company_response",
+            "review",
+            "initiated",
+            "flag",
+            "status",
+            "type",
+            "severity",
+        ],
+        unique_fields=["external_id"],
+        update_conflicts=True,
+        batch_size=10000,
+    )

wbportfolio/tests/analysis/test_claims.py

@@ -0,0 +1,85 @@
+from datetime import date, timedelta
+
+import pytest
+from pandas._libs.tslibs.offsets import BDay
+
+from wbportfolio.analysis.claims import ConsolidatedTradeSummary
+from wbportfolio.models import Claim
+
+
+@pytest.mark.django_db
+class TestConsolidatedTradeSummary:
+    def test_base(self, claim_factory, customer_trade_factory, product, instrument_price_factory):
+        d1 = date(2024, 1, 1)
+        d2 = date(2025, 1, 1)
+        p1 = instrument_price_factory.create(date=d1, instrument=product)  # noqa
+        p2 = instrument_price_factory.create(date=d2, instrument=product)
+        t1 = customer_trade_factory.create(
+            shares=1000, transaction_date=d1, underlying_instrument=product, portfolio=product.primary_portfolio
+        )
+        t2 = customer_trade_factory.create(
+            shares=500, transaction_date=d2, underlying_instrument=product, portfolio=product.primary_portfolio
+        )
+
+        c0 = claim_factory.create()  # noqa
+        c1 = claim_factory.create(shares=1000, status="APPROVED", trade=t1, date=d2, product=product)
+        c2 = claim_factory.create(shares=500, status="APPROVED", trade=t2, date=d1, product=product)
+        cts = ConsolidatedTradeSummary(Claim.objects.all(), d1, d2, "account", "account__title")
+
+        valid_date = dict(cts.queryset.values_list("id", "valid_date"))
+        assert valid_date == {c1.id: d2, c2.id: d2}
+
+        date_considered = dict(cts.queryset.values_list("id", "date_considered"))
+        assert date_considered == {c1.id: d2 + timedelta(days=1), c2.id: d2 + timedelta(days=1)}
+
+        aum = dict(cts.queryset.values_list("id", "aum"))
+        assert aum == {c1.id: p2.net_value * c1.shares, c2.id: p2.net_value * c2.shares}
+
+    def test_get_aum_df(self, claim_factory, product, instrument_price_factory, customer_trade_factory):
+        t1 = customer_trade_factory.create(
+            shares=10,
+            transaction_date=date(2024, 12, 31),
+            underlying_instrument=product,
+            portfolio=product.primary_portfolio,
+        )
+        t2 = customer_trade_factory.create(
+            shares=100,
+            transaction_date=date(2025, 2, 3),
+            underlying_instrument=product,
+            portfolio=product.primary_portfolio,
+        )
+        c1 = claim_factory.create(trade=t1, status="APPROVED")
+        c2 = claim_factory.create(trade=t2, status="APPROVED", account=c1.account)
+        d1 = date(2025, 1, 1)
+        d2 = date(2025, 3, 3)
+        product.prices.all().delete()
+        p1 = instrument_price_factory.create(
+            date=(d1 - BDay(7)).date(), instrument=product
+        )  # we test that the CTS uses the earliest date
+        p2 = instrument_price_factory.create(date=c2.date, instrument=product)  # noqa
+        p3 = instrument_price_factory.create(date=d2, instrument=product)
+
+        cts = ConsolidatedTradeSummary(Claim.objects.all(), d1, d2, "account", "account__title")
+        aum_start = float(round(p1.net_value * c1.shares))
+        aum_end = float(round(p3.net_value * (c1.shares + c2.shares)))
+        assert cts.get_aum_df().to_dict(orient="index") == {
+            c1.account.id: {
+                "sum_shares_start": c1.shares,
+                "sum_shares_end": c1.shares + c2.shares,
+                "sum_aum_start": aum_start,
+                "sum_aum_end": aum_end,
+                "sum_shares_diff": c2.shares,
+                "sum_shares_perf": (c1.shares + c2.shares) / c1.shares - 1,
+                "sum_aum_diff": aum_end - aum_start,
+                "sum_aum_perf": aum_end / aum_start - 1,
+            }
+        }
+
+        p0 = instrument_price_factory.create(date=c1.date, instrument=product)  # noqa
+
+        assert cts.get_nnm_df().to_dict(orient="index") == {
+            c1.account.id: {
+                "sum_nnm_2025-02": float(round(c2.shares * p2.net_value)),
+                "sum_nnm_total": float(round(c2.shares * p2.net_value)),
+            }
+        }, "Ensure the first claim that is considered in t+1 (on the CTS lower bound range) is excluded from the NNM"