wbportfolio 1.48.0__py2.py3-none-any.whl → 1.49.0__py2.py3-none-any.whl

wbportfolio/factories/__init__.py

@@ -9,18 +9,16 @@ from .claim import (
 from .custodians import CustodianFactory
 from .dividends import DividendTransactionsFactory
 from .fees import FeesFactory
-from wbfdm.factories.instrument_prices import InstrumentPriceFactory
 from .portfolios import (
     InstrumentPortfolioThroughModelFactory,
     ModelPortfolioFactory,
-    ModelPortfolioWithBaseProductFactory,
     PortfolioFactory,
 )
 from .portfolio_swing_pricings import PortfolioSwingPricingFactory
 from .portfolio_cash_targets import PortfolioCashTargetFactory
 from .portfolio_cash_flow import DailyPortfolioCashFlowFactory
 from .product_groups import ProductGroupFactory, ProductGroupRepresentantFactory
-from .products import IndexProductFactory, ProductFactory, WhiteLabelProductFactory
+from .products import IndexProductFactory, ProductFactory, WhiteLabelProductFactory, ModelPortfolioWithBaseProductFactory
 from .reconciliations import AccountReconciliationFactory, AccountReconciliationLineFactory
 from .roles import ManagerPortfolioRoleFactory, ProductPortfolioRoleFactory
 from .trades import CustomerTradeFactory, TradeFactory, TradeProposalFactory

wbportfolio/factories/portfolios.py

@@ -9,8 +9,6 @@ from wbportfolio.models import (
     PortfolioPortfolioThroughModel,
 )
 
-from .products import ProductFactory
-
 
 class PortfolioFactory(factory.django.DjangoModelFactory):
     class Meta:
@@ -43,16 +41,6 @@ class ModelPortfolioFactory(PortfolioFactory):
         )
 
 
-class ModelPortfolioWithBaseProductFactory(ModelPortfolioFactory):
-    @factory.post_generation
-    def create_instrument(self, create, extracted, **kwargs):
-        if create:
-            instrument = ProductFactory.create()
-            InstrumentPortfolioThroughModel.objects.update_or_create(
-                instrument=instrument, defaults={"portfolio": self}
-            )
-
-
 class InstrumentPortfolioThroughModelFactory(factory.django.DjangoModelFactory):
     instrument = factory.SubFactory("wbportfolio.factories.ProductFactory")
     portfolio = factory.SubFactory("wbportfolio.factories.PortfolioFactory")

wbportfolio/factories/product_groups.py

@@ -1,7 +1,8 @@
 import factory
 from wbfdm.factories.instruments import InstrumentFactory
 
-from wbportfolio.models import ProductGroup, ProductGroupRepresentant
+from wbportfolio.factories import PortfolioFactory
+from wbportfolio.models import InstrumentPortfolioThroughModel, ProductGroup, ProductGroupRepresentant
 
 
 class ProductGroupFactory(InstrumentFactory):
@@ -19,6 +20,12 @@ class ProductGroupFactory(InstrumentFactory):
     auditor = factory.SubFactory("wbcore.contrib.directory.factories.entries.CompanyFactory")
     paying_agent = factory.SubFactory("wbcore.contrib.directory.factories.entries.CompanyFactory")
 
+    @factory.post_generation
+    def create_initial_portfolio(product_group, *args, **kwargs):
+        if product_group.id and not product_group.portfolios.exists():
+            portfolio = PortfolioFactory.create()
+            InstrumentPortfolioThroughModel.objects.create(instrument=product_group, portfolio=portfolio)
+
 
 class ProductGroupRepresentantFactory(factory.django.DjangoModelFactory):
     class Meta:

wbportfolio/factories/products.py

@@ -4,6 +4,8 @@ import factory
 from wbcore.contrib.directory.factories.entries import CompanyFactory
 from wbfdm.factories.instruments import InstrumentFactory, InstrumentTypeFactory
 
+from wbportfolio.factories import ModelPortfolioFactory, PortfolioFactory
+from wbportfolio.models import InstrumentPortfolioThroughModel
 from wbportfolio.models.products import (
     AssetClass,
     InvestmentIndex,
@@ -37,6 +39,12 @@ class ProductFactory(InstrumentFactory):
     external_webpage = factory.Faker("url")
     instrument_type = factory.LazyAttribute(lambda o: InstrumentTypeFactory.create(name="Product", key="product"))
 
+    @factory.post_generation
+    def create_initial_portfolio(product, *args, **kwargs):
+        if product.id and not product.portfolios.exists():
+            portfolio = PortfolioFactory.create()
+            InstrumentPortfolioThroughModel.objects.create(instrument=product, portfolio=portfolio)
+
     # wbportfolio = factory.SubFactory(PortfolioFactory)
     # portfolio_computed = factory.SubFactory(PortfolioFactory)
 
@@ -55,3 +63,13 @@ class WhiteLabelProductFactory(ProductFactory):
 
 class IndexProductFactory(ProductFactory):
     pass
+
+
+class ModelPortfolioWithBaseProductFactory(ModelPortfolioFactory):
+    @factory.post_generation
+    def create_instrument(self, create, extracted, **kwargs):
+        if create:
+            instrument = ProductFactory.create()
+            InstrumentPortfolioThroughModel.objects.update_or_create(
+                instrument=instrument, defaults={"portfolio": self}
+            )

wbportfolio/factories/trades.py

@@ -1,11 +1,15 @@
 import random
 
 import factory
+from faker import Faker
+from pandas._libs.tslibs.offsets import BDay
 
 from wbportfolio.models import Trade, TradeProposal
 
 from .transactions import TransactionFactory
 
+fake = Faker()
+
 
 class TradeFactory(TransactionFactory):
     class Meta:
@@ -22,7 +26,7 @@ class TradeProposalFactory(factory.django.DjangoModelFactory):
     class Meta:
         model = TradeProposal
 
-    trade_date = factory.Faker("date_object")
+    trade_date = factory.LazyAttribute(lambda o: (fake.date_object() + BDay(1)).date())
     comment = factory.Faker("paragraph")
     portfolio = factory.SubFactory("wbportfolio.factories.PortfolioFactory")
     creator = factory.SubFactory("wbcore.contrib.directory.factories.PersonFactory")

wbportfolio/import_export/handlers/trade.py

@@ -24,6 +24,7 @@ class TradeImportHandler(ImportExportHandler):
         self.instrument_handler = InstrumentImportHandler(self.import_source)
         self.register_handler = RegisterImportHandler(self.import_source)
         self.currency_handler = CurrencyImportHandler(self.import_source)
+        self.trade_proposals = set()
 
     def _data_changed(self, _object, change_data: Dict[str, Any], initial_data: Dict[str, Any], **kwargs):
         if (new_register := change_data.get("register")) and (current_register := _object.register):
@@ -42,6 +43,7 @@ class TradeImportHandler(ImportExportHandler):
 
         if trade_proposal_id := data.pop("trade_proposal_id", None):
             trade_proposal = TradeProposal.objects.get(id=trade_proposal_id)
+            self.trade_proposals.add(trade_proposal)
             data["value_date"] = trade_proposal.last_effective_date
             data["transaction_date"] = trade_proposal.trade_date
             data["trade_proposal"] = trade_proposal
@@ -180,6 +182,12 @@ class TradeImportHandler(ImportExportHandler):
             if instrument.instrument_type.key == "product":
                 update_outstanding_shares_as_task.delay(instrument.id)
 
+        # if the trade import relates to a trade proposal, we reset the TP after the import to ensure it contains the deleted positions (often forgotten by user)
+        for changed_trade_proposal in self.trade_proposals:
+            changed_trade_proposal.reset_trades(
+                target_portfolio=changed_trade_proposal._build_dto().convert_to_portfolio()
+            )
+
     def _post_processing_updated_object(self, _object):
         if _object.marked_for_deletion:
             _object.marked_for_deletion = False

wbportfolio/migrations/0075_portfolio_initial_position_date_and_more.py

@@ -0,0 +1,28 @@
+# Generated by Django 5.0.13 on 2025-03-20 08:19
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('wbportfolio', '0074_alter_rebalancer_frequency_and_more'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='portfolio',
+            name='initial_position_date',
+            field=models.DateField(blank=True, null=True, verbose_name='Last Position Date'),
+        ),
+        migrations.AddField(
+            model_name='portfolio',
+            name='last_position_date',
+            field=models.DateField(blank=True, null=True, verbose_name='Last Position Date'),
+        ),
+        migrations.AlterField(
+            model_name='trade',
+            name='transaction_subtype',
+            field=models.CharField(choices=[('REBALANCE', 'Rebalance'), ('DECREASE', 'Decrease'), ('INCREASE', 'Increase'), ('SUBSCRIPTION', 'Subscription'), ('REDEMPTION', 'Redemption'), ('BUY', 'Buy'), ('SELL', 'Sell'), ('NO_CHANGE', 'No Change')], default='BUY', max_length=32, verbose_name='Trade Type'),
+        ),
+    ]

wbportfolio/models/portfolio.py

@@ -29,7 +29,6 @@ from django.dispatch import receiver
 from django.utils import timezone
 from django.utils.functional import cached_property
 from pandas._libs.tslibs.offsets import BDay
-from psycopg.types.range import DateRange
 from skfolio.preprocessing import prices_to_returns
 from wbcore.contrib.currency.models import Currency, CurrencyFXRates
 from wbcore.contrib.notifications.utils import create_notification_type
@@ -293,6 +292,9 @@ class Portfolio(DeleteToDisableMixin, WBModel):
         default=False, help_text="If true, this portfolio is a composition of other portfolio"
     )
     updated_at = models.DateTimeField(blank=True, null=True, verbose_name="Updated At")
+    last_position_date = models.DateField(blank=True, null=True, verbose_name="Last Position Date")
+    initial_position_date = models.DateField(blank=True, null=True, verbose_name="Last Position Date")
+
     bank_accounts = models.ManyToManyField(
         to="directory.BankingContact",
         related_name="wbportfolio_portfolios",
@@ -699,6 +701,11 @@ class Portfolio(DeleteToDisableMixin, WBModel):
             self.evaluate_rebalancing(val_date)
 
         self.updated_at = timezone.now()
+        if self.assets.filter(date=val_date).exists():
+            if not self.last_position_date or self.last_position_date < val_date:
+                self.last_position_date = val_date
+            if not self.initial_position_date or self.initial_position_date > val_date:
+                self.initial_position_date = val_date
         self.save()
 
         if compute_metrics:
@@ -1259,18 +1266,6 @@ def default_estimate_net_value(val_date: date, instrument: Instrument) -> float
             return analytic_portfolio.get_estimate_net_value(float(last_price.net_value))
 
 
-@receiver(post_save, sender="wbportfolio.Product")
-@receiver(post_save, sender="wbportfolio.ProductGroup")
-def post_product_creation(sender, instance, created, raw, **kwargs):
-    if not raw and (created or not InstrumentPortfolioThroughModel.objects.filter(instrument=instance).exists()):
-        portfolio = Portfolio.objects.create(
-            name=f"Portfolio: {instance.name}",
-            currency=instance.currency,
-            invested_timespan=DateRange(instance.inception_date if instance.inception_date else date.min, date.max),
-        )
-        InstrumentPortfolioThroughModel.objects.get_or_create(instrument=instance, defaults={"portfolio": portfolio})
-
-
 @receiver(post_save, sender="wbportfolio.PortfolioPortfolioThroughModel")
 def post_portfolio_relationship_creation(sender, instance, created, raw, **kwargs):
     if (

wbportfolio/models/transactions/rebalancing.py

@@ -133,7 +133,7 @@ class Rebalancer(ComplexToStringMixin, models.Model):
                 trade_proposal.reset_trades(target_portfolio)
                 trade_proposal.submit()
                 if self.approve_trade_proposal_automatically and self.portfolio.can_be_rebalanced:
-                    trade_proposal.approve()
+                    trade_proposal.approve(replay=False)
             except ValidationError:
                 # If we encountered a validation error, we set the trade proposal as failed
                 trade_proposal.status = TradeProposal.Status.FAILED
@@ -146,6 +146,12 @@ class Rebalancer(ComplexToStringMixin, models.Model):
     def rrule(self):
         return self.get_rrule()
 
+    def get_next_rebalancing_date(self, pivot_date: date) -> date | None:
+        for _dt in self.rrule:
+            _d = _dt.date()
+            if _d > pivot_date:
+                return _d
+
     @property
     def frequency_repr(self):
         return humanize_rrule(self.rrule)

wbportfolio/models/transactions/trade_proposals.py

@@ -11,12 +11,13 @@ from django.utils.functional import cached_property
 from django_fsm import FSMField, transition
 from pandas._libs.tslibs.offsets import BDay
 from wbcompliance.models.risk_management.mixins import RiskCheckMixin
+from wbcore.contrib.currency.models import Currency
 from wbcore.contrib.icons import WBIcon
 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.models.instruments.instruments import Instrument
+from wbfdm.models.instruments.instruments import Cash, Instrument
 
 from wbportfolio.models.roles import PortfolioRole
 from wbportfolio.pms.trading import TradingService
@@ -89,6 +90,10 @@ class TradeProposal(CloneMixin, RiskCheckMixin, WBModel):
     def check_evaluation_date(self):
         return self.trade_date
 
+    @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:
         """
@@ -96,8 +101,8 @@ class TradeProposal(CloneMixin, RiskCheckMixin, WBModel):
         """
         return TradingService(
             self.trade_date,
-            effective_portfolio=self.portfolio._build_dto(self.trade_date),
-            trades_batch=self._build_dto(),
+            effective_portfolio=self.portfolio._build_dto(self.last_effective_date),
+            target_portfolio=self._build_dto().convert_to_portfolio(),
         )
 
     @cached_property
@@ -150,9 +155,7 @@ class TradeProposal(CloneMixin, RiskCheckMixin, WBModel):
         Returns:
             DTO trade object
         """
-        return (
-            TradeBatchDTO(tuple([trade._build_dto() for trade in self.trades.all()])) if self.trades.exists() else None
-        )
+        return TradeBatchDTO(tuple([trade._build_dto() for trade in self.trades.all()]))
 
     # Start tools methods
     def _clone(self, **kwargs) -> SelfTradeProposal:
@@ -197,7 +200,6 @@ class TradeProposal(CloneMixin, RiskCheckMixin, WBModel):
             with suppress(Trade.DoesNotExist):
                 trade = self.trades.get(underlying_instrument_id=underlying_instrument_id)
                 trade.weighting = round(trade_dto.delta_weight, 6)
-                trade.shares = self.estimate_shares(trade)
                 trade.save()
                 total_target_weight += trade._target_weight
                 leftovers_trades = leftovers_trades.exclude(id=trade.id)
@@ -208,7 +210,7 @@ class TradeProposal(CloneMixin, RiskCheckMixin, WBModel):
             biggest_trade.weighting -= quantize_error
             biggest_trade.save()
 
-    def _get_target_portfolio(self, **kwargs) -> PortfolioDTO:
+    def _get_default_target_portfolio(self, **kwargs) -> PortfolioDTO:
         if self.rebalancing_model:
             params = {}
             if rebalancer := getattr(self.portfolio, "automatic_rebalancer", None):
@@ -217,50 +219,57 @@ class TradeProposal(CloneMixin, RiskCheckMixin, WBModel):
             return self.rebalancing_model.get_target_portfolio(
                 self.portfolio, self.trade_date, self.last_effective_date, **params
             )
+        if self.trades.exists():
+            return self._build_dto().convert_to_portfolio()
         # Return the current portfolio by default
         return self.portfolio._build_dto(self.last_effective_date)
 
-    def reset_trades(self, target_portfolio: PortfolioDTO | None = None):
+    def reset_trades(self, target_portfolio: PortfolioDTO | None = None, validate_trade: bool = True):
         """
         Will delete all existing trades and recreate them from the method `create_or_update_trades`
         """
         if self.status != TradeProposal.Status.DRAFT:
             raise ValueError("Cannot reset non-draft trade proposal. Revert this trade proposal first.")
         # delete all existing trades
-        self.trades.all().delete()
         last_effective_date = self.last_effective_date
         # Get effective and target portfolio
         effective_portfolio = self.portfolio._build_dto(last_effective_date)
         if not target_portfolio:
-            target_portfolio = self._get_target_portfolio()
-        # if not effective_portfolio:
-        #     effective_portfolio = target_portfolio
-        service = TradingService(
-            self.trade_date,
-            effective_portfolio=effective_portfolio,
-            target_portfolio=target_portfolio,
-        )
-        service.normalize()
-        service.is_valid()
-        for trade_dto in service.validated_trades:
-            instrument = Instrument.objects.get(id=trade_dto.underlying_instrument)
-            currency_fx_rate = instrument.currency.convert(
-                last_effective_date, self.portfolio.currency, exact_lookup=True
-            )
-            trade = Trade(
-                underlying_instrument=instrument,
-                transaction_subtype=Trade.Type.BUY if trade_dto.delta_weight > 0 else Trade.Type.SELL,
-                currency=instrument.currency,
-                value_date=last_effective_date,
-                transaction_date=self.trade_date,
-                trade_proposal=self,
-                portfolio=self.portfolio,
-                weighting=trade_dto.delta_weight,
-                status=Trade.Status.DRAFT,
-                currency_fx_rate=currency_fx_rate,
+            target_portfolio = self._get_default_target_portfolio()
+
+        if target_portfolio:
+            service = TradingService(
+                self.trade_date,
+                effective_portfolio=effective_portfolio,
+                target_portfolio=target_portfolio,
             )
-            trade.shares = self.estimate_shares(trade)
-            trade.save()
+            if validate_trade:
+                service.normalize()
+                service.is_valid()
+                trades = service.validated_trades
+            else:
+                trades = service.trades_batch.trades_map.values()
+            for trade_dto in trades:
+                instrument = Instrument.objects.get(id=trade_dto.underlying_instrument)
+                currency_fx_rate = instrument.currency.convert(
+                    last_effective_date, self.portfolio.currency, exact_lookup=True
+                )
+                # we cannot do a bulk-create because Trade is a multi table inheritance
+                try:
+                    trade = self.trades.get(underlying_instrument=instrument)
+                except Trade.DoesNotExist:
+                    trade = Trade(
+                        underlying_instrument=instrument,
+                        currency=instrument.currency,
+                        value_date=last_effective_date,
+                        transaction_date=self.trade_date,
+                        trade_proposal=self,
+                        portfolio=self.portfolio,
+                        weighting=trade_dto.delta_weight,
+                        status=Trade.Status.DRAFT,
+                        currency_fx_rate=currency_fx_rate,
+                    )
+                trade.save()
 
     def replay(self):
         last_trade_proposal = self
@@ -275,12 +284,15 @@ class TradeProposal(CloneMixin, RiskCheckMixin, WBModel):
             if last_trade_proposal.status == TradeProposal.Status.DRAFT:
                 if self.rebalancing_model:  # if there is no position (for any reason) or we the trade proposal has a rebalancer model attached (trades are computed based on an aglo), we reapply this trade proposal
                     logger.info(f"Resetting trades from rebalancer model {self.rebalancing_model} ...")
-                    self.reset_trades()
+                    with suppress(
+                        ValidationError
+                    ):  # we silent any validation error while setting proposal, because if this happens, we assume the current trade proposal state if valid and we continue to batch compute
+                        self.reset_trades()
                 logger.info("Submitting trade proposal ...")
                 last_trade_proposal.submit()
             if last_trade_proposal.status == TradeProposal.Status.SUBMIT:
                 logger.info("Approving trade proposal ...")
-                last_trade_proposal.approve()
+                last_trade_proposal.approve(replay=False)
             last_trade_proposal.save()
             next_trade_proposal = last_trade_proposal.next_trade_proposal
             next_trade_date = (
@@ -291,14 +303,79 @@ class TradeProposal(CloneMixin, RiskCheckMixin, WBModel):
             )
             last_trade_proposal = overriding_trade_proposal or next_trade_proposal
 
-    def estimate_shares(self, trade: Trade) -> Decimal | None:
-        if not self.portfolio.only_weighting and (quote := trade.underlying_quote_price):
-            trade_total_value_fx_portfolio = (
-                self.portfolio.get_total_asset_value(trade.value_date) * trade._target_weight
+    def get_estimated_shares(self, weight: Decimal, underlying_quote: Instrument) -> Decimal | None:
+        """
+        Estimates the number of shares for a trade based on the given weight and underlying quote.
+
+        This method calculates the estimated shares by dividing the trade's total value in the portfolio's currency by the price of the underlying quote in the same currency. It handles currency conversion and suppresses any ValueError that might occur during the price retrieval.
+
+        Args:
+            weight (Decimal): The weight of the trade.
+            underlying_quote (Instrument): The underlying instrument for the trade.
+
+        Returns:
+            Decimal | None: The estimated number of shares or None if the calculation fails.
+        """
+        try:
+            # Retrieve the price of the underlying quote on the trade date TODO: this is very slow and probably due to the to_date argument to the dl which slowdown drastically the query
+            quote_price = Decimal(underlying_quote.get_price(self.trade_date))
+
+            # Calculate the trade's total value in the portfolio's currency
+            trade_total_value_fx_portfolio = self.portfolio_total_asset_value * weight
+
+            # Convert the quote price to the portfolio's currency
+            price_fx_portfolio = quote_price * underlying_quote.currency.convert(
+                self.trade_date, self.portfolio.currency, exact_lookup=False
             )
-            price_fx_portfolio = quote.net_value * trade.currency_fx_rate
+
+            # If the price is valid, calculate and return the estimated shares
             if price_fx_portfolio:
                 return trade_total_value_fx_portfolio / price_fx_portfolio
+        except Exception:
+            # Suppress any ValueError and return None if the calculation fails
+            return None
+
+    def get_estimated_target_cash(self, currency: Currency) -> tuple[Decimal, Decimal]:
+        """
+        Estimates the target cash weight and shares for a trade proposal.
+
+        This method calculates the target cash weight by summing the weights of cash trades and adding any leftover weight from non-cash trades. It then estimates the target shares for this cash component if the portfolio is not only weighting-based.
+
+        Args:
+            currency (Currency): The currency for the target currency component
+
+        Returns:
+            tuple[Decimal, Decimal]: A tuple containing the target cash weight and the estimated target shares.
+        """
+        # Retrieve trades with base information
+        trades = self.trades.all().annotate_base_info()
+
+        # Calculate the target cash weight from cash trades
+        target_cash_weight = trades.filter(
+            underlying_instrument__is_cash=True, underlying_instrument__currency=currency
+        ).aggregate(s=models.Sum("target_weight"))["s"] or Decimal(0)
+        # if the specified currency match the portfolio's currency, we include the weight leftover to this cash compoenent
+        if currency == self.portfolio.currency:
+            # Calculate the total target weight of all trades
+            total_target_weight = trades.aggregate(s=models.Sum("target_weight"))["s"] or Decimal(0)
+
+            # Add any leftover weight as cash
+            target_cash_weight += Decimal(1) - total_target_weight
+
+        # Initialize target shares to zero
+        total_target_shares = Decimal(0)
+
+        # If the portfolio is not only weighting-based, estimate the target shares for the cash component
+        if not self.portfolio.only_weighting:
+            # Get or create a cash component for the portfolio's currency
+            cash_component = Cash.objects.get_or_create(
+                currency=currency, defaults={"is_cash": True, "name": currency.title}
+            )[0]
+
+            # Estimate the target shares for the cash component
+            total_target_shares = self.get_estimated_shares(target_cash_weight, cash_component)
+
+        return target_cash_weight, total_target_shares
 
     # Start FSM logics
 
@@ -323,9 +400,26 @@ class TradeProposal(CloneMixin, RiskCheckMixin, WBModel):
     )
     def submit(self, by=None, description=None, **kwargs):
         self.trades.update(comment="", status=Trade.Status.DRAFT)
+        self.reset_trades(target_portfolio=self._build_dto().convert_to_portfolio())
         for trade in self.trades.all():
             trade.submit()
             trade.save()
+
+        # If we estimate cash on this trade proposal, we make sure to create the corresponding cash component
+        cash_target_cash_weight, cash_target_cash_shares = self.get_estimated_target_cash(self.portfolio.currency)
+        if cash_target_cash_weight:
+            cash_component = Cash.objects.get_or_create(
+                currency=self.portfolio.currency, defaults={"name": self.portfolio.currency.title}
+            )[0]
+            self.trades.update_or_create(
+                underlying_instrument=cash_component,
+                defaults={
+                    "status": Trade.Status.SUBMIT,
+                    "weighting": cash_target_cash_weight,
+                    "shares": cash_target_cash_shares,
+                },
+            )
+
         self.evaluate_active_rules(
             self.trade_date, self.validated_trading_service.target_portfolio, asynchronously=True
         )
@@ -356,7 +450,7 @@ class TradeProposal(CloneMixin, RiskCheckMixin, WBModel):
 
     @property
     def can_be_approved_or_denied(self):
-        return self.has_no_rule_or_all_checked_succeed and self.portfolio.is_manageable
+        return not self.has_non_successful_checks and self.portfolio.is_manageable
 
     @transition(
         field=status,
@@ -378,7 +472,7 @@ class TradeProposal(CloneMixin, RiskCheckMixin, WBModel):
             )
         },
     )
-    def approve(self, by=None, description=None, synchronous=False, **kwargs):
+    def approve(self, by=None, description=None, replay: bool = True, **kwargs):
         # We validate trade 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.")
@@ -387,6 +481,8 @@ class TradeProposal(CloneMixin, RiskCheckMixin, WBModel):
         for trade in self.trades.all():
             trade.execute()
             trade.save()
+        if replay and self.portfolio.is_manageable:
+            replay_as_task.delay(self.id)
 
     def can_approve(self):
         errors = dict()
@@ -398,7 +494,7 @@ class TradeProposal(CloneMixin, RiskCheckMixin, WBModel):
             errors["portfolio"] = (
                 "The portfolio needs to be a model portfolio in order to approve this trade proposal manually"
             )
-        if self.has_assigned_active_rules and not self.has_all_check_completed_and_succeed:
+        if self.has_non_successful_checks:
             errors["non_field_errors"] = "The pre trades rules did not passed successfully"
         return errors
 
@@ -440,7 +536,8 @@ class TradeProposal(CloneMixin, RiskCheckMixin, WBModel):
         permission=lambda instance, user: PortfolioRole.is_portfolio_manager(
             user.profile, portfolio=instance.portfolio
         )
-        and instance.has_all_check_completed,  # we wait for all checks to succeed before proposing the back to draft transition
+        and instance.has_all_check_completed
+        or not instance.checks.exists(),  # we wait for all checks to succeed before proposing the back to draft transition
         custom={
             "_transition_button": ActionButton(
                 method=RequestType.PATCH,