wbportfolio 1.54.22__py2.py3-none-any.whl → 1.55.0__py2.py3-none-any.whl

wbportfolio/models/orders/order_proposals.py

@@ -26,6 +26,7 @@ from wbcompliance.models.risk_management.mixins import RiskCheckMixin
 from wbcore.contrib.authentication.models import User
 from wbcore.contrib.icons import WBIcon
 from wbcore.contrib.notifications.dispatch import send_notification
+from wbcore.contrib.notifications.utils import create_notification_type
 from wbcore.enums import RequestType
 from wbcore.metadata.configs.buttons import ActionButton
 from wbcore.models import WBModel
@@ -36,10 +37,14 @@ from wbfdm.models.instruments.instruments import Cash, Instrument
 from wbportfolio.models.asset import AssetPosition
 from wbportfolio.models.roles import PortfolioRole
 from wbportfolio.pms.trading import TradingService
+from wbportfolio.pms.typing import Order as OrderDTO
 from wbportfolio.pms.typing import Portfolio as PortfolioDTO
 from wbportfolio.pms.typing import Position as PositionDTO
 
+from ...order_routing import ExecutionStatus, RoutingException
+from ...order_routing.adapters import BaseCustodianAdapter
 from .orders import Order
+from .routing import cancel_rebalancing, execute_orders, get_execution_status
 
 logger = logging.getLogger("pms")
 
@@ -51,9 +56,11 @@ class OrderProposal(CloneMixin, RiskCheckMixin, WBModel):
 
     class Status(models.TextChoices):
         DRAFT = "DRAFT", "Draft"
-        SUBMIT = "SUBMIT", "Pending"
+        PENDING = "PENDING", "Pending"
         APPROVED = "APPROVED", "Approved"
         DENIED = "DENIED", "Denied"
+        APPLIED = "APPLIED", "Applied"
+        EXECUTION = "EXECUTION", "Execution"
         FAILED = "FAILED", "Failed"
 
     comment = models.TextField(default="", verbose_name="Order Comment", blank=True)
@@ -78,9 +85,34 @@ class OrderProposal(CloneMixin, RiskCheckMixin, WBModel):
         on_delete=models.PROTECT,
         verbose_name="Owner",
     )
+    approver = models.ForeignKey(
+        "directory.Person",
+        blank=True,
+        null=True,
+        related_name="approver_order_proposals",
+        on_delete=models.PROTECT,
+        verbose_name="Approver",
+    )
     min_order_value = models.IntegerField(
         default=0, verbose_name="Minimum Order Value", help_text="Minimum Order Value in the Portfolio currency"
     )
+    total_cash_weight = models.DecimalField(
+        default=Decimal("0"),
+        decimal_places=4,
+        max_digits=5,
+        verbose_name="Total Cash Weight",
+        help_text="The desired percentage for the cash component. The remaining percentage (100% minus this value) will be allocated to total target weighting. Default is 0%.",
+    )
+    total_effective_portfolio_contribution = models.DecimalField(
+        default=Decimal("1"),
+        max_digits=Order.ORDER_WEIGHTING_PRECISION * 2 + 3,
+        decimal_places=Order.ORDER_WEIGHTING_PRECISION * 2,
+    )
+    execution_status = models.CharField(
+        blank=True, default="", choices=ExecutionStatus.choices, verbose_name="Execution Status"
+    )
+    execution_status_detail = models.CharField(blank=True, default="", verbose_name="Execution Status Detail")
+    execution_comment = models.CharField(blank=True, default="", verbose_name="Execution Comment")
 
     class Meta:
         verbose_name = "Order Proposal"
@@ -92,6 +124,17 @@ class OrderProposal(CloneMixin, RiskCheckMixin, WBModel):
             ),
         ]
 
+        notification_types = [
+            create_notification_type(
+                "wbportfolio.order_proposal.push_model_changes",
+                "Push Model Changes",
+                "Sends a notification when a the change/orders are pushed to modeled after portfolios",
+                True,
+                True,
+                True,
+            )
+        ]
+
     def save(self, *args, **kwargs):
         # if a order proposal is created before the existing earliest order proposal, we automatically shift the linked instruments inception date to allow automatic NAV computation since the new inception date
         if not self.portfolio.order_proposals.filter(trade_date__lt=self.trade_date).exists():
@@ -134,6 +177,13 @@ class OrderProposal(CloneMixin, RiskCheckMixin, WBModel):
         except AssetPosition.DoesNotExist:
             return self.value_date
 
+    @cached_property
+    def custodian_adapter(self) -> BaseCustodianAdapter | None:
+        try:
+            return self.portfolio.get_authenticated_custodian_adapter(raise_exception=True)
+        except ValueError as e:
+            logger.warning("Error while instantiating custodian adapter: %s", e)
+
     @cached_property
     def value_date(self) -> date:
         return (self.trade_date - BDay(1)).date()
@@ -141,7 +191,7 @@ class OrderProposal(CloneMixin, RiskCheckMixin, WBModel):
     @property
     def previous_order_proposal(self) -> SelfOrderProposal | None:
         future_proposals = OrderProposal.objects.filter(portfolio=self.portfolio).filter(
-            trade_date__lt=self.trade_date, status=OrderProposal.Status.APPROVED
+            trade_date__lt=self.trade_date, status=OrderProposal.Status.APPLIED
         )
         if future_proposals.exists():
             return future_proposals.latest("trade_date")
@@ -150,7 +200,7 @@ class OrderProposal(CloneMixin, RiskCheckMixin, WBModel):
     @property
     def next_order_proposal(self) -> SelfOrderProposal | None:
         future_proposals = OrderProposal.objects.filter(portfolio=self.portfolio).filter(
-            trade_date__gt=self.trade_date, status=OrderProposal.Status.APPROVED
+            trade_date__gt=self.trade_date, status=OrderProposal.Status.APPLIED
         )
         if future_proposals.exists():
             return future_proposals.earliest("trade_date")
@@ -158,12 +208,34 @@ class OrderProposal(CloneMixin, RiskCheckMixin, WBModel):
 
     @property
     def cash_component(self) -> Cash:
-        return Cash.objects.get_or_create(
-            currency=self.portfolio.currency, defaults={"is_cash": True, "name": self.portfolio.currency.title}
-        )[0]
+        return self.portfolio.cash_component
+
+    @property
+    def total_effective_portfolio_weight(self) -> Decimal:
+        return Decimal("1.0")
+
+    @property
+    def total_expected_target_weight(self) -> Decimal:
+        return self.total_effective_portfolio_weight - self.total_cash_weight
+
+    @cached_property
+    def total_effective_portfolio_cash_weight(self) -> Decimal:
+        return self.portfolio.assets.filter(
+            models.Q(date=self.last_effective_date)
+            & (models.Q(underlying_quote__is_cash=True) | models.Q(underlying_quote__is_cash_equivalent=True))
+        ).aggregate(Sum("weighting"))["weighting__sum"] or Decimal("0")
+
+    @property
+    def execution_instruction(self):
+        # TODO make this dynamically configurable
+        return "MARKET_ON_CLOSE"
 
     def get_orders(self):
-        base_qs = self.orders.all().annotate(
+        # TODO Issue here: the cash is subqueried on the portfolio, on portfolio such as the fund, there is multiple cash component, that we exclude in the orders (and use a unique cash position instead)
+        # so the subquery returns the previous position (probably USD), but is missing the other cash aggregation. We need to find a way to handle that properly
+
+        orders = self.orders.all().annotate(
+            total_effective_portfolio_contribution=Value(self.total_effective_portfolio_contribution),
             last_effective_date=Subquery(
                 AssetPosition.unannotated_objects.filter(
                     date__lt=OuterRef("value_date"),
@@ -172,27 +244,33 @@ class OrderProposal(CloneMixin, RiskCheckMixin, WBModel):
                 .order_by("-date")
                 .values("date")[:1]
             ),
-            previous_weight=Coalesce(
-                Subquery(
-                    AssetPosition.unannotated_objects.filter(
-                        underlying_quote=OuterRef("underlying_instrument"),
-                        date=OuterRef("last_effective_date"),
-                        portfolio=OuterRef("portfolio"),
-                    )
-                    .values("portfolio")
-                    .annotate(s=Sum("weighting"))
-                    .values("s")[:1]
+            previous_weight=models.Case(
+                models.When(
+                    underlying_instrument__is_cash=False,
+                    then=Coalesce(
+                        Subquery(
+                            AssetPosition.unannotated_objects.filter(
+                                underlying_quote=OuterRef("underlying_instrument"),
+                                date=OuterRef("last_effective_date"),
+                                portfolio=OuterRef("portfolio"),
+                            )
+                            .values("portfolio")
+                            .annotate(s=Sum("weighting"))
+                            .values("s")[:1]
+                        ),
+                        Decimal(0),
+                    ),
                 ),
-                Decimal(0),
+                default=Value(self.total_effective_portfolio_cash_weight),
             ),
             contribution=F("previous_weight") * (F("daily_return") + Value(Decimal("1"))),
-        )
-        portfolio_contribution = base_qs.aggregate(s=Sum("contribution"))["s"] or Decimal("1")
-        orders = base_qs.annotate(
             effective_weight=Round(
-                F("contribution") / Value(portfolio_contribution), precision=Order.ORDER_WEIGHTING_PRECISION
+                models.Case(
+                    models.When(total_effective_portfolio_contribution=Value(Decimal("0")), then=Value(Decimal("0"))),
+                    default=F("contribution") / F("total_effective_portfolio_contribution"),
+                ),
+                precision=Order.ORDER_WEIGHTING_PRECISION,
             ),
-            tmp_effective_weight=F("contribution") / Value(portfolio_contribution),
             target_weight=Round(F("effective_weight") + F("weighting"), precision=Order.ORDER_WEIGHTING_PRECISION),
             effective_shares=Coalesce(
                 Subquery(
@@ -209,79 +287,155 @@ class OrderProposal(CloneMixin, RiskCheckMixin, WBModel):
             ),
             target_shares=F("effective_shares") + F("shares"),
         )
-        total_effective_weight = orders.aggregate(s=models.Sum("effective_weight"))["s"] or Decimal("1")
-        with suppress(Order.DoesNotExist):
-            largest_order = orders.latest("effective_weight")
-            if quant_error := Decimal("1") - total_effective_weight:
-                orders = orders.annotate(
-                    effective_weight=models.Case(
-                        models.When(
-                            id=largest_order.id, then=models.F("effective_weight") + models.Value(Decimal(quant_error))
+
+        if total_estimated_effective_weight := orders.aggregate(s=models.Sum("effective_weight"))["s"]:
+            with suppress(Order.DoesNotExist):
+                largest_order = orders.latest("effective_weight")
+                if quant_error := self.total_effective_portfolio_weight - total_estimated_effective_weight:
+                    orders = orders.annotate(
+                        effective_weight=models.Case(
+                            models.When(
+                                id=largest_order.id,
+                                then=models.F("effective_weight") + models.Value(Decimal(quant_error)),
+                            ),
+                            default=models.F("effective_weight"),
                         ),
-                        default=models.F("effective_weight"),
-                    ),
-                    target_weight=models.Case(
-                        models.When(
-                            id=largest_order.id, then=models.F("target_weight") + models.Value(Decimal(quant_error))
+                        target_weight=models.Case(
+                            models.When(
+                                id=largest_order.id,
+                                then=models.F("target_weight") + models.Value(Decimal(quant_error)),
+                            ),
+                            default=models.F("target_weight"),
                         ),
-                        default=models.F("target_weight"),
-                    ),
-                )
+                    )
         return orders.annotate(
             has_warnings=models.Case(
-                models.When(models.Q(price=0) | models.Q(target_weight__lt=0), then=Value(True)), default=Value(False)
+                models.When(
+                    (models.Q(price=0) & ~models.Q(target_weight=0)) | models.Q(target_weight__lt=0), then=Value(True)
+                ),
+                default=Value(False),
             ),
         )
 
+    def prepare_orders_for_execution(self) -> list[OrderDTO]:
+        executable_orders = []
+        for order in self.get_orders().select_related("underlying_instrument"):
+            instrument = order.underlying_instrument
+            # we support only the instrument type provided by the Order DTO class
+            asset_class = instrument.get_security_ancestor().instrument_type.key.upper()
+            try:
+                if instrument.refinitiv_identifier_code or instrument.ticker or instrument.sedol:
+                    executable_orders.append(
+                        OrderDTO(
+                            id=order.id,
+                            asset_class=OrderDTO.AssetType[asset_class],
+                            weighting=float(order.weighting),
+                            target_weight=float(order.target_weight),
+                            trade_date=order.value_date,
+                            shares=float(order.shares) if order.shares is not None else None,
+                            target_shares=float(order.target_shares) if order.target_shares is not None else None,
+                            refinitiv_identifier_code=instrument.refinitiv_identifier_code,
+                            bloomberg_ticker=instrument.ticker,
+                            sedol=instrument.sedol,
+                            execution_instruction=self.execution_instruction,
+                        )
+                    )
+                else:
+                    order.execution_confirmed = False
+                    order.execution_comment = "Underlying instrument does not have a valid identifier."
+                    order.save()
+            except AttributeError:
+                order.execution_confirmed = False
+                order.execution_comment = f"Unsupported asset class {asset_class.title()}."
+                order.save()
+
+        return executable_orders
+
     def __str__(self) -> str:
         return f"{self.portfolio.name}: {self.trade_date} ({self.status})"
 
-    def convert_to_portfolio(self, use_effective: bool = False, with_cash: bool = True) -> PortfolioDTO:
+    def convert_to_portfolio(
+        self, use_effective: bool = False, with_cash: bool = True, use_desired_target_weight: bool = False
+    ) -> PortfolioDTO:
         """
-        Data Transfer Object
+        Converts the internal portfolio state and pending orders into a PortfolioDTO.
+
+        Args:
+            use_effective: Use effective share quantities for positions if True.
+            with_cash: Include a cash position in the result if True.
+            use_desired_target_weight: Use desired target weights from orders if True.
+
         Returns:
-            DTO order object
+            PortfolioDTO: Object that encapsulates all portfolio positions.
         """
         portfolio = {}
-        for asset in self.portfolio.assets.filter(date=self.last_effective_date):
-            portfolio[asset.underlying_quote] = dict(
-                shares=asset._shares,
-                weighting=asset.weighting,
-                delta_weight=Decimal("0"),
-                price=asset._price,
-                currency_fx_rate=asset._currency_fx_rate,
-            )
-        for order in self.get_orders():
-            portfolio[order.underlying_instrument] = dict(
-                weighting=order._previous_weight,
-                delta_weight=order.weighting,
-                shares=order._target_shares if not use_effective else order._effective_shares,
-                price=order.price,
-                currency_fx_rate=order.currency_fx_rate,
-            )
-        previous_weights = dict(map(lambda r: (r[0].id, float(r[1]["weighting"])), portfolio.items()))
+
+        # 1. Gather all non-cash, positively weighted assets from the existing portfolio.
+        for asset in self.portfolio.assets.filter(
+            date=self.last_effective_date,
+            # underlying_quote__is_cash=False,
+            # underlying_quote__is_cash_equivalent=False,
+            weighting__gt=0,
+        ):
+            portfolio[asset.underlying_quote] = {
+                "shares": asset._shares,
+                "weighting": asset.weighting,
+                "delta_weight": Decimal("0"),
+                "price": asset._price,
+                "currency_fx_rate": asset._currency_fx_rate,
+            }
+
+        # 2. Add or update non-cash orders, possibly overriding weights.
+        for order in self.get_orders().filter(
+            underlying_instrument__is_cash=False, underlying_instrument__is_cash_equivalent=False
+        ):
+            if use_desired_target_weight and order.desired_target_weight is not None:
+                delta_weight = Decimal("0")
+                weighting = order.desired_target_weight
+            else:
+                delta_weight = order.weighting
+                weighting = order._previous_weight
+
+            portfolio[order.underlying_instrument] = {
+                "weighting": weighting,
+                "delta_weight": delta_weight,
+                "shares": order._target_shares if not use_effective else order._effective_shares,
+                "price": order.price,
+                "currency_fx_rate": order.currency_fx_rate,
+            }
+
+        # 3. Prepare a mapping from instrument IDs to weights for analytic calculations.
+        previous_weights = {instrument.id: float(info["weighting"]) for instrument, info in portfolio.items()}
+
+        # 4. Attempt to fetch analytic returns and portfolio contribution. Default on error.
         try:
-            last_returns, portfolio_contribution = self.portfolio.get_analytic_portfolio(
+            last_returns, contribution = self.portfolio.get_analytic_portfolio(
                 self.value_date, weights=previous_weights, use_dl=True
             ).get_contributions()
             last_returns = last_returns.to_dict()
         except ValueError:
-            last_returns, portfolio_contribution = {}, 1
+            last_returns, contribution = {}, 1
+
         positions = []
         total_weighting = Decimal("0")
+
+        # 5. Build PositionDTO objects for all instruments.
         for instrument, row in portfolio.items():
             weighting = row["weighting"]
             daily_return = Decimal(last_returns.get(instrument.id, 0))
-            if not use_effective:
-                drifted_weight = (
-                    round(
-                        weighting * (daily_return + Decimal("1")) / Decimal(portfolio_contribution),
+
+            # Optionally apply drift to weightings if required
+            if not use_effective and not use_desired_target_weight:
+                if contribution:
+                    drifted_weight = round(
+                        weighting * (daily_return + Decimal("1")) / Decimal(contribution),
                         Order.ORDER_WEIGHTING_PRECISION,
                     )
-                    if portfolio_contribution
-                    else weighting
-                )
+                else:
+                    drifted_weight = weighting
                 weighting = drifted_weight + row["delta_weight"]
+
+            # Assemble the position object
             positions.append(
                 PositionDTO(
                     underlying_instrument=instrument.id,
@@ -297,9 +451,18 @@ class OrderProposal(CloneMixin, RiskCheckMixin, WBModel):
                 )
             )
             total_weighting += weighting
-        if portfolio and with_cash and (cash_weight := Decimal("1") - total_weighting):
+
+        # 6. Optionally include a cash position to balance the total weighting.
+        if (
+            portfolio
+            and with_cash
+            and total_weighting
+            and self.total_effective_portfolio_weight
+            and (cash_weight := self.total_effective_portfolio_weight - total_weighting)
+        ):
             cash_position = self.get_estimated_target_cash(target_cash_weight=cash_weight)
             positions.append(cash_position._build_dto())
+
         return PortfolioDTO(positions)
 
     # Start tools methods
@@ -332,7 +495,7 @@ class OrderProposal(CloneMixin, RiskCheckMixin, WBModel):
 
         return order_proposal_clone
 
-    def normalize_orders(self, total_target_weight: Decimal = Decimal("1.0")):
+    def normalize_orders(self):
         """
         Call the trading service with the existing orders and normalize them in order to obtain a total sum target weight of 100%
         The existing order will be modified directly with the given normalization factor
@@ -341,7 +504,7 @@ class OrderProposal(CloneMixin, RiskCheckMixin, WBModel):
             self.trade_date,
             effective_portfolio=self._get_default_effective_portfolio(),
             target_portfolio=self.convert_to_portfolio(use_effective=False, with_cash=False),
-            total_target_weight=total_target_weight,
+            total_target_weight=self.total_expected_target_weight,
         )
         leftovers_orders = self.orders.all()
         for underlying_instrument_id, order_dto in service.trades_batch.trades_map.items():
@@ -351,14 +514,19 @@ class OrderProposal(CloneMixin, RiskCheckMixin, WBModel):
                 order.save()
                 leftovers_orders = leftovers_orders.exclude(id=order.id)
         leftovers_orders.delete()
-        t_weight = self.get_orders().aggregate(models.Sum("target_weight"))["target_weight__sum"] or Decimal("0.0")
-        # we handle quantization error due to the decimal max digits. In that case, we take the biggest order (highest weight) and we remove the quantization error
-        if quantize_error := (t_weight - total_target_weight):
-            biggest_order = self.orders.latest("weighting")
-            biggest_order.weighting -= quantize_error
-            biggest_order.save()
-
-    def _get_default_target_portfolio(self, **kwargs) -> PortfolioDTO:
+        self.fix_quantization()
+
+    def fix_quantization(self):
+        if self.orders.exists():
+            orders = self.get_orders()
+            t_weight = orders.aggregate(models.Sum("target_weight"))["target_weight__sum"] or Decimal("0.0")
+            # we handle quantization error due to the decimal max digits. In that case, we take the biggest order (highest weight) and we remove the quantization error
+            if quantize_error := (t_weight - self.total_expected_target_weight):
+                biggest_order = orders.exclude(underlying_instrument__is_cash=True).latest("target_weight")
+                biggest_order.weighting -= quantize_error
+                biggest_order.save()
+
+    def _get_default_target_portfolio(self, use_desired_target_weight: bool = False, **kwargs) -> PortfolioDTO:
         if self.rebalancing_model:
             params = {}
             if rebalancer := getattr(self.portfolio, "automatic_rebalancer", None):
@@ -367,7 +535,7 @@ class OrderProposal(CloneMixin, RiskCheckMixin, WBModel):
             return self.rebalancing_model.get_target_portfolio(
                 self.portfolio, self.trade_date, self.value_date, **params
             )
-        return self.convert_to_portfolio(use_effective=False)
+        return self.convert_to_portfolio(use_effective=False, use_desired_target_weight=use_desired_target_weight)
 
     def _get_default_effective_portfolio(self):
         return self.convert_to_portfolio(use_effective=True)
@@ -377,17 +545,19 @@ class OrderProposal(CloneMixin, RiskCheckMixin, WBModel):
         target_portfolio: PortfolioDTO | None = None,
         effective_portfolio: PortfolioRole | None = None,
         validate_order: bool = True,
-        total_target_weight: Decimal = Decimal("1.0"),
+        use_desired_target_weight: bool = False,
     ):
         """
         Will delete all existing orders and recreate them from the method `create_or_update_trades`
         """
         if self.rebalancing_model:
             self.orders.all().delete()
+        else:
+            self.orders.filter(underlying_instrument__is_cash=True).delete()
         # delete all existing orders
         # Get effective and target portfolio
         if not target_portfolio:
-            target_portfolio = self._get_default_target_portfolio()
+            target_portfolio = self._get_default_target_portfolio(use_desired_target_weight=use_desired_target_weight)
         if not effective_portfolio:
             effective_portfolio = self._get_default_effective_portfolio()
         if target_portfolio:
@@ -395,13 +565,15 @@ class OrderProposal(CloneMixin, RiskCheckMixin, WBModel):
                 self.trade_date,
                 effective_portfolio=effective_portfolio,
                 target_portfolio=target_portfolio,
-                total_target_weight=total_target_weight,
+                total_target_weight=self.total_expected_target_weight,
             )
             if validate_order:
                 service.is_valid()
                 orders = service.validated_trades
             else:
                 orders = service.trades_batch.trades_map.values()
+
+            objs = []
             for order_dto in orders:
                 instrument = Instrument.objects.get(id=order_dto.underlying_instrument)
                 currency_fx_rate = instrument.currency.convert(
@@ -424,25 +596,53 @@ class OrderProposal(CloneMixin, RiskCheckMixin, WBModel):
                         daily_return=daily_return,
                         currency_fx_rate=currency_fx_rate,
                     )
-                order.price = order.get_price()
-                order.order_type = Order.get_type(weighting, order_dto.previous_weight, order_dto.target_weight)
-                # if we cannot automatically find a price, we consider the stock is invalid and we sell it
-                if not order.price:
-                    order.price = Decimal("0.0")
-                    order.weighting = -order_dto.effective_weight
-
-                order.save()
+                order.desired_target_weight = order_dto.target_weight
+                order.order_type = Order.get_type(
+                    weighting, round(order_dto.previous_weight, 8), round(order_dto.target_weight, 8)
+                )
+                order.pre_save()
+                # # if we cannot automatically find a price, we consider the stock is invalid and we sell it
+                # if not order.price and order.weighting > 0:
+                #     order.price = Decimal("0.0")
+                #     order.weighting = -order_dto.effective_weight
+                objs.append(order)
+            Order.objects.bulk_create(
+                objs,
+                update_fields=[
+                    "value_date",
+                    "weighting",
+                    "daily_return",
+                    "currency_fx_rate",
+                    "order_type",
+                    "portfolio",
+                    "price",
+                    "price_gross",
+                    "desired_target_weight",
+                    # "shares"
+                ],
+                unique_fields=["order_proposal", "underlying_instrument"],
+                update_conflicts=True,
+                batch_size=1000,
+            )
         # final sanity check to make sure invalid order with effective and target weight of 0 are automatically removed:
-        self.get_orders().filter(target_weight=0, effective_weight=0).delete()
+        self.get_orders().exclude(underlying_instrument__is_cash=True).filter(
+            target_weight=0, effective_weight=0
+        ).delete()
+        self.get_orders().filter(target_weight=0).exclude(effective_shares=0).update(shares=-F("effective_shares"))
+        # self.fix_quantization()
+        self.total_effective_portfolio_contribution = effective_portfolio.portfolio_contribution
+        self.save()
 
-    def approve_workflow(
+    def apply_workflow(
         self,
-        approve_automatically: bool = True,
+        apply_automatically: bool = True,
         silent_exception: bool = False,
         force_reset_order: bool = False,
         **reset_order_kwargs,
     ):
-        if self.status == OrderProposal.Status.APPROVED:
+        # before, we need to save all positions in the builder first because effective weight depends on it
+        self.portfolio.builder.bulk_create_positions(delete_leftovers=True)
+        if self.status == OrderProposal.Status.APPLIED:
             logger.info("Reverting order proposal ...")
             self.revert()
         if self.status == OrderProposal.Status.DRAFT:
@@ -459,26 +659,35 @@ class OrderProposal(CloneMixin, RiskCheckMixin, WBModel):
                     return
             logger.info("Submitting order proposal ...")
             self.submit()
-        if self.status == OrderProposal.Status.SUBMIT:
-            logger.info("Approving order proposal ...")
-            if approve_automatically and self.portfolio.can_be_rebalanced:
-                self.approve(replay=False)
+        if self.status == OrderProposal.Status.PENDING:
+            self.approve()
+        if apply_automatically and self.portfolio.can_be_rebalanced:
+            logger.info("Applying order proposal ...")
+            self.apply(replay=False)
 
-    def replay(self, broadcast_changes_at_date: bool = True, reapply_order_proposal: bool = False):
+    def replay(
+        self,
+        broadcast_changes_at_date: bool = True,
+        reapply_order_proposal: bool = False,
+        synchronous: bool = False,
+        **reset_order_kwargs,
+    ):
         last_order_proposal = self
         last_order_proposal_created = False
-        self.portfolio.load_builder_returns(self.trade_date, date.today())
-        while last_order_proposal and last_order_proposal.status == OrderProposal.Status.APPROVED:
+        self.portfolio.load_builder_returns((self.trade_date - BDay(3)).date(), date.today())
+        while last_order_proposal and last_order_proposal.status == OrderProposal.Status.APPLIED:
             last_order_proposal.portfolio = self.portfolio  # we set the same ptf reference
             if not last_order_proposal_created:
-                if reapply_order_proposal:
+                if reapply_order_proposal or last_order_proposal.rebalancing_model:
                     logger.info(f"Replaying order proposal {last_order_proposal}")
-                    last_order_proposal.approve_workflow(silent_exception=True, force_reset_order=True)
+                    last_order_proposal.apply_workflow(
+                        silent_exception=True, force_reset_order=True, **reset_order_kwargs
+                    )
                     last_order_proposal.save()
                 else:
                     logger.info(f"Resetting order proposal {last_order_proposal}")
-                    last_order_proposal.reset_orders()
-                if last_order_proposal.status != OrderProposal.Status.APPROVED:
+                    last_order_proposal.reset_orders(**reset_order_kwargs)
+                if last_order_proposal.status != OrderProposal.Status.APPLIED:
                     break
             next_order_proposal = last_order_proposal.next_order_proposal
             if next_order_proposal:
@@ -517,8 +726,9 @@ class OrderProposal(CloneMixin, RiskCheckMixin, WBModel):
             else:
                 last_order_proposal_created = False
                 last_order_proposal = next_order_proposal
-        if broadcast_changes_at_date:
-            self.portfolio.builder.schedule_change_at_dates(synchronous=False, evaluate_rebalancer=False)
+        self.portfolio.builder.schedule_change_at_dates(
+            synchronous=synchronous, broadcast_changes_at_date=broadcast_changes_at_date
+        )
 
     def invalidate_future_order_proposal(self):
         # Delete all future automatic order proposals and set the manual one into a draft state
@@ -526,7 +736,7 @@ class OrderProposal(CloneMixin, RiskCheckMixin, WBModel):
             trade_date__gt=self.trade_date, rebalancing_model__isnull=False, comment="Automatic rebalancing"
         ).delete()
         for future_order_proposal in self.portfolio.order_proposals.filter(
-            trade_date__gt=self.trade_date, status=OrderProposal.Status.APPROVED
+            trade_date__gt=self.trade_date, status=OrderProposal.Status.APPLIED
         ):
             future_order_proposal.revert()
             future_order_proposal.save()
@@ -548,6 +758,11 @@ class OrderProposal(CloneMixin, RiskCheckMixin, WBModel):
         """
         # Retrieve the price of the underlying quote on the order date TODO: this is very slow and probably due to the to_date argument to the dl which slowdown drastically the query
 
+        # if an order exists for this estimation and the target weight is 0, then we return the inverse of the effective shares
+        with suppress(Order.DoesNotExist):
+            order = self.get_orders().get(underlying_instrument=underlying_quote)
+            if order.target_weight == 0:
+                return -order.effective_shares
         # Calculate the order's total value in the portfolio's currency
         trade_total_value_fx_portfolio = self.portfolio_total_asset_value * weight
 
@@ -585,9 +800,9 @@ class OrderProposal(CloneMixin, RiskCheckMixin, WBModel):
         # Retrieve orders with base information
         orders = self.get_orders()
         # Calculate the total target weight of all orders
-        total_target_weight = orders.exclude(underlying_instrument__is_cash=True).aggregate(
-            s=models.Sum("target_weight")
-        )["s"] or Decimal(0)
+        total_target_weight = orders.filter(
+            underlying_instrument__is_cash=False, underlying_instrument__is_cash_equivalent=False
+        ).aggregate(s=models.Sum("target_weight"))["s"] or Decimal(0)
         if target_cash_weight is None:
             target_cash_weight = Decimal("1") - total_target_weight
 
@@ -628,7 +843,7 @@ class OrderProposal(CloneMixin, RiskCheckMixin, WBModel):
     @transition(
         field=status,
         source=Status.DRAFT,
-        target=Status.SUBMIT,
+        target=Status.PENDING,
         permission=lambda instance, user: PortfolioRole.is_portfolio_manager(
             user.profile, portfolio=instance.portfolio
         ),
@@ -647,13 +862,16 @@ class OrderProposal(CloneMixin, RiskCheckMixin, WBModel):
     def submit(self, by=None, description=None, **kwargs):
         orders = []
         orders_validation_warnings = []
-        for order in self.get_orders():
+        qs = self.get_orders()
+        total_target_weight = Decimal("0")
+        for order in qs:
             order_warnings = order.submit(
                 by=by, description=description, portfolio_total_asset_value=self.portfolio_total_asset_value, **kwargs
             )
             if order_warnings:
                 orders_validation_warnings.extend(order_warnings)
             orders.append(order)
+            total_target_weight += order._target_weight
 
         Order.objects.bulk_update(orders, ["shares", "weighting", "desired_target_weight"])
 
@@ -663,6 +881,7 @@ class OrderProposal(CloneMixin, RiskCheckMixin, WBModel):
             estimated_cash_position._build_dto()
         )
         self.evaluate_active_rules(self.trade_date, target_portfolio, asynchronously=True)
+        self.total_cash_weight = Decimal("1") - total_target_weight
         return orders_validation_warnings
 
     def can_submit(self):
@@ -687,18 +906,14 @@ class OrderProposal(CloneMixin, RiskCheckMixin, WBModel):
                 del self.__dict__["validated_trading_service"]
         return errors
 
-    @property
-    def can_be_approved_or_denied(self):
-        return not self.has_non_successful_checks and self.portfolio.is_manageable
-
     @transition(
         field=status,
-        source=Status.SUBMIT,
+        source=Status.PENDING,
         target=Status.APPROVED,
         permission=lambda instance, user: PortfolioRole.is_portfolio_manager(
             user.profile, portfolio=instance.portfolio
         )
-        and instance.can_be_approved_or_denied,
+        and not instance.has_non_successful_checks,
         custom={
             "_transition_button": ActionButton(
                 method=RequestType.PATCH,
@@ -711,7 +926,65 @@ class OrderProposal(CloneMixin, RiskCheckMixin, WBModel):
             )
         },
     )
-    def approve(self, by=None, description=None, replay: bool = True, **kwargs):
+    def approve(self, by=None, description=None, **kwargs):
+        if by:
+            self.approver = getattr(by, "profile", None)
+        elif not self.approver:
+            self.approver = self.creator
+
+    def can_approve(self):
+        pass
+
+    @transition(
+        field=status,
+        source=Status.PENDING,
+        target=Status.DENIED,
+        permission=lambda instance, user: PortfolioRole.is_portfolio_manager(
+            user.profile, portfolio=instance.portfolio
+        )
+        and not instance.has_non_successful_checks,
+        custom={
+            "_transition_button": ActionButton(
+                method=RequestType.PATCH,
+                identifiers=("wbportfolio:orderproposal",),
+                icon=WBIcon.DENY.icon,
+                key="deny",
+                label="Deny",
+                action_label="Deny",
+                # description_fields="<p>Start: {{start}}</p><p>End: {{end}}</p><p>Title: {{title}}</p>",
+            )
+        },
+    )
+    def deny(self, by=None, description=None, **kwargs):
+        pass
+
+    def can_deny(self):
+        pass
+
+    @property
+    def can_be_applied(self):
+        return not self.has_non_successful_checks and self.portfolio.is_manageable
+
+    @transition(
+        field=status,
+        source=Status.APPROVED,
+        target=Status.APPLIED,
+        permission=lambda instance, user: PortfolioRole.is_portfolio_manager(
+            user.profile, portfolio=instance.portfolio
+        )
+        and instance.can_be_applied,
+        custom={
+            "_transition_button": ActionButton(
+                method=RequestType.PATCH,
+                identifiers=("wbportfolio:orderproposal",),
+                icon=WBIcon.SAVE.icon,
+                key="apply",
+                label="Apply",
+                action_label="Apply",
+            )
+        },
+    )
+    def apply(self, by=None, description=None, replay: bool = True, **kwargs):
         # We validate order which will create or update the initial asset positions
         if not self.portfolio.can_be_rebalanced:
             raise ValueError("Non-Rebalanceable portfolio cannot be traded manually.")
@@ -722,39 +995,47 @@ class OrderProposal(CloneMixin, RiskCheckMixin, WBModel):
         for order in self.get_orders():
             with suppress(ValueError):
                 # we add the corresponding asset only if it is not the cache position (already included in estimated_cash_position)
-                if order.underlying_instrument != estimated_cash_position.underlying_quote:
+                if (
+                    order.underlying_instrument != estimated_cash_position.underlying_quote
+                    and order._target_weight > 0
+                ):
                     assets[order.underlying_instrument.id] = order._target_weight
 
         # if there is cash leftover, we create an extra asset position to hold the cash component
-        if estimated_cash_position.weighting and len(assets) > 0:
+        if estimated_cash_position.weighting > 0 and len(assets) > 0:
             warnings.append(
                 f"We created automatically a cash position of weight {estimated_cash_position.weighting:.2%}"
             )
             assets[estimated_cash_position.underlying_quote.id] = estimated_cash_position.weighting
-
         self.portfolio.builder.add((self.trade_date, assets)).bulk_create_positions(
-            force_save=True, is_estimated=False
+            force_save=True, is_estimated=False, delete_leftovers=True
         )
         if replay and self.portfolio.is_manageable:
-            replay_as_task.delay(self.id, user_id=by.id if by else None, broadcast_changes_at_date=False)
+            replay_as_task.delay(
+                self.id, user_id=by.id if by else None, broadcast_changes_at_date=False, reapply_order_proposal=True
+            )
+        if by:
+            self.approver = by.profile
         return warnings
 
-    def can_approve(self):
+    def can_apply(self):
         errors = dict()
         orders = self.get_orders()
         if not self.portfolio.can_be_rebalanced:
             errors["non_field_errors"] = [_("The portfolio does not allow manual rebalanced")]
         if not orders.exists():
             errors["non_field_errors"] = [
-                _("At least one order needs to be submitted to be able to approve this proposal")
+                _("At least one order needs to be submitted to be able to apply this proposal")
             ]
         if not self.portfolio.can_be_rebalanced:
             errors["portfolio"] = [
-                [_("The portfolio needs to be a model portfolio in order to approve this order proposal manually")]
+                [_("The portfolio needs to be a model portfolio in order to apply this order proposal manually")]
             ]
         if self.has_non_successful_checks:
             errors["non_field_errors"] = [_("The pre orders rules did not passed successfully")]
-        if orders.filter(has_warnings=True).exclude(underlying_instrument__is_cash=True):
+        if orders.filter(has_warnings=True).filter(
+            underlying_instrument__is_cash=False, underlying_instrument__is_cash_equivalent=False
+        ):
             errors["non_field_errors"] = [
                 _("There is warning that needs to be addresses on the orders before approval.")
             ]
@@ -762,40 +1043,7 @@ class OrderProposal(CloneMixin, RiskCheckMixin, WBModel):
 
     @transition(
         field=status,
-        source=Status.SUBMIT,
-        target=Status.DENIED,
-        permission=lambda instance, user: PortfolioRole.is_portfolio_manager(
-            user.profile, portfolio=instance.portfolio
-        )
-        and instance.can_be_approved_or_denied,
-        custom={
-            "_transition_button": ActionButton(
-                method=RequestType.PATCH,
-                identifiers=("wbportfolio:orderproposal",),
-                icon=WBIcon.DENY.icon,
-                key="deny",
-                label="Deny",
-                action_label="Deny",
-                # description_fields="<p>Start: {{start}}</p><p>End: {{end}}</p><p>Title: {{title}}</p>",
-            )
-        },
-    )
-    def deny(self, by=None, description=None, **kwargs):
-        self.orders.all().delete()
-        with suppress(KeyError):
-            del self.__dict__["validated_trading_service"]
-
-    def can_deny(self):
-        errors = dict()
-        if not self.orders.all().exists():
-            errors["non_field_errors"] = [
-                _("At least one order needs to be submitted to be able to deny this proposal")
-            ]
-        return errors
-
-    @transition(
-        field=status,
-        source=Status.SUBMIT,
+        source=Status.PENDING,
         target=Status.DRAFT,
         permission=lambda instance, user: PortfolioRole.is_portfolio_manager(
             user.profile, portfolio=instance.portfolio
@@ -824,7 +1072,7 @@ class OrderProposal(CloneMixin, RiskCheckMixin, WBModel):
 
     @transition(
         field=status,
-        source=Status.APPROVED,
+        source=Status.APPLIED,
         target=Status.DRAFT,
         permission=lambda instance, user: PortfolioRole.is_portfolio_manager(
             user.profile, portfolio=instance.portfolio
@@ -842,6 +1090,7 @@ class OrderProposal(CloneMixin, RiskCheckMixin, WBModel):
         },
     )
     def revert(self, **kwargs):
+        self.approver = None
         with suppress(KeyError):
             del self.__dict__["validated_trading_service"]
         self.portfolio.assets.filter(date=self.trade_date, is_estimated=False).update(
@@ -856,6 +1105,84 @@ class OrderProposal(CloneMixin, RiskCheckMixin, WBModel):
             ]
         return errors
 
+    @transition(
+        field=status,
+        source=Status.APPROVED,
+        target=Status.EXECUTION,
+        permission=lambda instance, user: PortfolioRole.is_portfolio_manager(
+            user.profile, portfolio=instance.portfolio
+        )
+        and (user != instance.approver or user.is_superuser)
+        and instance.custodian_adapter
+        and not instance.has_non_successful_checks,
+        custom={
+            "_transition_button": ActionButton(
+                method=RequestType.PATCH,
+                identifiers=("wbportfolio:orderproposal",),
+                icon=WBIcon.DEAL_MONEY.icon,
+                key="execute",
+                label="Execute",
+                action_label="Execute",
+                description_fields="<p>Execute the orders through the setup custodian.</p>",
+            )
+        },
+    )
+    def execute(self, **kwargs):
+        self.execution_status = ExecutionStatus.PENDING
+        self.execution_comment = "Waiting for custodian confirmation"
+        execute_orders_as_task.delay(self.id)
+
+    def can_execute(self):
+        if not self.custodian_adapter:
+            return {"portfolio": ["No custodian adapter"]}
+
+    @transition(
+        field=status,
+        source=Status.EXECUTION,
+        target=Status.APPROVED,
+        permission=lambda instance, user: PortfolioRole.is_portfolio_manager(
+            user.profile, portfolio=instance.portfolio
+        )
+        and instance.execution_status in [ExecutionStatus.PENDING, ExecutionStatus.IN_DRAFT],
+        custom={
+            "_transition_button": ActionButton(
+                method=RequestType.PATCH,
+                identifiers=("wbportfolio:orderproposal",),
+                icon=WBIcon.PREVIOUS.icon,
+                key="cancelexecution",
+                label="Cancel Execution",
+                action_label="Cancel Execution",
+                description_fields="<p>Cancel the current requested execution. Time sensitive operation.</p>",
+            )
+        },
+    )
+    def cancelexecution(self, **kwargs):
+        warning = ""
+        try:
+            if cancel_rebalancing(self):
+                self.execution_comment, self.execution_status_detail, self.execution_status = (
+                    "",
+                    "",
+                    ExecutionStatus.CANCELLED,
+                )
+            else:
+                warning = "We could not cancel the rebalancing. It is probably already executed. Please refresh status or check with an administrator."
+        except (RoutingException, ValueError) as e:
+            warning = f"Could not cancel orders proposal {self}: {str(e)}"
+            logger.error(warning)
+        return warning
+
+    def can_cancelexecution(self):
+        if not self.execution_status in [ExecutionStatus.PENDING, ExecutionStatus.IN_DRAFT]:
+            return {"execution_status": "Execution can only be cancelled if it is not already executed"}
+
+    def update_execution_status(self):
+        try:
+            self.execution_status, self.execution_status_detail = get_execution_status(self)
+            self.save()
+        except (RoutingException, ValueError) as e:
+            logger.warning(f"Could not update rebalancing status: {str(e)}")
+
     # End FSM logics
 
     @classmethod
@@ -881,7 +1208,6 @@ def post_fail_order_proposal(sender, instance: OrderProposal, created, raw, **kw
     if not raw and instance.status == OrderProposal.Status.FAILED:
         # we delete all order proposal that have a rebalancing model and are marked as "automatic" (quite hardcoded yet)
         instance.invalidate_future_order_proposal()
-        instance.invalidate_future_order_proposal()
 
 
 @shared_task(queue="portfolio")
@@ -898,3 +1224,59 @@ def replay_as_task(order_proposal_id, user_id: int | None = None, **kwargs):
             reverse_name="wbportfolio:portfolio-detail",
             reverse_args=[order_proposal.portfolio.id],
         )
+
+
+@shared_task(queue="portfolio")
+def execute_orders_as_task(order_proposal_id: int):
+    order_proposal = OrderProposal.objects.get(id=order_proposal_id)
+    try:
+        status, comment = execute_orders(order_proposal)
+    except (ValueError, RoutingException) as e:
+        logger.error(f"Could not execute orders proposal {order_proposal}: {str(e)}")
+        status = ExecutionStatus.FAILED
+        comment = str(e)
+    order_proposal.execution_status = status
+    order_proposal.execution_comment = comment
+    order_proposal.save()
+
+
+@shared_task(queue="portfolio")
+def push_model_change_as_task(
+    model_order_proposal_id: int,
+    user_id: int,
+    only_for_portfolio_ids: list[int] | None = None,
+    approve_automatically: bool = False,
+):
+    # not happy with that but we will keep it for the MVP lifecycle
+    model_order_proposal = OrderProposal.objects.get(id=model_order_proposal_id)
+    trade_date = model_order_proposal.trade_date
+    user = User.objects.get(id=user_id)
+    from wbportfolio.models.rebalancing import RebalancingModel
+
+    model_rebalancing = RebalancingModel.objects.get(
+        class_path="wbportfolio.rebalancing.models.model_portfolio.ModelPortfolioRebalancing"
+    )
+    product_html_list = "<ul>\n"
+    for rel in model_order_proposal.portfolio.get_model_portfolio_relationships(trade_date):
+        if not only_for_portfolio_ids or rel.portfolio.id in only_for_portfolio_ids:
+            order_proposal, _ = OrderProposal.objects.update_or_create(
+                portfolio=rel.portfolio, trade_date=trade_date, defaults={"rebalancing_model": model_rebalancing}
+            )
+            order_proposal.reset_orders()
+            product_html_list += f"<li>{rel.portfolio}</li>\n"
+            if approve_automatically:
+                order_proposal.submit()
+                order_proposal.approve(by=user)
+                order_proposal.save()
+    product_html_list += "</ul>"
+
+    send_notification(
+        code="wbportfolio.order_proposal.push_model_changes",
+        title="Portfolio Model changes are pushed to dependant portfolios",
+        body=f"""
+<p>The latest updates to the portfolio model <strong>{model_order_proposal.portfolio}</strong> have been successfully applied to the associated portfolios, and corresponding orders have been created.</p>
+<p>To proceed with executing these orders, please review the following related portfolios: </p>
+        {product_html_list}
+        """,
+        user=user,
+    )