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

wbportfolio/models/orders/order_proposals.py

@@ -3,25 +3,30 @@ import math
 from contextlib import suppress
 from datetime import date, timedelta
 from decimal import Decimal
-from typing import Any, TypeVar
+from typing import Any, Self, TypeVar
 
+import pandas as pd
 from celery import shared_task
 from django.core.exceptions import ValidationError
+from django.core.validators import MaxValueValidator, MinValueValidator
 from django.db import DatabaseError, models
 from django.db.models import (
     F,
     OuterRef,
+    Q,
+    QuerySet,
     Subquery,
     Sum,
     Value,
 )
 from django.db.models.functions import Coalesce, Round
-from django.db.models.signals import post_save
+from django.db.models.signals import post_save, pre_delete
 from django.dispatch import receiver
 from django.utils.functional import cached_property
-from django.utils.translation import gettext_lazy as _
+from django.utils.translation import gettext_lazy
 from django_fsm import FSMField, transition
 from pandas._libs.tslibs.offsets import BDay
+from requests import HTTPError
 from wbcompliance.models.risk_management.mixins import RiskCheckMixin
 from wbcore.contrib.authentication.models import User
 from wbcore.contrib.icons import WBIcon
@@ -31,20 +36,20 @@ from wbcore.enums import RequestType
 from wbcore.metadata.configs.buttons import ActionButton
 from wbcore.models import WBModel
 from wbcore.utils.models import CloneMixin
+from wbfdm.enums import MarketData
 from wbfdm.models import InstrumentPrice
 from wbfdm.models.instruments.instruments import Cash, Instrument
+from wbfdm.signals import investable_universe_updated
 
 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 ...order_routing.router import Router
+from .. import Portfolio
 from .orders import Order
-from .routing import cancel_rebalancing, execute_orders, get_execution_status
 
 logger = logging.getLogger("pms")
 
@@ -59,8 +64,8 @@ class OrderProposal(CloneMixin, RiskCheckMixin, WBModel):
         PENDING = "PENDING", "Pending"
         APPROVED = "APPROVED", "Approved"
         DENIED = "DENIED", "Denied"
-        APPLIED = "APPLIED", "Applied"
         EXECUTION = "EXECUTION", "Execution"
+        CONFIRMED = "CONFIRMED", "Confirmed"
         FAILED = "FAILED", "Failed"
 
     comment = models.TextField(default="", verbose_name="Order Comment", blank=True)
@@ -96,12 +101,22 @@ class OrderProposal(CloneMixin, RiskCheckMixin, WBModel):
     min_order_value = models.IntegerField(
         default=0, verbose_name="Minimum Order Value", help_text="Minimum Order Value in the Portfolio currency"
     )
+    min_weighting = models.DecimalField(
+        max_digits=9,
+        decimal_places=Order.ORDER_WEIGHTING_PRECISION,
+        default=Decimal(0),
+        help_text="The minimum weight allowed for this order proposal ",
+        verbose_name="Minimum Weight",
+        validators=[MinValueValidator(Decimal("0")), MaxValueValidator(Decimal("1"))],
+    )
+
     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%.",
+        validators=[MinValueValidator(Decimal("0")), MaxValueValidator(Decimal("1"))],
     )
     total_effective_portfolio_contribution = models.DecimalField(
         default=Decimal("1"),
@@ -135,7 +150,17 @@ class OrderProposal(CloneMixin, RiskCheckMixin, WBModel):
             )
         ]
 
+    def __str__(self) -> str:
+        return f"{self.portfolio.name}: {self.trade_date} ({self.status})"
+
     def save(self, *args, **kwargs):
+        # if the order proposal is created, we default these fields with the portfolio default value for automatic value assignement
+        if not self.id and not self.min_order_value:
+            self.min_order_value = self.portfolio.default_order_proposal_min_order_value
+        if not self.id and not self.min_weighting:
+            self.min_weighting = self.portfolio.default_order_proposal_min_weighting
+        if not self.id and not self.total_cash_weight:
+            self.total_cash_weight = self.portfolio.default_order_proposal_total_cash_weight
         # 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():
             # we need to set the inception date as the first order proposal trade date (and thus, the first position date). We expect a NAV at 100 then
@@ -154,21 +179,7 @@ class OrderProposal(CloneMixin, RiskCheckMixin, WBModel):
 
     @cached_property
     def portfolio_total_asset_value(self) -> Decimal:
-        return self.portfolio.get_total_asset_value(self.last_effective_date)
-
-    @cached_property
-    def validated_trading_service(self) -> TradingService:
-        """
-        This property holds the validated trading services and cache it.This property expect to be set only if is_valid return True
-        """
-        target_portfolio = self.convert_to_portfolio()
-
-        return TradingService(
-            self.trade_date,
-            effective_portfolio=self._get_default_effective_portfolio(),
-            target_portfolio=target_portfolio,
-            total_target_weight=target_portfolio.total_weight,
-        )
+        return self.get_portfolio_total_asset_value()
 
     @cached_property
     def last_effective_date(self) -> date:
@@ -177,10 +188,10 @@ class OrderProposal(CloneMixin, RiskCheckMixin, WBModel):
         except AssetPosition.DoesNotExist:
             return self.value_date
 
-    @cached_property
-    def custodian_adapter(self) -> BaseCustodianAdapter | None:
+    @property
+    def custodian_router(self) -> Router | None:
         try:
-            return self.portfolio.get_authenticated_custodian_adapter(raise_exception=True)
+            return Router(self.portfolio.get_authenticated_custodian_adapter(raise_exception=True))
         except ValueError as e:
             logger.warning("Error while instantiating custodian adapter: %s", e)
 
@@ -191,7 +202,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.APPLIED
+            trade_date__lt=self.trade_date, status=OrderProposal.Status.CONFIRMED
         )
         if future_proposals.exists():
             return future_proposals.latest("trade_date")
@@ -200,7 +211,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.APPLIED
+            trade_date__gt=self.trade_date, status=OrderProposal.Status.CONFIRMED
         )
         if future_proposals.exists():
             return future_proposals.earliest("trade_date")
@@ -218,6 +229,14 @@ class OrderProposal(CloneMixin, RiskCheckMixin, WBModel):
     def total_expected_target_weight(self) -> Decimal:
         return self.total_effective_portfolio_weight - self.total_cash_weight
 
+    @property
+    def can_be_confirmed(self) -> bool:
+        return self.portfolio.can_be_rebalanced and self.status == self.Status.APPROVED
+
+    @property
+    def can_be_applied(self):
+        return not self.has_non_successful_checks and self.portfolio.is_manageable
+
     @cached_property
     def total_effective_portfolio_cash_weight(self) -> Decimal:
         return self.portfolio.assets.filter(
@@ -225,10 +244,24 @@ class OrderProposal(CloneMixin, RiskCheckMixin, WBModel):
             & (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_portfolio_total_asset_value(self):
+        return self.portfolio.get_total_asset_value(self.last_effective_date)
+        # return self.orders.annotate(
+        #     effective_shares=Coalesce(
+        #         Subquery(
+        #             AssetPosition.objects.filter(
+        #                 underlying_quote=OuterRef("underlying_instrument"),
+        #                 date=self.last_effective_date,
+        #                 portfolio=self.portfolio,
+        #             )
+        #             .values("portfolio")
+        #             .annotate(s=Sum("shares"))
+        #             .values("s")[:1]
+        #         ),
+        #         Decimal(0),
+        #     ),
+        #     effective_total_value_fx_portfolio=F("effective_shares") * F("currency_fx_rate") * F("price"),
+        # ).aggregate(s=Sum("effective_total_value_fx_portfolio"))["s"] or Decimal(0.0)
 
     def get_orders(self):
         # 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)
@@ -267,7 +300,7 @@ class OrderProposal(CloneMixin, RiskCheckMixin, WBModel):
             effective_weight=Round(
                 models.Case(
                     models.When(total_effective_portfolio_contribution=Value(Decimal("0")), then=Value(Decimal("0"))),
-                    default=F("contribution") / F("total_effective_portfolio_contribution"),
+                    default=F("contribution") / F("total_effective_portfolio_contribution") - F("quantization_error"),
                 ),
                 precision=Order.ORDER_WEIGHTING_PRECISION,
             ),
@@ -288,26 +321,6 @@ class OrderProposal(CloneMixin, RiskCheckMixin, WBModel):
             target_shares=F("effective_shares") + F("shares"),
         )
 
-        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"),
-                        ),
-                        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"),
-                        ),
-                    )
         return orders.annotate(
             has_warnings=models.Case(
                 models.When(
@@ -317,153 +330,224 @@ class OrderProposal(CloneMixin, RiskCheckMixin, WBModel):
             ),
         )
 
-    def prepare_orders_for_execution(self) -> list[OrderDTO]:
+    def get_trades_batch(self):
+        return self._get_default_effective_portfolio().get_orders(self.get_target_portfolio())
+
+    @property
+    def can_be_executed(self) -> bool:
+        return (
+            self.custodian_router is not None
+            and not self.has_non_successful_checks
+            and self.status == self.Status.APPROVED
+            and (not self.execution_status or self.execution_status == ExecutionStatus.CANCELLED)
+        )
+
+    def can_execute(self, user: User) -> bool:
+        return (not self.approver or user.is_superuser or user != self.approver.user_account) and self.can_be_executed
+
+    def prepare_orders_for_execution(self, prioritize_target_weight: bool = False) -> list[OrderDTO]:
+        """Prepares executable orders by filtering and converting them for submission.
+
+        Filters out cash instruments and orders with zero weighting and shares, then
+        creates OrderDTOs for those having valid instrument identifiers. Orders with
+        unsupported asset classes or missing identifiers are marked as ignored with comments.
+        Updates ignored orders in bulk.
+
+        Args:
+            prioritize_target_weight: If True, prioritize target weight over share quantities
+              when preparing order quantities.
+
+        Returns:
+            A list of OrderDTO objects ready for execution submission.
+        """
         executable_orders = []
+        updated_orders = []
+        self.orders.update(execution_status=Order.ExecutionStatus.IGNORED)
         for order in (
-            self.get_orders().exclude(underlying_instrument__is_cash=True).select_related("underlying_instrument")
+            self.get_orders()
+            .exclude(models.Q(underlying_instrument__is_cash=True) | (models.Q(weighting=0) & models.Q(shares=0)))
+            .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:
+                    quantity = {"target_weight": float(order.target_weight)}
+                    if not prioritize_target_weight and order.shares:
+                        quantity["shares"] = float(order.shares)
+                        quantity["target_shares"] = (
+                            float(order.target_shares) if order.target_shares is not None else None
+                        )
+
                     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,
+                            bloomberg_ticker=instrument.bloomberg_ticker,
                             sedol=instrument.sedol,
-                            execution_instruction=self.execution_instruction,
+                            execution_instruction=order.execution_instruction,
+                            execution_instruction_parameters=order.execution_instruction_parameters,
+                            **quantity,
                         )
                     )
                 else:
-                    order.execution_confirmed = False
+                    order.execution_status = Order.ExecutionStatus.FAILED
                     order.execution_comment = "Underlying instrument does not have a valid identifier."
-                    order.save()
+                    updated_orders.append(order)
             except (AttributeError, KeyError):
-                order.execution_confirmed = False
+                order.execution_status = Order.ExecutionStatus.FAILED
                 order.execution_comment = f"Unsupported asset class {asset_class.title()}."
-                order.save()
+                updated_orders.append(order)
 
+        Order.objects.bulk_update(updated_orders, ["execution_status", "execution_comment"])
         return executable_orders
 
-    def __str__(self) -> str:
-        return f"{self.portfolio.name}: {self.trade_date} ({self.status})"
+    def handle_orders(self, orders: list[OrderDTO]):
+        """Updates order statuses based on confirmed execution results.
 
-    def convert_to_portfolio(
-        self, use_effective: bool = False, with_cash: bool = True, use_desired_target_weight: bool = False
-    ) -> PortfolioDTO:
-        """
-        Converts the internal portfolio state and pending orders into a PortfolioDTO.
+        For each confirmed order, updates the corresponding database record with its
+        execution status, comment, and price when available. Orders not present in the
+        confirmation list are marked as failed.
 
         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:
-            PortfolioDTO: Object that encapsulates all portfolio positions.
+            orders: List of confirmed order DTOs returned from the custodian router.
         """
-        portfolio = {}
+        leftover_orders = self.orders.filter(underlying_instrument__is_cash=False).all()
+        # portfolio_value = self.portfolio_total_asset_value
 
-        # 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,
-            }
+        for confirmed_order in orders:
+            with suppress(Order.DoesNotExist):
+                order = leftover_orders.get(id=confirmed_order.id)
+                order.execution_status = Order.ExecutionStatus.CONFIRMED
+                order.execution_comment = confirmed_order.comment
+                # if execution_price := confirmed_order.execution_price:
+                #     order.price = round(Decimal(execution_price), 2)
+                #     order.execution_status = Order.ExecutionStatus.EXECUTED
+                # if shares := confirmed_order.shares:
+                #     order.set_shares(Decimal(shares), portfolio_value)
+                # elif weighting := confirmed_order.weighting:
+                #     order.set_weighting(Decimal(weighting), portfolio_value)
+                order.save()
+                leftover_orders = leftover_orders.exclude(id=order.id)
 
-        # 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
+        leftover_orders.delete()
+        self.refresh_cash_position()
 
-            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,
-            }
+    def execute_orders(self, prioritize_target_weight: bool = False):
+        """Submits prepared orders for execution via the custodian router and updates status.
 
-        # 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()}
+        Prepares orders based on the target weight priority, submits them for execution,
+        handles confirmed orders on success, and records execution status and comments.
+        Logs and marks the execution as failed if submission raises an error.
 
-        # 4. Attempt to fetch analytic returns and portfolio contribution. Default on error.
+        Args:
+            prioritize_target_weight: Whether to prioritize target weights when preparing orders.
+        """
+        self.status = self.Status.EXECUTION
+        orders = self.prepare_orders_for_execution(prioritize_target_weight=prioritize_target_weight)
         try:
-            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, contribution = {}, 1
+            confirmed_orders, (status, rebalancing_comment) = self.custodian_router.submit_rebalancing(orders)
+            self.handle_orders(confirmed_orders)
+        except (ValueError, RoutingException, HTTPError) as e:
+            logger.error(f"Could not execute orders proposal {self}: {e}")
+            status = ExecutionStatus.FAILED
+            rebalancing_comment = str(e)
+        self.execution_status = status
+        self.execution_comment = rebalancing_comment
+        self.save()
 
-        positions = []
-        total_weighting = Decimal("0")
+    def refresh_execution_status(self):
+        """Updates execution status from the custodian router and saves the model.
 
-        # 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))
+        Retrieves the latest rebalance status and details, assigns them to the instance,
+        and persists changes to the database.
+        """
+        self.execution_status, self.execution_status_detail = self.custodian_router.get_rebalance_status()
+        if self.execution_status == ExecutionStatus.COMPLETED:
+            self.execution_status = self.Status.CONFIRMED
+        self.save()
 
-            # 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,
-                    )
-                else:
-                    drifted_weight = weighting
-                weighting = drifted_weight + row["delta_weight"]
+    def cancel_rebalancing(self):
+        """Cancels the ongoing rebalance via the custodian router and updates the model.
 
-            # Assemble the position object
-            positions.append(
-                PositionDTO(
-                    underlying_instrument=instrument.id,
-                    instrument_type=instrument.instrument_type.id,
-                    weighting=weighting,
-                    daily_return=daily_return if use_effective else Decimal("0"),
-                    shares=row["shares"],
-                    currency=instrument.currency.id,
-                    date=self.last_effective_date if use_effective else self.trade_date,
-                    is_cash=instrument.is_cash or instrument.is_cash_equivalent,
-                    price=row["price"],
-                    currency_fx_rate=row["currency_fx_rate"],
-                )
+        If cancellation succeeds, clears execution details, marks the status as cancelled,
+        saves the instance, and returns the cancellation status.
+        """
+        cancel_rebalancing_status = self.custodian_router.cancel_rebalancing()
+        if cancel_rebalancing_status:
+            (
+                self.execution_comment,
+                self.execution_status_detail,
+                self.execution_status,
+            ) = (
+                "",
+                "",
+                ExecutionStatus.CANCELLED,
             )
-            total_weighting += weighting
+            self.save()
+        return cancel_rebalancing_status
 
-        # 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())
+    def get_target_portfolio(self):
+        positions = []
+        instrument_ids = []
+        for order in self.get_orders():
+            pos = order.to_dto()
+            instrument_ids.append(pos.underlying_instrument)
+            positions.append(pos)
+
+        # insert latest market data
+        df = pd.DataFrame(
+            Instrument.objects.filter(id__in=instrument_ids).dl.market_data(
+                [MarketData.MARKET_CAPITALIZATION_CONSOLIDATED, MarketData.VOLUME, MarketData.CLOSE],
+                from_date=self.trade_date - timedelta(days=50),
+                to_date=self.trade_date,
+                target_currency="USD",
+            )
+        )
+        df["volume_50d"] = df["volume"]
+        df = (
+            df[
+                [
+                    "valuation_date",
+                    "instrument_id",
+                    "volume",
+                    "volume_50d",
+                    "close",
+                    "market_capitalization_consolidated",
+                ]
+            ]
+            .sort_values(by="valuation_date")
+            .groupby("instrument_id")
+            .agg(
+                {
+                    "volume": "last",
+                    "volume_50d": "mean",
+                    "close": "last",
+                    "market_capitalization_consolidated": "last",
+                }
+            )
+        )
+        df["volume_usd"] = df.volume * df.close
+
+        for pos in positions:
+            if pos.underlying_instrument in df.index:
+                pos.market_capitalization_usd = df.loc[pos.underlying_instrument, "market_capitalization_consolidated"]
+                pos.volume_usd = (
+                    df.loc[pos.underlying_instrument, "volume"] * df.loc[pos.underlying_instrument, "close"]
+                )
+                if pos.shares:
+                    if volume_50d := df.loc[pos.underlying_instrument, "volume_50d"]:
+                        pos.daily_liquidity = float(pos.shares) / volume_50d / 0.33
+                    if pos.market_capitalization_usd:
+                        pos.market_share = (
+                            float(pos.shares)
+                            * df.loc[pos.underlying_instrument, "close"]
+                            / pos.market_capitalization_usd
+                        )
 
         return PortfolioDTO(positions)
 
@@ -497,35 +581,26 @@ class OrderProposal(CloneMixin, RiskCheckMixin, WBModel):
 
         return order_proposal_clone
 
-    def normalize_orders(self):
+    def normalize_orders(self, total_cash_weight: Decimal):
         """
-        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
+        Normalize the orders to accomodate the given cash weight
         """
-        service = TradingService(
-            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=self.total_expected_target_weight,
-        )
-        leftovers_orders = self.orders.all()
-        for underlying_instrument_id, order_dto in service.trades_batch.trades_map.items():
-            with suppress(Order.DoesNotExist):
-                order = self.orders.get(underlying_instrument_id=underlying_instrument_id)
-                order.weighting = round(order_dto.delta_weight, Order.ORDER_WEIGHTING_PRECISION)
-                order.save()
-                leftovers_orders = leftovers_orders.exclude(id=order.id)
-        leftovers_orders.delete()
-        self.fix_quantization()
+        self.total_cash_weight = total_cash_weight
+        self.reset_orders()
 
     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")
+            t_weight = orders.aggregate(models.Sum("effective_weight"))["effective_weight__sum"] or Decimal("0.0")
+            quantization_error = orders.aggregate(models.Sum("quantization_error"))[
+                "quantization_error__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
+            if t_weight and (
+                quantize_error := ((t_weight + quantization_error) - self.total_effective_portfolio_weight)
+            ):
+                biggest_order = orders.exclude(underlying_instrument__is_cash=True).latest("effective_weight")
+                biggest_order.quantization_error = quantize_error
                 biggest_order.save()
 
     def _get_default_target_portfolio(self, use_desired_target_weight: bool = False, **kwargs) -> PortfolioDTO:
@@ -537,16 +612,93 @@ 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, use_desired_target_weight=use_desired_target_weight)
+        return self._get_default_effective_portfolio(
+            include_delta_weight=True, use_desired_target_weight=use_desired_target_weight
+        )
 
-    def _get_default_effective_portfolio(self):
-        return self.convert_to_portfolio(use_effective=True)
+    def _get_default_effective_portfolio(
+        self, include_delta_weight: bool = False, use_desired_target_weight: bool = False
+    ):
+        """
+        Converts the internal portfolio state and pending orders into a PortfolioDTO.
+
+        Returns:
+            PortfolioDTO: Object that encapsulates all portfolio positions.
+        """
+        portfolio = {}
+
+        try:
+            analytic_portfolio = self.portfolio.get_analytic_portfolio(self.last_effective_date, use_dl=True)
+            last_returns, contribution = analytic_portfolio.get_contributions()
+            last_returns = last_returns.to_dict()
+            effective_weights = analytic_portfolio.get_next_weights()
+        except ValueError:
+            effective_weights, last_returns, contribution = {}, {}, 1
+        self.total_effective_portfolio_contribution = Decimal(contribution)
+        # 1. Gather all non-cash, positively weighted assets from the existing portfolio.
+        for asset in self.portfolio.assets.filter(
+            date=self.last_effective_date,
+            weighting__gt=0,
+        ):
+            portfolio[asset.underlying_quote] = {
+                "shares": asset._shares,
+                "weighting": Decimal(effective_weights.get(asset.underlying_quote.id, asset.weighting))
+                if not use_desired_target_weight
+                else 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
+        ):
+            order.daily_return = last_returns.get(order.underlying_instrument.id, 0)
+            if use_desired_target_weight and order.desired_target_weight:
+                weighting = order.desired_target_weight
+            else:
+                weighting = order._effective_weight
+                if include_delta_weight:
+                    weighting += order.weighting
+            portfolio[order.underlying_instrument] = {
+                "weighting": weighting,
+                "shares": order._effective_shares,
+                "price": order.price,
+                "currency_fx_rate": order.currency_fx_rate,
+            }
+        positions = []
+
+        # 5. Build PositionDTO objects for all instruments.
+        for instrument, row in portfolio.items():
+            daily_return = Decimal(last_returns.get(instrument.id, 0))
+            # Assemble the position object
+            pos = Order.create_dto(
+                instrument,
+                row["weighting"],
+                row["price"],
+                self.last_effective_date,
+                shares=row["shares"],
+                daily_return=daily_return,
+                currency_fx_rate=row["currency_fx_rate"],
+            )
+            positions.append(pos)
+        total_weighting = sum(map(lambda pos: pos.weighting, positions))
+        # 6. Optionally include a cash position to balance the total weighting.
+        if (
+            portfolio
+            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)
 
     def reset_orders(
         self,
+        effective_portfolio: PortfolioDTO
+        | None = None,  # we need to have this parameter as sometime we want to get the effective portfolio from drifted weight (unsaved)
         target_portfolio: PortfolioDTO | None = None,
-        effective_portfolio: PortfolioRole | None = None,
-        validate_order: bool = True,
         use_desired_target_weight: bool = False,
     ):
         """
@@ -556,38 +708,26 @@ class OrderProposal(CloneMixin, RiskCheckMixin, WBModel):
             self.orders.all().delete()
         else:
             self.orders.filter(underlying_instrument__is_cash=True).delete()
+        self.orders.update(quantization_error=0)
         # delete all existing orders
         # Get effective and target portfolio
-        if not 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:
-            service = TradingService(
-                self.trade_date,
-                effective_portfolio=effective_portfolio,
-                target_portfolio=target_portfolio,
-                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()
+        if not target_portfolio:
+            target_portfolio = self._get_default_target_portfolio(use_desired_target_weight=use_desired_target_weight)
 
+        if self.total_cash_weight:
+            target_portfolio = target_portfolio.normalize_cash(self.total_cash_weight)
+        if target_portfolio:
             objs = []
-            for order_dto in orders:
+            portfolio_value = self.portfolio_total_asset_value
+            for order_dto in effective_portfolio.get_orders(target_portfolio):
                 instrument = Instrument.objects.get(id=order_dto.underlying_instrument)
-                currency_fx_rate = instrument.currency.convert(
-                    self.value_date, self.portfolio.currency, exact_lookup=True
-                )
                 # we cannot do a bulk-create because Order is a multi table inheritance
                 weighting = round(order_dto.delta_weight, Order.ORDER_WEIGHTING_PRECISION)
                 daily_return = order_dto.daily_return
                 try:
                     order = self.orders.get(underlying_instrument=instrument)
-                    order.weighting = weighting
-                    order.currency_fx_rate = currency_fx_rate
                     order.daily_return = daily_return
                 except Order.DoesNotExist:
                     order = Order(
@@ -596,17 +736,21 @@ class OrderProposal(CloneMixin, RiskCheckMixin, WBModel):
                         value_date=self.trade_date,
                         weighting=weighting,
                         daily_return=daily_return,
-                        currency_fx_rate=currency_fx_rate,
                     )
-                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)
+                    weighting, round(order_dto.effective_weight, 8), round(order_dto.target_weight, 8)
                 )
+                order.quantization_error = order_dto.effective_quantization_error
+                if order_dto.price:
+                    order.price = order_dto.price
                 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
+                order.set_weighting(weighting, portfolio_value)
+                order.desired_target_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 and order.weighting > 0:
+                    order.price = Decimal("0.0")
+                    order.weighting = -order_dto.effective_weight
                 objs.append(order)
             Order.objects.bulk_create(
                 objs,
@@ -620,7 +764,8 @@ class OrderProposal(CloneMixin, RiskCheckMixin, WBModel):
                     "price",
                     "price_gross",
                     "desired_target_weight",
-                    # "shares"
+                    "quantization_error",
+                    "shares",
                 ],
                 unique_fields=["order_proposal", "underlying_instrument"],
                 update_conflicts=True,
@@ -631,41 +776,53 @@ class OrderProposal(CloneMixin, RiskCheckMixin, WBModel):
             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.fix_quantization()
         self.save()
 
-    def apply_workflow(
-        self,
-        apply_automatically: bool = True,
-        silent_exception: bool = False,
-        force_reset_order: bool = False,
-        **reset_order_kwargs,
-    ):
-        # 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:
-            if (
-                self.rebalancing_model or force_reset_order
-            ):  # if there is no position (for any reason) or we the order proposal has a rebalancer model attached (orders are computed based on an aglo), we reapply this order proposal
-                logger.info("Resetting orders ...")
-                try:  # we silent any validation error while setting proposal, because if this happens, we assume the current order proposal state if valid and we continue to batch compute
-                    self.reset_orders(**reset_order_kwargs)
-                except (ValidationError, DatabaseError) as e:
-                    self.status = OrderProposal.Status.FAILED
-                    if not silent_exception:
-                        raise ValidationError(e)
-                    return
-            logger.info("Submitting order proposal ...")
-            self.submit()
-        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 refresh_cash_position(self):
+        self.total_cash_weight = self.total_effective_portfolio_weight - self.get_orders().filter(
+            underlying_instrument__is_cash=False
+        ).aggregate(s=Sum("target_weight"))["s"] or Decimal("0")
+        cash_order = None
+        try:
+            cash_order = Order.objects.get(order_proposal=self, underlying_instrument=self.cash_component)
+        except Order.DoesNotExist:
+            if self.total_cash_weight:
+                cash_order = Order.objects.create(
+                    order_proposal=self, underlying_instrument=self.cash_component, weighting=Decimal("0")
+                )
+        if cash_order:
+            cash_order.weighting = self.total_cash_weight - cash_order._previous_weight
+            cash_order.save()
+
+    def refresh_returns(self):
+        weights = {
+            row[0]: float(row[1]) for row in self.get_orders().values_list("underlying_instrument", "previous_weight")
+        }
+        last_returns, contribution = self.portfolio.get_analytic_portfolio(
+            self.value_date, weights=weights, use_dl=True
+        ).get_contributions()
+        last_returns = last_returns.to_dict()
+        orders_to_update = []
+        for order in self.orders.all():
+            with suppress(KeyError):
+                order.price = self.portfolio.builder.prices[self.trade_date][order.underlying_instrument.id]
+            try:
+                order.daily_return = last_returns[order.underlying_instrument.id]
+            except KeyError:
+                order.daily_return = Decimal("1.0")
+            order.quantization_error = Decimal("0")
+            orders_to_update.append(order)
+        Order.objects.bulk_update(orders_to_update, ["daily_return", "price", "quantization_error"])
+        self.total_effective_portfolio_contribution = Decimal(contribution)
+        self.save()
+        # ensure that sell orders keep having target weight at zero (might happens when returns are refreshed expost)
+        for order in self.get_orders().filter(Q(order_type=Order.Type.SELL) & ~Q(weighting=-F("target_weight"))):
+            order.weighting = -order.effective_weight
+            order.save()
+
+        # At this point, user needs to manually modify the orders in order to account for ex-post change. I am not sure we should we quantization at that point. To be monitored
+        # self.fix_quantization()
 
     def replay(
         self,
@@ -677,7 +834,7 @@ class OrderProposal(CloneMixin, RiskCheckMixin, WBModel):
         last_order_proposal = self
         last_order_proposal_created = False
         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:
+        while last_order_proposal and last_order_proposal.status == OrderProposal.Status.CONFIRMED:
             last_order_proposal.portfolio = self.portfolio  # we set the same ptf reference
             if not last_order_proposal_created:
                 if reapply_order_proposal or last_order_proposal.rebalancing_model:
@@ -689,7 +846,7 @@ class OrderProposal(CloneMixin, RiskCheckMixin, WBModel):
                 else:
                     logger.info(f"Resetting order proposal {last_order_proposal}")
                     last_order_proposal.reset_orders(**reset_order_kwargs)
-                if last_order_proposal.status != OrderProposal.Status.APPLIED:
+                if last_order_proposal.status != OrderProposal.Status.CONFIRMED:
                     break
             next_order_proposal = last_order_proposal.next_order_proposal
             if next_order_proposal:
@@ -738,7 +895,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.APPLIED
+            trade_date__gt=self.trade_date, status=OrderProposal.Status.CONFIRMED
         ):
             future_order_proposal.revert()
             future_order_proposal.save()
@@ -772,7 +929,6 @@ class OrderProposal(CloneMixin, RiskCheckMixin, WBModel):
         price_fx_portfolio = quote_price * underlying_quote.currency.convert(
             self.trade_date, self.portfolio.currency, exact_lookup=False
         )
-
         # If the price is valid, calculate and return the estimated shares
         if price_fx_portfolio:
             return trade_total_value_fx_portfolio / price_fx_portfolio
@@ -840,8 +996,7 @@ class OrderProposal(CloneMixin, RiskCheckMixin, WBModel):
             is_estimated=False,
         )
 
-    # Start FSM logics
-
+    # WORKFLOW METHODS
     @transition(
         field=status,
         source=Status.DRAFT,
@@ -852,7 +1007,7 @@ class OrderProposal(CloneMixin, RiskCheckMixin, WBModel):
         custom={
             "_transition_button": ActionButton(
                 method=RequestType.PATCH,
-                identifiers=("wbportfolio:orderproposal",),
+                identifiers=("wbportfolio:order",),
                 icon=WBIcon.SEND.icon,
                 key="submit",
                 label="Submit",
@@ -861,51 +1016,28 @@ class OrderProposal(CloneMixin, RiskCheckMixin, WBModel):
             )
         },
     )
-    def submit(self, by=None, description=None, **kwargs):
+    def submit(self, by=None, description=None, pretrade_check: bool = True, **kwargs):
         orders = []
         orders_validation_warnings = []
         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"])
-
-        # If we estimate cash on this order proposal, we make sure to create the corresponding cash component
-        estimated_cash_position = self.get_estimated_target_cash()
-        target_portfolio = self.validated_trading_service.trades_batch.convert_to_portfolio(
-            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
+        if pretrade_check:
+            self.evaluate_pretrade_checks()
+        else:
+            self.refresh_cash_position()
         return orders_validation_warnings
 
     def can_submit(self):
         errors = dict()
-        errors_list = []
-        service = self.validated_trading_service
-        try:
-            service.is_valid(ignore_error=True)
-            # if service.trades_batch.total_abs_delta_weight == 0:
-            #     errors_list.append(
-            #         "There is no change detected in this order proposal. Please submit at last one valid order"
-            #     )
-            if len(service.validated_trades) == 0:
-                errors_list.append(_("There is no valid order on this proposal"))
-            if service.errors:
-                errors_list.extend(service.errors)
-            if errors_list:
-                errors["non_field_errors"] = errors_list
-        except ValidationError:
-            errors["non_field_errors"] = service.errors
-            with suppress(KeyError):
-                del self.__dict__["validated_trading_service"]
         return errors
 
     @transition(
@@ -919,7 +1051,7 @@ class OrderProposal(CloneMixin, RiskCheckMixin, WBModel):
         custom={
             "_transition_button": ActionButton(
                 method=RequestType.PATCH,
-                identifiers=("wbportfolio:orderproposal",),
+                identifiers=("wbportfolio:order",),
                 icon=WBIcon.APPROVE.icon,
                 key="approve",
                 label="Approve",
@@ -928,14 +1060,70 @@ class OrderProposal(CloneMixin, RiskCheckMixin, WBModel):
             )
         },
     )
-    def approve(self, by=None, description=None, **kwargs):
+    def approve(self, by=None, replay: bool = True, **kwargs):
         if by:
             self.approver = getattr(by, "profile", None)
         elif not self.approver:
             self.approver = self.creator
+        if self.portfolio.can_be_rebalanced:
+            self.apply()
+            if replay:
+                replay_as_task.apply_async(
+                    (self.id,),
+                    {
+                        "user_id": by.id if by else None,
+                        "broadcast_changes_at_date": False,
+                        "reapply_order_proposal": True,
+                    },
+                    countdown=10,
+                )
+        if by and self.custodian_router:
+            for user in User.objects.exclude(id=by.id).filter(
+                profile__in=PortfolioRole.portfolio_managers(), is_active=True
+            ):
+                send_notification(
+                    code="wbportfolio.portfolio.action_done",
+                    title="An Order Proposal was approved and is waiting execution",
+                    body=f"The order proposal {self} has been approved by {by.profile.full_name} and is now pending execution. Please review the orders carefully and proceed with execution if appropriate.",
+                    user=user,
+                    reverse_name="wbportfolio:orderproposal-detail",
+                    reverse_args=[self.id],
+                )
 
-    def can_approve(self):
-        pass
+    @transition(
+        field=status,
+        source=Status.APPROVED,
+        target=Status.CONFIRMED,
+        permission=lambda instance, user: PortfolioRole.is_portfolio_manager(
+            user.profile, portfolio=instance.portfolio
+        )
+        and instance.portfolio.can_be_rebalanced,
+        custom={
+            "_transition_button": ActionButton(
+                method=RequestType.PATCH,
+                identifiers=("wbportfolio:order",),
+                icon=WBIcon.LOCK.icon,
+                key="confirm",
+                label="Confirm",
+                action_label="Lock order proposal",
+                # description_fields="<p>Start: {{start}}</p><p>End: {{end}}</p><p>Title: {{title}}</p>",
+            )
+        },
+    )
+    def confirm(self, by=None, replay: bool = True, **kwargs):
+        self.refresh_cash_position()
+        if self.portfolio.can_be_rebalanced:
+            self.apply()
+            if replay:
+                replay_as_task.apply_async(
+                    (self.id,),
+                    {
+                        "user_id": by.id if by else None,
+                        "broadcast_changes_at_date": False,
+                        "reapply_order_proposal": True,
+                    },
+                    countdown=10,
+                )
 
     @transition(
         field=status,
@@ -948,7 +1136,7 @@ class OrderProposal(CloneMixin, RiskCheckMixin, WBModel):
         custom={
             "_transition_button": ActionButton(
                 method=RequestType.PATCH,
-                identifiers=("wbportfolio:orderproposal",),
+                identifiers=("wbportfolio:order",),
                 icon=WBIcon.DENY.icon,
                 key="deny",
                 label="Deny",
@@ -963,85 +1151,17 @@ class OrderProposal(CloneMixin, RiskCheckMixin, WBModel):
     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):
+    def apply(self):
         # 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.")
-        warnings = []
+
         # We do not want to create the estimated cash position if there is not orders in the order proposal (shouldn't be possible anyway)
-        estimated_cash_position = self.get_estimated_target_cash()
-        assets = {}
-        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
-                    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 > 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
+        target_portfolio = self.get_target_portfolio()
+        assets = {i: float(pos.weighting) for i, pos in target_portfolio.positions_map.items()}
         self.portfolio.builder.add((self.trade_date, assets)).bulk_create_positions(
             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, reapply_order_proposal=True
-            )
-        if by:
-            self.approver = by.profile
-        return warnings
-
-    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 apply this proposal")
-            ]
-        if not self.portfolio.can_be_rebalanced:
-            errors["portfolio"] = [
-                [_("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).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.")
-            ]
-        return errors
 
     @transition(
         field=status,
@@ -1055,7 +1175,7 @@ class OrderProposal(CloneMixin, RiskCheckMixin, WBModel):
         custom={
             "_transition_button": ActionButton(
                 method=RequestType.PATCH,
-                identifiers=("wbportfolio:orderproposal",),
+                identifiers=("wbportfolio:order",),
                 icon=WBIcon.UNDO.icon,
                 key="backtodraft",
                 label="Back to Draft",
@@ -1065,8 +1185,6 @@ class OrderProposal(CloneMixin, RiskCheckMixin, WBModel):
         },
     )
     def backtodraft(self, **kwargs):
-        with suppress(KeyError):
-            del self.__dict__["validated_trading_service"]
         self.checks.delete()
 
     def can_backtodraft(self):
@@ -1074,7 +1192,7 @@ class OrderProposal(CloneMixin, RiskCheckMixin, WBModel):
 
     @transition(
         field=status,
-        source=Status.APPLIED,
+        source=Status.CONFIRMED,
         target=Status.DRAFT,
         permission=lambda instance, user: PortfolioRole.is_portfolio_manager(
             user.profile, portfolio=instance.portfolio
@@ -1082,7 +1200,7 @@ class OrderProposal(CloneMixin, RiskCheckMixin, WBModel):
         custom={
             "_transition_button": ActionButton(
                 method=RequestType.PATCH,
-                identifiers=("wbportfolio:orderproposal",),
+                identifiers=("wbportfolio:order",),
                 icon=WBIcon.REGENERATE.icon,
                 key="revert",
                 label="Revert",
@@ -1093,8 +1211,6 @@ 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(
             is_estimated=True
         )  # we delete the existing portfolio as it has been reverted
@@ -1103,87 +1219,45 @@ class OrderProposal(CloneMixin, RiskCheckMixin, WBModel):
         errors = dict()
         if not self.portfolio.can_be_rebalanced:
             errors["portfolio"] = [
-                _("The portfolio needs to be a model portfolio in order to revert this order proposal manually")
+                gettext_lazy(
+                    "The portfolio needs to be a model portfolio in order to revert this order proposal manually"
+                )
             ]
         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,
-                )
+    def apply_workflow(
+        self,
+        apply_automatically: bool = True,
+        silent_exception: bool = False,
+        force_reset_order: bool = False,
+        **reset_order_kwargs,
+    ):
+        # 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.CONFIRMED:
+            logger.info("Reverting order proposal ...")
+            self.revert()
+        if self.status == OrderProposal.Status.DRAFT:
+            if (
+                self.rebalancing_model or force_reset_order
+            ):  # if there is no position (for any reason) or we the order proposal has a rebalancer model attached (orders are computed based on an aglo), we reapply this order proposal
+                logger.info("Resetting orders ...")
+                try:  # we silent any validation error while setting proposal, because if this happens, we assume the current order proposal state if valid and we continue to batch compute
+                    self.reset_orders(**reset_order_kwargs)
+                except (ValidationError, DatabaseError) as e:
+                    self.status = OrderProposal.Status.FAILED
+                    if not silent_exception:
+                        raise ValidationError(e) from e
+                    return
+            logger.info("Submitting order proposal ...")
+            self.submit(pretrade_check=False)
+        if apply_automatically:
+            logger.info("Applying order proposal ...")
+            if self.status == OrderProposal.Status.PENDING:
+                self.approve(replay=False)
             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)}")
+                self.apply()
+            self.status = self.Status.CONFIRMED
 
     # End FSM logics
 
@@ -1203,6 +1277,55 @@ class OrderProposal(CloneMixin, RiskCheckMixin, WBModel):
     def get_representation_label_key(cls) -> str:
         return "{{_portfolio.name}} ({{trade_date}})"
 
+    @classmethod
+    def build(
+        cls,
+        trade_date: date,
+        portfolio,
+        target_portfolio: PortfolioDTO,
+        creator: User | None = None,
+        approve_automatically: bool = True,
+    ) -> Self:
+        order_proposal, _ = OrderProposal.objects.update_or_create(
+            portfolio=portfolio,
+            trade_date=trade_date,
+            defaults={"status": OrderProposal.Status.DRAFT, "creator": creator.profile if creator else None},
+        )
+        order_proposal.reset_orders(target_portfolio=target_portfolio)
+        if approve_automatically:
+            order_proposal.submit()
+            order_proposal.approve(by=creator)
+            if portfolio.can_be_rebalanced:
+                order_proposal.apply()
+            order_proposal.save()
+        return order_proposal
+
+    def push_to_dependant_portfolios(
+        self, only_portfolios: QuerySet[Portfolio] | None = None, **build_kwargs
+    ) -> list[Self]:
+        order_proposals = []
+        for rel in self.portfolio.get_model_portfolio_relationships(self.trade_date):
+            existing_order_proposal = OrderProposal.objects.filter(
+                portfolio=rel.portfolio, trade_date=self.trade_date
+            ).first()
+            # we allow push only on existing draft order proposal
+            dependency_portfolio = rel.dependency_portfolio
+            if (
+                (only_portfolios is None or rel.portfolio in only_portfolios)
+                and (not existing_order_proposal or existing_order_proposal.status == OrderProposal.Status.DRAFT)
+                and dependency_portfolio.assets.filter(date=self.trade_date).exists()
+            ):
+                target_portfolio = dependency_portfolio._build_dto(self.trade_date)
+                order_proposals.append(
+                    OrderProposal.build(self.trade_date, rel.portfolio, target_portfolio, **build_kwargs)
+                )
+        return order_proposals
+
+    def evaluate_pretrade_checks(self, asynchronously: bool = True):
+        self.checks.all().delete()
+        self.refresh_cash_position()
+        self.evaluate_active_rules(self.trade_date, self.get_target_portfolio(), asynchronously=asynchronously)
+
 
 @receiver(post_save, sender="wbportfolio.OrderProposal")
 def post_fail_order_proposal(sender, instance: OrderProposal, created, raw, **kwargs):
@@ -1212,73 +1335,80 @@ def post_fail_order_proposal(sender, instance: OrderProposal, created, raw, **kw
         instance.invalidate_future_order_proposal()
 
 
-@shared_task(queue="portfolio")
+@shared_task(queue="oms")
 def replay_as_task(order_proposal_id, user_id: int | None = None, **kwargs):
     order_proposal = OrderProposal.objects.get(id=order_proposal_id)
     order_proposal.replay(**kwargs)
     if user_id:
+        body = f'We’ve successfully replayed your order proposal for "{order_proposal.portfolio}" from {order_proposal.trade_date:%Y-%m-%d}. You can now review its updated composition.'
         user = User.objects.get(id=user_id)
+        if order_proposal.portfolio.builder.excluded_positions:
+            excluded_quotes = []
+            for batch in order_proposal.portfolio.builder.excluded_positions.values():
+                for pos in batch:
+                    excluded_quotes.append(pos.underlying_instrument)
+            body += "<p><strong>Note</strong></p><p>While replaying and drifting the portfolio, we excluded the positions from the following quotes because of missing price</p> <ul>"
+            for excluded_quote in set(excluded_quotes):
+                body += f"<li>{excluded_quote}</li>"
+            body += "</ul>"
+            order_proposal.portfolio.builder.clear()
         send_notification(
-            code="wbportfolio.portfolio.replay_done",
+            code="wbportfolio.portfolio.action_done",
             title="Order Proposal Replay Completed",
-            body=f'We’ve successfully replayed your order proposal for "{order_proposal.portfolio}" from {order_proposal.trade_date:%Y-%m-%d}. You can now review its updated composition.',
+            body=body,
             user=user,
             reverse_name="wbportfolio:portfolio-detail",
             reverse_args=[order_proposal.portfolio.id],
         )
 
 
-@shared_task(queue="portfolio")
-def execute_orders_as_task(order_proposal_id: int):
+@shared_task(queue="oms")
+def execute_orders_as_task(order_proposal_id: int, prioritize_target_weight: bool = False, **kwargs):
     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")
+    order_proposal.execute_orders()
+
+
+@shared_task(queue="oms")
 def push_model_change_as_task(
     model_order_proposal_id: int,
-    user_id: int,
+    user_id: int | None = None,
     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
+    user = User.objects.get(id=user_id) if user_id else None
+    params = dict(approve_automatically=approve_automatically, creator=user)
+    only_portfolios = None
+    if only_for_portfolio_ids:
+        only_portfolios = Portfolio.objects.filter(id__in=only_for_portfolio_ids)
 
-    model_rebalancing = RebalancingModel.objects.get(
-        class_path="wbportfolio.rebalancing.models.model_portfolio.ModelPortfolioRebalancing"
-    )
+    order_proposals = model_order_proposal.push_to_dependant_portfolios(only_portfolios=only_portfolios, **params)
     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()
+    for order_proposal in order_proposals:
+        product_html_list += f"<li>{order_proposal.portfolio}</li>\n"
+
     product_html_list += "</ul>"
+    if user:
+        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,
+        )
 
-    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,
-    )
+
+@receiver(investable_universe_updated, sender="wbfdm.Instrument")
+def update_exante_order_proposal_returns(*args, end_date: date | None = None, **kwargs):
+    for op in OrderProposal.objects.filter(trade_date__gte=end_date):
+        op.refresh_returns()
+
+
+@receiver(pre_delete, sender=OrderProposal)
+def post_delete_adjustment(sender, instance: OrderProposal, **kwargs):
+    for check in instance.checks.all():
+        check.delete()