wbportfolio 2.2.1__py2.py3-none-any.whl

wbportfolio/viewsets/transactions/fees.py

@@ -0,0 +1,190 @@
+import pandas as pd
+from django.db.models import F, Sum
+from rest_framework import filters
+from wbcore.contrib.currency.models import CurrencyFXRates
+from wbcore.contrib.io.viewsets import ExportPandasAPIViewSet
+from wbcore.filters import DjangoFilterBackend
+from wbcore.pandas import fields as pf
+from wbcore.permissions.permissions import InternalUserPermissionMixin
+from wbcore.serializers import decorator
+from wbcore.utils.strings import format_number
+from wbportfolio.filters import FeesAggregatedFilter, FeesFilter, FeesPortfolioFilterSet
+from wbportfolio.models import Fees
+from wbportfolio.serializers import FeesModelSerializer
+
+from ..configs import (
+    FeeEndpointConfig,
+    FeesAggregatedPortfolioPandasDisplayConfig,
+    FeesAggregatedPortfolioPandasEndpointConfig,
+    FeesAggregatedPortfolioTitleConfig,
+    FeesButtonConfig,
+    FeesDisplayConfig,
+    FeesPortfolioDisplayConfig,
+    FeesPortfolioEndpointConfig,
+    FeesPortfolioTitleConfig,
+    FeesTitleConfig,
+)
+from ..mixins import UserPortfolioRequestPermissionMixin
+from .transactions import TransactionModelViewSet
+
+
+class FeesModelViewSet(TransactionModelViewSet):
+    filter_backends = (
+        DjangoFilterBackend,
+        filters.OrderingFilter,
+    )
+    queryset = Fees.valid_objects.all()
+    serializer_class = FeesModelSerializer
+    filterset_class = FeesFilter
+
+    display_config_class = FeesDisplayConfig
+    title_config_class = FeesTitleConfig
+    button_config_class = FeesButtonConfig
+    endpoint_config_class = FeeEndpointConfig
+    ordering = ["-fee_date", "id"]  # ordering by id because otherwise there is duplicates in the paginated view
+
+    def get_aggregates(self, queryset, paginated_queryset):
+        return {
+            "total_value_fx_portfolio": {
+                "Σ": format_number(queryset.aggregate(s=Sum("total_value_fx_portfolio"))["s"])
+            },
+            "total_value_gross_fx_portfolio": {
+                "Σ": format_number(queryset.aggregate(s=Sum("total_value_gross_fx_portfolio"))["s"])
+            },
+        }
+
+    def get_queryset(self):
+        if self.is_manager:
+            return super().get_queryset().select_related("import_source", "linked_product")
+        return Fees.objects.none()
+
+
+class FeesPortfolioModelViewSet(FeesModelViewSet):
+    IDENTIFIER = "wbportfolio:portfolio-fees"
+
+    filterset_class = FeesPortfolioFilterSet
+
+    display_config_class = FeesPortfolioDisplayConfig
+    title_config_class = FeesPortfolioTitleConfig
+    endpoint_config_class = FeesPortfolioEndpointConfig
+
+    def get_queryset(self):
+        if self.is_portfolio_manager:
+            return super().get_queryset().filter(portfolio=self.portfolio)
+
+        return Fees.objects.none()
+
+
+class FeesAggregatedPortfolioPandasView(
+    UserPortfolioRequestPermissionMixin, InternalUserPermissionMixin, ExportPandasAPIViewSet
+):
+    IDENTIFIER = "wbportfolio:aggregetedfees"
+
+    filterset_class = FeesAggregatedFilter
+
+    queryset = Fees.valid_objects.all()
+
+    display_config_class = FeesAggregatedPortfolioPandasDisplayConfig
+    title_config_class = FeesAggregatedPortfolioTitleConfig
+    endpoint_config_class = FeesAggregatedPortfolioPandasEndpointConfig
+
+    pandas_fields = pf.PandasFields(
+        fields=(
+            pf.PKField(key="id", label="ID"),
+            pf.CharField(key="fee_date", label="Instrument"),
+            pf.FloatField(
+                key="TRANSACTION",
+                label="Transactions",
+                decorators=(decorator(decorator_type="text", position="left", value="$"),),
+            ),
+            pf.FloatField(
+                key="PERFORMANCE_CRYSTALIZED",
+                label="Performance",
+                decorators=(decorator(decorator_type="text", position="left", value="$"),),
+            ),
+            pf.FloatField(
+                key="PERFORMANCE",
+                label="Performance Crystalized",
+                decorators=(decorator(decorator_type="text", position="left", value="$"),),
+            ),
+            pf.FloatField(
+                key="MANAGEMENT",
+                label="Management",
+                decorators=(decorator(decorator_type="text", position="left", value="$"),),
+            ),
+            pf.FloatField(
+                key="ISSUER",
+                label="Issuer",
+                decorators=(decorator(decorator_type="text", position="left", value="$"),),
+            ),
+            pf.FloatField(
+                key="OTHER", label="Other", decorators=(decorator(decorator_type="text", position="left", value="$"),)
+            ),
+            pf.FloatField(
+                key="total", label="Total", decorators=(decorator(decorator_type="text", position="left", value="$"),)
+            ),
+        )
+    )
+    ordering = ["-fee_date"]
+    ordering_fields = [
+        "fee_date",
+        "TRANSACTION",
+        "PERFORMANCE_CRYSTALIZED",
+        "PERFORMANCE",
+        "MANAGEMENT",
+        "ISSUER",
+        "OTHER",
+        "total",
+    ]
+
+    def get_aggregates(self, request, df):
+        if df.empty:
+            return {}
+        return {
+            "TRANSACTION": {"Σ": format_number(df["TRANSACTION"].sum())},
+            "PERFORMANCE_CRYSTALIZED": {"Σ": format_number(df["PERFORMANCE_CRYSTALIZED"].sum())},
+            "PERFORMANCE": {"Σ": format_number(df["PERFORMANCE"].sum())},
+            "MANAGEMENT": {"Σ": format_number(df["MANAGEMENT"].sum())},
+            "ISSUER": {"Σ": format_number(df["ISSUER"].sum())},
+            "OTHER": {"Σ": format_number(df["OTHER"].sum())},
+            "total": {"Σ": format_number(df["total"].sum())},
+        }
+
+    def get_queryset(self):
+        if self.is_portfolio_manager:
+            qs = super().get_queryset().filter(portfolio=self.portfolio)
+            return qs.annotate(
+                currency_fx_rate_usd=CurrencyFXRates.get_fx_rates_subquery(
+                    "fee_date", currency="currency", lookup_expr="exact"
+                ),
+                total_value_fx_usd=F("total_value") * F("currency_fx_rate_usd"),
+            )
+        return Fees.objects.none()
+
+    def get_dataframe(self, request, queryset, **kwargs):
+        df = pd.DataFrame(queryset.values("fee_date", "transaction_subtype", "total_value_fx_usd"))
+        if not df.empty:
+            df = (
+                df.pivot_table(
+                    index="fee_date",
+                    columns=["transaction_subtype"],
+                    values="total_value_fx_usd",
+                    aggfunc="sum",
+                )
+                .rename_axis(None, axis=1)
+                .reset_index()
+            )
+            for type in Fees.Type.values:
+                if type not in df:
+                    df[type] = 0
+            df["total"] = (
+                df["TRANSACTION"]
+                + df["PERFORMANCE_CRYSTALIZED"]
+                + df["PERFORMANCE"]
+                + df["MANAGEMENT"]
+                + df["ISSUER"]
+                + df["OTHER"]
+            )
+            df["id"] = df["fee_date"]
+            df = df.fillna(0)
+        return df

wbportfolio/viewsets/transactions/mixins.py

@@ -0,0 +1,19 @@
+from datetime import date, datetime
+
+from django.http import HttpRequest
+from django.utils.functional import cached_property
+from wbportfolio.models.transactions.claim import Claim
+
+
+class ClaimPermissionMixin:
+    queryset = Claim.objects.all()
+    request: HttpRequest
+
+    @cached_property
+    def validity_date(self) -> date:
+        if validity_date_repr := self.request.GET.get("validity_date"):
+            return datetime.strptime(validity_date_repr, "%Y-%m-%d")
+        return date.today()
+
+    def get_queryset(self):
+        return super().get_queryset().filter_for_user(self.request.user, validity_date=self.validity_date)

wbportfolio/viewsets/transactions/trade_proposals.py

@@ -0,0 +1,93 @@
+from django.shortcuts import get_object_or_404
+from rest_framework.decorators import action
+from rest_framework.response import Response
+from wbcompliance.viewsets.risk_management.mixins import RiskCheckViewSetMixin
+from wbcore import viewsets
+from wbcore.metadata.configs.display.instance_display import (
+    Display,
+    create_simple_display,
+)
+from wbcore.permissions.permissions import InternalUserPermissionMixin
+from wbcore.utils.views import CloneMixin
+from wbportfolio.models import TradeProposal
+from wbportfolio.models.transactions.trade_proposals import (
+    apply_trades_proposal_as_task,
+)
+from wbportfolio.serializers import (
+    TradeProposalModelSerializer,
+    TradeProposalRepresentationSerializer,
+)
+
+from ..configs import (
+    TradeProposalButtonConfig,
+    TradeProposalDisplayConfig,
+    TradeProposalEndpointConfig,
+    TradeProposalPortfolioEndpointConfig,
+)
+
+
+class TradeProposalRepresentationViewSet(InternalUserPermissionMixin, viewsets.RepresentationViewSet):
+    IDENTIFIER = "wbportfolio:trade"
+    queryset = TradeProposal.objects.all()
+    serializer_class = TradeProposalRepresentationSerializer
+
+
+class TradeProposalModelViewSet(CloneMixin, RiskCheckViewSetMixin, InternalUserPermissionMixin, viewsets.ModelViewSet):
+    ordering_fields = ("trade_date",)
+    ordering = ("-trade_date",)
+    search_fields = ("comment",)
+    filterset_fields = {"trade_date": ["exact", "gte", "lte"], "status": ["exact"]}
+
+    queryset = TradeProposal.objects.select_related("model_portfolio", "portfolio")
+    serializer_class = TradeProposalModelSerializer
+    display_config_class = TradeProposalDisplayConfig
+    button_config_class = TradeProposalButtonConfig
+    endpoint_config_class = TradeProposalEndpointConfig
+
+    @classmethod
+    def get_clone_instance_display(cls) -> Display:
+        return create_simple_display(
+            [
+                ["comment"],
+                ["trade_date"],
+            ]
+        )
+
+    @classmethod
+    def _get_risk_checks_button_title(cls) -> str:
+        return "Pre-Trade Checks"
+
+    @action(detail=True, methods=["PATCH"])
+    def reset(self, request, pk=None):
+        trade_proposal = get_object_or_404(TradeProposal, pk=pk)
+        if trade_proposal.status == TradeProposal.Status.DRAFT:
+            trade_proposal.reset_trades()
+            return Response({"send": True})
+
+    @action(detail=True, methods=["PATCH"])
+    def normalize(self, request, pk=None):
+        trade_proposal = get_object_or_404(TradeProposal, pk=pk)
+        if trade_proposal.status == TradeProposal.Status.DRAFT:
+            trade_proposal.normalize_trades()
+            return Response({"send": True})
+
+    @action(detail=True, methods=["PATCH"])
+    def replay(self, request, pk=None):
+        trade_proposal = get_object_or_404(TradeProposal, pk=pk)
+        if trade_proposal.portfolio.is_manageable:
+            apply_trades_proposal_as_task.delay(trade_proposal.id)
+            return Response({"send": True})
+
+    @action(detail=True, methods=["PATCH"])
+    def deleteall(self, request, pk=None):
+        trade_proposal = get_object_or_404(TradeProposal, pk=pk)
+        if trade_proposal.status == TradeProposal.Status.DRAFT:
+            trade_proposal.trades.all().delete()
+            return Response({"send": True})
+
+
+class TradeProposalPortfolioModelViewSet(TradeProposalModelViewSet):
+    endpoint_config_class = TradeProposalPortfolioEndpointConfig
+
+    def get_queryset(self):
+        return TradeProposal.objects.filter(portfolio=self.kwargs["portfolio_id"])

wbportfolio/viewsets/transactions/trades.py

@@ -0,0 +1,395 @@
+from decimal import Decimal
+
+import pandas as pd
+import plotly.graph_objects as go
+from django.contrib.messages import warning
+from django.db.models import BooleanField, Case, F, OuterRef, Subquery, Sum, Value, When
+from django.db.models.functions import Coalesce
+from django.shortcuts import get_object_or_404
+from django.utils.functional import cached_property
+from django_filters.rest_framework import DjangoFilterBackend
+from wbcore import viewsets
+from wbcore.permissions.permissions import InternalUserPermissionMixin
+from wbcore.utils.strings import format_number
+from wbcrm.models import Account
+from wbcore.viewsets.mixins import OrderableMixin
+from wbportfolio.filters import (
+    SubscriptionRedemptionFilterSet,
+    SubscriptionRedemptionPortfolioFilterSet,
+    TradeFilter,
+    TradeInstrumentFilterSet,
+    TradePortfolioFilter,
+)
+from wbportfolio.import_export.resources.trades import TradeProposalTradeResource
+from wbportfolio.models import Trade, TradeProposal
+from wbportfolio.models.transactions.claim import Claim
+from wbportfolio.serializers import (
+    ReadOnlyTradeTradeProposalModelSerializer,
+    TradeModelSerializer,
+    TradeProposalRepresentationSerializer,
+    TradeRepresentationSerializer,
+    TradeTradeProposalModelSerializer,
+)
+from wbportfolio.viewsets.configs.titles.trades import (
+    CustomerDistributionInstrumentTitleConfig,
+)
+
+from ..configs import (
+    CustodianDistributionInstrumentEndpointConfig,
+    CustodianDistributionInstrumentTitleConfig,
+    SubscriptionRedemptionDisplayConfig,
+    SubscriptionRedemptionEndpointConfig,
+    SubscriptionRedemptionTitleConfig,
+    TradeButtonConfig,
+    TradeDisplayConfig,
+    TradeEndpointConfig,
+    TradeInstrumentButtonConfig,
+    TradeInstrumentEndpointConfig,
+    TradeInstrumentTitleConfig,
+    TradePortfolioDisplayConfig,
+    TradePortfolioEndpointConfig,
+    TradePortfolioTitleConfig,
+    TradeTitleConfig,
+    TradeTradeProposalButtonConfig,
+    TradeTradeProposalDisplayConfig,
+    TradeTradeProposalEndpointConfig,
+)
+from ..mixins import UserPortfolioRequestPermissionMixin
+from .transactions import TransactionModelViewSet
+
+
+class TradeProposalRepresentationViewSet(InternalUserPermissionMixin, viewsets.RepresentationViewSet):
+    IDENTIFIER = "wbportfolio:trade"
+    queryset = TradeProposal.objects.all()
+    serializer_class = TradeProposalRepresentationSerializer
+
+
+class TradeRepresentationViewSet(InternalUserPermissionMixin, viewsets.RepresentationViewSet):
+    filterset_class = TradeFilter
+
+    ordering_fields = ("transaction_date", "shares")
+    ordering = ["-transaction_date"]
+    search_fields = (
+        "underlying_instrument__name",
+        "bank",
+        "shares",
+        "comment",
+        "external_id",
+        "register__register_name_1",
+        "register__register_name_2",
+        "register__custodian_name_1",
+        "register__custodian_name_2",
+    )
+
+    queryset = Trade.objects.select_related("underlying_instrument")
+    serializer_class = TradeRepresentationSerializer
+
+    def get_queryset(self):
+        return (
+            Trade.objects.filter(marked_for_deletion=False, pending=False)
+            .select_related("portfolio")
+            .select_related("underlying_instrument")
+            .prefetch_related("claims")
+        )
+
+
+class TradeModelViewSet(TransactionModelViewSet):
+    IDENTIFIER = "wbportfolio:trade"
+
+    ordering_fields = (
+        "id",
+        "transaction_subtype",
+        "transaction_date",
+        "underlying_instrument__name",
+        "shares",
+        "approved_claimed_shares",
+        "pending_claimed_shares",
+        "price",
+        "total_value",
+        "total_value_fx_portfolio",
+        "total_value_usd",
+        "currency_fx_rate",
+        "currency__key",
+        "bank",
+        "register__computed_str",
+        "comment",
+    )
+    search_fields = (
+        "portfolio__name",
+        "underlying_instrument__name",
+        "bank",
+        "comment",
+        "external_id",
+        "register__computed_str",
+        "register__register_name_1",
+        "register__register_name_2",
+        "register__custodian_name_1",
+        "register__custodian_name_2",
+    )
+
+    filterset_class = TradeFilter
+    queryset = Trade.objects.all()
+    serializer_class = TradeModelSerializer
+
+    display_config_class = TradeDisplayConfig
+    endpoint_config_class = TradeEndpointConfig
+    title_config_class = TradeTitleConfig
+    button_config_class = TradeButtonConfig
+
+    def get_aggregates(self, queryset, paginated_queryset):
+        return {
+            "shares": {
+                "Σ": format_number(queryset.aggregate(s=Sum("shares"))["s"] or Decimal(0)),
+            },
+            **super().get_aggregates(queryset, paginated_queryset),
+        }
+
+    def get_queryset(self):
+        qs = super().get_queryset()
+        if not self.is_portfolio_manager:
+            qs = qs.filter(transaction_subtype__in=[Trade.Type.REDEMPTION, Trade.Type.SUBSCRIPTION])
+        qs = (
+            qs.annotate(
+                approved_claimed_shares=Coalesce(
+                    Subquery(
+                        Claim.objects.filter(status=Claim.Status.APPROVED, trade=OuterRef("pk"))
+                        .values("trade")
+                        .annotate(sum_shares=Sum("shares"))
+                        .values("sum_shares")[:1]
+                    ),
+                    Decimal(0.0),
+                ),
+                pending_claimed_shares=Coalesce(
+                    Subquery(
+                        Claim.objects.filter(
+                            status__in=[Claim.Status.PENDING, Claim.Status.DRAFT], trade=OuterRef("pk")
+                        )
+                        .values("trade")
+                        .annotate(sum_shares=Sum("shares"))
+                        .values("sum_shares")[:1]
+                    ),
+                    Decimal(0.0),
+                ),
+                completely_claimed=Case(
+                    When(shares=F("approved_claimed_shares"), then=Value(True)),
+                    default=Value(False),
+                    output_field=BooleanField(),
+                ),
+                completely_claimed_if_approved=Case(
+                    When(completely_claimed=True, then=Value(False)),
+                    When(shares=F("approved_claimed_shares") + F("pending_claimed_shares"), then=Value(True)),
+                    default=Value(False),
+                    output_field=BooleanField(),
+                ),
+            )
+            .select_related("underlying_instrument")
+            .select_related("register")
+            .select_related("portfolio")
+            .select_related("currency")
+            .select_related("custodian")
+            .select_related("import_source")
+            .prefetch_related("claims")
+            .prefetch_related("claims__account")
+            .prefetch_related("claims__claimant")
+            .prefetch_related("claims__product")
+        )
+        return qs
+
+
+class SubscriptionRedemptionModelViewSet(TradeModelViewSet):
+    IDENTIFIER = "wbportoflio:subscriptionredemption"
+    filterset_class = SubscriptionRedemptionFilterSet
+    display_config_class = SubscriptionRedemptionDisplayConfig
+    title_config_class = SubscriptionRedemptionTitleConfig
+    endpoint_config_class = SubscriptionRedemptionEndpointConfig
+
+    def get_queryset(self):
+        return super().get_queryset().filter(transaction_subtype__in=[Trade.Type.REDEMPTION, Trade.Type.SUBSCRIPTION])
+
+
+class TradePortfolioModelViewSet(TradeModelViewSet):
+    IDENTIFIER = "wbportfolio:trade"
+    filterset_class = TradePortfolioFilter
+    title_config_class = TradePortfolioTitleConfig
+    endpoint_config_class = TradePortfolioEndpointConfig
+    display_config_class = TradePortfolioDisplayConfig
+
+    def get_aggregates(self, queryset, paginated_queryset):
+        if queryset.exists():
+            return {
+                "total_value_fx_portfolio": {
+                    "Σ": format_number(queryset.aggregate(s=Sum(F("total_value_fx_portfolio")))["s"])
+                },
+                **super().get_aggregates(queryset, paginated_queryset),
+            }
+        return dict()
+
+    def get_queryset(self):
+        return super().get_queryset().filter(portfolio=self.portfolio)
+
+
+class TradeInstrumentModelViewSet(TradeModelViewSet):
+    IDENTIFIER = "wbportfolio:trade"
+
+    filterset_class = TradeInstrumentFilterSet
+
+    title_config_class = TradeInstrumentTitleConfig
+    endpoint_config_class = TradeInstrumentEndpointConfig
+    button_config_class = TradeInstrumentButtonConfig
+
+    def get_aggregates(self, queryset, paginated_queryset):
+        if queryset.exists():
+            return {
+                "total_value": {"Σ": format_number(queryset.aggregate(s=Sum(F("total_value")))["s"])},
+                **super().get_aggregates(queryset, paginated_queryset),
+            }
+        return dict()
+
+    def get_queryset(self):
+        return (
+            super().get_queryset().filter(underlying_instrument__in=self.instrument.get_descendants(include_self=True))
+        )
+
+
+class SubscriptionRedemptionInstrumentModelViewSet(SubscriptionRedemptionModelViewSet):
+    filterset_class = SubscriptionRedemptionPortfolioFilterSet
+
+    def get_queryset(self):
+        return (
+            super()
+            .get_queryset()
+            .filter(
+                underlying_instrument__in=self.instrument.get_descendants(include_self=True),
+                transaction_subtype__in=[Trade.Type.REDEMPTION, Trade.Type.SUBSCRIPTION],
+            )
+        )
+
+
+class CustodianDistributionInstrumentChartViewSet(UserPortfolioRequestPermissionMixin, viewsets.ChartViewSet):
+    IDENTIFIER = "wbportfolio:custodiandistribution"
+    filterset_fields = {
+        "transaction_date": ["lte"],
+    }
+    filter_backends = (DjangoFilterBackend,)
+    queryset = Trade.objects.all()
+
+    title_config_class = CustodianDistributionInstrumentTitleConfig
+    endpoint_config_class = CustodianDistributionInstrumentEndpointConfig
+
+    def get_plotly(self, queryset):
+        fig = go.Figure()
+        if queryset.exists():
+            df = pd.DataFrame(queryset.values("custodian__name", "custodian__id", "shares"))
+            df = df.groupby("custodian__id").agg({"custodian__name": "first", "shares": "sum"})
+            fig = go.Figure(data=[go.Pie(labels=df.custodian__name, values=df.shares)])
+        return fig
+
+    def get_queryset(self):
+        return Trade.objects.filter(underlying_instrument=self.instrument)
+
+
+class CustomerDistributionInstrumentChartViewSet(UserPortfolioRequestPermissionMixin, viewsets.ChartViewSet):
+    IDENTIFIER = "wbportfolio:custodiandistribution"
+    filterset_fields = {
+        "transaction_date": ["lte"],
+    }
+    filter_backends = (DjangoFilterBackend,)
+    queryset = Trade.objects.all()
+
+    title_config_class = CustomerDistributionInstrumentTitleConfig
+    endpoint_config_class = CustodianDistributionInstrumentEndpointConfig
+
+    # TODO: Consider moving into a helper class?
+    def group_smaller_items(self, df, threshold=0.01, text="Others"):
+        df["weight"] = df.sum_shares / df.sum_shares.sum()
+        group_sum = df.loc[df["weight"] < threshold].sum().to_frame().T
+        group_sum["account_name"] = text
+        rest = df.loc[df["weight"] >= threshold]
+        return pd.concat([group_sum, rest])
+
+    def get_plotly(self, queryset):
+        fig = go.Figure()
+        if queryset.exists():
+            df = self.group_smaller_items(
+                pd.DataFrame(queryset.values("account_name", "sum_shares")),
+            )
+
+            fig = go.Figure(data=[go.Pie(labels=df.account_name, values=df.sum_shares)])
+        return fig
+
+    def get_queryset(self):
+        return (
+            Trade.objects.filter(
+                underlying_instrument=self.instrument, transaction_subtype__in=["SUBSCRIPTION", "REDEMPTION"]
+            )
+            .values("claims")
+            .annotate(
+                shares=F("claims__shares"),
+                account_tree_id=F("claims__account__tree_id"),
+                status=F("claims__status"),
+            )
+            .filter(status="APPROVED")
+            .values("account_tree_id")
+            .annotate(
+                account_name=Subquery(
+                    Account.objects.filter(tree_id=OuterRef("account_tree_id"), level=0).values("title")[:1]
+                ),
+                sum_shares=Sum("shares"),
+            )
+            .filter(account_name__isnull=False)
+        )
+
+
+class TradeTradeProposalModelViewSet(
+    UserPortfolioRequestPermissionMixin, InternalUserPermissionMixin, OrderableMixin, viewsets.ModelViewSet
+):
+    ordering = (
+        "trade_proposal",
+        "order",
+    )
+    IDENTIFIER = "wbportfolio:tradeproposal"
+    search_fields = ("underlying_instrument__name",)
+    filterset_fields = {}
+    queryset = Trade.objects.all()
+
+    display_config_class = TradeTradeProposalDisplayConfig
+    endpoint_config_class = TradeTradeProposalEndpointConfig
+    serializer_class = TradeTradeProposalModelSerializer
+    button_config_class = TradeTradeProposalButtonConfig
+
+    @cached_property
+    def trade_proposal_status(self):
+        return get_object_or_404(TradeProposal, pk=self.kwargs["trade_proposal_id"]).status
+
+    def get_resource_class(self):
+        return TradeProposalTradeResource
+
+    def get_aggregates(self, queryset, paginated_queryset):
+        if queryset.exists():
+            aggregates = queryset.aggregate(
+                sum_target_weight=Sum(F("target_weight")),
+                sum_effective_weight=Sum(F("effective_weight")),
+                sum_weighting=Sum(F("weighting")),
+            )
+            return {
+                "target_weight": {"Σ": format_number(aggregates["sum_target_weight"], decimal=5)},
+                "effective_weight": {"Σ": format_number(aggregates["sum_effective_weight"], decimal=5)},
+                "weighting": {"Σ": format_number(aggregates["sum_weighting"], decimal=5)},
+            }
+        return {}
+
+    def get_serializer_class(self):
+        if self.trade_proposal_status != TradeProposal.Status.DRAFT:
+            return ReadOnlyTradeTradeProposalModelSerializer
+        return TradeTradeProposalModelSerializer
+
+    def add_messages(self, request, queryset=None, paginated_queryset=None, instance=None, initial=False):
+        if queryset:
+            total_target_weight = float(queryset.aggregate(c=Sum(F("target_weight")))["c"]) or 0
+            if round(total_target_weight, 3) != 1:
+                warning(request, "The total target weight does not equals to 1")
+
+    def get_queryset(self):
+        if self.is_portfolio_manager:
+            return super().get_queryset().filter(trade_proposal=self.kwargs["trade_proposal_id"])
+        return TradeProposal.objects.none()