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

wbportfolio/models/orders/orders.py

@@ -1,3 +1,4 @@
+from contextlib import suppress
 from datetime import date
 from decimal import Decimal
 
@@ -6,12 +7,18 @@ from django.db import models
 from django.db.models import (
     Sum,
 )
+from django.dispatch import receiver
 from ordered_model.models import OrderedModel
+from pandas import Timestamp
+from wbcore.contrib.currency.models import CurrencyFXRates
 from wbcore.contrib.io.mixins import ImportMixin
+from wbfdm.models import Instrument
 
 from wbportfolio.import_export.handlers.orders import OrderImportHandler
 from wbportfolio.models.asset import AssetPosition
 from wbportfolio.models.transactions.transactions import TransactionMixin
+from wbportfolio.order_routing import ExecutionInstruction
+from wbportfolio.pms.typing import Position as PositionDTO
 
 
 class Order(TransactionMixin, ImportMixin, OrderedModel, models.Model):
@@ -30,6 +37,13 @@ class Order(TransactionMixin, ImportMixin, OrderedModel, models.Model):
         SELL = "SELL", "Sell"
         NO_CHANGE = "NO_CHANGE", "No Change"  # default transaction subtype if weighing is 0
 
+    class ExecutionStatus(models.TextChoices):
+        PENDING = "PENDING", "Pending"
+        CONFIRMED = "CONFIRMED", "Confirmed"
+        EXECUTED = "EXECUTED", "Executed"
+        FAILED = "FAILED", "Failed"
+        IGNORED = "IGNORED", "Ignored"
+
     order_type = models.CharField(max_length=32, default=Type.BUY, choices=Type.choices, verbose_name="Trade Type")
     shares = models.DecimalField(
         max_digits=15,
@@ -67,42 +81,56 @@ class Order(TransactionMixin, ImportMixin, OrderedModel, models.Model):
         verbose_name="Daily Return",
         help_text="The Ex-Post daily return",
     )
-
-    execution_confirmed = models.BooleanField(default=False, verbose_name="Execution Confirmed")
+    quantization_error = models.DecimalField(
+        max_digits=9,
+        decimal_places=ORDER_WEIGHTING_PRECISION,
+        default=Decimal(0),
+        verbose_name="Quantization Error",
+    )
+    execution_status = models.CharField(
+        max_length=12,
+        default=ExecutionStatus.PENDING.value,
+        choices=ExecutionStatus.choices,
+        verbose_name="Execution Status",
+    )
+    execution_instruction = models.CharField(
+        max_length=26,
+        choices=ExecutionInstruction.choices,
+        default=ExecutionInstruction.MARKET_ON_CLOSE.value,
+        verbose_name="Execution Instruction",
+    )
+    execution_instruction_parameters = models.JSONField(
+        default=dict, blank=True, verbose_name="Execution Instruction Parameters"
+    )
     execution_comment = models.TextField(default="", blank=True, verbose_name="Execution Comment")
 
-    def submit(self, by=None, description=None, portfolio_total_asset_value=None, **kwargs):
-        warnings = []
+    execution_trade = models.OneToOneField(
+        to="wbportfolio.Trade",
+        related_name="order",
+        on_delete=models.SET_NULL,
+        blank=True,
+        null=True,
+        help_text="The executed Trade",
+    )
+    order_with_respect_to = "order_proposal"
 
-        # if shares is defined and the underlying instrument defines a round lot size different than 1 and exchange allows its application, we round the share accordingly
-        if self.order_proposal and not self.portfolio.only_weighting:
-            shares = self.order_proposal.get_round_lot_size(self.shares, self.underlying_instrument)
-            if shares != self.shares:
-                warnings.append(
-                    f"{self.underlying_instrument.computed_str} has a round lot size of  {self.underlying_instrument.round_lot_size}: shares were rounded from {self.shares} to {shares}"
-                )
-            shares = round(shares)  # ensure fractional shares are converted into integer
-            # we need to recompute the delta weight has we changed the number of shares
-            if shares != self.shares:
-                self.shares = shares
-                if portfolio_total_asset_value:
-                    self.weighting = self.shares * self.price * self.currency_fx_rate / portfolio_total_asset_value
-        if self.shares and abs(self.total_value_fx_portfolio) < self.order_proposal.min_order_value:
-            warnings.append(
-                f"Total Value for order {self.underlying_instrument.computed_str} ({self.total_value_fx_portfolio}) is bellow the allowed Minimum Order Value ({self.order_proposal.min_order_value})"
-            )
-            self.shares = Decimal("0")
-            self.weighting = Decimal("0")
-        if not self.price:
-            warnings.append(f"No price for {self.underlying_instrument.computed_str}")
-        if (
-            not self.underlying_instrument.is_cash
-            and not self.underlying_instrument.is_cash_equivalent
-            and self._target_weight < -1e-8
-        ):  # any value below -1e8 will be considered zero
-            warnings.append(f"Negative target weight for {self.underlying_instrument.computed_str}")
-        self.desired_target_weight = self._target_weight
-        return warnings
+    class Meta(OrderedModel.Meta):
+        verbose_name = "Order"
+        verbose_name_plural = "Orders"
+        indexes = [
+            models.Index(fields=["order_proposal"]),
+            models.Index(fields=["underlying_instrument", "value_date"]),
+            models.Index(fields=["portfolio", "underlying_instrument", "value_date"]),
+            models.Index(fields=["order_proposal", "underlying_instrument"]),
+            # models.Index(fields=["date", "underlying_instrument"]),
+        ]
+        constraints = [
+            models.UniqueConstraint(
+                fields=["order_proposal", "underlying_instrument"],
+                name="unique_order",
+            ),
+        ]
+        # notification_email_template = "portfolio/email/trade_notification.html"
 
     @property
     def product(self):
@@ -150,12 +178,7 @@ class Order(TransactionMixin, ImportMixin, OrderedModel, models.Model):
         return getattr(
             self,
             "effective_shares",
-            AssetPosition.objects.filter(
-                underlying_quote=self.underlying_instrument,
-                date=self.value_date,
-                portfolio=self.portfolio,
-            ).aggregate(s=Sum("shares"))["s"]
-            or Decimal(0),
+            self.get_effective_shares(),
         )
 
     @property
@@ -170,52 +193,38 @@ class Order(TransactionMixin, ImportMixin, OrderedModel, models.Model):
     def _target_shares(self) -> Decimal:
         return getattr(self, "target_shares", self._effective_shares + self.shares)
 
-    order_with_respect_to = "order_proposal"
-
-    class Meta(OrderedModel.Meta):
-        verbose_name = "Order"
-        verbose_name_plural = "Orders"
-        indexes = [
-            models.Index(fields=["order_proposal"]),
-            models.Index(fields=["underlying_instrument", "value_date"]),
-            models.Index(fields=["portfolio", "underlying_instrument", "value_date"]),
-            models.Index(fields=["order_proposal", "underlying_instrument"]),
-            # models.Index(fields=["date", "underlying_instrument"]),
-        ]
-        constraints = [
-            models.UniqueConstraint(
-                fields=["order_proposal", "underlying_instrument"],
-                name="unique_order",
-            ),
-        ]
-        # notification_email_template = "portfolio/email/trade_notification.html"
+    def __str__(self):
+        ticker = f"{self.underlying_instrument.ticker}:" if self.underlying_instrument.ticker else ""
+        return f"{ticker}{self.weighting}"
 
     def pre_save(self):
         self.portfolio = self.order_proposal.portfolio
         self.value_date = self.order_proposal.trade_date
+        self.set_currency_fx_rate()
 
         if not self.price:
-            # we try to get the price if not provided directly from the underlying instrument
-            if self.underlying_instrument.is_cash or self.underlying_instrument.is_cash_equivalent:
-                self.price = Decimal("1")
-            else:
-                self.price = self.get_price()
-        if not self.portfolio.only_weighting:
+            self.set_price()
+        if not self.portfolio.only_weighting and not self.shares:
             estimated_shares = self.order_proposal.get_estimated_shares(
                 self.weighting, self.underlying_instrument, self.price
             )
             if estimated_shares:
                 self.shares = estimated_shares
+        if effective_shares := self.get_effective_shares():
+            if self.order_type == self.Type.SELL:
+                self.shares = -effective_shares
+            else:
+                self.shares = max(self.shares, -effective_shares)
         super().pre_save()
 
     def save(self, *args, **kwargs):
+        if self.id:
+            self.set_type()
         self.pre_save()
         if not self.underlying_instrument.is_investable_universe:
             self.underlying_instrument.is_investable_universe = True
             self.underlying_instrument.save()
 
-        if self.id:
-            self.set_type()
         super().save(*args, **kwargs)
 
     @classmethod
@@ -234,15 +243,168 @@ class Order(TransactionMixin, ImportMixin, OrderedModel, models.Model):
                 else:
                     return Order.Type.SELL
 
+    def get_effective_shares(self) -> Decimal:
+        return AssetPosition.objects.filter(
+            underlying_quote=self.underlying_instrument,
+            date=self.order_proposal.last_effective_date,
+            portfolio=self.portfolio,
+        ).aggregate(s=Sum("shares"))["s"] or Decimal("0")
+
     def set_type(self):
-        self.order_type = self.get_type(self.weighting, self._previous_weight, self._target_weight)
+        effective_weight = self._effective_weight
+        self.order_type = self.get_type(self.weighting, effective_weight, effective_weight + self.weighting)
 
-    def get_price(self) -> Decimal:
-        try:
-            return self.underlying_instrument.get_price(self.value_date)
-        except ValueError:
-            return Decimal("0")
+    def _get_price(self) -> tuple[Decimal, Decimal]:
+        daily_return = last_price = Decimal("0")
 
-    def __str__(self):
-        ticker = f"{self.underlying_instrument.ticker}:" if self.underlying_instrument.ticker else ""
-        return f"{ticker}{self.weighting}"
+        effective_date = self.order_proposal.last_effective_date
+        if self.underlying_instrument.is_cash or self.underlying_instrument.is_cash_equivalent:
+            last_price = Decimal("1")
+        else:
+            try:
+                last_price = Decimal(self.portfolio.builder.prices[self.value_date][self.underlying_instrument.id])
+                daily_return = self.portfolio.builder.returns.loc[
+                    Timestamp(self.value_date), self.underlying_instrument.id
+                ]
+            except KeyError:
+                prices, returns = Instrument.objects.filter(id=self.underlying_instrument.id).get_returns_df(
+                    from_date=effective_date,
+                    to_date=self.value_date,
+                    to_currency=self.order_proposal.portfolio.currency,
+                    use_dl=True,
+                )
+                with suppress(IndexError):
+                    daily_return = Decimal(returns.iloc[-1, 0])
+                with suppress(KeyError, TypeError):
+                    last_price = Decimal(
+                        prices.get(self.value_date, prices[effective_date])[self.underlying_instrument.id]
+                    )
+        return last_price, daily_return
+
+    def set_price(self):
+        last_price, daily_return = self._get_price()
+        self.daily_return = daily_return
+        self.price = last_price
+
+    def set_currency_fx_rate(self):
+        self.currency_fx_rate = Decimal("1")
+        if self.order_proposal.portfolio.currency != self.underlying_instrument.currency:
+            with suppress(CurrencyFXRates.DoesNotExist):
+                self.currency_fx_rate = self.underlying_instrument.currency.convert(
+                    self.value_date, self.portfolio.currency, exact_lookup=True
+                )
+
+    def set_weighting(self, weighting: Decimal, portfolio_value: Decimal):
+        self.weighting = weighting
+        price_fx_portfolio = self.price * self.currency_fx_rate
+        if price_fx_portfolio and portfolio_value:
+            total_value = self.weighting * portfolio_value
+            self.shares = total_value / price_fx_portfolio
+        else:
+            self.shares = Decimal("0")
+
+    def set_shares(self, shares: Decimal, portfolio_value: Decimal):
+        if portfolio_value:
+            price_fx_portfolio = self.price * self.currency_fx_rate
+            self.shares = shares
+            total_value = shares * price_fx_portfolio
+            self.weighting = total_value / portfolio_value
+        else:
+            self.weighting = self.shares = Decimal("0")
+
+    def set_total_value_fx_portfolio(self, total_value_fx_portfolio: Decimal, portfolio_value: Decimal):
+        price_fx_portfolio = self.price * self.currency_fx_rate
+        if price_fx_portfolio and portfolio_value:
+            self.shares = total_value_fx_portfolio / price_fx_portfolio
+            self.weighting = total_value_fx_portfolio / portfolio_value
+        else:
+            self.weighting = self.shares = Decimal("0")
+
+    def submit(self, by=None, description=None, portfolio_total_asset_value=None, **kwargs):
+        warnings = []
+        # if shares is defined and the underlying instrument defines a round lot size different than 1 and exchange allows its application, we round the share accordingly
+        if self._target_weight:
+            if self.order_proposal and not self.portfolio.only_weighting:
+                shares = self.order_proposal.get_round_lot_size(self.shares, self.underlying_instrument)
+                if shares != self.shares:
+                    warnings.append(
+                        f"{self.underlying_instrument.computed_str} has a round lot size of  {self.underlying_instrument.round_lot_size}: shares were rounded from {self.shares} to {shares}"
+                    )
+                shares = round(shares)  # ensure fractional shares are converted into integer
+                # we need to recompute the delta weight has we changed the number of shares
+                if shares != self.shares:
+                    self.set_shares(shares, portfolio_total_asset_value)
+            if abs(self.weighting) < self.order_proposal.min_weighting:
+                warnings.append(
+                    f"Weighting for order {self.underlying_instrument.computed_str} ({self.weighting}) is bellow the allowed Minimum Weighting ({self.order_proposal.min_weighting})"
+                )
+                self.set_weighting(Decimal("0"), portfolio_total_asset_value)
+            if self.shares and abs(self.total_value_fx_portfolio) < self.order_proposal.min_order_value:
+                warnings.append(
+                    f"Total Value for order {self.underlying_instrument.computed_str} ({self.total_value_fx_portfolio}) is bellow the allowed Minimum Order Value ({self.order_proposal.min_order_value})"
+                )
+                self.set_weighting(Decimal("0"), portfolio_total_asset_value)
+        if not self.price:
+            warnings.append(f"No price for {self.underlying_instrument.computed_str}")
+        if (
+            not self.underlying_instrument.is_cash
+            and not self.underlying_instrument.is_cash_equivalent
+            and self._target_weight < -1e-8
+        ):  # any value below -1e8 will be considered zero
+            warnings.append(f"Negative target weight for {self.underlying_instrument.computed_str}")
+        self.desired_target_weight = self._target_weight
+        return warnings
+
+    def to_dto(self) -> PositionDTO:
+        return self.create_dto(
+            self.underlying_instrument,
+            self._target_weight,
+            self.price,
+            self.value_date,
+            shares=self._target_shares,
+            currency_fx_rate=self.currency_fx_rate,
+            daily_return=self.daily_return,
+        )
+
+    @classmethod
+    def create_dto(
+        cls,
+        instrument: Instrument,
+        weighting: Decimal,
+        price: Decimal,
+        trade_date: date,
+        shares: Decimal | None = None,
+        **extra_param,
+    ) -> PositionDTO:
+        price_data = {}
+
+        return PositionDTO(
+            underlying_instrument=instrument.id,
+            instrument_type=instrument.security_instrument_type.id,
+            weighting=weighting,
+            shares=shares,
+            currency=instrument.currency.id,
+            date=trade_date,
+            asset_valuation_date=trade_date,
+            is_cash=instrument.is_cash or instrument.is_cash_equivalent,
+            price=price,
+            exchange=instrument.exchange.id if instrument.exchange else None,
+            country=instrument.country.id if instrument.country else None,
+            **price_data,
+            **extra_param,
+        )
+
+
+@receiver(models.signals.post_save, sender="wbportfolio.Trade")
+def link_trade_to_order(sender, instance, created, raw, **kwargs):
+    """Gets or create the fees for a given price and updates them if necessary"""
+    if not raw and created and not instance.underlying_instrument.is_cash and not instance.is_customer_trade:
+        with suppress(Order.DoesNotExist):
+            order = Order.objects.get(
+                portfolio=instance.portfolio,
+                underlying_instrument=instance.underlying_instrument,
+                value_date=instance.book_date,
+            )
+            order.execution_trade = instance
+            order.execution_status = Order.ExecutionStatus.EXECUTED
+            order.save()

wbportfolio/models/portfolio.py

@@ -1,4 +1,5 @@
 import logging
+from collections import defaultdict
 from contextlib import suppress
 from datetime import date, timedelta
 from decimal import Decimal
@@ -9,6 +10,7 @@ import pandas as pd
 from celery import shared_task
 from django.contrib.postgres.fields import DateRangeField
 from django.core.exceptions import ObjectDoesNotExist
+from django.core.validators import MaxValueValidator, MinValueValidator
 from django.db import models
 from django.db.models import Exists, F, OuterRef, Q, QuerySet, Sum
 from django.db.models.signals import post_save
@@ -16,7 +18,9 @@ from django.dispatch import receiver
 from django.utils import timezone
 from django.utils.functional import cached_property
 from pandas._libs.tslibs.offsets import BDay
+from wbcore.contrib.authentication.models import User
 from wbcore.contrib.currency.models import Currency
+from wbcore.contrib.notifications.dispatch import send_notification
 from wbcore.contrib.notifications.utils import create_notification_type
 from wbcore.models import WBModel
 from wbcore.utils.importlib import import_from_dotted_path
@@ -39,7 +43,7 @@ from wbportfolio.pms.typing import Position as PositionDTO
 
 from ..constants import EQUITY_TYPE_KEYS
 from ..order_routing.adapters import BaseCustodianAdapter
-from . import ProductGroup
+from . import PortfolioRole, ProductGroup
 
 logger = logging.getLogger("pms")
 if TYPE_CHECKING:
@@ -71,7 +75,7 @@ class DefaultPortfolioQueryset(QuerySet):
         """
         A method to sort the given queryset to return undependable portfolio first. This is very useful if a routine needs to be applied sequentially on portfolios by order of dependence.
         """
-        MAX_ITERATIONS: int = (
+        max_iterations: int = (
             5  # in order to avoid circular dependency and infinite loop, we need to stop recursion at a max depth
         )
         remaining_portfolios = set(self)
@@ -84,7 +88,7 @@ class DefaultPortfolioQueryset(QuerySet):
             dependency_relationships = PortfolioPortfolioThroughModel.objects.filter(
                 portfolio=p, dependency_portfolio__in=remaining_portfolios
             )  # get dependency portfolios
-            if iterator_counter >= MAX_ITERATIONS or (
+            if iterator_counter >= max_iterations or (
                 not dependency_relationships.exists() and not bool(parent_portfolios)
             ):  # if not dependency portfolio or parent portfolio that remained, then we yield
                 remaining_portfolios.remove(p)
@@ -125,22 +129,25 @@ class ActiveTrackedPortfolioManager(DefaultPortfolioManager):
 
 class PortfolioPortfolioThroughModel(models.Model):
     class Type(models.TextChoices):
-        PRIMARY = "PRIMARY", "Primary"
+        LOOK_THROUGH = "LOOK_THROUGH", "Look-through"
         MODEL = "MODEL", "Model"
         CUSTODIAN = "CUSTODIAN", "Custodian"
+        HIERARCHICAL = "HIERARCHICAL", "Hierarchical"
 
     portfolio = models.ForeignKey("wbportfolio.Portfolio", on_delete=models.CASCADE, related_name="dependency_through")
     dependency_portfolio = models.ForeignKey(
         "wbportfolio.Portfolio", on_delete=models.CASCADE, related_name="dependent_through"
     )
-    type = models.CharField(choices=Type.choices, default=Type.PRIMARY, verbose_name="Type")
+    type = models.CharField(choices=Type.choices, default=Type.LOOK_THROUGH, verbose_name="Type")
 
     def __str__(self):
         return f"{self.portfolio} dependant on {self.dependency_portfolio} ({self.Type[self.type].label})"
 
     class Meta:
         constraints = [
-            models.UniqueConstraint(fields=["portfolio", "type"], name="unique_primary", condition=Q(type="PRIMARY")),
+            models.UniqueConstraint(
+                fields=["portfolio", "type"], name="unique_lookthrough", condition=Q(type="LOOK_THROUGH")
+            ),
             models.UniqueConstraint(fields=["portfolio", "type"], name="unique_model", condition=Q(type="MODEL")),
         ]
 
@@ -233,6 +240,25 @@ class Portfolio(DeleteToDisableMixin, WBModel):
         blank=True,
     )
 
+    # OMS default parameters. Used to seed order proposal default value upon creation
+    default_order_proposal_min_order_value = models.IntegerField(
+        default=0, verbose_name="Default Order Proposal Minimum Order Value"
+    )
+    default_order_proposal_min_weighting = models.DecimalField(
+        max_digits=9,
+        decimal_places=8,
+        default=Decimal(0),
+        verbose_name="Default Order Proposal Minimum Weight",
+        validators=[MinValueValidator(Decimal("0")), MaxValueValidator(Decimal("1"))],
+    )
+    default_order_proposal_total_cash_weight = models.DecimalField(
+        default=Decimal("0"),
+        decimal_places=4,
+        max_digits=5,
+        verbose_name="Default Order Proposal Total Cash Weight",
+        validators=[MinValueValidator(Decimal("0")), MaxValueValidator(Decimal("1"))],
+    )
+
     objects = DefaultPortfolioManager()
     tracked_objects = ActiveTrackedPortfolioManager()
 
@@ -244,7 +270,7 @@ class Portfolio(DeleteToDisableMixin, WBModel):
     def primary_portfolio(self):
         with suppress(PortfolioPortfolioThroughModel.DoesNotExist):
             return PortfolioPortfolioThroughModel.objects.get(
-                portfolio=self, type=PortfolioPortfolioThroughModel.Type.PRIMARY
+                portfolio=self, type=PortfolioPortfolioThroughModel.Type.LOOK_THROUGH
             ).dependency_portfolio
 
     @property
@@ -402,12 +428,22 @@ class Portfolio(DeleteToDisableMixin, WBModel):
                 True,
             ),
             create_notification_type(
-                "wbportfolio.portfolio.replay_done",
-                "Portfolio Replay finished",
-                "Sends a notification when a the requested order proposal replay is done",
+                "wbportfolio.portfolio.action_done",
+                "Portfolio Action finished",
+                "Sends a notification when a the requested portfolio action is done (e.g. replay, quote adjustment...)",
+                True,
+                True,
+                True,
+                is_lock=True,
+            ),
+            create_notification_type(
+                "wbportfolio.portfolio.warning",
+                "PMS Warning",
+                "Sends a notification to warn portfolio manager or administrator regarding issue that needs action.",
                 True,
                 True,
                 True,
+                is_lock=True,
             ),
         ]
 
@@ -694,6 +730,8 @@ class Portfolio(DeleteToDisableMixin, WBModel):
         broadcast_changes_at_date: bool = True,
         **kwargs,
     ):
+        if not self.is_tracked:
+            return
         logger.info(f"change at date for {self} at {val_date}")
 
         if fix_quantization:
@@ -726,7 +764,7 @@ class Portfolio(DeleteToDisableMixin, WBModel):
         if self.is_tracked:
             for rel in PortfolioPortfolioThroughModel.objects.filter(
                 dependency_portfolio=self,
-                type=PortfolioPortfolioThroughModel.Type.PRIMARY,
+                type=PortfolioPortfolioThroughModel.Type.LOOK_THROUGH,
                 portfolio__is_lookthrough=True,
             ):
                 rel.portfolio.compute_lookthrough(val_date)
@@ -818,7 +856,7 @@ class Portfolio(DeleteToDisableMixin, WBModel):
                 break
             try:
                 order_proposal = self.order_proposals.get(
-                    trade_date=to_date, rebalancing_model__isnull=True, status="APPLIED"
+                    trade_date=to_date, rebalancing_model__isnull=True, status="CONFIRMED"
                 )
             except ObjectDoesNotExist:
                 if rebalancer and rebalancer.is_valid(to_date):
@@ -929,7 +967,7 @@ class Portfolio(DeleteToDisableMixin, WBModel):
                 except IndexError:
                     position.portfolio_created = None
 
-                setattr(position, "path", path)
+                position.path = path
                 position.initial_shares = None
                 if portfolio_total_asset_value and (price_fx_portfolio := position.price * position.currency_fx_rate):
                     position.initial_shares = (position.weighting * portfolio_total_asset_value) / price_fx_portfolio
@@ -962,13 +1000,13 @@ class Portfolio(DeleteToDisableMixin, WBModel):
             )
         if not to_date:
             to_date = from_date
-        for from_date in pd.date_range(from_date, to_date, freq="B").date:
-            logger.info(f"Compute Look-Through for {self} at {from_date}")
+        for val_date in pd.date_range(from_date, to_date, freq="B").date:
+            logger.info(f"Compute Look-Through for {self} at {val_date}")
             portfolio_total_asset_value = (
-                self.primary_portfolio.get_total_asset_under_management(from_date) if not self.only_weighting else None
+                self.primary_portfolio.get_total_asset_under_management(val_date) if not self.only_weighting else None
             )
             self.builder.add(
-                list(self.primary_portfolio.get_lookthrough_positions(from_date, portfolio_total_asset_value)),
+                list(self.primary_portfolio.get_lookthrough_positions(val_date, portfolio_total_asset_value)),
                 infer_underlying_quote_price=True,
             )
         self.builder.bulk_create_positions(delete_leftovers=True)
@@ -1194,7 +1232,7 @@ def post_portfolio_relationship_creation(sender, instance, created, raw, **kwarg
         not raw
         and created
         and instance.portfolio.is_lookthrough
-        and instance.type == PortfolioPortfolioThroughModel.Type.PRIMARY
+        and instance.type == PortfolioPortfolioThroughModel.Type.LOOK_THROUGH
     ):
         with suppress(AssetPosition.DoesNotExist):
             earliest_primary_position_date = instance.dependency_portfolio.assets.earliest("date").date
@@ -1219,10 +1257,33 @@ def update_portfolio_after_investable_universe(*args, end_date: date | None = No
         end_date = date.today()
     end_date = (end_date + timedelta(days=1) - BDay(1)).date()  # shift in case of business day
     from_date = (end_date - BDay(1)).date()
+    excluded_positions = defaultdict(list)
     for portfolio in Portfolio.tracked_objects.all().to_dependency_iterator(from_date):
         if not portfolio.is_lookthrough:
             try:
                 portfolio.propagate_or_update_assets(from_date, end_date)
+                for positions in portfolio.builder.excluded_positions.values():
+                    for pos in positions:
+                        excluded_positions[pos.underlying_quote].append(portfolio)
+                portfolio.builder.clear()
             except Exception as e:
                 logger.error(f"Exception while propagating portfolio assets {portfolio}: {e}")
         portfolio.estimate_net_asset_values(end_date)
+    # if there were excluded positions, we compiled a itemized list of quote per portfolio that got excluded and warn the current portfolio manager
+    if excluded_positions:
+        body = (
+            "<p>While drifting the portfolios, the following quotes got excluded because of missing prices: </p><ul>"
+        )
+        for quote, portfolios in excluded_positions.items():
+            body += f"<li>{quote}</li><p>Impacted portfolios: </p><ul>"
+            for portfolio in portfolios:
+                body += f"<li>{portfolio}</li>"
+            body += "</ul>"
+        body += "</ul> <p>Note: If the quote has simply changed its primary exchange, please use the adjustment tool provided. Otherwise, please contact a system administrator.</p>"
+        for user in User.objects.filter(profile__in=PortfolioRole.portfolio_managers(), is_active=True):
+            send_notification(
+                code="wbportfolio.portfolio.warning",
+                title="Positions were automatically excluded",
+                body=body,
+                user=user,
+            )

wbportfolio/models/portfolio_relationship.py

@@ -61,6 +61,9 @@ class InstrumentPortfolioThroughModel(models.Model):
             models.UniqueConstraint(fields=["instrument", "portfolio"], name="unique_portfolio_relationship"),
         ]
 
+    def __str__(self) -> str:
+        return f"{self.instrument} - {self.portfolio}"
+
     @classmethod
     def get_portfolio(cls, instrument):
         with suppress(InstrumentPortfolioThroughModel.DoesNotExist):
@@ -99,6 +102,9 @@ class PortfolioInstrumentPreferredClassificationThroughModel(models.Model):
         related_name="preferred_classification_group_throughs",
     )
 
+    def __str__(self) -> str:
+        return f"{self.portfolio} - {self.instrument}: ({self.classification})"
+
     def save(self, *args, **kwargs) -> None:
         if not self.classification_group and self.classification:
             self.classification_group = self.classification.group

wbportfolio/models/products.py

@@ -190,6 +190,9 @@ class FeeProductPercentage(models.Model):
             ),
         ]
 
+    def __str__(self) -> str:
+        return f"{self.product.name} ({self.type})"
+
     @property
     def net_percent(self) -> Decimal:
         return self.percent

wbportfolio/models/rebalancing.py

@@ -89,6 +89,9 @@ class Rebalancer(ComplexToStringMixin, models.Model):
         help_text=_("The Evaluation Frequency in RRULE format"),
     )
 
+    def __str__(self) -> str:
+        return f"{self.portfolio.name} ({self.rebalancing_model})"
+
     def save(self, *args, **kwargs):
         if not self.activation_date:
             try:
@@ -108,7 +111,7 @@ class Rebalancer(ComplexToStringMixin, models.Model):
     def is_valid(self, trade_date: date) -> bool:
         if OrderProposal.objects.filter(
             portfolio=self.portfolio,
-            status=OrderProposal.Status.APPLIED,
+            status=OrderProposal.Status.CONFIRMED,
             trade_date=trade_date,
             rebalancing_model__isnull=True,
         ).exists():  # if a already applied order proposal exists, we do not allow a re-evaluatioon of the rebalancing (only possible if "replayed")