wbportfolio 1.54.14__py2.py3-none-any.whl → 1.54.15__py2.py3-none-any.whl

wbportfolio/viewsets/orders/configs/displays/orders.py

@@ -0,0 +1,180 @@
+from typing import Optional
+
+from django.shortcuts import get_object_or_404
+from django.utils.translation import gettext_lazy as _
+from wbcore.contrib.color.enums import WBColor
+from wbcore.enums import Unit
+from wbcore.metadata.configs import display as dp
+from wbcore.metadata.configs.display.instance_display.shortcuts import (
+    Display,
+    create_simple_display,
+)
+from wbcore.metadata.configs.display.instance_display.utils import repeat_field
+from wbcore.metadata.configs.display.view_config import DisplayViewConfig
+
+from wbportfolio.models import Order, OrderProposal
+
+ORDER_STATUS_LEGENDS = dp.Legend(
+    key="has_warnings",
+    items=[
+        dp.LegendItem(icon=WBColor.YELLOW_DARK.value, label=_("Warning"), value=True),
+    ],
+)
+
+ORDER_STATUS_FORMATTING = dp.Formatting(
+    column="has_warnings",
+    formatting_rules=[
+        dp.FormattingRule(
+            style={"backgroundColor": WBColor.YELLOW_DARK.value},
+            condition=("==", True),
+        )
+    ],
+)
+ORDER_TYPE_FORMATTING_RULES = [
+    dp.FormattingRule(
+        style={"color": WBColor.RED_DARK.value, "fontWeight": "bold"},
+        condition=("==", Order.Type.SELL.name),
+    ),
+    dp.FormattingRule(
+        style={"color": WBColor.RED.value, "fontWeight": "bold"},
+        condition=("==", Order.Type.DECREASE.name),
+    ),
+    dp.FormattingRule(
+        style={"color": WBColor.GREEN.value, "fontWeight": "bold"},
+        condition=("==", Order.Type.INCREASE.name),
+    ),
+    dp.FormattingRule(
+        style={"color": WBColor.GREEN_DARK.value, "fontWeight": "bold"},
+        condition=("==", Order.Type.BUY.name),
+    ),
+    dp.FormattingRule(
+        style={"color": WBColor.GREY.value, "fontWeight": "bold"},
+        condition=("==", Order.Type.NO_CHANGE.name),
+    ),
+]
+
+VALUE_FORMATTING_RULES = [
+    dp.FormattingRule(
+        style={"color": WBColor.RED_DARK.value, "fontWeight": "bold"},
+        condition=("<", 0),
+    ),
+    dp.FormattingRule(
+        style={"color": WBColor.GREEN_DARK.value, "fontWeight": "bold"},
+        condition=(">", 0),
+    ),
+]
+
+
+class OrderOrderProposalDisplayConfig(DisplayViewConfig):
+    def get_list_display(self) -> Optional[dp.ListDisplay]:
+        order_proposal = get_object_or_404(OrderProposal, pk=self.view.kwargs.get("order_proposal_id", None))
+        fields = [
+            dp.Field(
+                label="Instrument",
+                open_by_default=True,
+                key=None,
+                children=[
+                    dp.Field(key="underlying_instrument", label="Name", width=Unit.PIXEL(250)),
+                    dp.Field(key="underlying_instrument_isin", label="ISIN", width=Unit.PIXEL(125)),
+                    dp.Field(key="underlying_instrument_ticker", label="Ticker", width=Unit.PIXEL(100)),
+                    dp.Field(
+                        key="underlying_instrument_refinitiv_identifier_code", label="RIC", width=Unit.PIXEL(100)
+                    ),
+                    dp.Field(key="underlying_instrument_instrument_type", label="Asset Class", width=Unit.PIXEL(125)),
+                ],
+            ),
+            dp.Field(
+                label="Weight",
+                open_by_default=False,
+                key=None,
+                children=[
+                    dp.Field(key="effective_weight", label="Effective Weight", show="open", width=Unit.PIXEL(150)),
+                    dp.Field(key="target_weight", label="Target Weight", show="open", width=Unit.PIXEL(150)),
+                    dp.Field(
+                        key="weighting",
+                        label="Delta Weight",
+                        formatting_rules=VALUE_FORMATTING_RULES,
+                        width=Unit.PIXEL(150),
+                    ),
+                ],
+            ),
+        ]
+        if not order_proposal.portfolio.only_weighting:
+            fields.append(
+                dp.Field(
+                    label="Shares",
+                    open_by_default=False,
+                    key=None,
+                    children=[
+                        dp.Field(key="effective_shares", label="Effective Shares", show="open", width=Unit.PIXEL(150)),
+                        dp.Field(key="target_shares", label="Target Shares", show="open", width=Unit.PIXEL(150)),
+                        dp.Field(
+                            key="shares",
+                            label="Shares",
+                            formatting_rules=VALUE_FORMATTING_RULES,
+                            width=Unit.PIXEL(150),
+                        ),
+                    ],
+                )
+            )
+            fields.append(
+                dp.Field(
+                    label="Total Value",
+                    open_by_default=False,
+                    key=None,
+                    children=[
+                        dp.Field(
+                            key="effective_total_value_fx_portfolio",
+                            label="Effective Total Value",
+                            show="open",
+                            width=Unit.PIXEL(150),
+                        ),
+                        dp.Field(
+                            key="target_total_value_fx_portfolio",
+                            label="Target Total Value",
+                            show="open",
+                            width=Unit.PIXEL(150),
+                        ),
+                        dp.Field(
+                            key="total_value_fx_portfolio",
+                            label="Total Value",
+                            formatting_rules=VALUE_FORMATTING_RULES,
+                            width=Unit.PIXEL(150),
+                        ),
+                    ],
+                )
+            )
+        fields.append(
+            dp.Field(
+                label="Information",
+                open_by_default=False,
+                key=None,
+                children=[
+                    dp.Field(
+                        key="order_type",
+                        label="Direction",
+                        formatting_rules=ORDER_TYPE_FORMATTING_RULES,
+                        width=Unit.PIXEL(125),
+                    ),
+                    dp.Field(key="comment", label="Comment", width=Unit.PIXEL(250)),
+                    dp.Field(key="order", label="Order", show="open", width=Unit.PIXEL(100)),
+                ],
+            )
+        )
+        return dp.ListDisplay(
+            fields=fields,
+            legends=[ORDER_STATUS_LEGENDS],
+            formatting=[ORDER_STATUS_FORMATTING],
+        )
+
+    def get_instance_display(self) -> Display:
+        order_proposal = get_object_or_404(OrderProposal, pk=self.view.kwargs.get("order_proposal_id", None))
+
+        fields = [
+            ["company", "security", "underlying_instrument"],
+            ["effective_weight", "target_weight", "weighting"],
+        ]
+        if not order_proposal.portfolio.only_weighting:
+            fields.append(["effective_shares", "target_shares", "shares"])
+        fields.append([repeat_field(3, "comment")])
+        return create_simple_display(fields)

wbportfolio/viewsets/orders/configs/endpoints/__init__.py

@@ -0,0 +1,2 @@
+from .order_proposals import OrderProposalEndpointConfig, OrderProposalPortfolioEndpointConfig
+from .orders import OrderOrderProposalEndpointConfig

wbportfolio/viewsets/orders/configs/endpoints/order_proposals.py

@@ -0,0 +1,21 @@
+from django.shortcuts import get_object_or_404
+from rest_framework.reverse import reverse
+from wbcore.metadata.configs.endpoints import EndpointViewConfig
+
+from wbportfolio.models import OrderProposal
+
+
+class OrderProposalEndpointConfig(EndpointViewConfig):
+    def get_delete_endpoint(self, **kwargs):
+        if pk := self.view.kwargs.get("pk", None):
+            order_proposal = get_object_or_404(OrderProposal, pk=pk)
+            if order_proposal.status == OrderProposal.Status.DRAFT:
+                return super().get_endpoint()
+        return None
+
+
+class OrderProposalPortfolioEndpointConfig(OrderProposalEndpointConfig):
+    def get_endpoint(self, **kwargs):
+        return reverse(
+            "wbportfolio:portfolio-orderproposal-list", args=[self.view.kwargs["portfolio_id"]], request=self.request
+        )

wbportfolio/viewsets/orders/configs/endpoints/orders.py

@@ -0,0 +1,26 @@
+from contextlib import suppress
+
+from rest_framework.reverse import reverse
+from wbcore.metadata.configs.endpoints import EndpointViewConfig
+
+from wbportfolio.models import OrderProposal
+
+
+class OrderOrderProposalEndpointConfig(EndpointViewConfig):
+    def get_endpoint(self, **kwargs):
+        if order_proposal_id := self.view.kwargs.get("order_proposal_id", None):
+            order_proposal = OrderProposal.objects.get(id=order_proposal_id)
+            if order_proposal.status == OrderProposal.Status.DRAFT:
+                return reverse(
+                    "wbportfolio:orderproposal-order-list",
+                    args=[self.view.kwargs["order_proposal_id"]],
+                    request=self.request,
+                )
+        return None
+
+    def get_delete_endpoint(self, **kwargs):
+        with suppress(AttributeError, AssertionError):
+            order = self.view.get_object()
+            if order._effective_weight:  # we make sure order with a valid effective position cannot be deleted
+                return None
+        return super().get_delete_endpoint(**kwargs)

wbportfolio/viewsets/{transactions/trade_proposals.py → orders/order_proposals.py}

@@ -19,49 +19,49 @@ from wbcore.metadata.configs.display.instance_display import (
 from wbcore.permissions.permissions import InternalUserPermissionMixin
 from wbcore.utils.views import CloneMixin
 
-from wbportfolio.models import AssetPosition, TradeProposal
-from wbportfolio.models.transactions.trade_proposals import (
+from wbportfolio.models import AssetPosition, OrderProposal
+from wbportfolio.models.orders.order_proposals import (
     replay_as_task,
 )
 from wbportfolio.serializers import (
-    ReadOnlyTradeProposalModelSerializer,
-    TradeProposalModelSerializer,
-    TradeProposalRepresentationSerializer,
+    OrderProposalModelSerializer,
+    OrderProposalRepresentationSerializer,
+    ReadOnlyOrderProposalModelSerializer,
 )
 
-from ..configs import (
-    TradeProposalButtonConfig,
-    TradeProposalDisplayConfig,
-    TradeProposalEndpointConfig,
-    TradeProposalPortfolioEndpointConfig,
-)
 from ..mixins import UserPortfolioRequestPermissionMixin
+from .configs import (
+    OrderProposalButtonConfig,
+    OrderProposalDisplayConfig,
+    OrderProposalEndpointConfig,
+    OrderProposalPortfolioEndpointConfig,
+)
 
 
-class TradeProposalRepresentationViewSet(InternalUserPermissionMixin, viewsets.RepresentationViewSet):
+class OrderProposalRepresentationViewSet(InternalUserPermissionMixin, viewsets.RepresentationViewSet):
     IDENTIFIER = "wbportfolio:trade"
-    queryset = TradeProposal.objects.all()
-    serializer_class = TradeProposalRepresentationSerializer
+    queryset = OrderProposal.objects.all()
+    serializer_class = OrderProposalRepresentationSerializer
 
 
-class TradeProposalModelViewSet(CloneMixin, RiskCheckViewSetMixin, InternalUserPermissionMixin, viewsets.ModelViewSet):
+class OrderProposalModelViewSet(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("rebalancing_model", "portfolio")
-    serializer_class = TradeProposalModelSerializer
-    display_config_class = TradeProposalDisplayConfig
-    button_config_class = TradeProposalButtonConfig
-    endpoint_config_class = TradeProposalEndpointConfig
+    queryset = OrderProposal.objects.select_related("rebalancing_model", "portfolio")
+    serializer_class = OrderProposalModelSerializer
+    display_config_class = OrderProposalDisplayConfig
+    button_config_class = OrderProposalButtonConfig
+    endpoint_config_class = OrderProposalEndpointConfig
 
     def get_serializer_class(self):
         if self.new_mode or (
-            "pk" in self.kwargs and (obj := self.get_object()) and obj.status == TradeProposal.Status.DRAFT
+            "pk" in self.kwargs and (obj := self.get_object()) and obj.status == OrderProposal.Status.DRAFT
         ):
-            return TradeProposalModelSerializer
-        return ReadOnlyTradeProposalModelSerializer
+            return OrderProposalModelSerializer
+        return ReadOnlyOrderProposalModelSerializer
 
     # 2 methods to parametrize the clone button functionality
     def get_clone_button_serializer_class(self, instance):
@@ -82,13 +82,13 @@ class TradeProposalModelViewSet(CloneMixin, RiskCheckViewSetMixin, InternalUserP
         )
 
     def add_messages(self, request, instance=None, **kwargs):
-        if instance and instance.status == TradeProposal.Status.SUBMIT:
+        if instance and instance.status == OrderProposal.Status.SUBMIT:
             if not instance.portfolio.is_manageable:
-                info(request, "This trade proposal cannot be approved the portfolio is considered unmanaged.")
+                info(request, "This order proposal cannot be approved the portfolio is considered unmanaged.")
             if instance.has_non_successful_checks:
                 warning(
                     request,
-                    "This trade proposal cannot be approved because there is unsuccessful pre-trade checks. Please rectify accordingly and resubmit a valid trade proposal",
+                    "This order proposal cannot be approved because there is unsuccessful pre-trade checks. Please rectify accordingly and resubmit a valid order proposal",
                 )
 
     @classmethod
@@ -97,41 +97,41 @@ class TradeProposalModelViewSet(CloneMixin, RiskCheckViewSetMixin, InternalUserP
 
     @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.trades.all().update(weighting=0)
-            trade_proposal.reset_trades()
+        order_proposal = get_object_or_404(OrderProposal, pk=pk)
+        if order_proposal.status == OrderProposal.Status.DRAFT:
+            order_proposal.orders.all().update(weighting=0)
+            order_proposal.reset_orders()
             return Response({"send": True})
-        return Response({"status": "Trade proposal is not Draft"}, status=status.HTTP_400_BAD_REQUEST)
+        return Response({"status": "Order Proposal is not Draft"}, status=status.HTTP_400_BAD_REQUEST)
 
     @action(detail=True, methods=["PATCH"])
     def normalize(self, request, pk=None):
-        trade_proposal = get_object_or_404(TradeProposal, pk=pk)
+        order_proposal = get_object_or_404(OrderProposal, pk=pk)
         total_cash_weight = Decimal(request.data.get("total_cash_weight", Decimal("0.0")))
-        if trade_proposal.status == TradeProposal.Status.DRAFT:
-            trade_proposal.normalize_trades(total_target_weight=Decimal("1.0") - total_cash_weight)
+        if order_proposal.status == OrderProposal.Status.DRAFT:
+            order_proposal.normalize_orders(total_target_weight=Decimal("1.0") - total_cash_weight)
             return Response({"send": True})
-        return Response({"status": "Trade proposal is not Draft"}, status=status.HTTP_400_BAD_REQUEST)
+        return Response({"status": "Order Proposal is not Draft"}, status=status.HTTP_400_BAD_REQUEST)
 
     @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:
-            replay_as_task.delay(trade_proposal.id, user_id=self.request.user.id)
+        order_proposal = get_object_or_404(OrderProposal, pk=pk)
+        if order_proposal.portfolio.is_manageable:
+            replay_as_task.delay(order_proposal.id, user_id=self.request.user.id)
             return Response({"send": True})
-        return Response({"status": "Trade proposal is not Draft"}, status=status.HTTP_400_BAD_REQUEST)
+        return Response({"status": "Order Proposal is not Draft"}, status=status.HTTP_400_BAD_REQUEST)
 
     @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()
+        order_proposal = get_object_or_404(OrderProposal, pk=pk)
+        if order_proposal.status == OrderProposal.Status.DRAFT:
+            order_proposal.orders.all().delete()
             return Response({"send": True})
-        return Response({"status": "Trade proposal is not Draft"}, status=status.HTTP_400_BAD_REQUEST)
+        return Response({"status": "Order Proposal is not Draft"}, status=status.HTTP_400_BAD_REQUEST)
 
 
-class TradeProposalPortfolioModelViewSet(UserPortfolioRequestPermissionMixin, TradeProposalModelViewSet):
-    endpoint_config_class = TradeProposalPortfolioEndpointConfig
+class OrderProposalPortfolioModelViewSet(UserPortfolioRequestPermissionMixin, OrderProposalModelViewSet):
+    endpoint_config_class = OrderProposalPortfolioEndpointConfig
 
     @cached_property
     def default_trade_date(self) -> date | None:
@@ -139,4 +139,4 @@ class TradeProposalPortfolioModelViewSet(UserPortfolioRequestPermissionMixin, Tr
             return (self.portfolio.assets.latest("date").date + BDay(1)).date()
 
     def get_queryset(self):
-        return TradeProposal.objects.filter(portfolio=self.kwargs["portfolio_id"])
+        return OrderProposal.objects.filter(portfolio=self.kwargs["portfolio_id"])

wbportfolio/viewsets/orders/orders.py

@@ -0,0 +1,219 @@
+from decimal import Decimal
+
+from django.contrib.messages import error, warning
+from django.db.models import (
+    Case,
+    F,
+    Sum,
+    Value,
+    When,
+)
+from django.shortcuts import get_object_or_404
+from django.utils.functional import cached_property
+from wbcore import viewsets
+from wbcore.permissions.permissions import InternalUserPermissionMixin
+from wbcore.utils.strings import format_number
+from wbcore.viewsets.mixins import OrderableMixin
+
+from wbportfolio.import_export.resources.trades import OrderProposalTradeResource
+from wbportfolio.models import Order, OrderProposal
+from wbportfolio.serializers import (
+    OrderOrderProposalListModelSerializer,
+    OrderOrderProposalModelSerializer,
+    ReadOnlyOrderOrderProposalModelSerializer,
+)
+
+from ...filters.orders import OrderFilterSet
+from ..mixins import UserPortfolioRequestPermissionMixin
+from .configs import (
+    OrderOrderProposalButtonConfig,
+    OrderOrderProposalDisplayConfig,
+    OrderOrderProposalEndpointConfig,
+)
+
+
+class OrderOrderProposalModelViewSet(
+    UserPortfolioRequestPermissionMixin, InternalUserPermissionMixin, OrderableMixin, viewsets.ModelViewSet
+):
+    IMPORT_ALLOWED = True
+    ordering = (
+        "order_proposal",
+        "order",
+    )
+    ordering_fields = (
+        "underlying_instrument__name",
+        "underlying_instrument_isin",
+        "underlying_instrument_ticker",
+        "underlying_instrument_refinitiv_identifier_code",
+        "underlying_instrument_instrument_type",
+        "target_weight",
+        "effective_weight",
+        "effective_shares",
+        "target_shares",
+        "shares",
+        "weighting",
+    )
+    IDENTIFIER = "wbportfolio:orderproposal"
+    search_fields = ("underlying_instrument__name",)
+    queryset = Order.objects.none()
+    filterset_class = OrderFilterSet
+
+    display_config_class = OrderOrderProposalDisplayConfig
+    endpoint_config_class = OrderOrderProposalEndpointConfig
+    serializer_class = OrderOrderProposalModelSerializer
+    button_config_class = OrderOrderProposalButtonConfig
+
+    @cached_property
+    def order_proposal(self):
+        return get_object_or_404(OrderProposal, pk=self.kwargs["order_proposal_id"])
+
+    @cached_property
+    def portfolio_total_asset_value(self):
+        return self.order_proposal.portfolio_total_asset_value
+
+    def has_import_permission(self, request) -> bool:  # allow import only on draft order proposal
+        return super().has_import_permission(request) and self.order_proposal.status == OrderProposal.Status.DRAFT
+
+    def get_import_resource_kwargs(self):
+        resource_kwargs = super().get_import_resource_kwargs()
+        resource_kwargs["columns_mapping"] = {"underlying_instrument": "underlying_instrument__isin"}
+        return resource_kwargs
+
+    def get_resource_class(self):
+        return OrderProposalTradeResource
+
+    def get_aggregates(self, queryset, *args, **kwargs):
+        agg = {}
+        if queryset.exists():
+            noncash_aggregates = queryset.filter(underlying_instrument__is_cash=False).aggregate(
+                sum_target_weight=Sum(F("target_weight")),
+                sum_effective_weight=Sum(F("effective_weight")),
+                sum_target_total_value_fx_portfolio=Sum(F("target_total_value_fx_portfolio")),
+                sum_effective_total_value_fx_portfolio=Sum(F("effective_total_value_fx_portfolio")),
+            )
+
+            # weights aggregates
+            cash_sum_effective_weight = Decimal("1.0") - noncash_aggregates["sum_effective_weight"]
+            cash_sum_target_cash_weight = Decimal("1.0") - noncash_aggregates["sum_target_weight"]
+            noncash_sum_effective_weight = noncash_aggregates["sum_effective_weight"] or Decimal(0)
+            noncash_sum_target_weight = noncash_aggregates["sum_target_weight"] or Decimal(0)
+            sum_buy_weight = queryset.filter(weighting__gte=0).aggregate(s=Sum(F("weighting")))["s"] or Decimal(0)
+            sum_sell_weight = queryset.filter(weighting__lt=0).aggregate(s=Sum(F("weighting")))["s"] or Decimal(0)
+
+            # shares aggregates
+            cash_sum_effective_total_value_fx_portfolio = cash_sum_effective_weight * self.portfolio_total_asset_value
+            cash_sum_target_total_value_fx_portfolio = cash_sum_target_cash_weight * self.portfolio_total_asset_value
+            noncash_sum_effective_total_value_fx_portfolio = noncash_aggregates[
+                "sum_effective_total_value_fx_portfolio"
+            ] or Decimal(0)
+            noncash_sum_target_total_value_fx_portfolio = noncash_aggregates[
+                "sum_target_total_value_fx_portfolio"
+            ] or Decimal(0)
+            sum_buy_total_value_fx_portfolio = queryset.filter(total_value_fx_portfolio__gte=0).aggregate(
+                s=Sum(F("total_value_fx_portfolio"))
+            )["s"] or Decimal(0)
+            sum_sell_total_value_fx_portfolio = queryset.filter(total_value_fx_portfolio__lt=0).aggregate(
+                s=Sum(F("total_value_fx_portfolio"))
+            )["s"] or Decimal(0)
+
+            agg = {
+                "effective_weight": {
+                    "Cash": format_number(cash_sum_effective_weight, decimal=Order.ORDER_WEIGHTING_PRECISION),
+                    "Non-Cash": format_number(noncash_sum_effective_weight, decimal=Order.ORDER_WEIGHTING_PRECISION),
+                    "Total": format_number(
+                        noncash_sum_effective_weight + cash_sum_effective_weight,
+                        decimal=Order.ORDER_WEIGHTING_PRECISION,
+                    ),
+                },
+                "target_weight": {
+                    "Cash": format_number(cash_sum_target_cash_weight, decimal=Order.ORDER_WEIGHTING_PRECISION),
+                    "Non-Cash": format_number(noncash_sum_target_weight, decimal=Order.ORDER_WEIGHTING_PRECISION),
+                    "Total": format_number(
+                        cash_sum_target_cash_weight + noncash_sum_target_weight,
+                        decimal=Order.ORDER_WEIGHTING_PRECISION,
+                    ),
+                },
+                "effective_total_value_fx_portfolio": {
+                    "Cash": format_number(cash_sum_effective_total_value_fx_portfolio, decimal=6),
+                    "Non-Cash": format_number(noncash_sum_effective_total_value_fx_portfolio, decimal=6),
+                    "Total": format_number(
+                        cash_sum_effective_total_value_fx_portfolio + noncash_sum_effective_total_value_fx_portfolio,
+                        decimal=6,
+                    ),
+                },
+                "target_total_value_fx_portfolio": {
+                    "Cash": format_number(cash_sum_target_total_value_fx_portfolio, decimal=6),
+                    "Non-Cash": format_number(noncash_sum_target_total_value_fx_portfolio, decimal=6),
+                    "Total": format_number(
+                        cash_sum_target_total_value_fx_portfolio + noncash_sum_target_total_value_fx_portfolio,
+                        decimal=6,
+                    ),
+                },
+                "weighting": {
+                    "Cash Flow": format_number(
+                        cash_sum_target_cash_weight - cash_sum_effective_weight,
+                        decimal=Order.ORDER_WEIGHTING_PRECISION,
+                    ),
+                    "Buy": format_number(sum_buy_weight, decimal=Order.ORDER_WEIGHTING_PRECISION),
+                    "Sell": format_number(sum_sell_weight, decimal=Order.ORDER_WEIGHTING_PRECISION),
+                },
+                "total_value_fx_portfolio": {
+                    "Cash Flow": format_number(
+                        cash_sum_target_total_value_fx_portfolio - cash_sum_effective_total_value_fx_portfolio,
+                        decimal=6,
+                    ),
+                    "Buy": format_number(sum_buy_total_value_fx_portfolio, decimal=6),
+                    "Sell": format_number(sum_sell_total_value_fx_portfolio, decimal=6),
+                },
+            }
+
+        return agg
+
+    def get_serializer_class(self):
+        if self.order_proposal.status != OrderProposal.Status.DRAFT:
+            return ReadOnlyOrderOrderProposalModelSerializer
+        elif not self.new_mode and "pk" not in self.kwargs:
+            return OrderOrderProposalListModelSerializer
+        return OrderOrderProposalModelSerializer
+
+    def add_messages(self, request, queryset=None, paginated_queryset=None, instance=None, initial=False):
+        if queryset is not None and queryset.exists() and self.order_proposal.status != OrderProposal.Status.APPROVED:
+            total_target_weight = queryset.aggregate(c=Sum(F("target_weight")))["c"] or Decimal(0)
+            if round(total_target_weight, 8) != 1:
+                warning(
+                    request,
+                    "The total target weight does not equal 1. To avoid automatic cash allocation, please adjust the order weights to sum up to 1. Otherwise, a cash component will be added when this order proposal is submitted.",
+                )
+            if queryset.filter(has_warnings=True).exists():
+                error(
+                    request,
+                    "Some orders failed preparation. To resolve this, please revert the order proposal to draft, review and correct the orders, and then resubmit.",
+                )
+
+    @cached_property
+    def orders(self):
+        if self.is_portfolio_manager:
+            return self.order_proposal.get_orders()
+        else:
+            return Order.objects.none()
+
+    def get_queryset(self):
+        return self.orders.annotate(
+            underlying_instrument_isin=F("underlying_instrument__isin"),
+            underlying_instrument_ticker=F("underlying_instrument__ticker"),
+            underlying_instrument_refinitiv_identifier_code=F("underlying_instrument__refinitiv_identifier_code"),
+            underlying_instrument_instrument_type=Case(
+                When(
+                    underlying_instrument__parent__is_security=True,
+                    then=F("underlying_instrument__parent__instrument_type__short_name"),
+                ),
+                default=F("underlying_instrument__instrument_type__short_name"),
+            ),
+            effective_total_value_fx_portfolio=F("effective_weight") * Value(self.portfolio_total_asset_value),
+            target_total_value_fx_portfolio=F("target_weight") * Value(self.portfolio_total_asset_value),
+            portfolio_currency=F("portfolio__currency__symbol"),
+            security=F("underlying_instrument__parent"),
+            company=F("underlying_instrument__parent__parent"),
+        ).select_related(
+            "underlying_instrument", "underlying_instrument__parent", "underlying_instrument__parent__parent"
+        )