wbportfolio 1.49.0__tar.gz → 1.49.2__tar.gz

{wbportfolio-1.49.0 → wbportfolio-1.49.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wbportfolio
-Version: 1.49.0
+Version: 1.49.2
 Author-email: Christopher Wittlinger <c.wittlinger@stainly.com>
 License-File: LICENSE
 Requires-Dist: cryptography==3.4.*

{wbportfolio-1.49.0 → wbportfolio-1.49.2}/wbportfolio/factories/dividends.py

@@ -11,5 +11,6 @@ class DividendTransactionsFactory(TransactionFactory):
     class Meta:
         model = DividendTransaction
 
+    retrocession = 1.0
     shares = factory.LazyAttribute(lambda o: random.randint(10, 10000))
     price = factory.LazyAttribute(lambda o: random.randint(10, 10000))

{wbportfolio-1.49.0 → wbportfolio-1.49.2}/wbportfolio/import_export/handlers/dividend.py

@@ -23,7 +23,7 @@ class DividendImportHandler(ImportExportHandler):
         data["value_date"] = datetime.strptime(data["value_date"], "%Y-%m-%d").date()
         from wbportfolio.models import Portfolio
 
-        data["portfolio"] = Portfolio.objects.get(id=data["portfolio"])
+        data["portfolio"] = Portfolio.all_objects.get(id=data["portfolio"])
         instrument = self.instrument_handler.process_object(
             data["underlying_instrument"], only_security=False, read_only=True
         )[0]

{wbportfolio-1.49.0 → wbportfolio-1.49.2}/wbportfolio/import_export/handlers/fees.py

@@ -26,7 +26,7 @@ class FeesImportHandler(ImportExportHandler):
 
         data["linked_product"] = Product.objects.get(id=data["linked_product"])
         if "porfolio" in data:
-            data["portfolio"] = Portfolio.objects.get(id=data["portfolio"])
+            data["portfolio"] = Portfolio.all_objects.get(id=data["portfolio"])
         else:
             data["portfolio"] = data["linked_product"].primary_portfolio
         data["underlying_instrument"] = Cash.objects.filter(currency=data["portfolio"].currency).first()

{wbportfolio-1.49.0 → wbportfolio-1.49.2}/wbportfolio/import_export/handlers/portfolio_cash_flow.py

@@ -19,7 +19,7 @@ class DailyPortfolioCashFlowImportHandler(ImportExportHandler):
 
     def _deserialize(self, data):
         data["value_date"] = datetime.strptime(data["value_date"], "%Y-%m-%d").date()
-        data["portfolio"] = Portfolio.objects.get(id=data["portfolio"])
+        data["portfolio"] = Portfolio.all_objects.get(id=data["portfolio"])
         if "cash" in data:
             data["cash"] = Decimal(data["cash"])
 

{wbportfolio-1.49.0 → wbportfolio-1.49.2}/wbportfolio/import_export/handlers/trade.py

@@ -1,3 +1,4 @@
+import math
 from datetime import datetime
 from decimal import Decimal
 from typing import Any, Dict, Optional
@@ -71,7 +72,10 @@ class TradeImportHandler(ImportExportHandler):
 
         for field in self.model._meta.get_fields():
             if not (value := data.get(field.name, None)) is None and isinstance(field, models.DecimalField):
-                data[field.name] = Decimal(value)
+                q = (
+                    1 / (math.pow(10, 4))
+                )  # we need that convertion mechanism otherwise there is floating point approximation error while casting to decimal and get_instance does not work as expected
+                data[field.name] = Decimal(value).quantize(Decimal(str(q)))
 
     def _create_instance(self, data: Dict[str, Any], **kwargs) -> models.Model:
         if "transaction_date" not in data:  # we might get only book date and not transaction date
@@ -81,7 +85,6 @@ class TradeImportHandler(ImportExportHandler):
 
     def _get_instance(self, data: Dict[str, Any], history: Optional[models.QuerySet] = None, **kwargs) -> models.Model:
         self.import_source.log += "\nGet Trade Instance."
-
         if transaction_date := data.get("transaction_date"):
             dates_lookup = {"transaction_date": transaction_date}
         elif book_date := data.get("book_date"):

{wbportfolio-1.49.0 → wbportfolio-1.49.2}/wbportfolio/import_export/parsers/sg_lux/custodian_positions.py

@@ -29,7 +29,7 @@ def get_portfolio_id(row: pd.Series) -> int:
     Raises: Portfolio.DoesNotExist: We raise an error intentionally if the portfolio does not exist to make the import fail
     """
     iban = str(IBAN.generate(BANK_COUNTRY_CODE, bank_code=BANK_CODE, account_code=str(row["account_number"])))
-    return Portfolio.objects.get(bank_accounts__iban=iban).id
+    return Portfolio.all_objects.get(bank_accounts__iban=iban).id
 
 
 def parse(import_source: "ImportSource") -> dict:

{wbportfolio-1.49.0 → wbportfolio-1.49.2}/wbportfolio/import_export/parsers/sg_lux/portfolio_future_cash_flow.py

@@ -13,7 +13,7 @@ def parse(import_source):
 
     def get_portfolio_id(row) -> int | None:
         with suppress(Portfolio.DoesNotExist):
-            return Portfolio.objects.get(instruments__children__isin__in=[row["Isin"]]).pk
+            return Portfolio.all_objects.get(instruments__children__isin__in=[row["Isin"]]).pk
 
     df = df[~df["Isin"].isnull()]
     df["Trade date"] = df["Trade date"].ffill()

wbportfolio-1.49.2/wbportfolio/migrations/0076_alter_dividendtransaction_price_and_more.py

@@ -0,0 +1,126 @@
+# Generated by Django 5.0.13 on 2025-03-21 12:30
+
+import django.db.models.expressions
+from decimal import Decimal
+from django.db import migrations, models
+
+def migrate_default_values(apps, schema_editor):
+    Transaction = apps.get_model("wbportfolio", "Transaction")
+    Trade = apps.get_model("wbportfolio", "Trade")
+    Expiry = apps.get_model("wbportfolio", "Expiry")
+    DividendTransaction = apps.get_model("wbportfolio", "DividendTransaction")
+    Transaction.objects.filter(book_date__isnull=True).update(book_date=models.F("transaction_date"))
+    Transaction.objects.filter(value_date__isnull=True).update(value_date=models.F("transaction_date"))
+    Trade.objects.filter(price_gross__isnull=True).update(price_gross=models.F("price"))
+    Expiry.objects.filter(price_gross__isnull=True).update(price_gross=models.F("price"))
+    DividendTransaction.objects.filter(price_gross__isnull=True).update(price_gross=models.F("price"))
+    Transaction.objects.filter(total_value_gross__isnull=True).update(total_value_gross=models.F("total_value"))
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('wbportfolio', '0075_portfolio_initial_position_date_and_more'),
+    ]
+
+    operations = [
+        migrations.RunPython(migrate_default_values),
+        migrations.AlterField(
+            model_name='transaction',
+            name='book_date',
+            field=models.DateField(help_text='The date that this transaction was booked.',
+                                   verbose_name='Trade Date'),
+            preserve_default=False,
+        ),
+        migrations.AlterField(
+            model_name='transaction',
+            name='value_date',
+            field=models.DateField(help_text='The date that this transaction was valuated.',
+                                   verbose_name='Value Date'),
+            preserve_default=False,
+        ),
+        migrations.AlterField(
+            model_name='dividendtransaction',
+            name='price',
+            field=models.DecimalField(decimal_places=4, default=Decimal('0.0'), help_text='The price per share.', max_digits=16, verbose_name='Price'),
+        ),
+        migrations.AlterField(
+            model_name='dividendtransaction',
+            name='price_gross',
+            field=models.DecimalField(decimal_places=4, default=Decimal('0.0'), help_text='The gross price per share.', max_digits=16, verbose_name='Gross Price'),
+            preserve_default=False,
+        ),
+        migrations.AlterField(
+            model_name='dividendtransaction',
+            name='shares',
+            field=models.DecimalField(decimal_places=4, default=Decimal('0.0'), help_text='The number of shares that were traded.', max_digits=15, verbose_name='Shares'),
+        ),
+        migrations.AlterField(
+            model_name='expiry',
+            name='price',
+            field=models.DecimalField(decimal_places=4, default=Decimal('0.0'), help_text='The price per share.', max_digits=16, verbose_name='Price'),
+        ),
+        migrations.AlterField(
+            model_name='expiry',
+            name='price_gross',
+            field=models.DecimalField(decimal_places=4, default=Decimal('0.0'), help_text='The gross price per share.', max_digits=16, verbose_name='Gross Price'),
+            preserve_default=False,
+        ),
+        migrations.AlterField(
+            model_name='expiry',
+            name='shares',
+            field=models.DecimalField(decimal_places=4, default=Decimal('0.0'), help_text='The number of shares that were traded.', max_digits=15, verbose_name='Shares'),
+        ),
+        migrations.AlterField(
+            model_name='trade',
+            name='price',
+            field=models.DecimalField(decimal_places=4, default=Decimal('0.0'), help_text='The price per share.', max_digits=16, verbose_name='Price'),
+        ),
+        migrations.AlterField(
+            model_name='trade',
+            name='price_gross',
+            field=models.DecimalField(decimal_places=4, default=Decimal('0.0'), help_text='The gross price per share.', max_digits=16, verbose_name='Gross Price'),
+            preserve_default=False,
+        ),
+        migrations.AlterField(
+            model_name='trade',
+            name='shares',
+            field=models.DecimalField(decimal_places=4, default=Decimal('0.0'), help_text='The number of shares that were traded.', max_digits=15, verbose_name='Shares'),
+        ),
+
+        migrations.AlterField(
+            model_name='transaction',
+            name='total_value',
+            field=models.DecimalField(decimal_places=4, default=Decimal('0.0'), max_digits=20, verbose_name='Total Value'),
+            preserve_default=False,
+        ),
+        migrations.AlterField(
+            model_name='transaction',
+            name='total_value_gross',
+            field=models.DecimalField(decimal_places=4, default=Decimal('0.0'), max_digits=20, verbose_name='Total Value Gross'),
+            preserve_default=False,
+        ),
+        migrations.RemoveField(
+            model_name='transaction',
+            name='total_value_fx_portfolio',
+        ),
+        migrations.RemoveField(
+            model_name='transaction',
+            name='total_value_gross_fx_portfolio',
+        ),
+        migrations.AddField(
+            model_name='transaction',
+            name='total_value_fx_portfolio',
+            field=models.GeneratedField(db_persist=True, expression=django.db.models.expressions.CombinedExpression(
+                models.F('currency_fx_rate'), '*', models.F('total_value')),
+                                        output_field=models.DecimalField(decimal_places=4, max_digits=20)),
+            preserve_default=False,
+        ),
+        migrations.AddField(
+            model_name='transaction',
+            name='total_value_gross_fx_portfolio',
+            field=models.GeneratedField(db_persist=True, expression=django.db.models.expressions.CombinedExpression(models.F('currency_fx_rate'), '*', models.F('total_value_gross')), output_field=models.DecimalField(decimal_places=4, max_digits=20)),
+            preserve_default=False,
+        ),
+
+    ]

{wbportfolio-1.49.0 → wbportfolio-1.49.2}/wbportfolio/models/portfolio.py

@@ -411,7 +411,7 @@ class Portfolio(DeleteToDisableMixin, WBModel):
         )
 
     def __str__(self):
-        return f"{self.id:06} ({self.name})"
+        return f"{self.id:06}: {self.name}"
 
     class Meta:
         verbose_name = "Portfolio"
@@ -853,7 +853,6 @@ class Portfolio(DeleteToDisableMixin, WBModel):
             adjusted_weighting,
             adjusted_currency_fx_rate,
             adjusted_is_estimated,
-            portfolio_created=None,
             path=None,
         ):
             if not path:
@@ -866,7 +865,18 @@ class Portfolio(DeleteToDisableMixin, WBModel):
                 position.is_estimated = (adjusted_is_estimated or position.is_estimated) and not (
                     position.weighting == 1.0
                 )
-                position.portfolio_created = portfolio_created
+                # to get from which portfolio this position is created, we need to differantiate between:
+                # * Composition portfolio: where the portfolio created is the second encountered portfolio
+                # * Other: portfolio created is the last encountered portfolio
+                # If `path` is empty, we use None as portfolio_created
+                try:
+                    if self.is_composition:
+                        position.portfolio_created = path[1]
+                    else:
+                        position.portfolio_created = path[-1]
+                except IndexError:
+                    position.portfolio_created = None
+
                 setattr(position, "path", path)
                 position.initial_shares = None
                 if portfolio_total_asset_value:
@@ -881,7 +891,6 @@ class Portfolio(DeleteToDisableMixin, WBModel):
                         position.weighting,
                         position.currency_fx_rate,
                         position.is_estimated,
-                        portfolio_created=child_portfolio,
                         path=path.copy(),
                     )
                 elif position.weighting:  # we do not yield position with weight 0 because of issue with certain multi-thematic portfolios which contain duplicates
@@ -979,7 +988,11 @@ class Portfolio(DeleteToDisableMixin, WBModel):
             for position in positions:
                 position.portfolio = self
                 update_dates.add(position.date)
-            # self.assets.filter(date__in=update_dates, is_estimated=True).delete()
+
+            # we need to delete the existing estimated portfolio because otherwise we risk to have existing and not
+            # overlapping positions remaining (as they will not be updating by the bulk create). E.g. when someone
+            # change completely the trades of a portfolio model and drift it.
+            self.assets.filter(date__in=update_dates, is_estimated=True).delete()
             leftover_positions_ids = list(
                 self.assets.filter(date__in=update_dates).values_list("id", flat=True)
             )  # we need to get the ids otherwise the queryset is reevaluated later
@@ -1014,7 +1027,7 @@ class Portfolio(DeleteToDisableMixin, WBModel):
     @classmethod
     def _get_or_create_portfolio(cls, instrument_handler, portfolio_data):
         if isinstance(portfolio_data, int):
-            return Portfolio.objects.get(id=portfolio_data)
+            return Portfolio.all_objects.get(id=portfolio_data)
         instrument = portfolio_data
         if isinstance(portfolio_data, dict):
             instrument = instrument_handler.process_object(instrument, only_security=False, read_only=True)[0]

{wbportfolio-1.49.0 → wbportfolio-1.49.2}/wbportfolio/models/transactions/claim.py

@@ -14,6 +14,7 @@ from django.db.models import (
 )
 from django.db.models.functions import Greatest
 from django.dispatch import receiver
+from django.utils.translation import gettext_lazy as _
 from django_fsm import FSMField, transition
 from wbcore.contrib.ai.llm.config import add_llm_prompt
 from wbcore.contrib.authentication.models import User
@@ -335,13 +336,13 @@ class Claim(ReferenceIDMixin, WBModel):
         errors = dict()
 
         if not self.trade:
-            errors["trade"] = ["With this status, this has to be provided."]
+            errors["trade"] = [_("With this status, this has to be provided.")]
 
         if not self.product:
-            errors["product"] = ["With this status, this has to be provided."]
+            errors["product"] = [_("With this status, this has to be provided.")]
 
         if not self.account:
-            errors["account"] = ["With this status, this has to be provided."]
+            errors["account"] = [_("With this status, this has to be provided.")]
 
         # check if the specified product have a valid nav at the specified date
         if (
@@ -350,13 +351,13 @@ class Claim(ReferenceIDMixin, WBModel):
             and not product.valuations.filter(date=claim_date).exists()
         ):
             if (prices_qs := product.valuations.filter(date__lt=claim_date)).exists():
-                errors["date"] = (
+                errors["date"] = [
                     f"For product {product.name}, the latest valid valuation date before {claim_date:%Y-%m-%d} is {prices_qs.latest('date').date:%Y-%m-%d}: Please select a valid date."
-                )
+                ]
             else:
-                errors["date"] = (
+                errors["date"] = [
                     f"There is no valuation before {claim_date:%Y-%m-%d} for product {product.name}: Please select a valid date."
-                )
+                ]
         return errors
 
     @transition(

wbportfolio-1.49.2/wbportfolio/models/transactions/dividends.py

@@ -0,0 +1,15 @@
+from decimal import Decimal
+
+from django.db import models
+
+from wbportfolio.import_export.handlers.dividend import DividendImportHandler
+
+from .transactions import ShareMixin, Transaction
+
+
+class DividendTransaction(Transaction, ShareMixin, models.Model):
+    import_export_handler_class = DividendImportHandler
+    retrocession = models.FloatField(default=1)
+
+    def save(self, *args, **kwargs):
+        super().save(*args, factor=Decimal(self.retrocession), **kwargs)

{wbportfolio-1.49.0 → wbportfolio-1.49.2}/wbportfolio/models/transactions/trade_proposals.py

@@ -8,6 +8,7 @@ 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
@@ -166,7 +167,7 @@ class TradeProposal(CloneMixin, RiskCheckMixin, WBModel):
         Returns:
             The cloned trade proposal
         """
-        trade_date = kwargs.get("trade_date", self.trade_date)
+        trade_date = kwargs.get("clone_date", self.trade_date)
 
         # Find the next valid trade date
         while TradeProposal.objects.filter(portfolio=self.portfolio, trade_date=trade_date).exists():
@@ -174,7 +175,7 @@ class TradeProposal(CloneMixin, RiskCheckMixin, WBModel):
 
         trade_proposal_clone = TradeProposal.objects.create(
             trade_date=trade_date,
-            comment=kwargs.get("comment", self.comment),
+            comment=kwargs.get("clone_comment", self.comment),
             status=TradeProposal.Status.DRAFT,
             rebalancing_model=self.rebalancing_model,
             portfolio=self.portfolio,
@@ -228,8 +229,6 @@ class TradeProposal(CloneMixin, RiskCheckMixin, WBModel):
         """
         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
         last_effective_date = self.last_effective_date
         # Get effective and target portfolio
@@ -303,7 +302,7 @@ class TradeProposal(CloneMixin, RiskCheckMixin, WBModel):
             )
             last_trade_proposal = overriding_trade_proposal or next_trade_proposal
 
-    def get_estimated_shares(self, weight: Decimal, underlying_quote: Instrument) -> Decimal | None:
+    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.
 
@@ -332,8 +331,7 @@ class TradeProposal(CloneMixin, RiskCheckMixin, WBModel):
             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
+            raise ValueError("We couldn't estimate the number of shares")
 
     def get_estimated_target_cash(self, currency: Currency) -> tuple[Decimal, Decimal]:
         """
@@ -373,7 +371,8 @@ class TradeProposal(CloneMixin, RiskCheckMixin, WBModel):
             )[0]
 
             # Estimate the target shares for the cash component
-            total_target_shares = self.get_estimated_shares(target_cash_weight, cash_component)
+            with suppress(ValueError):
+                total_target_shares = self.get_estimated_shares(target_cash_weight, cash_component)
 
         return target_cash_weight, total_target_shares
 
@@ -428,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)
@@ -437,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:
@@ -487,15 +486,17 @@ class TradeProposal(CloneMixin, RiskCheckMixin, WBModel):
     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"
-            )
+            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"
+            errors["non_field_errors"] = [_("The pre trades rules did not passed successfully")]
         return errors
 
     @transition(
@@ -526,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(
@@ -589,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-1.49.0 → wbportfolio-1.49.2}/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
@@ -320,9 +321,11 @@ class Trade(ShareMixin, Transaction, OrderedModel, WBModel):
 
     def can_execute(self):
         if not self.last_underlying_quote_price:
-            return {"underlying_instrument": "Cannot execute a trade without a valid 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,
@@ -498,22 +501,16 @@ class Trade(ShareMixin, Transaction, OrderedModel, WBModel):
             self.transaction_date = self.trade_proposal.trade_date
             self.value_date = self.trade_proposal.last_effective_date
             if not self.portfolio.only_weighting:
-                self.shares = self.trade_proposal.get_estimated_shares(self.weighting, self.underlying_instrument)
+                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 or self.trade_proposal:

{wbportfolio-1.49.0 → wbportfolio-1.49.2}/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)