wbportfolio 1.54.23__py2.py3-none-any.whl → 1.55.0__py2.py3-none-any.whl

wbportfolio/tests/models/test_portfolios.py

@@ -10,6 +10,7 @@ from django.forms.models import model_to_dict
 from faker import Faker
 from pandas.tseries.offsets import BDay
 from psycopg.types.range import DateRange
+from wbcore.contrib.currency.factories import CurrencyFactory
 from wbcore.contrib.geography.factories import CountryFactory
 
 from wbportfolio.models import (
@@ -106,11 +107,10 @@ class TestPortfolioModel(PortfolioTestMixin):
         )
         assert portfolio.get_geographical_breakdown(weekday).shape[0] == 2
 
-    def test_get_currency_exposure(self, portfolio, asset_position_factory, currency_factory, equity_factory, weekday):
+    def test_get_currency_exposure(self, portfolio, asset_position_factory, equity_factory, weekday):
         a1 = asset_position_factory.create(
             portfolio=portfolio,
-            underlying_instrument=equity_factory.create(),
-            currency=currency_factory.create(),
+            underlying_instrument=equity_factory.create(currency=CurrencyFactory.create()),
             date=weekday,
         )
         asset_position_factory.create(
@@ -118,8 +118,7 @@ class TestPortfolioModel(PortfolioTestMixin):
         )
         asset_position_factory.create(
             portfolio=portfolio,
-            underlying_instrument=equity_factory.create(),
-            currency=currency_factory.create(),
+            underlying_instrument=equity_factory.create(currency=CurrencyFactory.create()),
             date=weekday,
         )
         assert portfolio.get_currency_exposure(weekday).shape[0] == 2
@@ -253,14 +252,14 @@ class TestPortfolioModel(PortfolioTestMixin):
 
     @patch.object(Portfolio, "estimate_net_asset_values", autospec=True)
     def test_change_at_date(self, mock_estimate_net_asset_values, asset_position_factory, portfolio, weekday):
-        asset_position_factory.create_batch(10, portfolio=portfolio, date=weekday)
+        a1 = asset_position_factory.create(portfolio=portfolio, date=weekday, weighting=Decimal("0.1"))
+        a2 = asset_position_factory.create(portfolio=portfolio, date=weekday, weighting=Decimal("0.3"))
+        a3 = asset_position_factory.create(portfolio=portfolio, date=weekday, weighting=Decimal("0.5"))
 
-        portfolio.change_at_date(weekday, recompute_weighting=True)
+        portfolio.change_at_date(weekday, fix_quantization=True)
 
-        # test that change at date normalize the weighting
-        total_value = AssetPosition.objects.aggregate(s=Sum("total_value_fx_portfolio"))["s"]
-        for pos in AssetPosition.objects.all():
-            assert float(pos.weighting) == pytest.approx(float(pos.total_value_fx_portfolio / total_value), rel=1e-2)
+        cash_pos = portfolio.assets.get(date=weekday, portfolio=portfolio, underlying_quote=portfolio.cash_component)
+        assert cash_pos.weighting == Decimal("1.0") - (a1.weighting + a2.weighting + a3.weighting)
 
         mock_estimate_net_asset_values.assert_called_once_with(
             portfolio, (weekday + BDay(1)).date(), analytic_portfolio=None
@@ -530,8 +529,9 @@ class TestPortfolioModel(PortfolioTestMixin):
         assert res1
 
     def test_get_total_asset_under_management(
-        self, portfolio, customer_trade_factory, instrument_factory, instrument_price_factory, weekday
+        self, portfolio_factory, customer_trade_factory, instrument_factory, instrument_price_factory, weekday
     ):
+        portfolio = portfolio_factory.create()
         i1 = instrument_factory.create()
         i2 = instrument_factory.create()
         previous_day = (weekday - BDay(5)).date()
@@ -1001,8 +1001,8 @@ class TestPortfolioModel(PortfolioTestMixin):
         fx_portfolio = currency_fx_rates_factory.create(currency=portfolio.currency, date=weekday)
         fx_instrument = currency_fx_rates_factory.create(currency=instrument.currency, date=weekday)
         instrument_id: int = instrument.id
-        weights = {instrument_id: random.random()}
-        portfolio.builder.set_prices({weekday: {instrument_id: p.net_value}})
+        weights = {instrument_id: Decimal(random.random())}
+        portfolio.builder.prices = {weekday: {instrument_id: p.net_value}}
         portfolio.builder.add((weekday, weights), infer_underlying_quote_price=False)
 
         res = list(portfolio.builder.get_positions())
@@ -1012,7 +1012,7 @@ class TestPortfolioModel(PortfolioTestMixin):
         assert a.underlying_quote == instrument
         assert a.underlying_quote_price == None
         assert a.initial_price == p.net_value
-        assert a.weighting == pytest.approx(weights[instrument.id], abs=10e-6)
+        assert a.weighting == pytest.approx(weights[instrument.id], abs=Decimal(10e-6))
         assert a.currency_fx_rate_portfolio_to_usd == fx_portfolio
         assert a.currency_fx_rate_instrument_to_usd == fx_instrument
 
@@ -1057,7 +1057,7 @@ class TestPortfolioModel(PortfolioTestMixin):
         except StopIteration as e:
             rebalancing_order_proposal = e.value
             assert rebalancing_order_proposal.trade_date == rebalancing_date
-            assert rebalancing_order_proposal.status == "SUBMIT"
+            assert rebalancing_order_proposal.status == "APPROVED"
 
             # we expect a equally rebalancing (default) so both orders needs to be created
             orders = rebalancing_order_proposal.get_orders()
@@ -1067,8 +1067,8 @@ class TestPortfolioModel(PortfolioTestMixin):
             assert t2._target_weight == Decimal("0.5")
 
             # we approve the rebalancing order proposal
-            assert rebalancing_order_proposal.status == "SUBMIT"
-            rebalancing_order_proposal.approve(replay=False)
+            assert rebalancing_order_proposal.status == "APPROVED"
+            rebalancing_order_proposal.apply(replay=False)
             rebalancing_order_proposal.save()
 
         # check that the rebalancing was applied and position reflect that
@@ -1084,17 +1084,17 @@ class TestPortfolioModel(PortfolioTestMixin):
         a1 = asset_position_factory.build(date=weekday, portfolio=portfolio, underlying_instrument=i1)
 
         # check initial creation
-        portfolio.builder.add([a1]).bulk_create_positions(compute_metrics=True)
+        portfolio.builder.add([a1]).bulk_create_positions(fix_quantization=False, compute_metrics=True)
         assert AssetPosition.objects.get(portfolio=portfolio, date=weekday).weighting == a1.weighting
         assert AssetPosition.objects.get(portfolio=portfolio, date=weekday).underlying_instrument == i1
 
-        # check that if we change key value, an already exising position will be updated accordingly
+        # check that if we change key value, an already existing position will be updated accordingly
         a1.weighting = Decimal(0.5)
-        portfolio.builder.add([a1]).bulk_create_positions()
+        portfolio.builder.add([a1]).bulk_create_positions(fix_quantization=False)
         assert AssetPosition.objects.get(portfolio=portfolio, date=weekday).weighting == Decimal(0.5)
 
         a2 = asset_position_factory.build(date=weekday, portfolio=portfolio, underlying_instrument=i2)
-        portfolio.builder.add([a2]).bulk_create_positions()
+        portfolio.builder.add([a2]).bulk_create_positions(fix_quantization=False)
         assert (
             AssetPosition.objects.get(portfolio=portfolio, date=weekday, underlying_instrument=i1).weighting
             == a1.weighting
@@ -1105,7 +1105,7 @@ class TestPortfolioModel(PortfolioTestMixin):
         )
 
         a3 = asset_position_factory.build(date=weekday, portfolio=portfolio, underlying_instrument=i3)
-        portfolio.builder.add([a3]).bulk_create_positions(delete_leftovers=True)
+        portfolio.builder.add([a3]).bulk_create_positions(delete_leftovers=True, fix_quantization=False)
         assert AssetPosition.objects.get(portfolio=portfolio, date=weekday).weighting == a3.weighting
         assert AssetPosition.objects.get(portfolio=portfolio, date=weekday).underlying_instrument == i3
 
@@ -1136,3 +1136,37 @@ class TestPortfolioModel(PortfolioTestMixin):
 
         primary_portfolio.handle_controlling_portfolio_change_at_date(weekday)
         mock_compute_lookthrough.assert_called_once_with(lookthrough_portfolio, weekday)
+
+    def test_get_model_portfolio_relationships(self, portfolio_factory, asset_position_factory, weekday):
+        model_portfolio = portfolio_factory.create()
+        model_index = model_portfolio.get_or_create_index()
+        dependent_portfolio = portfolio_factory.create()
+        re1 = PortfolioPortfolioThroughModel.objects.create(
+            portfolio=dependent_portfolio,
+            dependency_portfolio=model_portfolio,
+            type=PortfolioPortfolioThroughModel.Type.MODEL,
+        )
+
+        assert set(model_portfolio.get_model_portfolio_relationships(weekday)) == {
+            re1,
+        }
+        parent_portfolio = portfolio_factory.create()
+        child_portfolio = portfolio_factory.create()
+        re2 = PortfolioPortfolioThroughModel.objects.create(
+            portfolio=child_portfolio,
+            dependency_portfolio=parent_portfolio,
+            type=PortfolioPortfolioThroughModel.Type.MODEL,
+        )
+        assert set(model_portfolio.get_model_portfolio_relationships(weekday)) == {
+            re1,
+        }  # child portfolio is not considered in the tree because there is no position yet
+
+        asset_position_factory.create(portfolio=parent_portfolio, underlying_instrument=model_index, date=weekday)
+        assert set(model_portfolio.get_model_portfolio_relationships(weekday)) == {re1, re2}
+
+        dependent_portfolio.is_active = False  # disable this portfolio
+        dependent_portfolio.deletion_datetime = weekday - timedelta(days=1)
+        dependent_portfolio.save()
+        assert set(model_portfolio.get_model_portfolio_relationships(weekday)) == {
+            re2,
+        }

wbportfolio/tests/models/transactions/test_rebalancing.py

@@ -47,7 +47,7 @@ class TestRebalancer:
     def test_evaluate_rebalancing(
         self, weekday, rebalancer_factory, asset_position_factory, instrument_factory, instrument_price_factory
     ):
-        rebalancer = rebalancer_factory.create(approve_order_proposal_automatically=True)
+        rebalancer = rebalancer_factory.create(apply_order_proposal_automatically=True)
         trade_date = (weekday + BDay(1)).date()
 
         i1 = instrument_factory.create()
@@ -65,7 +65,7 @@ class TestRebalancer:
         )
         order_proposal = rebalancer.evaluate_rebalancing(trade_date)
         assert order_proposal.orders.count() == 2
-        assert order_proposal.status == OrderProposal.Status.APPROVED
+        assert order_proposal.status == OrderProposal.Status.APPLIED
         assert AssetPosition.objects.get(
             portfolio=rebalancer.portfolio, date=trade_date, underlying_quote=a1.underlying_instrument
         ).weighting == Decimal(0.5)

wbportfolio/tests/rebalancing/test_models.py

@@ -56,9 +56,7 @@ class TestModelPortfolioRebalancing:
         asset_position_factory.create(portfolio=model.portfolio, date=model.last_effective_date)
         assert not model.is_valid()
 
-        a = asset_position_factory.create(portfolio=model.model_portfolio, date=model.last_effective_date)
-        assert not model.is_valid()
-        instrument_price_factory.create(instrument=a.underlying_quote, date=model.trade_date)
+        asset_position_factory.create(portfolio=model.model_portfolio, date=model.last_effective_date)
         assert model.is_valid()
 
     def test_get_target_portfolio(self, portfolio, weekday, model, asset_position_factory):
@@ -84,7 +82,7 @@ class TestCompositeRebalancing:
         assert not model.is_valid()
 
         order_proposal = OrderProposalFactory.create(
-            portfolio=model.portfolio, trade_date=model.last_effective_date, status=OrderProposal.Status.APPROVED
+            portfolio=model.portfolio, trade_date=model.last_effective_date, status=OrderProposal.Status.APPLIED
         )
         t1 = OrderFactory.create(
             portfolio=model.portfolio,
@@ -106,7 +104,7 @@ class TestCompositeRebalancing:
 
     def test_get_target_portfolio(self, portfolio, weekday, model, asset_position_factory):
         order_proposal = OrderProposalFactory.create(
-            portfolio=model.portfolio, trade_date=model.last_effective_date, status=OrderProposal.Status.APPROVED
+            portfolio=model.portfolio, trade_date=model.last_effective_date, status=OrderProposal.Status.APPLIED
         )
         asset_position_factory(portfolio=portfolio, date=model.last_effective_date)  # noise
         asset_position_factory(portfolio=portfolio, date=model.last_effective_date)  # noise

wbportfolio/viewsets/charts/assets.py

@@ -71,7 +71,10 @@ class AbstractDistributionMixin(UserPortfolioRequestPermissionMixin):
 
     @cached_property
     def group_by(self) -> AssetPositionGroupBy:
-        return AssetPositionGroupBy(self.request.GET.get("group_by", "classification"))
+        try:
+            return AssetPositionGroupBy(self.request.GET.get("group_by", "classification"))
+        except ValueError:
+            return AssetPositionGroupBy.INDUSTRY
 
     @cached_property
     def val_date(self) -> dt.date:

wbportfolio/viewsets/configs/display/rebalancing.py

@@ -11,7 +11,7 @@ class RebalancerDisplayConfig(DisplayViewConfig):
             fields=[
                 dp.Field(key="portfolio", label="Portfolio"),
                 dp.Field(key="rebalancing_model", label="Rebalancing Model"),
-                dp.Field(key="approve_order_proposal_automatically", label="Approve automatically"),
+                dp.Field(key="apply_order_proposal_automatically", label="Approve automatically"),
                 dp.Field(key="frequency_repr", label="Frequency"),
                 dp.Field(key="activation_date", label="Activation Date"),
             ],
@@ -20,7 +20,7 @@ class RebalancerDisplayConfig(DisplayViewConfig):
     def get_instance_display(self) -> Display:
         return create_simple_display(
             [
-                ["rebalancing_model", "approve_order_proposal_automatically"],
+                ["rebalancing_model", "apply_order_proposal_automatically"],
                 ["frequency", "activation_date"],
                 ["rebalancing_dates", "rebalancing_dates"],
             ]

wbportfolio/viewsets/configs/menu/__init__.py

@@ -27,3 +27,4 @@ from .roles import PORTFOLIOROLE_MENUITEM
 from .trades import SUBSCRIPTION_REDEMPTION_MENUITEM, TRADE_MENUITEM
 from .portfolio_cash_flow import PORTFOLIO_DAILY_CASH_FLOW
 from .reconciliations import ACCOUNT_RECONCILIATION_MENU_ITEM
+from .orders import OrderProposalMenuItem

wbportfolio/viewsets/configs/menu/orders.py

@@ -0,0 +1,11 @@
+from wbcore.menus import ItemPermission, MenuItem
+from wbcore.permissions.shortcuts import is_internal_user
+
+OrderProposalMenuItem = MenuItem(
+    label="Order Proposals",
+    endpoint="wbportfolio:orderproposal-list",
+    endpoint_get_parameters={"waiting_for_input": True},
+    permission=ItemPermission(
+        permissions=["wbportfolio.view_orderproposal"], method=lambda request: is_internal_user(request.user)
+    ),
+)

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

@@ -1,3 +1,6 @@
+from contextlib import suppress
+
+from rest_framework.reverse import reverse
 from wbcore import serializers as wb_serializers
 from wbcore.contrib.icons import WBIcon
 from wbcore.enums import RequestType
@@ -5,6 +8,9 @@ from wbcore.metadata.configs import buttons as bt
 from wbcore.metadata.configs.buttons.view_config import ButtonViewConfig
 from wbcore.metadata.configs.display import create_simple_display
 
+from wbportfolio.models import OrderProposal, Portfolio
+from wbportfolio.serializers import PortfolioRepresentationSerializer
+
 
 class NormalizeSerializer(wb_serializers.Serializer):
     total_cash_weight = wb_serializers.FloatField(default=0, precision=4, percent=True)
@@ -20,7 +26,44 @@ class ResetSerializer(wb_serializers.Serializer):
 
 class OrderProposalButtonConfig(ButtonViewConfig):
     def get_custom_list_instance_buttons(self):
-        return {
+        buttons = []
+        with suppress(AttributeError, AssertionError):
+            order_proposal = self.view.get_object()
+            if order_proposal.status == OrderProposal.Status.APPLIED.value and order_proposal.portfolio.is_model:
+
+                class PushModelChangeSerializer(wb_serializers.Serializer):
+                    only_for_portfolio_ids = wb_serializers.PrimaryKeyRelatedField(
+                        label="Only for Portfolios", queryset=Portfolio.objects.all()
+                    )
+                    _only_for_portfolio_ids = PortfolioRepresentationSerializer(
+                        source="only_for_portfolio_ids",
+                        many=True,
+                        filter_params={"modeled_after": order_proposal.portfolio.id},
+                    )
+                    approve_automatically = wb_serializers.BooleanField(
+                        default=False,
+                        help_text="True if you want all created orders to be automatically move to the approve state.",
+                    )
+
+                buttons.append(
+                    bt.ActionButton(
+                        method=RequestType.PATCH,
+                        identifiers=("wbportfolio:orderproposal",),
+                        endpoint=reverse("wbportfolio:orderproposal-pushmodelchange", args=[order_proposal.id]),
+                        icon=WBIcon.BROADCAST.icon,
+                        label="Push Model Changes",
+                        description_fields=f"""
+                        Push this rebalancing to all portfolios that are modeled after {order_proposal.portfolio}
+                        """,
+                        action_label="Push Model Changes",
+                        title="Push Model Changes",
+                        serializer=PushModelChangeSerializer,
+                        instance_display=create_simple_display(
+                            [["only_for_portfolio_ids"], ["approve_automatically"]]
+                        ),
+                    )
+                )
+        buttons.append(
             bt.DropDownButton(
                 label="Tools",
                 buttons=(
@@ -31,8 +74,8 @@ class OrderProposalButtonConfig(ButtonViewConfig):
                         icon=WBIcon.SYNCHRONIZE.icon,
                         label="Replay Orders",
                         description_fields="""
-                        <p>Replay Orders. It will recompute all assets positions until next order proposal day (or today otherwise) </p>
-                        """,
+                            <p>Replay Orders. It will recompute all assets positions until next order proposal day (or today otherwise) </p>
+                            """,
                         action_label="Replay Order",
                         title="Replay Order",
                     ),
@@ -43,9 +86,9 @@ class OrderProposalButtonConfig(ButtonViewConfig):
                         icon=WBIcon.REGENERATE.icon,
                         label="Reset Orders",
                         description_fields="""
-                            <p><strong>Warning:</strong>This action will reset the order delta weight to either 0 or the difference between the previous weight and the locked target weight, depending on the user’s choice.</p>
-                            <p><strong>Note:</strong>This operation will change the current delta weights and cannot be undone</p>
-                            """,
+                                <p><strong>Warning:</strong>This action will reset the order delta weight to either 0 or the difference between the previous weight and the locked target weight, depending on the user’s choice.</p>
+                                <p><strong>Note:</strong>This operation will change the current delta weights and cannot be undone</p>
+                                """,
                         action_label="Reset Orders",
                         title="Reset Orders",
                         serializer=ResetSerializer,
@@ -58,8 +101,8 @@ class OrderProposalButtonConfig(ButtonViewConfig):
                         icon=WBIcon.EDIT.icon,
                         label="Normalize Orders",
                         description_fields="""
-                            <p>Make sure all orders normalize to a total target weight of (100 - {{total_cash_weight}})%</p>
-                            """,
+                                <p>Make sure all orders normalize to a total target weight of (100 - {{total_cash_weight}})%</p>
+                                """,
                         action_label="Normalize Orders",
                         title="Normalize Orders",
                         serializer=NormalizeSerializer,
@@ -72,14 +115,15 @@ class OrderProposalButtonConfig(ButtonViewConfig):
                         icon=WBIcon.DELETE.icon,
                         label="Delete All Orders",
                         description_fields="""
-                    <p>Delete all orders from this order proposal?</p>
-                    """,
+                        <p>Delete all orders from this order proposal?</p>
+                        """,
                         action_label="Delete All Orders",
                         title="Delete All Orders",
                     ),
                 ),
-            ),
-        }
+            )
+        )
+        return set(buttons)
 
     def get_custom_instance_buttons(self):
         return self.get_custom_list_instance_buttons()

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

@@ -1,7 +1,9 @@
+from contextlib import suppress
 from typing import Optional
 
 from wbcore.contrib.color.enums import WBColor
 from wbcore.metadata.configs import display as dp
+from wbcore.metadata.configs.display import Section
 from wbcore.metadata.configs.display.instance_display import Inline, Layout, Page
 from wbcore.metadata.configs.display.instance_display.operators import default
 from wbcore.metadata.configs.display.instance_display.shortcuts import Display
@@ -14,9 +16,12 @@ class OrderProposalDisplayConfig(DisplayViewConfig):
     def get_list_display(self) -> Optional[dp.ListDisplay]:
         return dp.ListDisplay(
             fields=[
+                dp.Field(key="portfolio", label="Portfolio") if "portfolio_id" not in self.view.kwargs else None,
                 dp.Field(key="trade_date", label="Order Date"),
                 dp.Field(key="rebalancing_model", label="Rebalancing Model"),
                 dp.Field(key="comment", label="Comment"),
+                dp.Field(key="creator", label="Creator"),
+                dp.Field(key="approver", label="Approver"),
             ],
             legends=[
                 dp.Legend(
@@ -29,8 +34,8 @@ class OrderProposalDisplayConfig(DisplayViewConfig):
                         ),
                         dp.LegendItem(
                             icon=WBColor.YELLOW_LIGHT.value,
-                            label=OrderProposal.Status.SUBMIT.label,
-                            value=OrderProposal.Status.SUBMIT.value,
+                            label=OrderProposal.Status.PENDING.label,
+                            value=OrderProposal.Status.PENDING.value,
                         ),
                         dp.LegendItem(
                             icon=WBColor.GREEN_LIGHT.value,
@@ -43,9 +48,14 @@ class OrderProposalDisplayConfig(DisplayViewConfig):
                             value=OrderProposal.Status.DENIED.value,
                         ),
                         dp.LegendItem(
-                            icon=WBColor.RED_DARK.value,
-                            label=OrderProposal.Status.FAILED.label,
-                            value=OrderProposal.Status.FAILED.value,
+                            icon=WBColor.GREEN.value,
+                            label=OrderProposal.Status.APPLIED.label,
+                            value=OrderProposal.Status.APPLIED.value,
+                        ),
+                        dp.LegendItem(
+                            icon=WBColor.GREY.value,
+                            label=OrderProposal.Status.EXECUTION.label,
+                            value=OrderProposal.Status.EXECUTION.value,
                         ),
                     ],
                 ),
@@ -60,12 +70,20 @@ class OrderProposalDisplayConfig(DisplayViewConfig):
                         ),
                         dp.FormattingRule(
                             style={"backgroundColor": WBColor.YELLOW_LIGHT.value},
-                            condition=("==", OrderProposal.Status.SUBMIT.value),
+                            condition=("==", OrderProposal.Status.PENDING.value),
                         ),
                         dp.FormattingRule(
                             style={"backgroundColor": WBColor.GREEN_LIGHT.value},
                             condition=("==", OrderProposal.Status.APPROVED.value),
                         ),
+                        dp.FormattingRule(
+                            style={"backgroundColor": WBColor.GREEN.value},
+                            condition=("==", OrderProposal.Status.APPLIED.value),
+                        ),
+                        dp.FormattingRule(
+                            style={"backgroundColor": WBColor.GREY.value},
+                            condition=("==", OrderProposal.Status.EXECUTION.value),
+                        ),
                         dp.FormattingRule(
                             style={"backgroundColor": WBColor.RED_LIGHT.value},
                             condition=("==", OrderProposal.Status.DENIED.value),
@@ -80,6 +98,33 @@ class OrderProposalDisplayConfig(DisplayViewConfig):
         )
 
     def get_instance_display(self) -> Display:
+        orders_grid_template_areas = [["orders"]]
+        orders_grid_template_rows = ["1fr"]
+        sections = []
+        with suppress(AttributeError, AssertionError):
+            op = self.view.get_object()
+            if op.execution_status:
+                orders_grid_template_areas = [["execution"], ["orders"]]
+                orders_grid_template_rows = ["100px", "1fr"]
+                sections.append(
+                    Section(
+                        key="execution",
+                        title="Execution",
+                        collapsed=False,
+                        display=Display(
+                            pages=[
+                                Page(
+                                    layouts={
+                                        default(): Layout(
+                                            grid_template_areas=[["execution_status_repr", "execution_comment"]],
+                                            grid_template_columns=["0.3fr", "0.7fr"],
+                                        )
+                                    }
+                                )
+                            ]
+                        ),
+                    )
+                )
         return Display(
             pages=[
                 Page(
@@ -91,7 +136,7 @@ class OrderProposalDisplayConfig(DisplayViewConfig):
                                 ["trade_date", "total_cash_weight", "min_order_value"],
                                 ["rebalancing_model", "target_portfolio", "target_portfolio"]
                                 if self.view.new_mode
-                                else ["rebalancing_model", "rebalancing_model", "rebalancing_model"],
+                                else ["rebalancing_model", "creator", "approver"],
                                 ["comment", "comment", "comment"],
                             ],
                         ),
@@ -101,9 +146,10 @@ class OrderProposalDisplayConfig(DisplayViewConfig):
                     title="Orders",
                     layouts={
                         default(): Layout(
-                            grid_template_areas=[["orders"]],
-                            grid_template_rows=["1fr"],
+                            grid_template_areas=orders_grid_template_areas,
+                            grid_template_rows=orders_grid_template_rows,
                             inlines=[Inline(key="orders", endpoint="orders")],
+                            sections=sections,
                         ),
                     },
                 ),

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

@@ -81,6 +81,7 @@ class OrderOrderProposalDisplayConfig(DisplayViewConfig):
                         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(key="underlying_instrument_exchange", label="Exchange", width=Unit.PIXEL(125)),
                 ],
             ),
             dp.Field(
@@ -161,6 +162,18 @@ class OrderOrderProposalDisplayConfig(DisplayViewConfig):
                 ],
             )
         )
+        if order_proposal.execution_status:
+            fields.append(
+                dp.Field(
+                    label="Execution",
+                    open_by_default=True,
+                    key=None,
+                    children=[
+                        dp.Field(key="execution_confirmed", label="Confirmed", width=Unit.PIXEL(50)),
+                        dp.Field(key="execution_comment", label="Comment", width=Unit.PIXEL(100)),
+                    ],
+                )
+            )
         return dp.ListDisplay(
             fields=fields,
             legends=[ORDER_STATUS_LEGENDS],

wbportfolio/viewsets/orders/order_proposals.py

@@ -21,6 +21,7 @@ from wbcore.utils.views import CloneMixin
 
 from wbportfolio.models import AssetPosition, OrderProposal
 from wbportfolio.models.orders.order_proposals import (
+    push_model_change_as_task,
     replay_as_task,
 )
 from wbportfolio.serializers import (
@@ -29,6 +30,8 @@ from wbportfolio.serializers import (
     ReadOnlyOrderProposalModelSerializer,
 )
 
+from ...filters.orders import OrderProposalFilterSet
+from ...order_routing import ExecutionStatus
 from ..mixins import UserPortfolioRequestPermissionMixin
 from .configs import (
     OrderProposalButtonConfig,
@@ -52,6 +55,7 @@ class OrderProposalModelViewSet(CloneMixin, RiskCheckViewSetMixin, InternalUserP
 
     queryset = OrderProposal.objects.select_related("rebalancing_model", "portfolio")
     serializer_class = OrderProposalModelSerializer
+    filterset_class = OrderProposalFilterSet
     display_config_class = OrderProposalDisplayConfig
     button_config_class = OrderProposalButtonConfig
     endpoint_config_class = OrderProposalEndpointConfig
@@ -81,14 +85,29 @@ class OrderProposalModelViewSet(CloneMixin, RiskCheckViewSetMixin, InternalUserP
             ]
         )
 
-    def add_messages(self, request, instance=None, **kwargs):
-        if instance and instance.status == OrderProposal.Status.SUBMIT:
-            if not instance.portfolio.is_manageable:
-                info(request, "This order proposal cannot be approved the portfolio is considered unmanaged.")
-            if instance.has_non_successful_checks:
+    def add_messages(self, request, instance: OrderProposal | None = None, **kwargs):
+        if instance:
+            if instance.status == OrderProposal.Status.PENDING:
+                if not instance.portfolio.is_manageable:
+                    info(request, "This order proposal cannot be approved the portfolio is considered unmanaged.")
+                if instance.has_non_successful_checks:
+                    warning(
+                        request,
+                        "This order proposal cannot be approved because there is unsuccessful pre-trade checks. Please rectify accordingly and resubmit a valid order proposal",
+                    )
+            if (
+                instance.execution_status in [ExecutionStatus.IN_DRAFT, ExecutionStatus.COMPLETED]
+                and instance.orders.filter(execution_confirmed=False).exists()
+            ):
+                warning(request, "Some orders failed confirmation. Check the list for further details.")
+            if instance.execution_status in [
+                ExecutionStatus.REJECTED,
+                ExecutionStatus.FAILED,
+                ExecutionStatus.UNKNOWN,
+            ]:
                 warning(
                     request,
-                    "This order proposal cannot be approved because there is unsuccessful pre-trade checks. Please rectify accordingly and resubmit a valid order proposal",
+                    f"The execution status is {ExecutionStatus[instance.execution_status].label}. Detail: {instance.execution_comment}",
                 )
 
     @classmethod
@@ -130,6 +149,26 @@ class OrderProposalModelViewSet(CloneMixin, RiskCheckViewSetMixin, InternalUserP
             return Response({"send": True})
         return Response({"status": "Order Proposal is not Draft"}, status=status.HTTP_400_BAD_REQUEST)
 
+    @action(detail=True, methods=["PATCH"])
+    def pushmodelchange(self, request, pk=None):
+        order_proposal = get_object_or_404(OrderProposal, pk=pk)
+        only_for_portfolio_ids = list(
+            map(lambda o: int(o), filter(lambda r: r, request.data.get("only_for_portfolio_ids", "").split(",")))
+        )
+        approve_automatically = request.data.get("approve_automatically") == "true"
+        if order_proposal.status == OrderProposal.Status.APPLIED and order_proposal.portfolio.is_model:
+            push_model_change_as_task.delay(
+                order_proposal.id,
+                request.user.id,
+                only_for_portfolio_ids=only_for_portfolio_ids,
+                approve_automatically=approve_automatically,
+            )
+            return Response({"send": True})
+        return Response(
+            {"status": "Order Proposal needs to be approved and linked to be a model portfolio"},
+            status=status.HTTP_400_BAD_REQUEST,
+        )
+
 
 class OrderProposalPortfolioModelViewSet(UserPortfolioRequestPermissionMixin, OrderProposalModelViewSet):
     endpoint_config_class = OrderProposalPortfolioEndpointConfig