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

wbportfolio/models/transactions/trade_proposals.py

@@ -8,15 +8,17 @@ from celery import shared_task
 from django.core.exceptions import ValidationError
 from django.db import models
 from django.utils.functional import cached_property
+from django.utils.translation import gettext_lazy as _
 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 +91,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 +102,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 +156,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 +201,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 +211,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 +220,55 @@ 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 +283,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 +302,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:
+        """
+        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:
+            raise ValueError("We couldn't estimate the number of shares")
+
+    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
+            with suppress(ValueError):
+                total_target_shares = self.get_estimated_shares(target_cash_weight, cash_component)
+
+        return target_cash_weight, total_target_shares
 
     # Start FSM logics
 
@@ -323,9 +399,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
         )
@@ -334,7 +427,7 @@ class TradeProposal(CloneMixin, RiskCheckMixin, WBModel):
         errors = dict()
         errors_list = []
         if self.trades.exists() and self.trades.exclude(status=Trade.Status.DRAFT).exists():
-            errors_list.append("All trades need to be draft before submitting")
+            errors_list.append(_("All trades need to be draft before submitting"))
         service = self.validated_trading_service
         try:
             service.is_valid(ignore_error=True)
@@ -343,7 +436,7 @@ class TradeProposal(CloneMixin, RiskCheckMixin, WBModel):
             #         "There is no change detected in this trade proposal. Please submit at last one valid trade"
             #     )
             if len(service.validated_trades) == 0:
-                errors_list.append("There is no valid trade on this proposal")
+                errors_list.append(_("There is no valid trade on this proposal"))
             if service.errors:
                 errors_list.extend(service.errors)
             if errors_list:
@@ -356,7 +449,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 +471,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,19 +480,23 @@ 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()
         if not self.portfolio.can_be_rebalanced:
-            errors["non_field_errors"] = "The portfolio does not allow manual rebalanced"
+            errors["non_field_errors"] = [_("The portfolio does not allow manual rebalanced")]
         if self.trades.exclude(status=Trade.Status.SUBMIT).exists():
-            errors["non_field_errors"] = "At least one trade needs to be submitted to be able to approve this proposal"
+            errors["non_field_errors"] = [
+                _("At least one trade needs to be submitted to be able to approve this proposal")
+            ]
         if not self.portfolio.can_be_rebalanced:
-            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:
-            errors["non_field_errors"] = "The pre trades rules did not passed successfully"
+            errors["portfolio"] = [
+                [_("The portfolio needs to be a model portfolio in order to approve this trade proposal manually")]
+            ]
+        if self.has_non_successful_checks:
+            errors["non_field_errors"] = [_("The pre trades rules did not passed successfully")]
         return errors
 
     @transition(
@@ -430,7 +527,9 @@ class TradeProposal(CloneMixin, RiskCheckMixin, WBModel):
     def can_deny(self):
         errors = dict()
         if self.trades.exclude(status=Trade.Status.SUBMIT).exists():
-            errors["non_field_errors"] = "At least one trade needs to be submitted to be able to deny this proposal"
+            errors["non_field_errors"] = [
+                _("At least one trade needs to be submitted to be able to deny this proposal")
+            ]
         return errors
 
     @transition(
@@ -440,7 +539,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,
@@ -492,9 +592,9 @@ class TradeProposal(CloneMixin, RiskCheckMixin, WBModel):
     def can_revert(self):
         errors = dict()
         if not self.portfolio.can_be_rebalanced:
-            errors["portfolio"] = (
-                "The portfolio needs to be a model portfolio in order to revert this trade proposal manually"
-            )
+            errors["portfolio"] = [
+                _("The portfolio needs to be a model portfolio in order to revert this trade proposal manually")
+            ]
         return errors
 
     # End FSM logics

wbportfolio/models/transactions/trades.py

@@ -20,6 +20,7 @@ from django.db.models.functions import Coalesce
 from django.db.models.signals import post_save
 from django.dispatch import receiver
 from django.utils.functional import cached_property
+from django.utils.translation import gettext_lazy as _
 from django_fsm import GET_STATE, FSMField, transition
 from ordered_model.models import OrderedModel, OrderedModelManager, OrderedModelQuerySet
 from wbcore.contrib.icons import WBIcon
@@ -136,6 +137,7 @@ class Trade(ShareMixin, Transaction, OrderedModel, WBModel):
         REDEMPTION = "REDEMPTION", "Redemption"
         BUY = "BUY", "Buy"
         SELL = "SELL", "Sell"
+        NO_CHANGE = "NO_CHANGE", "No Change"  # default transaction subtype if weighing is 0
 
     external_identifier2 = models.CharField(
         max_length=255,
@@ -224,7 +226,7 @@ class Trade(ShareMixin, Transaction, OrderedModel, WBModel):
         source=Status.DRAFT,
         target=GET_STATE(
             lambda self, **kwargs: (
-                self.Status.SUBMIT if self.underlying_quote_price is not None else self.Status.FAILED
+                self.Status.SUBMIT if self.last_underlying_quote_price is not None else self.Status.FAILED
             ),
             states=[Status.SUBMIT, Status.FAILED],
         ),
@@ -245,7 +247,7 @@ class Trade(ShareMixin, Transaction, OrderedModel, WBModel):
         on_error="FAILED",
     )
     def submit(self, by=None, description=None, **kwargs):
-        if not self.underlying_quote_price:
+        if not self.last_underlying_quote_price:
             self.comment = f"Trade failed because no price is found for {self.underlying_instrument.computed_str} on {self.transaction_date:%Y-%m-%d}"
 
     def can_submit(self):
@@ -263,13 +265,15 @@ class Trade(ShareMixin, Transaction, OrderedModel, WBModel):
         self.comment = f"Trade failed because no price is found for {self.underlying_instrument.computed_str} on {self.transaction_date:%Y-%m-%d}"
 
     @cached_property
-    def underlying_quote_price(self) -> InstrumentPrice | None:
+    def last_underlying_quote_price(self) -> InstrumentPrice | None:
         try:
+            # we try t0 first
             return InstrumentPrice.objects.filter_only_valid_prices().get(
-                instrument=self.underlying_instrument, date=self.value_date
+                instrument=self.underlying_instrument, date=self.transaction_date
             )
         except InstrumentPrice.DoesNotExist:
             with suppress(InstrumentPrice.DoesNotExist):
+                # we fall back to the latest price before t0
                 return (
                     InstrumentPrice.objects.filter_only_valid_prices()
                     .filter(instrument=self.underlying_instrument, date__lte=self.value_date)
@@ -296,7 +300,7 @@ class Trade(ShareMixin, Transaction, OrderedModel, WBModel):
         },
     )
     def execute(self, **kwargs):
-        if self.underlying_quote_price:
+        if self.last_underlying_quote_price:
             asset, created = AssetPosition.unannotated_objects.update_or_create(
                 underlying_quote=self.underlying_instrument,
                 portfolio_created=None,
@@ -305,9 +309,9 @@ class Trade(ShareMixin, Transaction, OrderedModel, WBModel):
                 defaults={
                     "initial_currency_fx_rate": self.currency_fx_rate,
                     "weighting": self._target_weight,
-                    "initial_price": self.underlying_quote_price.net_value,
+                    "initial_price": self.last_underlying_quote_price.net_value,
                     "initial_shares": None,
-                    "underlying_quote_price": self.underlying_quote_price,
+                    "underlying_quote_price": self.last_underlying_quote_price,
                     "asset_valuation_date": self.transaction_date,
                     "currency": self.currency,
                     "is_estimated": False,
@@ -316,10 +320,12 @@ class Trade(ShareMixin, Transaction, OrderedModel, WBModel):
             asset.set_weighting(self._target_weight)
 
     def can_execute(self):
-        if not self.underlying_quote_price:
-            return {"underlying_instrument": "Cannot execute a trade without a valid quote price"}
+        if not self.last_underlying_quote_price:
+            return {"underlying_instrument": [_("Cannot execute a trade without a valid quote price")]}
         if not self.portfolio.is_manageable:
-            return {"portfolio": "The portfolio needs to be a model portfolio in order to execute this trade manually"}
+            return {
+                "portfolio": [_("The portfolio needs to be a model portfolio in order to execute this trade manually")]
+            }
 
     @transition(
         field=status,
@@ -494,26 +500,20 @@ class Trade(ShareMixin, Transaction, OrderedModel, WBModel):
             self.portfolio = self.trade_proposal.portfolio
             self.transaction_date = self.trade_proposal.trade_date
             self.value_date = self.trade_proposal.last_effective_date
-            if self._effective_shares:
-                self.shares = self._effective_shares * self.weighting
+            if not self.portfolio.only_weighting:
+                with suppress(ValueError):
+                    self.shares = self.trade_proposal.get_estimated_shares(self.weighting, self.underlying_instrument)
 
         if not self.custodian and self.bank:
             self.custodian = Custodian.get_by_mapping(self.bank)
         if self.price is None:
             # we try to get the price if not provided directly from the underlying instrument
-            with suppress(InstrumentPrice.DoesNotExist):
-                self.price = self.underlying_instrument.valuations.get(date=self.value_date).net_value
-        if self.price is not None and self.price_gross is None:
-            self.price_gross = self.price
-
-        if self.price is not None and self.shares is not None and self.total_value is None:
-            self.total_value = self.price * self.shares
+            with suppress(Exception):
+                self.price = self.underlying_instrument.get_price(self.value_date)
 
-        if self.price_gross is not None and self.shares is not None and self.total_value_gross is None:
-            self.total_value_gross = self.price_gross * self.shares
         self.transaction_type = Transaction.Type.TRADE
 
-        if self.transaction_subtype is None:
+        if self.transaction_subtype is None or self.trade_proposal:
             # if subtype not provided, we extract it automatically from the existing data.
             self._set_transaction_subtype()
         if self.id and hasattr(self, "claims"):
@@ -525,6 +525,8 @@ class Trade(ShareMixin, Transaction, OrderedModel, WBModel):
         super().save(*args, **kwargs)
 
     def _set_transaction_subtype(self):
+        if self.weighting == 0:
+            self.transaction_subtype = Trade.Type.NO_CHANGE
         if self.underlying_instrument.instrument_type.key == "product":
             if self.shares is not None:
                 if self.shares > 0:

wbportfolio/models/transactions/transactions.py

@@ -13,16 +13,16 @@ class ShareMixin(models.Model):
     shares = models.DecimalField(
         max_digits=15,
         decimal_places=4,
-        null=True,
-        blank=True,
+        default=Decimal("0.0"),
         help_text="The number of shares that were traded.",
         verbose_name="Shares",
     )
     price = models.DecimalField(
         max_digits=16,
         decimal_places=4,
-        null=True,
-        blank=True,
+        default=Decimal(
+            "0.0"
+        ),  # we shouldn't default to anything but we have trade with price=None. Needs to be handled carefully
         help_text="The price per share.",
         verbose_name="Price",
     )
@@ -30,12 +30,23 @@ class ShareMixin(models.Model):
     price_gross = models.DecimalField(
         max_digits=16,
         decimal_places=4,
-        null=True,
-        blank=True,
         help_text="The gross price per share.",
         verbose_name="Gross Price",
     )
 
+    def save(
+        self,
+        *args,
+        factor: Decimal = Decimal("1.0"),
+        **kwargs,
+    ):
+        if self.price_gross is None:
+            self.price_gross = self.price
+
+        self.total_value = self.price * self.shares * factor
+        self.total_value_gross = self.price_gross * self.shares * factor
+        super().save(*args, **kwargs)
+
     class Meta:
         abstract = True
 
@@ -68,14 +79,10 @@ class Transaction(ImportMixin, models.Model):
         help_text="The date that this transaction was traded.",
     )
     book_date = models.DateField(
-        null=True,
-        blank=True,
         verbose_name="Trade Date",
         help_text="The date that this transaction was booked.",
     )
     value_date = models.DateField(
-        null=True,
-        blank=True,
         verbose_name="Value Date",
         help_text="The date that this transaction was valuated.",
     )
@@ -89,17 +96,23 @@ class Transaction(ImportMixin, models.Model):
     currency_fx_rate = models.DecimalField(
         max_digits=14, decimal_places=8, default=Decimal(1.0), verbose_name="FOREX rate"
     )
-    total_value = models.DecimalField(
-        max_digits=20, decimal_places=4, null=True, blank=True, verbose_name="Total Value"
-    )
-    total_value_fx_portfolio = models.DecimalField(
-        max_digits=20, decimal_places=4, null=True, blank=True, verbose_name="Total Value Fx Portfolio"
-    )
-    total_value_gross = models.DecimalField(
-        max_digits=20, decimal_places=4, null=True, blank=True, verbose_name="Total Value Gross"
-    )
-    total_value_gross_fx_portfolio = models.DecimalField(
-        max_digits=20, decimal_places=4, null=True, blank=True, verbose_name="Total Value Gross Fx Portfolio"
+    total_value = models.DecimalField(max_digits=20, decimal_places=4, verbose_name="Total Value")
+    total_value_gross = models.DecimalField(max_digits=20, decimal_places=4, verbose_name="Total Value Gross")
+    total_value_fx_portfolio = models.GeneratedField(
+        expression=models.F("currency_fx_rate") * models.F("total_value"),
+        output_field=models.DecimalField(
+            max_digits=20,
+            decimal_places=4,
+        ),
+        db_persist=True,
+    )
+    total_value_gross_fx_portfolio = models.GeneratedField(
+        expression=models.F("currency_fx_rate") * models.F("total_value_gross"),
+        output_field=models.DecimalField(
+            max_digits=20,
+            decimal_places=4,
+        ),
+        db_persist=True,
     )
     external_id = models.CharField(
         max_length=255,
@@ -118,28 +131,15 @@ class Transaction(ImportMixin, models.Model):
 
         if not getattr(self, "currency", None) and self.underlying_instrument:
             self.currency = self.underlying_instrument.currency
-        if not self.currency_fx_rate:
+        if self.currency_fx_rate is None:
             self.currency_fx_rate = self.underlying_instrument.currency.convert(
                 self.value_date, self.portfolio.currency, exact_lookup=True
             )
         if not self.transaction_type:
             self.transaction_type = self.__class__.__name__
-        if (
-            self.total_value is not None
-            and self.currency_fx_rate is not None
-            and self.total_value_fx_portfolio is None
-        ):
-            self.total_value_fx_portfolio = self.total_value * self.currency_fx_rate
-
-        if self.total_value is not None and self.total_value_gross is None and self.total_value_gross is None:
-            self.total_value_gross = self.total_value
 
-        if (
-            self.currency_fx_rate is not None
-            and self.total_value_gross is not None
-            and self.total_value_gross_fx_portfolio is None
-        ):
-            self.total_value_gross_fx_portfolio = self.total_value_gross * self.currency_fx_rate
+        if self.total_value_gross is None:
+            self.total_value_gross = self.total_value
 
         super().save(*args, **kwargs)
 

wbportfolio/pms/trading/handler.py

@@ -62,7 +62,7 @@ class TradingService:
         Test the given value against all the validators on the field,
         and either raise a `ValidationError` or simply return.
         """
-        TradeBatch(validated_trades).validate()
+        # TradeBatch(validated_trades).validate()
         if self.effective_portfolio:
             for trade in validated_trades:
                 if (

wbportfolio/pms/typing.py

@@ -70,6 +70,9 @@ class Portfolio:
     def to_df(self):
         return pd.DataFrame([asdict(pos) for pos in self.positions])
 
+    def to_dict(self) -> dict[int, Decimal]:
+        return {underlying_instrument: pos.weighting for underlying_instrument, pos in self.positions_map.items()}
+
     def __len__(self):
         return len(self.positions)