wbportfolio 1.55.8__py2.py3-none-any.whl → 1.59.4__py2.py3-none-any.whl

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

@@ -49,8 +49,8 @@ class OrderProposalDisplayConfig(DisplayViewConfig):
                         ),
                         dp.LegendItem(
                             icon=WBColor.GREEN.value,
-                            label=OrderProposal.Status.APPLIED.label,
-                            value=OrderProposal.Status.APPLIED.value,
+                            label=OrderProposal.Status.CONFIRMED.label,
+                            value=OrderProposal.Status.CONFIRMED.value,
                         ),
                         dp.LegendItem(
                             icon=WBColor.GREY.value,
@@ -78,7 +78,7 @@ class OrderProposalDisplayConfig(DisplayViewConfig):
                         ),
                         dp.FormattingRule(
                             style={"backgroundColor": WBColor.GREEN.value},
-                            condition=("==", OrderProposal.Status.APPLIED.value),
+                            condition=("==", OrderProposal.Status.CONFIRMED.value),
                         ),
                         dp.FormattingRule(
                             style={"backgroundColor": WBColor.GREY.value},
@@ -125,33 +125,33 @@ class OrderProposalDisplayConfig(DisplayViewConfig):
                         ),
                     )
                 )
-        return Display(
-            pages=[
-                Page(
-                    title="Main Information",
-                    layouts={
-                        default(): Layout(
-                            grid_template_areas=[
-                                ["status", "status", "status"],
-                                ["trade_date", "total_cash_weight", "min_order_value"],
-                                ["rebalancing_model", "target_portfolio", "target_portfolio"]
-                                if self.view.new_mode
-                                else ["rebalancing_model", "creator", "approver"],
-                                ["comment", "comment", "comment"],
-                            ],
-                        ),
-                    },
+
+        main_info_page = Page(
+            title="Main Information",
+            layouts={
+                default(): Layout(
+                    grid_template_areas=[
+                        ["status", "status", "status", "status"],
+                        ["trade_date", "total_cash_weight", "min_order_value", "min_weighting"],
+                        ["rebalancing_model", "rebalancing_model", "target_portfolio", "target_portfolio"]
+                        if self.view.new_mode
+                        else ["rebalancing_model", "rebalancing_model", "creator", "approver"],
+                        ["comment", "comment", "comment", "comment"],
+                    ],
                 ),
-                Page(
-                    title="Orders",
-                    layouts={
-                        default(): Layout(
-                            grid_template_areas=orders_grid_template_areas,
-                            grid_template_rows=orders_grid_template_rows,
-                            inlines=[Inline(key="orders", endpoint="orders")],
-                            sections=sections,
-                        ),
-                    },
+            },
+        )
+        orders_page = Page(
+            title="Orders",
+            layouts={
+                default(): Layout(
+                    grid_template_areas=orders_grid_template_areas,
+                    grid_template_rows=orders_grid_template_rows,
+                    inlines=[Inline(key="orders", endpoint="orders")],
+                    sections=sections,
                 ),
-            ]
+            },
+        )
+        return Display(
+            pages=[orders_page, main_info_page] if "pk" in self.view.kwargs else [main_info_page, orders_page]
         )

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

@@ -71,17 +71,27 @@ class OrderOrderProposalDisplayConfig(DisplayViewConfig):
         fields = [
             dp.Field(
                 label="Instrument",
-                open_by_default=True,
+                open_by_default=False,
                 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_ticker", label="Ticker", width=Unit.PIXEL(100), show="open"),
+                    dp.Field(
+                        key="underlying_instrument_refinitiv_identifier_code",
+                        label="RIC",
+                        width=Unit.PIXEL(100),
+                        show="open",
+                    ),
                     dp.Field(
-                        key="underlying_instrument_refinitiv_identifier_code", label="RIC", width=Unit.PIXEL(100)
+                        key="underlying_instrument_instrument_type",
+                        label="Asset Class",
+                        width=Unit.PIXEL(125),
+                        show="open",
+                    ),
+                    dp.Field(
+                        key="underlying_instrument_exchange", label="Exchange", width=Unit.PIXEL(125), show="open"
                     ),
-                    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(
@@ -157,23 +167,52 @@ class OrderOrderProposalDisplayConfig(DisplayViewConfig):
                         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)),
+                    dp.Field(
+                        key="desired_target_weight", label="Desired Target Weight", show="open", width=Unit.PIXEL(100)
+                    ),
+                    dp.Field(key="daily_return", label="Daily Return", show="open", width=Unit.PIXEL(100)),
+                    dp.Field(key="currency_fx_rate", label="FX Rate", show="open", width=Unit.PIXEL(100)),
+                    dp.Field(key="price", label="Price", show="open", width=Unit.PIXEL(100)),
+                    dp.Field(key="order", label="Order", show="open", width=Unit.PIXEL(50)),
+                    dp.Field(key="comment", label="Comment", show="open", width=Unit.PIXEL(250)),
                 ],
             )
         )
+        execution_fields = [
+            dp.Field(
+                label="Instruction",
+                open_by_default=False,
+                key=None,
+                children=[
+                    dp.Field(key="execution_instruction", label="Type", width=Unit.PIXEL(125)),
+                    dp.Field(
+                        key="execution_instruction_parameters_repr",
+                        label="Parameters",
+                        width=Unit.PIXEL(125),
+                        show="open",
+                    ),
+                ],
+            )
+        ]
+
         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)),
-                    ],
-                )
+            execution_fields.extend(
+                [
+                    dp.Field(key="execution_status", label="Status", width=Unit.PIXEL(100)),
+                    dp.Field(key="execution_comment", label="Comment", width=Unit.PIXEL(150), show="open"),
+                    dp.Field(
+                        label="Trade",
+                        open_by_default=False,
+                        key=None,
+                        children=[
+                            dp.Field(key="execution_date", label="Date", width=Unit.PIXEL(100), show="open"),
+                            dp.Field(key="execution_price", label="Price", width=Unit.PIXEL(100), show="open"),
+                            dp.Field(key="execution_traded_shares", label="Shares", width=Unit.PIXEL(100)),
+                        ],
+                    ),
+                ]
             )
+        fields.append(dp.Field(label="Execution", open_by_default=False, key=None, children=execution_fields))
         return dp.ListDisplay(
             fields=fields,
             legends=[ORDER_STATUS_LEGENDS],

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

@@ -9,7 +9,7 @@ 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:
+            if order_proposal.status in [OrderProposal.Status.DRAFT, OrderProposal.Status.DENIED]:
                 return super().get_endpoint()
         return None
 

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

@@ -1,5 +1,3 @@
-from contextlib import suppress
-
 from rest_framework.reverse import reverse
 from wbcore.metadata.configs.endpoints import EndpointViewConfig
 
@@ -18,9 +16,13 @@ class OrderOrderProposalEndpointConfig(EndpointViewConfig):
                 )
         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)
+    def get_update_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 or order_proposal.can_be_confirmed:
+                return reverse(
+                    "wbportfolio:orderproposal-order-list",
+                    args=[self.view.kwargs["order_proposal_id"]],
+                    request=self.request,
+                )
+        return None

wbportfolio/viewsets/orders/order_proposals.py

@@ -2,7 +2,7 @@ from contextlib import suppress
 from datetime import date
 from decimal import Decimal
 
-from django.contrib.messages import info, warning
+from django.contrib.messages import error, warning
 from django.shortcuts import get_object_or_404
 from django.utils.functional import cached_property
 from pandas._libs.tslibs.offsets import BDay
@@ -19,8 +19,9 @@ 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, OrderProposal
+from wbportfolio.models import AssetPosition, Order, OrderProposal
 from wbportfolio.models.orders.order_proposals import (
+    execute_orders_as_task,
     push_model_change_as_task,
     replay_as_task,
 )
@@ -31,7 +32,8 @@ from wbportfolio.serializers import (
 )
 
 from ...filters.orders import OrderProposalFilterSet
-from ...order_routing import ExecutionStatus
+from ...order_routing import ExecutionStatus, RoutingException
+from ...permissions import IsPortfolioManager
 from ..mixins import UserPortfolioRequestPermissionMixin
 from .configs import (
     OrderProposalButtonConfig,
@@ -48,6 +50,7 @@ class OrderProposalRepresentationViewSet(InternalUserPermissionMixin, viewsets.R
 
 
 class OrderProposalModelViewSet(CloneMixin, RiskCheckViewSetMixin, InternalUserPermissionMixin, viewsets.ModelViewSet):
+    IDENTIFIER = "wbportfolio:order"
     ordering_fields = ("trade_date",)
     ordering = ("-trade_date",)
     search_fields = ("comment",)
@@ -87,16 +90,16 @@ class OrderProposalModelViewSet(CloneMixin, RiskCheckViewSetMixin, InternalUserP
 
     def add_messages(self, request, instance: OrderProposal | None = None, **kwargs):
         if instance:
-            if instance.status == OrderProposal.Status.APPROVED and not instance.portfolio.is_manageable:
-                info(request, "This order proposal cannot be approved the portfolio is considered unmanaged.")
             if instance.status == OrderProposal.Status.PENDING and 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()
+                instance.status == OrderProposal.Status.EXECUTION
+                and instance.orders.exclude(shares=0, weighting=0)
+                .filter(execution_status=Order.ExecutionStatus.FAILED)
+                .exists()
             ):
                 warning(request, "Some orders failed confirmation. Check the list for further details.")
             if instance.execution_status in [
@@ -108,12 +111,17 @@ class OrderProposalModelViewSet(CloneMixin, RiskCheckViewSetMixin, InternalUserP
                     request,
                     f"The execution status is {ExecutionStatus[instance.execution_status].label}. Detail: {instance.execution_comment}",
                 )
+            elif instance.can_be_executed and instance.approver == request.user.profile:
+                warning(
+                    request,
+                    "As the approver of these orders, you are not authorized to execute them yourself. Please assign execution to another qualified individual.",
+                )
 
     @classmethod
     def _get_risk_checks_button_title(cls) -> str:
         return "Pre-Trade Checks"
 
-    @action(detail=True, methods=["PATCH"])
+    @action(detail=True, methods=["PATCH"], permission_classes=[IsPortfolioManager])
     def reset(self, request, pk=None):
         order_proposal = get_object_or_404(OrderProposal, pk=pk)
         use_desired_target_weight = request.GET.get("use_desired_target_weight") == "true"
@@ -123,16 +131,16 @@ 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"])
+    @action(detail=True, methods=["PATCH"], permission_classes=[IsPortfolioManager])
     def normalize(self, request, pk=None):
         order_proposal = get_object_or_404(OrderProposal, pk=pk)
         total_cash_weight = Decimal(request.data.get("total_cash_weight", Decimal("0.0")))
         if order_proposal.status == OrderProposal.Status.DRAFT:
-            order_proposal.normalize_orders(total_target_weight=Decimal("1.0") - total_cash_weight)
+            order_proposal.normalize_orders(total_cash_weight)
             return Response({"send": True})
         return Response({"status": "Order Proposal is not Draft"}, status=status.HTTP_400_BAD_REQUEST)
 
-    @action(detail=True, methods=["PATCH"])
+    @action(detail=True, methods=["PATCH"], permission_classes=[IsPortfolioManager])
     def replay(self, request, pk=None):
         order_proposal = get_object_or_404(OrderProposal, pk=pk)
         if order_proposal.portfolio.is_manageable:
@@ -140,22 +148,14 @@ 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 deleteall(self, request, pk=None):
-        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": "Order Proposal is not Draft"}, status=status.HTTP_400_BAD_REQUEST)
-
-    @action(detail=True, methods=["PATCH"])
+    @action(detail=True, methods=["PATCH"], permission_classes=[IsPortfolioManager])
     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:
+        if order_proposal.status == OrderProposal.Status.APPROVED and order_proposal.portfolio.is_model:
             push_model_change_as_task.delay(
                 order_proposal.id,
                 request.user.id,
@@ -168,6 +168,77 @@ class OrderProposalModelViewSet(CloneMixin, RiskCheckViewSetMixin, InternalUserP
             status=status.HTTP_400_BAD_REQUEST,
         )
 
+    @action(detail=True, methods=["PATCH"], permission_classes=[IsPortfolioManager])
+    def execute(self, request, pk=None):
+        order_proposal = get_object_or_404(OrderProposal, pk=pk)
+        if order_proposal.can_execute(request.user):
+            prioritize_target_weight = request.data.get("prioritize_target_weight") == "true"
+            order_proposal.execution_status = ExecutionStatus.PENDING
+            order_proposal.execution_comment = "Waiting for custodian confirmation"
+            order_proposal.save()
+            execute_orders_as_task.delay(order_proposal.id, prioritize_target_weight=prioritize_target_weight)
+            return Response({"send": True})
+        return Response({"status": "Order Proposal is not Draft"}, status=status.HTTP_400_BAD_REQUEST)
+
+    @action(detail=True, methods=["PATCH"], permission_classes=[IsPortfolioManager])
+    def cancelexecution(self, request, pk=None):
+        order_proposal = get_object_or_404(OrderProposal, pk=pk)
+        if order_proposal.execution_status and order_proposal.execution_status != ExecutionStatus.CANCELLED:
+            try:
+                if not order_proposal.cancel_rebalancing():
+                    warning(
+                        request,
+                        "We could not cancel the rebalancing. It is probably already executed. Please refresh status or check with an administrator.",
+                    )
+            except (RoutingException, ValueError) as e:
+                error(request, f"Could not cancel orders proposal {order_proposal}: {str(e)}")
+            return Response({"send": True})
+        return Response(
+            {"status": "Order Proposal is not in an execution phase, therefore, it cannot be cancelled."},
+            status=status.HTTP_400_BAD_REQUEST,
+        )
+
+    @action(detail=True, methods=["PATCH"], permission_classes=[IsPortfolioManager])
+    def updateexecutionstatus(self, request, pk=None):
+        order_proposal = get_object_or_404(OrderProposal, pk=pk)
+        if order_proposal.execution_status:
+            try:
+                if not order_proposal.custodian_router:
+                    raise RoutingException(
+                        "There is no custodian router for this portfolio. Please check with an administrator."
+                    )
+                order_proposal.refresh_execution_status()
+            except (RoutingException, ValueError) as e:
+                error(request, f"Could not update rebalancing status: {str(e)}")
+            return Response(
+                {
+                    "send": True,
+                }
+            )
+        return Response(
+            {"status": "Order Proposal is not in an execution phase, therefore, its status cannot be fetched."},
+            status=status.HTTP_400_BAD_REQUEST,
+        )
+
+    @action(detail=True, methods=["PATCH"], permission_classes=[IsPortfolioManager])
+    def refreshreturn(self, request, pk=None):
+        order_proposal = get_object_or_404(OrderProposal, pk=pk)
+        order_proposal.refresh_returns()
+        return Response(
+            {"status": "Returns were refreshed with success"},
+            status=status.HTTP_200_OK,
+        )
+
+    @action(detail=True, methods=["PATCH"], permission_classes=[IsPortfolioManager])
+    def refreshpretradechecks(self, request, pk=None):
+        order_proposal = get_object_or_404(OrderProposal, pk=pk)
+        if order_proposal.status == OrderProposal.Status.DRAFT:
+            order_proposal.evaluate_pretrade_checks()
+        return Response(
+            {"status": "Evaluate pretrade checks"},
+            status=status.HTTP_200_OK,
+        )
+
 
 class OrderProposalPortfolioModelViewSet(UserPortfolioRequestPermissionMixin, OrderProposalModelViewSet):
     endpoint_config_class = OrderProposalPortfolioEndpointConfig

wbportfolio/viewsets/orders/orders.py

@@ -3,13 +3,17 @@ from decimal import Decimal
 from django.contrib.messages import error, info
 from django.db.models import (
     Case,
+    CharField,
     F,
+    Func,
     Sum,
     Value,
     When,
 )
 from django.shortcuts import get_object_or_404
 from django.utils.functional import cached_property
+from rest_framework.decorators import action
+from rest_framework.response import Response
 from wbcore import viewsets
 from wbcore.permissions.permissions import InternalUserPermissionMixin
 from wbcore.utils.strings import format_number
@@ -24,17 +28,20 @@ from wbportfolio.serializers import (
 )
 
 from ...filters.orders import OrderFilterSet
+from ...permissions import IsPortfolioManager
 from ..mixins import UserPortfolioRequestPermissionMixin
 from .configs import (
     OrderOrderProposalButtonConfig,
     OrderOrderProposalDisplayConfig,
     OrderOrderProposalEndpointConfig,
 )
+from .configs.buttons.orders import ExecutionInstructionSerializer
 
 
 class OrderOrderProposalModelViewSet(
     UserPortfolioRequestPermissionMixin, InternalUserPermissionMixin, OrderableMixin, viewsets.ModelViewSet
 ):
+    IDENTIFIER = "wbportfolio:order"
     IMPORT_ALLOWED = True
     ordering = (
         "order_proposal",
@@ -53,7 +60,7 @@ class OrderOrderProposalModelViewSet(
         "shares",
         "weighting",
     )
-    IDENTIFIER = "wbportfolio:orderproposal"
+    IDENTIFIER = "wbportfolio:order"
     search_fields = ("underlying_instrument__name",)
     queryset = Order.objects.none()
     filterset_class = OrderFilterSet
@@ -92,10 +99,10 @@ class OrderOrderProposalModelViewSet(
                 sum_effective_total_value_fx_portfolio=Sum(F("effective_total_value_fx_portfolio")),
             )
             # weights aggregates
-            cash_sum_effective_weight = (
-                self.order_proposal.total_effective_portfolio_weight - noncash_aggregates["sum_effective_weight"]
+            cash_sum_effective_weight = self.order_proposal.total_effective_portfolio_weight - (
+                noncash_aggregates["sum_effective_weight"] or Decimal(0)
             )
-            cash_sum_target_cash_weight = Decimal("1.0") - noncash_aggregates["sum_target_weight"]
+            cash_sum_target_cash_weight = Decimal("1.0") - (noncash_aggregates["sum_target_weight"] or Decimal(0))
             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)
@@ -171,11 +178,25 @@ class OrderOrderProposalModelViewSet(
         return agg
 
     def get_serializer_class(self):
-        if self.order_proposal.status != OrderProposal.Status.DRAFT:
+        if self.order_proposal.status != OrderProposal.Status.DRAFT and not self.order_proposal.can_be_confirmed:
             return ReadOnlyOrderOrderProposalModelSerializer
-        elif not self.new_mode and "pk" not in self.kwargs:
-            return OrderOrderProposalListModelSerializer
-        return OrderOrderProposalModelSerializer
+        if not self.new_mode and "pk" not in self.kwargs:
+            serializer_base_class = OrderOrderProposalListModelSerializer
+        else:
+            serializer_base_class = OrderOrderProposalModelSerializer
+        if not self.order_proposal.portfolio_total_asset_value:
+
+            class OnlyWeightSerializerClass(serializer_base_class):
+                class Meta(serializer_base_class.Meta):
+                    read_only_fields = list(serializer_base_class.Meta.read_only_fields) + [
+                        "shares",
+                        "target_shares",
+                        "total_value_fx_portfolio",
+                        "target_total_value_fx_portfolio",
+                    ]
+
+            return OnlyWeightSerializerClass
+        return serializer_base_class
 
     def add_messages(self, request, queryset=None, paginated_queryset=None, instance=None, initial=False):
         if self.orders.exists() and self.order_proposal.status in [
@@ -202,23 +223,55 @@ class OrderOrderProposalModelViewSet(
         return qs
 
     def get_queryset(self):
-        return self.orders.annotate(  # .exclude(underlying_instrument__is_cash=True)
-            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"),
+        return (
+            self.orders.filter(underlying_instrument__is_cash=False)
+            .annotate(  # .exclude(underlying_instrument__is_cash=True)
+                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"),
                 ),
-                default=F("underlying_instrument__instrument_type__short_name"),
-            ),
-            underlying_instrument_exchange=F("underlying_instrument__exchange__name"),
-            effective_total_value_fx_portfolio=F("previous_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"
+                underlying_instrument_exchange=F("underlying_instrument__exchange__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"),
+                underlying_instrument_currency=F("underlying_instrument__currency__symbol"),
+                security=F("underlying_instrument__parent"),
+                company=F("underlying_instrument__parent__parent"),
+                execution_instruction_parameters_repr=Func(
+                    "execution_instruction_parameters",
+                    function="string_agg",
+                    template="(SELECT string_agg(key || '=' || value, ',') FROM jsonb_each_text(%(expressions)s))",
+                    output_field=CharField(),
+                ),
+                execution_date=F("execution_trade__transaction_date"),
+                execution_price=F("execution_trade__price"),
+                execution_traded_shares=F("execution_trade__shares"),
+            )
+            .select_related(
+                "underlying_instrument", "underlying_instrument__parent", "underlying_instrument__parent__parent"
+            )
         )
+
+    @action(detail=True, methods=["PUT"], permission_classes=[IsPortfolioManager])
+    def changeexecutioninstruction(self, request, pk=None, order_proposal_id=None, **kwargs):
+        serializer = ExecutionInstructionSerializer(data=request.data)
+        order_proposal = get_object_or_404(OrderProposal, pk=order_proposal_id)
+        if serializer.is_valid(raise_exception=True):
+            parameters = dict(serializer.data)
+            orders_to_update = order_proposal.orders.all()
+            execution_instruction = parameters.pop("execution_instruction")
+            apply_execution_instruction_to_all_orders = parameters.pop("apply_execution_instruction_to_all_orders")
+            execution_parameters = {k: v for k, v in parameters.items() if v}
+            if not apply_execution_instruction_to_all_orders:
+                orders_to_update = orders_to_update.filter(id=pk)
+            orders_to_update.update(
+                execution_instruction=execution_instruction, execution_instruction_parameters=execution_parameters
+            )
+
+        return Response({"send": True})

wbportfolio/viewsets/portfolios.py

@@ -2,6 +2,7 @@ from contextlib import suppress
 from datetime import date, datetime
 
 import pandas as pd
+from celery import chain
 from django.db.models import OuterRef, Q, Subquery, Sum
 from django.http import HttpResponse
 from django.shortcuts import get_object_or_404
@@ -14,6 +15,7 @@ from rest_framework.reverse import reverse
 from wbcore import viewsets
 from wbcore.contrib.currency.models import Currency
 from wbcore.contrib.io.viewsets import ExportPandasAPIViewSet
+from wbcore.contrib.notifications.dispatch import send_notification_as_task
 from wbcore.pandas import fields as pf
 from wbcore.permissions.permissions import InternalUserPermissionMixin
 from wbfdm.models import Instrument
@@ -35,6 +37,8 @@ from wbportfolio.serializers import (
 )
 
 from ..models.graphs.portfolio import PortfolioGraph
+from ..models.utils import adjust_quote_as_task
+from ..permissions import IsPortfolioManager
 from .configs import (
     PortfolioButtonConfig,
     PortfolioDisplayConfig,
@@ -178,6 +182,26 @@ class PortfolioModelViewSet(UserPortfolioRequestPermissionMixin, InternalUserPer
 
         return HttpResponse("Bad arguments", status=400)
 
+    @action(detail=False, methods=["POST"], permission_classes=[IsPortfolioManager])
+    def adjustquote(self, request, pk=None):
+        old_quote = get_object_or_404(Instrument, pk=request.POST["old_quote"])
+        new_quote = get_object_or_404(Instrument, pk=request.POST["new_quote"])
+        adjust_after = parse_date(request.data["adjust_after"]) if "adjust_after" in request.data else None
+        only_portfolio_ids = request.data["only_portfolios"].split(",") if "only_portfolios" in request.data else []
+
+        chain(
+            adjust_quote_as_task.si(
+                old_quote.id, new_quote.id, adjust_after=adjust_after, only_portfolio_ids=only_portfolio_ids
+            ),
+            send_notification_as_task.si(
+                "wbportfolio.portfolio.action_done",
+                f"Quote adjustment from {old_quote} to {new_quote} is done",
+                "The associated positions and orders were successfully adjusted",
+                request.user.id,
+            ),
+        ).apply_async()
+        return HttpResponse("Ok", status=200)
+
 
 class PortfolioPortfolioThroughModelViewSet(InternalUserPermissionMixin, viewsets.ModelViewSet):
     serializer_class = PortfolioPortfolioThroughModelSerializer

{wbportfolio-1.55.8.dist-info → wbportfolio-1.59.4.dist-info}/METADATA

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