wbportfolio 2.2.1__py2.py3-none-any.whl

wbportfolio/filters/performances.py

@@ -0,0 +1,171 @@
+from django.db.models import Q, TextChoices
+from django.utils.timezone import localdate
+from wbcore import filters as wb_filters
+from wbcore.pandas.filterset import PandasFilterSetMixin
+from wbcore.utils.date import current_financial_month
+from wbfdm.filters.utils import last_period_date_range
+from wbfdm.models import Instrument
+from wbportfolio.models import Product
+
+from .products import BaseProductFilterSet
+
+
+def current_date(*args, **kwargs):
+    return localdate()
+
+
+class PerformancePandasFilter(PandasFilterSetMixin, BaseProductFilterSet):
+    class PerformanceBy(TextChoices):
+        NNM = "NNM", "NNM"
+        AUM = "AUM", "AUM"
+        PRICE = "PRICE", "Price"
+
+    is_forex_fix = wb_filters.BooleanFilter(label="Fix Forex rate", method="fake_filter", default=False)
+
+    date = wb_filters.FinancialPerformanceDateRangeFilter(
+        label="Date Range",
+        method=lambda queryset, label, value: queryset,
+        required=True,
+        clearable=False,
+        default=current_financial_month,
+    )
+
+    performance_by = wb_filters.ChoiceFilter(
+        label="Performance By",
+        choices=PerformanceBy.choices,
+        default=PerformanceBy.PRICE.name,
+        method="fake_filter",
+        clearable=False,
+        required=True,
+    )
+    white_label_customers = (
+        classifications
+    ) = classifications_neq = unclassified = invested = portfolio = content_type = tags = None
+
+    class Meta:
+        model = Product
+        fields = {}
+        df_fields = {
+            "diff__gte": wb_filters.NumberFilter(
+                precision=2, label="Difference", lookup_expr="gte", field_name="diff"
+            ),
+            "perf__gte": wb_filters.NumberFilter(
+                precision=2, label="Performance", lookup_expr="gte", field_name="perf"
+            ),
+            "n1__gte": wb_filters.NumberFilter(precision=2, label="N1", lookup_expr="gte", field_name="n1"),
+            "n2__gte": wb_filters.NumberFilter(precision=2, label="N2", lookup_expr="gte", field_name="n2"),
+            "n1_usd__gte": wb_filters.NumberFilter(
+                precision=2, label="N1 (USD)", lookup_expr="gte", field_name="n1_usd"
+            ),
+            "n2_usd__gte": wb_filters.NumberFilter(
+                precision=2, label="N2 (USD)", lookup_expr="gte", field_name="n2_usd"
+            ),
+            "diff_usd__gte": wb_filters.NumberFilter(
+                precision=2, label="Difference (USD)", lookup_expr="gte", field_name="diff_usd"
+            ),
+            "perf_usd__gte": wb_filters.NumberFilter(
+                precision=2, label="Performance (USD)", lookup_expr="gte", field_name="perf_usd"
+            ),
+            "diff__lte": wb_filters.NumberFilter(
+                precision=2, label="Difference", lookup_expr="lte", field_name="diff"
+            ),
+            "perf__lte": wb_filters.NumberFilter(
+                precision=2, label="Performance", lookup_expr="lte", field_name="perf"
+            ),
+            "n1__lte": wb_filters.NumberFilter(precision=2, label="N1", lookup_expr="lte", field_name="n1"),
+            "n2__lte": wb_filters.NumberFilter(precision=2, label="N2", lookup_expr="lte", field_name="n2"),
+            "n1_usd__lte": wb_filters.NumberFilter(
+                precision=2, label="N1 (USD)", lookup_expr="lte", field_name="n1_usd"
+            ),
+            "n2_usd__lte": wb_filters.NumberFilter(
+                precision=2, label="N2 (USD)", lookup_expr="lte", field_name="n2_usd"
+            ),
+            "diff_usd__lte": wb_filters.NumberFilter(
+                precision=2, label="Difference (USD)", lookup_expr="lte", field_name="diff_usd"
+            ),
+            "perf_usd__lte": wb_filters.NumberFilter(
+                precision=2, label="Performance (USD)", lookup_expr="lte", field_name="perf_usd"
+            ),
+        }
+
+
+class ProductPerformanceNetNewMoneyFilter(PandasFilterSetMixin, BaseProductFilterSet):
+    is_active = wb_filters.BooleanFilter(label="Is Active", method="filter_active_products", default=True)
+    net_negative_money__gte = wb_filters.NumberFilter(
+        label="Net Negative money", lookup_expr="gte", field_name="net_negative_money"
+    )
+    net_negative_money__lte = wb_filters.NumberFilter(
+        label="Net Negative money", lookup_expr="lte", field_name="net_negative_money"
+    )
+    net_positive_money__gte = wb_filters.NumberFilter(
+        label="Net Positive money", lookup_expr="gte", field_name="net_positive_money"
+    )
+    net_positive_money__lte = wb_filters.NumberFilter(
+        label="Net Positive money", lookup_expr="lte", field_name="net_positive_money"
+    )
+    net_positive_money_usd__gte = wb_filters.NumberFilter(
+        label="Net Positive money ($)", lookup_expr="gte", field_name="net_positive_money_usd"
+    )
+    net_positive_money_usd__lte = wb_filters.NumberFilter(
+        label="Net Positive money ($)", lookup_expr="lte", field_name="net_positive_money_usd"
+    )
+    net_negative_money_usd__gte = wb_filters.NumberFilter(
+        label="Net Negative money ($)", lookup_expr="gte", field_name="net_negative_money_usd"
+    )
+    net_negative_money_usd__lte = wb_filters.NumberFilter(
+        label="Net Negative money ($)", lookup_expr="lte", field_name="net_negative_money_usd"
+    )
+    net_money__gte = wb_filters.NumberFilter(label="Net Money", lookup_expr="gte", field_name="net_money")
+    net_money__lte = wb_filters.NumberFilter(label="Net Money", lookup_expr="lte", field_name="net_money")
+    net_money_usd__gte = wb_filters.NumberFilter(label="Net Money ($)", lookup_expr="gte", field_name="net_money_usd")
+    net_money_usd__lte = wb_filters.NumberFilter(label="Net Money ($)", lookup_expr="lte", field_name="net_money_usd")
+
+    date = wb_filters.DateRangeFilter(
+        label="Date Range",
+        method=lambda queryset, label, value: queryset,
+        required=True,
+        clearable=False,
+        default=last_period_date_range,
+    )
+
+    def filter_active_products(self, queryset, name, value):
+        if value is True:
+            return queryset.filter(~Q(net_money=0.0))
+        elif value is False:
+            return queryset.filter(Q(net_money=0.0))
+
+        return queryset
+
+    white_label_customers = (
+        classifications
+    ) = classifications_neq = unclassified = invested = portfolio = content_type = tags = None
+
+    class Meta:
+        model = Product
+        fields = {
+            "computed_str": ["exact", "icontains"],
+        }
+
+
+class PerformanceComparisonFilter(PandasFilterSetMixin, BaseProductFilterSet):
+    classifications = unclassified = invested = None
+    dates = wb_filters.FinancialPerformanceDateRangeFilter(
+        method=lambda q, n, v: q, label="Compute Performance between these dates"
+    )
+
+    comparison_instrument = wb_filters.ModelChoiceFilter(
+        label="Compare with...",
+        queryset=Instrument.objects.all(),
+        endpoint=Instrument.get_representation_endpoint(),
+        value_key=Instrument.get_representation_value_key(),
+        label_key=Instrument.get_representation_label_key(),
+        filter_params={"level": 0},
+        method="fake_filter",
+    )
+    compare_primary_benchmark = wb_filters.BooleanFilter(
+        default=False, label="Compare against primary benchmark", method="fake_filter"
+    )
+
+    class Meta:
+        model = Product
+        fields = {}

wbportfolio/filters/portfolios.py

@@ -0,0 +1,24 @@
+from wbcore import filters as wb_filters
+from wbfdm.models import Instrument
+from wbportfolio.models import Portfolio
+
+
+class PortfolioFilterSet(wb_filters.FilterSet):
+    instrument = wb_filters.ModelChoiceFilter(
+        label="Instrument",
+        queryset=Instrument.objects.all(),
+        endpoint=Instrument.get_representation_endpoint(),
+        value_key=Instrument.get_representation_value_key(),
+        label_key=Instrument.get_representation_label_key(),
+        filter_params={"is_managed": True},
+        method="filter_instrument",
+    )
+
+    def filter_instrument(self, queryset, name, value):
+        if value:
+            return queryset.filter(instruments=value)
+        return queryset
+
+    class Meta:
+        model = Portfolio
+        fields = {"currency": ["exact"], "is_manageable": ["exact"]}

wbportfolio/filters/positions.py

@@ -0,0 +1,178 @@
+import datetime as dt
+
+from django.db.models import TextChoices
+from pandas.tseries.offsets import BDay
+from wbcore import filters as wb_filters
+from wbcore.contrib.currency.models import CurrencyFXRates
+from wbcore.pandas.filterset import PandasFilterSetMixin
+from wbcore.utils.date import current_financial_month
+from wbportfolio.filters.assets import (
+    DateFilterMixin,
+    get_latest_end_quarter_date_asset_position,
+)
+from wbportfolio.models import AssetPosition
+
+
+class GroupbyChoice(TextChoices):
+    UNDERLYING_INSTRUMENT = "UNDERLYING_INSTRUMENT", "Underlying Instrument"
+    CURRENCY = "CURRENCY", "Currency"
+    COUNTRY = "COUNTRY", "Country"
+    PORTFOLIO = "PORTFOLIO", "Portfolio"
+    PRIMARY_CLASSIFICATION = "PRIMARY_CLASSIFICATION", "Primary Classification (Specified Height)"
+    PREFERRED_CLASSIFICATION = "PREFERRED_CLASSIFICATION", "Preferred Classification (Specified Height)"
+
+    @classmethod
+    def get_id(cls, name: str) -> str:
+        return {
+            "UNDERLYING_INSTRUMENT": "underlying_instrument",
+            "CURRENCY": "underlying_instrument__currency",
+            "COUNTRY": "underlying_instrument__country",
+            "PORTFOLIO": "portfolio",
+            "PRIMARY_CLASSIFICATION": "classification_id",
+            "PREFERRED_CLASSIFICATION": "classification_id",
+        }[name]
+
+    @classmethod
+    def get_repr(cls, name: str) -> str:
+        return {
+            "UNDERLYING_INSTRUMENT": "underlying_instrument__name_repr",
+            "CURRENCY": "underlying_instrument__currency__key",
+            "COUNTRY": "underlying_instrument__country__name",
+            "PORTFOLIO": "portfolio__name",
+            "PRIMARY_CLASSIFICATION": "classification_title",
+            "PREFERRED_CLASSIFICATION": "classification_title",
+        }[name]
+
+
+def get_latest_date_based_on_multiple_models(field, request, view):
+    models = [AssetPosition.objects, CurrencyFXRates.objects]
+    default_date = (dt.date.today() - BDay(1)).date()  # default latest date
+    if not any(model.exists() for model in models):  # if at least one model is empty, it return the default date.
+        return default_date
+
+    def get_most_recent_common_date(date):
+        for model in models:
+            latest_model_date = model.filter(date__lte=date).latest("date").date
+            if latest_model_date != date:
+                return get_most_recent_common_date(latest_model_date)
+        return date
+
+    latest_date = get_most_recent_common_date(default_date)
+    return latest_date
+
+
+class AssetPositionPandasFilter(DateFilterMixin, PandasFilterSetMixin, wb_filters.FilterSet):
+    # price_start = wb_filters.NumberFilter(label="Price Start")
+    # price_end = wb_filters.NumberFilter(label="Price End")
+
+    date = total_value_fx_usd = total_value_fx_usd__gte = total_value_fx_usd__lte = None
+
+    date = wb_filters.FinancialPerformanceDateRangeFilter(
+        method=wb_filters.DateRangeFilter.base_date_range_filter_method,
+        label="Date Range",
+        required=True,
+        clearable=False,
+        default=current_financial_month,
+    )
+
+    group_by = wb_filters.ChoiceFilter(
+        label="Group By",
+        choices=GroupbyChoice.choices,
+        default=GroupbyChoice.UNDERLYING_INSTRUMENT,
+        method="fake_filter",
+        clearable=False,
+        required=True,
+    )
+
+    groupby_classification_height = wb_filters.NumberFilter(
+        method="fake_filter", label="Classification Height (groupby)", default=0, clearable=False, required=True
+    )
+
+    class Meta:
+        model = AssetPosition
+        fields = {
+            # "price_start" : ["gte", "exact", "lte"],
+            # "price_end" : ["gte", "exact", "lte"],
+            "underlying_instrument": ["exact"],
+            "portfolio": ["exact"],
+            "currency": ["exact"],
+            "exchange": ["exact"],
+        }
+        df_fields = {
+            "total_value_start__gte": wb_filters.NumberFilter(
+                precision=1, label="Total Value Start", lookup_expr="gte", field_name="total_value_start"
+            ),
+            "total_value_end__gte": wb_filters.NumberFilter(
+                precision=1, label="Total Value End", lookup_expr="gte", field_name="total_value_end"
+            ),
+            "allocation_start__gte": wb_filters.NumberFilter(
+                precision=2, label="Weighting Start", lookup_expr="gte", field_name="allocation_start"
+            ),
+            "allocation_end__gte": wb_filters.NumberFilter(
+                precision=2, label="Weighting End", lookup_expr="gte", field_name="allocation_end"
+            ),
+            "performance_total__gte": wb_filters.NumberFilter(
+                precision=2, label="Total Performance", lookup_expr="gte", field_name="performance_total"
+            ),
+            "contribution_total__gte": wb_filters.NumberFilter(
+                precision=2, label="Total Contribution", lookup_expr="gte", field_name="contribution_total"
+            ),
+            "performance_forex__gte": wb_filters.NumberFilter(
+                precision=2, label="Forex Performance", lookup_expr="gte", field_name="performance_forex"
+            ),
+            "contribution_forex__gte": wb_filters.NumberFilter(
+                precision=2, label="Forex  Contribution", lookup_expr="gte", field_name="contribution_forex"
+            ),
+            "market_share__gte": wb_filters.NumberFilter(
+                precision=2, label="Market Shares", lookup_expr="gte", field_name="market_share"
+            ),
+            "total_value_start__lte": wb_filters.NumberFilter(
+                lookup_expr="lte", field_name="total_value_start", precision=1, label="Total Value Start"
+            ),
+            "total_value_end__lte": wb_filters.NumberFilter(
+                lookup_expr="lte", field_name="total_value_end", precision=1, label="Total Value End"
+            ),
+            "allocation_start__lte": wb_filters.NumberFilter(
+                lookup_expr="lte", field_name="allocation_start", precision=2, label="Weighting Start"
+            ),
+            "allocation_end__lte": wb_filters.NumberFilter(
+                lookup_expr="lte", field_name="allocation_end", precision=2, label="Weighting End"
+            ),
+            "performance_total__lte": wb_filters.NumberFilter(
+                lookup_expr="lte", field_name="performance_total", precision=2, label="Total Performance"
+            ),
+            "contribution_total__lte": wb_filters.NumberFilter(
+                lookup_expr="lte", field_name="contribution_total", precision=2, label="Total Contribution"
+            ),
+            "performance_forex__lte": wb_filters.NumberFilter(
+                lookup_expr="lte", field_name="performance_forex", precision=2, label="Forex Performance"
+            ),
+            "contribution_forex__lte": wb_filters.NumberFilter(
+                lookup_expr="lte", field_name="contribution_forex", precision=2, label="Forex  Contribution"
+            ),
+            "market_share__lte": wb_filters.NumberFilter(
+                lookup_expr="lte", field_name="market_share", precision=2, label="Market Shares"
+            ),
+        }
+
+
+class AggregatedAssetPositionLiquidityFilter(PandasFilterSetMixin, wb_filters.FilterSet):
+    historic_date = wb_filters.DateFilter(
+        label="Historic Date",
+        method=lambda queryset, label, value: queryset,
+        default=get_latest_date_based_on_multiple_models,
+        required=True,
+    )
+    compared_date = wb_filters.DateFilter(
+        label="Compared Date",
+        method=lambda queryset, label, value: queryset,
+        default=get_latest_end_quarter_date_asset_position,
+        required=True,
+    )
+    bigger_than_x = wb_filters.NumberFilter(
+        label="Bigger Than..", method=lambda queryset, label, value: queryset, default=1.00, required=True, precision=2
+    )
+
+    class Meta:
+        model = AssetPosition
+        fields = {}

wbportfolio/filters/products.py

@@ -0,0 +1,157 @@
+from django.db.models import Q
+from wbcore import filters as wb_filters
+from wbcore.contrib.directory.models import Company, Entry
+from wbfdm.filters.instruments import InstrumentFilterSet
+from wbfdm.filters.utils import last_period_date_range
+from wbfdm.models import Classification
+from wbportfolio.models import Product, ProductGroup
+
+
+class BaseProductFilterSet(InstrumentFilterSet):
+    classifications = wb_filters.ModelChoiceFilter(
+        label="Classification",
+        queryset=Classification.objects.all(),
+        endpoint=Classification.get_representation_endpoint(),
+        value_key=Classification.get_representation_value_key(),
+        label_key=Classification.get_representation_label_key(),
+        filter_params={"instrument_type_key": "product"},
+        method="filter_classification",
+    )
+
+    bank = wb_filters.ModelMultipleChoiceFilter(
+        label="Bank",
+        queryset=Company.bank_objects.all(),
+        endpoint=Company.get_representation_endpoint(),
+        filter_params={"bank_product": True},
+        value_key=Company.get_representation_value_key(),
+        label_key=Company.get_representation_label_key(),
+    )
+    white_label_customers = wb_filters.ModelMultipleChoiceFilter(
+        label="White Label Customers",
+        queryset=Entry.objects.all(),
+        endpoint=Entry.get_representation_endpoint(),
+        value_key=Entry.get_representation_value_key(),
+        label_key=Entry.get_representation_label_key(),
+    )
+    parent = wb_filters.ModelChoiceFilter(
+        label="Group",
+        queryset=ProductGroup.objects.all(),
+        endpoint=ProductGroup.get_representation_endpoint(),
+        value_key=ProductGroup.get_representation_value_key(),
+        label_key=ProductGroup.get_representation_label_key(),
+    )
+    is_invested = wb_filters.BooleanFilter(label="Invested")
+    is_active = wb_filters.BooleanFilter(label="Only Active", method="filter_is_active", default=True)
+
+    class Meta:
+        model = Product
+        fields = {"currency": ["exact"]}
+
+
+class ProductFilter(BaseProductFilterSet):
+    is_white_label = wb_filters.BooleanFilter(label="Is White Label", method="filter_is_white_label")
+
+    net_value = wb_filters.NumberFilter(label="Last NAV")
+    net_value__gte = wb_filters.NumberFilter(field_name="net_value", label="Last NAV", lookup_expr="gte")
+    net_value__lte = wb_filters.NumberFilter(field_name="net_value", label="Last NAV", lookup_expr="lte")
+
+    assets_under_management__gte = wb_filters.NumberFilter(
+        lookup_expr="gte", field_name="assets_under_management", label="Asset under management"
+    )
+    assets_under_management__lte = wb_filters.NumberFilter(
+        lookup_expr="lte", field_name="assets_under_management", label="Asset under management"
+    )
+
+    assets_under_management_usd__gte = wb_filters.NumberFilter(
+        lookup_expr="gte", field_name="assets_under_management_usd", label="Asset under management ($)"
+    )
+    assets_under_management_usd__lte = wb_filters.NumberFilter(
+        lookup_expr="lte", field_name="assets_under_management_usd", label="Asset under management ($)"
+    )
+
+    last_valuation_date = wb_filters.DateFilter(
+        field_name="last_valuation_date", lookup_expr="exact", label="Last Valuation Date"
+    )
+
+    def filter_is_white_label(self, queryset, name, value):
+        if value:
+            return queryset.filter(is_white_label=True)
+        return queryset
+
+    class Meta(BaseProductFilterSet.Meta):
+        fields = {
+            "isin": ["exact", "icontains"],
+            "ticker": ["exact", "icontains"],
+            "currency": ["exact"],
+        }
+
+
+class ProductCustomerFilter(wb_filters.FilterSet):
+    net_value = wb_filters.NumberFilter(label="Net Value")
+    net_value__gte = wb_filters.NumberFilter(field_name="net_value", label="Last NAV", lookup_expr="gte")
+    net_value__lte = wb_filters.NumberFilter(field_name="net_value", label="Last NAV", lookup_expr="lte")
+
+    class Meta:
+        model = Product
+        fields = {}
+
+
+class ProductFeeFilter(BaseProductFilterSet):
+    sum_management_fees = wb_filters.NumberFilter(label="Sum Management Fees")
+    sum_management_fees__gte = wb_filters.NumberFilter(
+        lookup_expr="gte", field_name="sum_management_fees", label="Sum Management Fees"
+    )
+    sum_management_fees__lte = wb_filters.NumberFilter(
+        lookup_expr="lte", field_name="sum_management_fees", label="Sum Management Fees"
+    )
+
+    sum_management_fees_usd__gte = wb_filters.NumberFilter(
+        lookup_expr="gte", field_name="sum_management_fees_usd", label="Sum Management Fees (USD)"
+    )
+    sum_performance_fees_net__gte = wb_filters.NumberFilter(
+        lookup_expr="gte", field_name="sum_performance_fees_net", label="Sum Performance Fees"
+    )
+    sum_performance_fees_net_usd__gte = wb_filters.NumberFilter(
+        lookup_expr="gte", field_name="sum_performance_fees_net_usd", label="Sum Performance Fees (USD)"
+    )
+    sum_total_usd__gte = wb_filters.NumberFilter(
+        lookup_expr="gte", field_name="sum_total_usd", label="Total Fees (USD)"
+    )
+
+    sum_management_fees_usd__lte = wb_filters.NumberFilter(
+        lookup_expr="lte", field_name="sum_management_fees_usd", label="Sum Management Fees (USD)"
+    )
+    sum_performance_fees_net__lte = wb_filters.NumberFilter(
+        lookup_expr="lte", field_name="sum_performance_fees_net", label="Sum Performance Fees"
+    )
+    sum_performance_fees_net_usd__lte = wb_filters.NumberFilter(
+        lookup_expr="lte", field_name="sum_performance_fees_net_usd", label="Sum Performance Fees (USD)"
+    )
+    sum_total_usd__lte = wb_filters.NumberFilter(
+        lookup_expr="lte", field_name="sum_total_usd", label="Total Fees (USD)"
+    )
+
+    assets_under_management__gte = (
+        assets_under_management__lte
+    ) = (
+        assets_under_management_usd__gte
+    ) = (
+        assets_under_management_usd__lte
+    ) = date = net_value = net_value__lte = net_value__gte = assets_under_management_usd = name = ticker = None
+
+    date = wb_filters.DateRangeFilter(
+        label="Date Range",
+        method=lambda queryset, label, value: queryset,
+        required=True,
+        clearable=False,
+        default=last_period_date_range(),
+    )
+
+    def filter_active_products(self, queryset, name, value):
+        if value:
+            return queryset.filter(~(Q(sum_management_fees=0.0) & Q(sum_performance_fees_net=0.0)))
+        return queryset
+
+    class Meta:
+        model = Product
+        fields = {"currency": ["exact"]}

wbportfolio/filters/roles.py

@@ -0,0 +1,26 @@
+from django.db.models import Q
+from django.utils import timezone
+from wbcore import filters as wb_filters
+from wbportfolio.models import PortfolioRole
+
+
+class PortfolioRoleFilterSet(wb_filters.FilterSet):
+    is_active = wb_filters.BooleanFilter(method="filter_is_active", default=True, label="Is Active")
+
+    def filter_is_active(self, queryset, name, value):
+        if value is True:
+            return queryset.filter(Q(end__isnull=True) | Q(end__gte=timezone.now())).distinct()
+        elif value is False:
+            return queryset.filter(end__lte=timezone.now())
+        return queryset
+
+    class Meta:
+        model = PortfolioRole
+        fields = {
+            "role_type": ["exact"],
+            "person": ["exact"],
+            "start": ["gte", "exact", "lte"],
+            "end": ["gte", "exact", "lte"],
+            "weighting": ["gte", "exact", "lte"],
+            "instrument": ["exact"],
+        }

wbportfolio/filters/signals.py

@@ -0,0 +1,92 @@
+from datetime import date
+
+from django.db.models import Exists, OuterRef
+from django.dispatch import receiver
+from wbcore import filters as wb_filters
+from wbcore.contrib.directory.filters import CompanyFilter
+from wbcore.signals.filters import add_filters
+from wbfdm.filters import BaseClassifiedInstrumentFilterSet, ClassificationFilter
+from wbfdm.models import InstrumentClassificationThroughModel
+from wbportfolio.models import AssetPosition, Portfolio
+
+
+@receiver(add_filters, sender=CompanyFilter)
+def add_bank_product_filter(sender, request=None, *args, **kwargs):
+    def method_bank(queryset, name, value):
+        if value is True:
+            return queryset.filter(issues_products__isnull=False).distinct()
+        elif value is False:
+            return queryset.filter(issues_products__isnull=True).distinct()
+        return queryset
+
+    return {
+        "bank_product": wb_filters.BooleanFilter(
+            field_name="bank_product",
+            label="Is a Bank",
+            help_text="Filter for companies that are a bank and serve as the custodian of a product in the PMS",
+            method=method_bank,
+        )
+    }
+
+
+@receiver(add_filters, sender=ClassificationFilter)
+def add_portfolio_filter(sender, request=None, *args, **kwargs):
+    def _filter_portfolio(queryset, name, value):
+        if value:
+            try:
+                last_position_date = value.assets.latest("date").date
+            except AssetPosition.DoesNotExist:
+                last_position_date = (
+                    AssetPosition.objects.latest("date").date if AssetPosition.objects.exists() else date.today()
+                )
+            invested_instruments = AssetPosition.get_invested_instruments(last_position_date, portfolio=value)
+            rels = InstrumentClassificationThroughModel.objects.filter(
+                instrument__in=invested_instruments.values("root")
+            )
+            return queryset.filter(id__in=rels.values("classification"))
+        return queryset
+
+    def _filter_invested(queryset, name, value):
+        if value:
+            last_position_date = (
+                AssetPosition.objects.latest("date").date if AssetPosition.objects.exists() else date.today()
+            )
+            invested_instruments = AssetPosition.get_invested_instruments(last_position_date)
+            rels = InstrumentClassificationThroughModel.objects.filter(
+                instrument__in=invested_instruments.values("root")
+            )
+            return queryset.filter(id__in=rels.values("classification"))
+        return queryset
+
+    return {
+        "portfolio": wb_filters.ModelChoiceFilter(
+            label="Associated Portfolio",
+            queryset=Portfolio.objects.all(),
+            endpoint=Portfolio.get_representation_endpoint(),
+            value_key=Portfolio.get_representation_value_key(),
+            label_key=Portfolio.get_representation_label_key(),
+            method=_filter_portfolio,
+        ),
+        "only_invested": wb_filters.BooleanFilter(
+            label="Only invested instruments (anytime)",
+            method=_filter_invested,
+        ),
+    }
+
+
+@receiver(add_filters, sender=BaseClassifiedInstrumentFilterSet)
+def add_classification_instrument_filter(sender, request=None, *args, **kwargs):
+    def _filter_invested(queryset, name, value):
+        if value:
+            last_invested_date = (
+                AssetPosition.objects.latest("date").date if AssetPosition.objects.exists() else date.today()
+            )
+            invested_instruments = AssetPosition.get_invested_instruments(last_invested_date)
+            return queryset.filter(Exists(invested_instruments.filter(root=OuterRef("instrument"))))
+        return queryset
+
+    return {
+        "only_invested": wb_filters.BooleanFilter(
+            method=_filter_invested, label="Invested Instruments (last date)", default=False
+        )
+    }

wbportfolio/filters/transactions/__init__.py

@@ -0,0 +1,20 @@
+from .claim import (
+    ClaimFilter,
+    ClaimGroupByFilter,
+    ConsolidatedTradeSummaryTableFilterSet,
+    CumulativeNNMChartFilter,
+    CustomerAPIFilter,
+    CustomerClaimFilter,
+    CustomerClaimGroupByFilter,
+    NegativeTermimalAccountPerProductFilterSet,
+    ProfitAndLossPandasFilter,
+)
+from .fees import FeesAggregatedFilter, FeesFilter, FeesPortfolioFilterSet
+from .trades import (
+    SubscriptionRedemptionFilterSet,
+    SubscriptionRedemptionPortfolioFilterSet,
+    TradeFilter,
+    TradeInstrumentFilterSet,
+    TradePortfolioFilter,
+)
+from .transactions import TransactionFilterSet, TransactionPortfolioFilterSet