wbportfolio 1.47.1__tar.gz → 1.48.0__tar.gz

{wbportfolio-1.47.1 → wbportfolio-1.48.0}/PKG-INFO

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

{wbportfolio-1.47.1 → wbportfolio-1.48.0}/wbportfolio/contrib/company_portfolio/tasks.py

@@ -1,11 +1,13 @@
 from datetime import date
 
 from celery import shared_task
+from django.db.models import Exists, OuterRef
 from tqdm import tqdm
 from wbcore.contrib.currency.models import CurrencyFXRates
-from wbcore.contrib.directory.models import Company, Entry
+from wbcore.contrib.directory.models import Company
+from wbcrm.models import Account
 
-from .models import Updater
+from .models import CompanyPortfolioData, Updater
 
 
 @shared_task(queue="portfolio")
@@ -13,7 +15,9 @@ def update_all_portfolio_data(val_date: date | None = None):
     if not val_date:
         val_date = CurrencyFXRates.objects.latest("date").date
     updater = Updater(val_date)
-    account_owners = Entry.objects.filter(accounts__isnull=False)
-    qs = Company.objects.filter(id__in=account_owners)
+    qs = Company.objects.annotate(
+        has_account=Exists(Account.objects.filter(owner=OuterRef("pk"))),
+        has_portfolio_data=Exists(CompanyPortfolioData.objects.filter(company=OuterRef("pk"))),
+    )
     for company in tqdm(qs, total=qs.count()):
         updater.update_company_data(company)

{wbportfolio-1.47.1 → wbportfolio-1.48.0}/wbportfolio/dynamic_preferences_registry.py

@@ -56,3 +56,12 @@ class AccountHoldingReconciliationNotificationBodyUpdate(LongStringPreference):
     section = portfolio
     name = "account_holding_reconciliation_notification_body_update"
     default = """A reconcilation has been updated and requires your review. Please review the reconciliation for the account {account} on {reconciliation_date}."""
+
+
+@global_preferences_registry.register
+class ProductTerminationNoticePeriod(IntegerPreference):
+    section = portfolio
+    name = "product_termination_notice_period"
+    default = 6 * 30  # approx 6 months
+
+    verbose_name = "Product Termination notice period"

wbportfolio-1.48.0/wbportfolio/import_export/resources/trades.py

@@ -0,0 +1,55 @@
+import rstr
+from faker import Faker
+from import_export import fields
+from import_export.widgets import ForeignKeyWidget
+from wbcore.contrib.io.resources import FilterModelResource
+from wbfdm.models import Instrument
+
+from wbportfolio.models import Trade
+
+fake = Faker()
+
+
+class TradeProposalTradeResource(FilterModelResource):
+    """
+    Trade Resource class to use to import trade from the trade proposal
+    """
+
+    DUMMY_FIELD_MAP = {
+        "underlying_instrument__isin": lambda: rstr.xeger("([A-Z]{2}[A-Z0-9]{9}[0-9]{1})"),
+        "underlying_instrument__ticker": "AAA",
+        "underlying_instrument__name": "stock name",
+        "weighting": 1.0,
+        "shares": 1000.2536,
+        "comment": lambda: fake.sentence(),
+        "order": 1,
+    }
+    underlying_instrument__isin = fields.Field(
+        column_name="underlying_instrument__isin",
+        attribute="underlying_instrument",
+        widget=ForeignKeyWidget(Instrument, field="isin"),
+    )
+    underlying_instrument__name = fields.Field(
+        column_name="underlying_instrument__name",
+        attribute="underlying_instrument",
+        widget=ForeignKeyWidget(Instrument, field="name"),
+    )
+    underlying_instrument__ticker = fields.Field(
+        column_name="underlying_instrument__ticker",
+        attribute="underlying_instrument",
+        widget=ForeignKeyWidget(Instrument, field="ticker"),
+    )
+
+    class Meta:
+        fields = (
+            "id",
+            "underlying_instrument__isin",
+            "underlying_instrument__name",
+            "underlying_instrument__ticker",
+            "weighting",
+            "shares",
+            "comment",
+            "order",
+        )
+        export_order = fields
+        model = Trade

{wbportfolio-1.47.1 → wbportfolio-1.48.0}/wbportfolio/metric/backends/base.py

@@ -2,12 +2,11 @@ from datetime import date
 
 import numpy as np
 import pandas as pd
-from django.db.models import Exists, OuterRef, QuerySet
+from django.db.models import QuerySet
 from wbfdm.contrib.metric.backends.base import AbstractBackend, Metric
 from wbfdm.contrib.metric.exceptions import MetricInvalidParameterException
-from wbfdm.models import InstrumentType
 
-from wbportfolio.models import AssetPosition, InstrumentPortfolioThroughModel, Portfolio
+from wbportfolio.models import AssetPosition, Portfolio
 
 
 class PortfolioMetricBaseBackend(AbstractBackend[Portfolio]):
@@ -66,18 +65,7 @@ class PortfolioMetricBaseBackend(AbstractBackend[Portfolio]):
             raise MetricInvalidParameterException()
 
     def get_queryset(self) -> QuerySet[Portfolio]:
-        product_portfolios = (
-            super()
-            .get_queryset()
-            .annotate(
-                has_product=Exists(
-                    InstrumentPortfolioThroughModel.objects.filter(
-                        instrument__instrument_type=InstrumentType.PRODUCT, portfolio=OuterRef("pk")
-                    )
-                )
-            )
-            .filter(has_product=True, is_active=True)
-        )
+        product_portfolios = super().get_queryset().filter_active_and_tracked()
         try:
             last_position_date = (
                 AssetPosition.objects.filter(portfolio__in=product_portfolios, is_estimated=False).latest("date").date

{wbportfolio-1.47.1 → wbportfolio-1.48.0}/wbportfolio/models/__init__.py

@@ -1,5 +1,5 @@
 # Import CRM relevant data
-
+from .roles import PortfolioRole
 from .adjustments import Adjustment
 from .asset import AssetPosition, AssetPositionGroupBy
 from .custodians import Custodian
@@ -16,6 +16,5 @@ from .portfolio_cash_targets import PortfolioCashTarget
 from .portfolio_cash_flow import DailyPortfolioCashFlow
 from .portfolio_swing_pricings import PortfolioSwingPricing
 from .registers import Register
-from .roles import PortfolioRole
 from .transactions import *
 from .reconciliations import AccountReconciliation, AccountReconciliationLine

{wbportfolio-1.47.1 → wbportfolio-1.48.0}/wbportfolio/models/asset.py

@@ -528,7 +528,7 @@ class AssetPosition(ImportMixin, models.Model):
             shares=self._shares,
             date=self.date,
             asset_valuation_date=self.asset_valuation_date,
-            instrument_type=self.underlying_quote.instrument_type.id,
+            instrument_type=self.underlying_quote.security_instrument_type.id,
             currency=self.underlying_quote.currency.id,
             country=self.underlying_quote.country.id if self.underlying_quote.country else None,
             is_cash=self.underlying_quote.is_cash,

{wbportfolio-1.47.1 → wbportfolio-1.48.0}/wbportfolio/models/portfolio.py

@@ -129,6 +129,15 @@ class DefaultPortfolioQueryset(QuerySet):
             & (Q(invested_timespan__endswith__gt=val_date) | Q(invested_timespan__endswith__isnull=True))
         )
 
+    def filter_active_and_tracked(self):
+        return self.annotate(
+            has_product=Exists(
+                InstrumentPortfolioThroughModel.objects.filter(
+                    instrument__instrument_type=InstrumentType.PRODUCT, portfolio=OuterRef("pk")
+                )
+            )
+        ).filter((Q(has_product=True) | Q(is_manageable=True)) & Q(is_active=True) & Q(is_tracked=True))
+
     def to_dependency_iterator(self, val_date: date) -> Iterable["Portfolio"]:
         """
         A method to sort the given queryset to return undependable portfolio first. This is very useful if a routine needs to be applied sequentially on portfolios by order of dependence.
@@ -171,6 +180,9 @@ class DefaultPortfolioManager(ActiveObjectManager):
     def filter_invested_at_date(self, val_date: date):
         return self.get_queryset().filter_invested_at_date(val_date)
 
+    def filter_active_and_tracked(self):
+        return self.get_queryset().filter_active_and_tracked()
+
 
 class ActiveTrackedPortfolioManager(DefaultPortfolioManager):
     def get_queryset(self):

{wbportfolio-1.47.1 → wbportfolio-1.48.0}/wbportfolio/models/products.py

@@ -1,5 +1,5 @@
 from contextlib import suppress
-from datetime import date, datetime, time
+from datetime import date, datetime, time, timedelta
 from decimal import Decimal
 
 from celery import shared_task
@@ -25,6 +25,9 @@ from pandas.tseries.offsets import BDay
 from wbcore.contrib.ai.llm.config import add_llm_prompt
 from wbcore.contrib.currency.models import CurrencyFXRates
 from wbcore.contrib.directory.models import Entry
+from wbcore.contrib.notifications.dispatch import send_notification
+from wbcore.contrib.notifications.utils import create_notification_type
+from wbcore.permissions.shortcuts import get_internal_users
 from wbcore.signals import pre_merge
 from wbcore.utils.enum import ChoiceEnum
 from wbcrm.models.accounts import Account
@@ -34,6 +37,8 @@ from wbfdm.models.instruments.instruments import InstrumentManager, InstrumentTy
 from wbportfolio.models.llm.wbcrm.analyze_relationship import get_holding_prompt
 from wbportfolio.models.portfolio_relationship import InstrumentPortfolioThroughModel
 
+from ..preferences import get_product_termination_notice_period
+from . import PortfolioRole
 from .mixins.instruments import PMSInstrument, PMSInstrumentAbstractModel
 
 
@@ -316,6 +321,17 @@ class Product(PMSInstrumentAbstractModel):
     class Meta:
         verbose_name = "Product"
         verbose_name_plural = "Products"
+        notification_types = [
+            create_notification_type(
+                "wbportfolio.product.termination_notice",
+                "Product Termination Notice",
+                "Sends a notification when a product is expected termination in the near future",
+                True,
+                True,
+                True,
+                is_lock=True,
+            ),
+        ]
 
     def pre_save(self):
         super().pre_save()
@@ -341,6 +357,39 @@ class Product(PMSInstrumentAbstractModel):
         computed_str += f" ({self.isin})"
         return computed_str
 
+    def check_and_notify_product_termination_on_date(self, today: date) -> bool:
+        """
+        Checks if today is the expected notice date for product termination and sends notifications if applicable.
+
+        The expected notice date is calculated by subtracting the product termination notice period from the product's delisted date. Notifications are sent to users associated with the product's portfolio roles.
+
+        Args:
+            today (date): The date to check against the expected notice date.
+
+        Returns:
+            bool: True if termination is due, False otherwise.
+        """
+        if self.delisted_date:
+            product_termination_expected_notice_date = self.delisted_date - timedelta(
+                days=get_product_termination_notice_period()
+            )
+            if today == product_termination_expected_notice_date:
+                roles = PortfolioRole.objects.filter(
+                    (models.Q(instrument=self) | models.Q(instrument__isnull=True))
+                    & (models.Q(start__isnull=True) | models.Q(start__gte=today))
+                    & (models.Q(end__isnull=True) | models.Q(end__lte=today))
+                    & models.Q(person__user_account__isnull=False)
+                )
+                for user in get_internal_users().filter(is_active=True, id__in=roles.values("person__user_account")):
+                    send_notification(
+                        code="wbportfolio.product.termination_notice",
+                        title="Product Termination Notice",
+                        body=f"The product {self} will be terminated on the {self.delisted_date:%Y-%m-%d}",
+                        user=user,
+                    )
+                return True
+        return False
+
     @property
     def white_label_product(self):
         return self.white_label_customers.all().count() > 0

{wbportfolio-1.47.1 → wbportfolio-1.48.0}/wbportfolio/models/transactions/trade_proposals.py

@@ -15,6 +15,7 @@ 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 wbportfolio.models.roles import PortfolioRole
@@ -30,7 +31,7 @@ logger = logging.getLogger("pms")
 SelfTradeProposal = TypeVar("SelfTradeProposal", bound="TradeProposal")
 
 
-class TradeProposal(RiskCheckMixin, WBModel):
+class TradeProposal(CloneMixin, RiskCheckMixin, WBModel):
     trade_date = models.DateField(verbose_name="Trading Date")
 
     class Status(models.TextChoices):
@@ -76,17 +77,17 @@ class TradeProposal(RiskCheckMixin, WBModel):
     def save(self, *args, **kwargs):
         if not self.trade_date and self.portfolio.assets.exists():
             self.trade_date = (self.portfolio.assets.latest("date").date + BDay(1)).date()
-        if not self.rebalancing_model and (rebalancer := getattr(self.portfolio, "automatic_rebalancer", None)):
-            self.rebalancing_model = rebalancer.rebalancing_model
         super().save(*args, **kwargs)
         if self.status == TradeProposal.Status.APPROVED:
             self.portfolio.change_at_date(self.trade_date)
 
-    def _get_checked_object_field_name(self) -> str:
-        """
-        Mandatory function from the Riskcheck mixin that returns the field (aka portfolio), representing the object to check the rules against.
-        """
-        return "portfolio"
+    @property
+    def checked_object(self):
+        return self.portfolio
+
+    @property
+    def check_evaluation_date(self):
+        return self.trade_date
 
     @cached_property
     def validated_trading_service(self) -> TradingService:
@@ -154,7 +155,7 @@ class TradeProposal(RiskCheckMixin, WBModel):
         )
 
     # Start tools methods
-    def clone(self, **kwargs) -> SelfTradeProposal:
+    def _clone(self, **kwargs) -> SelfTradeProposal:
         """
         Method to clone self as a new trade proposal. It will automatically shift the trade date if a proposal already exists
         Args:
@@ -176,6 +177,11 @@ class TradeProposal(RiskCheckMixin, WBModel):
             portfolio=self.portfolio,
             creator=self.creator,
         )
+        for trade in self.trades.all():
+            trade.id = None
+            trade.trade_proposal = trade_proposal_clone
+            trade.save()
+
         return trade_proposal_clone
 
     def normalize_trades(self):
@@ -263,17 +269,19 @@ class TradeProposal(RiskCheckMixin, WBModel):
             last_trade_proposal.portfolio.assets.filter(
                 date=last_trade_proposal.trade_date
             ).delete()  # we delete the existing position and we reapply the trade proposal
-            if not last_trade_proposal.portfolio.assets.filter(date=last_trade_proposal.trade_date).exists():
-                if last_trade_proposal.status == TradeProposal.Status.APPROVED:
-                    logger.info("Reverting trade proposal ...")
-                    last_trade_proposal.revert()
-                if last_trade_proposal.status == TradeProposal.Status.DRAFT:
-                    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.save()
+            if last_trade_proposal.status == TradeProposal.Status.APPROVED:
+                logger.info("Reverting trade proposal ...")
+                last_trade_proposal.revert()
+            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()
+                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.save()
             next_trade_proposal = last_trade_proposal.next_trade_proposal
             next_trade_date = (
                 next_trade_proposal.trade_date - timedelta(days=1) if next_trade_proposal else date.today()

{wbportfolio-1.47.1 → wbportfolio-1.48.0}/wbportfolio/models/transactions/trades.py

@@ -487,6 +487,7 @@ 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()
 
     def save(self, *args, **kwargs):
         if self.trade_proposal:
@@ -514,19 +515,7 @@ class Trade(ShareMixin, Transaction, OrderedModel, WBModel):
 
         if self.transaction_subtype is None:
             # if subtype not provided, we extract it automatically from the existing data.
-            if self.underlying_instrument.instrument_type.key == "product":
-                if self.shares is not None:
-                    if self.shares > 0:
-                        self.transaction_subtype = Trade.Type.SUBSCRIPTION
-                    elif self.shares < 0:
-                        self.transaction_subtype = Trade.Type.REDEMPTION
-            elif self.weighting is not None:
-                if self.weighting > 0:
-                    self.transaction_subtype = Trade.Type.BUY
-                elif self.weighting < 0:
-                    self.transaction_subtype = Trade.Type.SELL
-            else:
-                self.transaction_subtype = Trade.Type.REBALANCE
+            self._set_transaction_subtype()
         if self.id and hasattr(self, "claims"):
             self.claimed_shares = self.trade.claims.filter(status="APPROVED").aggregate(s=Sum("shares"))[
                 "s"
@@ -535,6 +524,21 @@ class Trade(ShareMixin, Transaction, OrderedModel, WBModel):
             self.marked_as_internal = True
         super().save(*args, **kwargs)
 
+    def _set_transaction_subtype(self):
+        if self.underlying_instrument.instrument_type.key == "product":
+            if self.shares is not None:
+                if self.shares > 0:
+                    self.transaction_subtype = Trade.Type.SUBSCRIPTION
+                elif self.shares < 0:
+                    self.transaction_subtype = Trade.Type.REDEMPTION
+        elif self.weighting is not None:
+            if self.weighting > 0:
+                self.transaction_subtype = Trade.Type.BUY
+            elif self.weighting < 0:
+                self.transaction_subtype = Trade.Type.SELL
+        else:
+            self.transaction_subtype = Trade.Type.REBALANCE
+
     def get_transaction_subtype(self) -> str:
         """
         Return the expected transaction subtype based n
@@ -560,7 +564,7 @@ class Trade(ShareMixin, Transaction, OrderedModel, WBModel):
             underlying_instrument=self.underlying_instrument.id,
             effective_weight=self._effective_weight,
             target_weight=self._target_weight,
-            instrument_type=self.underlying_instrument.security_instrument_type,
+            instrument_type=self.underlying_instrument.security_instrument_type.id,
             currency=self.underlying_instrument.currency,
             date=self.transaction_date,
         )

wbportfolio-1.48.0/wbportfolio/preferences.py

@@ -0,0 +1,11 @@
+from dynamic_preferences.registries import global_preferences_registry
+
+
+def get_monthly_nnm_target(*args, **kwargs) -> int:
+    global_preferences = global_preferences_registry.manager()
+    return global_preferences["wbportfolio__monthly_nnm_target"]
+
+
+def get_product_termination_notice_period(*args, **kwargs) -> int:
+    global_preferences = global_preferences_registry.manager()
+    return global_preferences["wbportfolio__product_termination_notice_period"]

{wbportfolio-1.47.1 → wbportfolio-1.48.0}/wbportfolio/risk_management/backends/accounts.py

@@ -3,6 +3,7 @@ from typing import Generator
 
 import pandas as pd
 from django.contrib.contenttypes.models import ContentType
+from django.contrib.humanize.templatetags.humanize import intcomma
 from django.db import models
 from wbcompliance.models.risk_management import backend
 from wbcompliance.models.risk_management.dispatch import register
@@ -148,15 +149,22 @@ class RuleBackend(backend.AbstractRuleBackend):
                         report_details = {
                             "Period": f"{cts_generator.start_date:%d.%m.%Y} - {cts_generator.end_date:%d.%m.%Y}",
                         }
+
+                        # create report detail template
                         color = "red" if percentage < 0 else "green"
+                        number_prefix = ""
+
                         if self.field == "AUM":
-                            report_details["AUM Change"] = (
-                                f'<span style="color:{color}">{start_df.loc[breached_obj_id]:.0f} $ → {end_df.loc[breached_obj_id]:.0f} $</span>'
-                            )
+                            key = "AUM Change"
+                            number_prefix = "$"
                         else:
-                            report_details["Shares Change"] = (
-                                f"<span style='color:{color}'>{start_df.loc[breached_obj_id]:.0f} → {end_df.loc[breached_obj_id]:.0f}</span>"
-                            )
+                            key = "Shares Change"
+
+                        template = f'{number_prefix}{{}} → {number_prefix}{{}} <span style="color:{color}"><strong>Δ {number_prefix}{{}}</strong></span>'
+                        start = intcomma(int(start_df.loc[breached_obj_id].round(0)))
+                        end = intcomma(int(end_df.loc[breached_obj_id].round(0)))
+                        diff = intcomma(int((end_df.loc[breached_obj_id] - start_df.loc[breached_obj_id]).round(0)))
+                        report_details[key] = template.format(start, end, diff)
                         report_details["Group By"] = self.group_by.value
                         yield backend.IncidentResult(
                             breached_object=breached_obj,

{wbportfolio-1.47.1 → wbportfolio-1.48.0}/wbportfolio/risk_management/backends/exposure_portfolio.py

@@ -137,11 +137,12 @@ class RuleBackend(
         if not (df := self._filter_df(portfolio.to_df())).empty:
             df = df[[self.group_by.value, self.field.value]].groupby(self.group_by.value).sum().astype(float)
             for threshold in self.thresholds:
-                dff = df.copy()
                 numerical_range = threshold.numerical_range
-                dff = dff[(dff[self.field.value] > numerical_range[0]) & (dff[self.field.value] < numerical_range[1])]
-                if not dff.empty:
-                    for id, row in dff.to_dict("index").items():
+                incident_df = df[
+                    (df[self.field.value] >= numerical_range[0]) & (df[self.field.value] < numerical_range[1])
+                ]
+                if not incident_df.empty:
+                    for id, row in incident_df.to_dict("index").items():
                         obj, obj_repr = self._get_obj_repr(id)
                         severity: RiskIncidentType = threshold.severity
                         if self.field == self.Field.WEIGHTING:
@@ -165,9 +166,9 @@ class RuleBackend(
             return df
         if self.is_cash is True or self.is_cash is False:
             df = df[df["is_cash"] == self.is_cash]
-
         if self.asset_classes:
             df = df[df["instrument_type"].isin(list(map(lambda o: o.id, self.asset_classes)))]
+
         if self.countries:
             df = df[(~df["country"].isnull() & df["country"].isin(list(map(lambda o: o.id, self.countries))))]
         if self.currencies:
@@ -179,6 +180,7 @@ class RuleBackend(
                     & df["primary_classification"].isin(list(map(lambda o: o.id, self.classifications)))
                 )
             ]
+
         return df
 
     def _get_obj_repr(self, pivot_object_id) -> tuple[models.Model | None, str]:

{wbportfolio-1.47.1 → wbportfolio-1.48.0}/wbportfolio/serializers/transactions/trade_proposals.py

@@ -10,10 +10,7 @@ from .. import PortfolioRepresentationSerializer, RebalancingModelRepresentation
 
 
 class TradeProposalModelSerializer(wb_serializers.ModelSerializer):
-    rebalancing_model = wb_serializers.PrimaryKeyRelatedField(
-        queryset=RebalancingModel.objects.all(),
-        default=DefaultFromView("portfolio.automatic_rebalancer.rebalancing_model"),
-    )
+    rebalancing_model = wb_serializers.PrimaryKeyRelatedField(queryset=RebalancingModel.objects.all(), required=False)
     _rebalancing_model = RebalancingModelRepresentationSerializer(source="rebalancing_model")
     target_portfolio = wb_serializers.PrimaryKeyRelatedField(
         queryset=Portfolio.objects.all(), write_only=True, required=False, default=DefaultFromView("portfolio")
@@ -32,15 +29,7 @@ class TradeProposalModelSerializer(wb_serializers.ModelSerializer):
         obj = super().create(validated_data)
 
         target_portfolio_dto = None
-        if (
-            target_portfolio
-            and not rebalancing_model
-            and (
-                last_effective_date := target_portfolio.get_latest_asset_position_date(
-                    obj.trade_date, with_estimated=True
-                )
-            )
-        ):
+        if target_portfolio and not rebalancing_model and (last_effective_date := obj.last_effective_date):
             target_portfolio_dto = target_portfolio._build_dto(last_effective_date)
         try:
             obj.reset_trades(target_portfolio=target_portfolio_dto)

{wbportfolio-1.47.1 → wbportfolio-1.48.0}/wbportfolio/tasks.py

@@ -10,10 +10,13 @@ from .fdm.tasks import *  # noqa
 
 
 @shared_task(queue="portfolio")
-def periodically_update_outstanding_shares_for_active_products():
+def daily_active_product_task(today: date | None = None):
+    if not today:
+        today = date.today()
     qs = Product.active_objects.all()
     for product in tqdm(qs, total=qs.count()):
         update_outstanding_shares_as_task(product.id)
+        product.check_and_notify_product_termination_on_date(today)
 
 
 @shared_task(queue="portfolio")

{wbportfolio-1.47.1 → wbportfolio-1.48.0}/wbportfolio/tests/conftest.py

@@ -117,7 +117,7 @@ register(ContinentFactory)
 
 register(CompanyFactory)
 register(PersonFactory)
-register(InternalUserFactory)
+register(InternalUserFactory, "internal_user")
 register(EntryFactory)
 register(CustomerStatusFactory)
 register(CompanyTypeFactory)

{wbportfolio-1.47.1 → wbportfolio-1.48.0}/wbportfolio/tests/models/test_products.py

@@ -1,5 +1,7 @@
 import datetime
+from datetime import timedelta
 from decimal import Decimal
+from unittest.mock import patch
 
 import pytest
 from faker import Faker
@@ -7,6 +9,7 @@ from wbfdm.models import Instrument
 
 from wbportfolio.models import Product, Trade
 
+from ...preferences import get_product_termination_notice_period
 from .utils import PortfolioTestMixin
 
 fake = Faker()
@@ -188,3 +191,26 @@ class TestProductModel(PortfolioTestMixin):
         product.initial_high_water_mark = 400
         product.save()
         assert product.get_high_water_mark(p4.date) == 400
+
+    @patch("wbportfolio.models.products.send_notification")
+    def test_check_and_notify_product_termination_on_date(
+        self, mock_fct, weekday, product, manager_portfolio_role_factory, internal_user
+    ):
+        assert not product.check_and_notify_product_termination_on_date(weekday)
+
+        product.delisted_date = weekday + datetime.timedelta(days=get_product_termination_notice_period())
+        product.save()
+        assert product.check_and_notify_product_termination_on_date(weekday)
+        mock_fct.assert_not_called()
+        assert not product.check_and_notify_product_termination_on_date(
+            weekday + timedelta(days=1)
+        )  # one day later is not valid anymore
+
+        manager_portfolio_role_factory.create(person=internal_user.profile)
+        product.check_and_notify_product_termination_on_date(weekday)
+        mock_fct.assert_called_with(
+            code="wbportfolio.product.termination_notice",
+            title="Product Termination Notice",
+            body=f"The product {product} will be terminated on the {product.delisted_date:%Y-%m-%d}",
+            user=internal_user,
+        )