wbportfolio 1.52.0__py2.py3-none-any.whl → 1.52.2__py2.py3-none-any.whl

wbportfolio/models/transactions/dividends.py

@@ -1,15 +1,51 @@
-from decimal import Decimal
-
 from django.db import models
+from wbcore.contrib.io.mixins import ImportMixin
 
 from wbportfolio.import_export.handlers.dividend import DividendImportHandler
 
-from .transactions import ShareMixin, Transaction
+from .transactions import TransactionMixin
 
 
-class DividendTransaction(Transaction, ShareMixin, models.Model):
+class DividendTransaction(TransactionMixin, ImportMixin, models.Model):
     import_export_handler_class = DividendImportHandler
+
+    class DistributionMethod(models.TextChoices):
+        PAYMENT = "Payment", "Payment"
+        REINVESTMENT = "Reinvestment", "Reinvestment"
+
+    ex_date = models.DateField(
+        verbose_name="Ex-Dividend Date",
+        help_text="The date on which the stock starts trading without the dividend",
+    )
+    record_date = models.DateField(
+        verbose_name="Record Date",
+        help_text="The date on which the holder must own the shares to be eligible for the dividend",
+    )
+    distribution_method = models.CharField(
+        max_length=255, verbose_name="Type", choices=DistributionMethod.choices, default=DistributionMethod.PAYMENT
+    )
     retrocession = models.FloatField(default=1)
+    price = models.DecimalField(
+        max_digits=15,
+        decimal_places=4,
+        help_text="The amount paid per share",
+        verbose_name="DPS",
+    )
+    total_value_gross = models.GeneratedField(
+        expression=models.F("price") * models.F("shares") * models.F("retrocession"),
+        output_field=models.DecimalField(
+            max_digits=20,
+            decimal_places=4,
+        ),
+        db_persist=True,
+    )
 
     def save(self, *args, **kwargs):
-        super().save(*args, factor=Decimal(self.retrocession), **kwargs)
+        if not self.record_date and self.ex_date:
+            self.record_date = self.ex_date
+        elif self.record_date and not self.ex_date:
+            self.ex_date = self.record_date
+        super().save(*args, **kwargs)
+
+    def __str__(self):
+        return f"{self.total_value} - {self.value_date:%d.%m.%Y} : {str(self.underlying_instrument)} (in {str(self.portfolio)})"

wbportfolio/models/transactions/fees.py

@@ -1,17 +1,17 @@
 import importlib
 from contextlib import suppress
+from decimal import Decimal
 
 from celery import shared_task
 from django.db import models
 from django.db.models import Exists, OuterRef, Q, QuerySet
 from django.dispatch import receiver
+from wbcore.contrib.io.mixins import ImportMixin
 from wbfdm.models.instruments.instrument_prices import InstrumentPrice
 
 from wbportfolio.import_export.handlers.fees import FeesImportHandler
 from wbportfolio.models.products import Product
 
-from .transactions import Transaction
-
 
 class ValidFeesQueryset(QuerySet):
     def filter_only_valid_fees(self) -> QuerySet:
@@ -22,7 +22,7 @@ class ValidFeesQueryset(QuerySet):
             real_fees_exists=Exists(
                 self.filter(
                     transaction_subtype=OuterRef("transaction_subtype"),
-                    linked_product=OuterRef("linked_product"),
+                    product=OuterRef("product"),
                     fee_date=OuterRef("fee_date"),
                     calculated=False,
                 )
@@ -43,7 +43,7 @@ class ValidFeesManager(DefaultFeesManager):
         return super().get_queryset().filter_only_valid_fees()
 
 
-class Fees(Transaction):
+class Fees(ImportMixin, models.Model):
     import_export_handler_class = FeesImportHandler
 
     class Type(models.TextChoices):
@@ -57,31 +57,61 @@ class Fees(Transaction):
     transaction_subtype = models.CharField(
         max_length=255, verbose_name="Fees Type", choices=Type.choices, default=Type.MANAGEMENT
     )
-
-    fee_date = models.DateField()  # needed for indexing
+    fee_date = models.DateField(
+        verbose_name="Fees Date",
+        help_text="The date that this fee was paid.",
+    )  # needed for indexing
+    product = models.ForeignKey(
+        "wbportfolio.Product",
+        related_name="fees",
+        on_delete=models.PROTECT,
+        verbose_name="Product",
+    )
+    currency = models.ForeignKey(
+        "currency.Currency",
+        related_name="fees",
+        on_delete=models.PROTECT,
+        verbose_name="Currency",
+    )
+    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, 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,
+    )
     calculated = models.BooleanField(
         default=True,
         help_text="A marker whether the fees were calculated or supplied.",
         verbose_name="Is calculated",
     )
-
-    linked_product = models.ForeignKey(
-        "wbportfolio.Product",
-        related_name="transactionfees",
-        on_delete=models.PROTECT,
-        verbose_name="Product",
-    )
+    created = models.DateTimeField(auto_now_add=True)
+    updated = models.DateTimeField(auto_now=True)
 
     class Meta:
         verbose_name = "Fees"
         verbose_name_plural = "Fees"
         indexes = [
-            models.Index(fields=["linked_product"]),
-            models.Index(fields=["transaction_subtype", "linked_product", "fee_date", "calculated"]),
+            models.Index(fields=["product"]),
+            models.Index(fields=["transaction_subtype", "product", "fee_date", "calculated"]),
         ]
         constraints = [
             models.UniqueConstraint(
-                fields=["linked_product", "fee_date", "transaction_subtype", "calculated"], name="unique_fees"
+                fields=["product", "fee_date", "transaction_subtype", "calculated"], name="unique_fees"
             ),
         ]
 
@@ -89,11 +119,14 @@ class Fees(Transaction):
     valid_objects = ValidFeesManager()
 
     def save(self, *args, **kwargs):
-        self.fee_date = self.transaction_date
+        if self.total_value_gross is None and self.total_value is not None:
+            self.total_value_gross = self.total_value
+        elif self.total_value is None and self.total_value_gross is not None:
+            self.total_value = self.total_value_gross
         super().save(*args, **kwargs)
 
     def __str__(self):
-        return f"{self.transaction_date:%d.%m.%Y} - {self.Type[self.transaction_subtype]}: {self.portfolio.name}"
+        return f"{self.fee_date:%d.%m.%Y} - {self.Type[self.transaction_subtype]}: {self.product.name}"
 
     @classmethod
     def get_endpoint_basename(cls):
@@ -111,8 +144,8 @@ class FeeCalculation(models.Model):
             calculation_module = importlib.import_module(import_path)
             for new_fees in calculation_module.fees_calculation(price.id):
                 Fees.objects.update_or_create(
-                    linked_product=new_fees.pop("linked_product"),
-                    transaction_date=new_fees.pop("transaction_date"),
+                    product=new_fees.pop("product"),
+                    fee_date=new_fees.pop("fee_date"),
                     transaction_subtype=new_fees.pop("transaction_subtype"),
                     calculated=True,
                     defaults=new_fees,
@@ -145,10 +178,10 @@ def update_or_create_fees_post(sender, instance, created, raw, **kwargs):
 #         .filter(
 #             transaction_date=instance.transaction_date,
 #             transaction_subtype=instance.transaction_subtype,
-#             linked_product=instance.linked_product,
+#             product=instance.product,
 #         )
 #         .exists()
 #     ):
 #         raise ValueError(
-#             f"A fees object already exists with date, type and product = {instance.transaction_date}, {instance.transaction_subtype}, {instance.linked_product}"
+#             f"A fees object already exists with date, type and product = {instance.transaction_date}, {instance.type}, {instance.product}"
 #         )

wbportfolio/models/transactions/trade_proposals.py

@@ -5,6 +5,7 @@ from decimal import Decimal
 from typing import TypeVar
 
 from celery import shared_task
+from django.contrib.messages import error, info
 from django.core.exceptions import ValidationError
 from django.db import models
 from django.utils.functional import cached_property
@@ -243,7 +244,6 @@ class TradeProposal(CloneMixin, RiskCheckMixin, WBModel):
         effective_portfolio = self.portfolio._build_dto(last_effective_date)
         if not target_portfolio:
             target_portfolio = self._get_default_target_portfolio()
-
         if target_portfolio:
             service = TradingService(
                 self.trade_date,
@@ -251,7 +251,6 @@ class TradeProposal(CloneMixin, RiskCheckMixin, WBModel):
                 target_portfolio=target_portfolio,
             )
             if validate_trade:
-                service.normalize()
                 service.is_valid()
                 trades = service.validated_trades
             else:
@@ -450,12 +449,18 @@ class TradeProposal(CloneMixin, RiskCheckMixin, WBModel):
     def submit(self, by=None, description=None, **kwargs):
         self.reset_trades(target_portfolio=self._build_dto().convert_to_portfolio())
         trades = []
+        trades_validation_errors = []
         for trade in self.trades.all():
-            trade.status = Trade.Status.SUBMIT
-            trade.comment = ""
+            if not trade.last_underlying_quote_price:
+                trade.status = Trade.Status.FAILED
+                trades_validation_errors.append(
+                    f"Trade failed because no price is found for {trade.underlying_instrument.computed_str} on {trade.transaction_date:%Y-%m-%d}"
+                )
+            else:
+                trade.status = Trade.Status.SUBMIT
             trades.append(trade)
 
-        Trade.objects.bulk_update(trades, ["status", "comment"])
+        Trade.objects.bulk_update(trades, ["status"])
 
         # If we estimate cash on this trade proposal, we make sure to create the corresponding cash component
         estimated_cash_position = self.get_estimated_target_cash(self.portfolio.currency)
@@ -470,9 +475,19 @@ class TradeProposal(CloneMixin, RiskCheckMixin, WBModel):
                     estimated_cash_position._build_dto()
                 )
             target_portfolio = PortfolioDTO(positions=tuple(target_portfolio.positions_map.values()))
-
         self.evaluate_active_rules(self.trade_date, target_portfolio, asynchronously=True)
 
+        if (
+            trades_validation_errors
+            and (fsm_context := getattr(self, "fsm_context", None))
+            and (request := fsm_context.get("request", None))
+        ):
+            msg = f"""The reason for the failed trades are: <ul>
+            {''.join(map(lambda o: '<li>' + o + '</li>', trades_validation_errors))}
+            </ul>
+            """
+            error(request, msg, extra_tags="auto_close=0")
+
     def can_submit(self):
         errors = dict()
         errors_list = []
@@ -543,6 +558,11 @@ class TradeProposal(CloneMixin, RiskCheckMixin, WBModel):
         if estimated_cash_position.weighting and len(trades) > 0:
             estimated_cash_position.pre_save()
             assets.append(estimated_cash_position)
+            if (fsm_context := getattr(self, "fsm_context", None)) and (request := fsm_context.get("request", None)):
+                info(
+                    request,
+                    f"We created automatically a cash position of weight {estimated_cash_position.weighting:.2%}",
+                )
 
         Trade.objects.bulk_update(trades, ["status"])
         self.portfolio.bulk_create_positions(

wbportfolio/models/transactions/trades.py

@@ -24,11 +24,14 @@ 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
+from wbcore.contrib.io.mixins import ImportMixin
 from wbcore.enums import RequestType
 from wbcore.metadata.configs.buttons import ActionButton
-from wbcore.models import WBModel
+from wbcore.signals import pre_merge
 from wbcore.signals.models import pre_collection
+from wbfdm.models import Instrument
 from wbfdm.models.instruments.instrument_prices import InstrumentPrice
+from wbfdm.signals import add_instrument_to_investable_universe
 
 from wbportfolio.import_export.handlers.trade import TradeImportHandler
 from wbportfolio.models.asset import AssetPosition
@@ -36,7 +39,7 @@ from wbportfolio.models.custodians import Custodian
 from wbportfolio.models.roles import PortfolioRole
 from wbportfolio.pms.typing import Trade as TradeDTO
 
-from .transactions import ShareMixin, Transaction
+from .transactions import TransactionMixin
 
 
 class TradeQueryset(OrderedModelQuerySet):
@@ -117,7 +120,7 @@ class ValidCustomerTradeManager(DefaultTradeManager):
         return qs
 
 
-class Trade(ShareMixin, Transaction, OrderedModel, WBModel):
+class Trade(TransactionMixin, ImportMixin, OrderedModel, models.Model):
     import_export_handler_class = TradeImportHandler
 
     TRADE_WINDOW_INTERVAL = 7
@@ -139,18 +142,26 @@ class Trade(ShareMixin, Transaction, OrderedModel, WBModel):
         SELL = "SELL", "Sell"
         NO_CHANGE = "NO_CHANGE", "No Change"  # default transaction subtype if weighing is 0
 
-    external_identifier2 = models.CharField(
-        max_length=255,
-        null=True,
-        blank=True,
-        help_text="A second external identifier that was supplied.",
-        verbose_name="External Identifier 2",
-    )
-
     transaction_subtype = models.CharField(
         max_length=32, default=Type.BUY, choices=Type.choices, verbose_name="Trade Type"
     )
     status = FSMField(default=Status.CONFIRMED, choices=Status.choices, verbose_name="Status")
+    transaction_date = models.DateField(
+        verbose_name="Trade Date",
+        help_text="The date that this transaction was traded.",
+    )
+    book_date = models.DateField(
+        verbose_name="Trade Date",
+        help_text="The date that this transaction was booked.",
+    )
+    shares = models.DecimalField(
+        max_digits=15,
+        decimal_places=4,
+        default=Decimal("0.0"),
+        help_text="The number of shares that were traded.",
+        verbose_name="Shares",
+    )
+
     weighting = models.DecimalField(
         max_digits=16,
         decimal_places=6,
@@ -158,36 +169,45 @@ class Trade(ShareMixin, Transaction, OrderedModel, WBModel):
         help_text="The weight to be multiplied against the target",
         verbose_name="Weight",
     )
-    bank = models.CharField(
-        max_length=255,
-        help_text="The bank/counterparty/custodian the trade went through.",
-        verbose_name="Counterparty",
+    claimed_shares = models.DecimalField(
+        max_digits=15,
+        decimal_places=4,
+        default=Decimal(0),
+        help_text="The number of shares that were claimed.",
+        verbose_name="Claimed Shares",
     )
-    custodian = models.ForeignKey(
-        "wbportfolio.Custodian", null=True, blank=True, on_delete=models.SET_NULL, related_name="trades"
+    diff_shares = models.GeneratedField(
+        expression=F("shares") - F("claimed_shares"),
+        output_field=models.DecimalField(max_digits=15, decimal_places=4),
+        db_persist=True,
+    )
+    internal_trade = models.OneToOneField(
+        "wbportfolio.Trade",
+        null=True,
+        blank=True,
+        on_delete=models.SET_NULL,
+        related_name="internal_subscription_redemption_trade",
     )
     marked_for_deletion = models.BooleanField(
         default=False,
         help_text="If this is checked, then the trade is supposed to be deleted.",
         verbose_name="To be deleted",
     )
-
-    # Only valid for subscription and redemption trade
     marked_as_internal = models.BooleanField(
         default=False,
         help_text="If this is checked, then this subscription or redemption is considered internal and will not be considered in any AUM computation",
         verbose_name="Internal",
     )
-    internal_trade = models.OneToOneField(
-        "wbportfolio.Trade",
-        null=True,
-        blank=True,
-        on_delete=models.SET_NULL,
-        related_name="internal_subscription_redemption_trade",
-    )
-
     pending = models.BooleanField(default=False)
     exclude_from_history = models.BooleanField(default=False)
+    bank = models.CharField(
+        max_length=255,
+        help_text="The bank/counterparty/custodian the trade went through.",
+        verbose_name="Counterparty",
+    )
+    custodian = models.ForeignKey(
+        "wbportfolio.Custodian", null=True, blank=True, on_delete=models.SET_NULL, related_name="trades"
+    )
     register = models.ForeignKey(
         to="wbportfolio.Register",
         null=True,
@@ -195,7 +215,6 @@ class Trade(ShareMixin, Transaction, OrderedModel, WBModel):
         related_name="trades",
         on_delete=models.PROTECT,
     )
-
     trade_proposal = models.ForeignKey(
         to="wbportfolio.TradeProposal",
         null=True,
@@ -204,18 +223,23 @@ class Trade(ShareMixin, Transaction, OrderedModel, WBModel):
         on_delete=models.CASCADE,
         help_text="The Trade Proposal this trade is coming from",
     )
-    claimed_shares = models.DecimalField(
-        max_digits=15,
-        decimal_places=4,
-        default=Decimal(0),
-        help_text="The number of shares that were claimed.",
-        verbose_name="Claimed Shares",
+
+    external_id = models.CharField(
+        max_length=255,
+        null=True,
+        blank=True,
+        help_text="An external identifier that was supplied.",
+        verbose_name="External Identifier",
     )
-    diff_shares = models.GeneratedField(
-        expression=F("shares") - F("claimed_shares"),
-        output_field=models.DecimalField(max_digits=15, decimal_places=4),
-        db_persist=True,
+    external_id_alternative = models.CharField(
+        max_length=255,
+        null=True,
+        blank=True,
+        help_text="A second external identifier that was supplied.",
+        verbose_name="Alternative External Identifier",
     )
+
+    # Manager
     objects = DefaultTradeManager()
     annotated_objects = DefaultTradeManager(with_annotation=True)
     valid_customer_trade_objects = ValidCustomerTradeManager()
@@ -247,8 +271,7 @@ class Trade(ShareMixin, Transaction, OrderedModel, WBModel):
         on_error="FAILED",
     )
     def submit(self, by=None, description=None, **kwargs):
-        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}"
+        pass
 
     def can_submit(self):
         pass
@@ -262,7 +285,7 @@ class Trade(ShareMixin, Transaction, OrderedModel, WBModel):
         ),
     )
     def fail(self, **kwargs):
-        self.comment = f"Trade failed because no price is found for {self.underlying_instrument.computed_str} on {self.transaction_date:%Y-%m-%d}"
+        pass
 
     @cached_property
     def last_underlying_quote_price(self) -> InstrumentPrice | None:
@@ -470,6 +493,11 @@ class Trade(ShareMixin, Transaction, OrderedModel, WBModel):
     class Meta(OrderedModel.Meta):
         verbose_name = "Trade"
         verbose_name_plural = "Trades"
+        indexes = [
+            models.Index(fields=["underlying_instrument", "transaction_date"]),
+            models.Index(fields=["portfolio", "underlying_instrument", "transaction_date"]),
+            # models.Index(fields=["date", "underlying_instrument"]),
+        ]
         constraints = [
             models.CheckConstraint(
                 check=models.Q(marked_as_internal=False)
@@ -487,6 +515,11 @@ class Trade(ShareMixin, Transaction, OrderedModel, WBModel):
                 ),
                 name="internal_trade_set_only_for_subred",
             ),
+            models.UniqueConstraint(
+                fields=["portfolio", "transaction_date", "underlying_instrument"],
+                name="unique_manual_trade",
+                condition=Q(trade_proposal__isnull=False),
+            ),
         ]
         # notification_email_template = "portfolio/email/trade_notification.html"
 
@@ -494,9 +527,13 @@ class Trade(ShareMixin, Transaction, OrderedModel, WBModel):
         super().__init__(*args, **kwargs)
         if target_weight is not None:  # if target weight is provided, we guess the corresponding weighting
             self.weighting = Decimal(target_weight) - self._effective_weight
-            self._set_transaction_subtype()
+            self._set_type()
 
     def save(self, *args, **kwargs):
+        if not self.value_date:
+            self.value_date = self.transaction_date
+        if not self.book_date:
+            self.book_date = self.transaction_date
         if self.trade_proposal:
             self.portfolio = self.trade_proposal.portfolio
             self.transaction_date = self.trade_proposal.trade_date
@@ -512,20 +549,16 @@ class Trade(ShareMixin, Transaction, OrderedModel, WBModel):
             with suppress(Exception):
                 self.price = self.underlying_instrument.get_price(self.value_date)
 
-        self.transaction_type = Transaction.Type.TRADE
-
         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()
+            self._set_type()
         if self.id and hasattr(self, "claims"):
-            self.claimed_shares = self.trade.claims.filter(status="APPROVED").aggregate(s=Sum("shares"))[
-                "s"
-            ] or Decimal(0)
+            self.claimed_shares = self.claims.filter(status="APPROVED").aggregate(s=Sum("shares"))["s"] or Decimal(0)
         if self.internal_trade:
             self.marked_as_internal = True
         super().save(*args, **kwargs)
 
-    def _set_transaction_subtype(self):
+    def _set_type(self):
         if self.weighting == 0:
             self.transaction_subtype = Trade.Type.NO_CHANGE
         if self.underlying_instrument.instrument_type.key == "product":
@@ -548,7 +581,7 @@ class Trade(ShareMixin, Transaction, OrderedModel, WBModel):
         else:
             self.transaction_subtype = Trade.Type.REBALANCE
 
-    def get_transaction_subtype(self) -> str:
+    def get_type(self) -> str:
         """
         Return the expected transaction subtype based n
 
@@ -742,6 +775,10 @@ class Trade(ShareMixin, Transaction, OrderedModel, WBModel):
     def get_representation_label_key(cls):
         return "{{|:-}}{{transaction_date}}{{|::}}{{bank}}{{|-:}} {{claimed_shares}} / {{shares}} (∆ {{diff_shares}})"
 
+    @classmethod
+    def get_representation_value_key(cls):
+        return "id"
+
 
 @shared_task
 def align_custodian():
@@ -756,3 +793,27 @@ def align_custodian():
 def compute_claimed_shares_on_claim_save(sender, instance, created, raw, **kwargs):
     if not raw and instance.trade:
         instance.trade.save()
+
+
+@receiver(pre_merge, sender="wbfdm.Instrument")
+def pre_merge_instrument(sender: models.Model, merged_object: "Instrument", main_object: "Instrument", **kwargs):
+    """
+    Simply reassign the transactions linked to the merged instrument to the main instrument
+    """
+    merged_object.trades.update(underlying_instrument=main_object)
+
+
+@receiver(add_instrument_to_investable_universe, sender="wbfdm.Instrument")
+def add_instrument_to_investable_universe_from_transactions(sender: models.Model, **kwargs) -> list[int]:
+    """
+    register all instrument linked to assets as within the investible universe
+    """
+    return list(
+        (
+            Instrument.objects.annotate(
+                transaction_exists=models.Exists(Trade.objects.filter(underlying_instrument=models.OuterRef("pk")))
+            ).filter(transaction_exists=True)
+        )
+        .distinct()
+        .values_list("id", flat=True)
+    )