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

wbportfolio/models/roles.py

@@ -52,16 +52,10 @@ class PortfolioRole(models.Model):
         return f"{self.role_type} {self.person.computed_str}"
 
     def save(self, *args, **kwargs):
-        assert (
-            self.role_type in [self.RoleType.MANAGER, self.RoleType.RISK_MANAGER] and not self.instrument
-        ) or self.role_type in [
-            self.RoleType.PORTFOLIO_MANAGER,
-            self.RoleType.ANALYST,
-        ], self.default_error_messages["manager"].format(model="instrument")
-
-        assert (self.start and self.end and self.start < self.end) or (
-            not self.start or not self.end
-        ), self.default_error_messages["start_end"]
+        if self.role_type in [self.RoleType.MANAGER, self.RoleType.RISK_MANAGER] and self.instrument:
+            raise ValueError(self.default_error_messages["manager"].format(model="instrument"))
+        if self.start and self.end and self.start > self.end:
+            raise ValueError(self.default_error_messages["start_end"])
 
         super().save(*args, **kwargs)
 

wbportfolio/models/transactions/claim.py

@@ -259,9 +259,10 @@ class Claim(ReferenceIDMixin, WBModel):
         return f"{self.reference_id} {self.product.name} ({self.bank} - {self.shares:,} shares - {self.date}) "
 
     def save(self, *args, auto_match: bool = True, **kwargs):
-        assert (
-            self.shares is not None or self.nominal_amount is not None
-        ), f"Either shares or nominal amount have to be provided. Shares={self.shares}, Nominal={self.nominal_amount}"
+        if self.shares is None and self.nominal_amount is None:
+            raise ValueError(
+                f"Either shares or nominal amount have to be provided. Shares={self.shares}, Nominal={self.nominal_amount}"
+            )
         if self.product:
             if self.shares is not None:
                 self.nominal_amount = self.shares * self.product.share_price
@@ -447,7 +448,7 @@ class Claim(ReferenceIDMixin, WBModel):
         return self.can_approve()
 
     def auto_match(self) -> Trade | None:
-        SHARES_EPSILON = 1  # share
+        shares_epsilon = 1  # share
         auto_match_trade = None
         # Obvious filtering
         trades = Trade.valid_customer_trade_objects.filter(
@@ -458,7 +459,7 @@ class Claim(ReferenceIDMixin, WBModel):
             trades = trades.filter(underlying_instrument=self.product)
         # Find trades by shares (or remaining to be claimed)
         trades = trades.filter(
-            Q(diff_shares__lte=self.shares + SHARES_EPSILON) & Q(diff_shares__gte=self.shares - SHARES_EPSILON)
+            Q(diff_shares__lte=self.shares + shares_epsilon) & Q(diff_shares__gte=self.shares - shares_epsilon)
         )
         if trades.count() == 1:
             auto_match_trade = trades.first()

wbportfolio/models/transactions/dividends.py

@@ -41,6 +41,7 @@ class DividendTransaction(TransactionMixin, ImportMixin, models.Model):
     )
 
     def save(self, *args, **kwargs):
+        self.pre_save()
         if not self.record_date and self.ex_date:
             self.record_date = self.ex_date
         elif self.record_date and not self.ex_date:

wbportfolio/models/transactions/trades.py

@@ -194,6 +194,10 @@ class Trade(TransactionMixin, ImportMixin, models.Model):
         # notification_email_template = "portfolio/email/trade_notification.html"
 
     def save(self, *args, **kwargs):
+        self.pre_save()
+        if not self.weighting and (total_asset_value := self.portfolio.get_total_asset_value(self.transaction_date)):
+            self.weighting = self.currency_fx_rate * self.price * self.shares / total_asset_value
+
         if abs(self.weighting) < 10e-6:
             self.weighting = Decimal("0")
         if not self.price:

wbportfolio/models/transactions/transactions.py

@@ -71,6 +71,22 @@ class TransactionMixin(models.Model):
         ),
         db_persist=True,
     )
+    price_fx_portfolio = models.GeneratedField(
+        expression=models.F("currency_fx_rate") * models.F("price"),
+        output_field=models.DecimalField(
+            max_digits=20,
+            decimal_places=4,
+        ),
+        db_persist=True,
+    )
+    price_gross_fx_portfolio = models.GeneratedField(
+        expression=models.F("currency_fx_rate") * models.F("price_gross"),
+        output_field=models.DecimalField(
+            max_digits=20,
+            decimal_places=4,
+        ),
+        db_persist=True,
+    )
     total_value_fx_portfolio = models.GeneratedField(
         expression=models.F("currency_fx_rate") * models.F("price") * models.F("shares"),
         output_field=models.DecimalField(
@@ -100,14 +116,10 @@ class TransactionMixin(models.Model):
             self.price_gross = self.price
         elif self.price_gross is not None and self.price is None:
             self.price = self.price_gross
-
-    def save(self, *args, **kwargs):
-        self.pre_save()
         if self.currency_fx_rate is None:
             self.currency_fx_rate = self.underlying_instrument.currency.convert(
                 self.value_date, self.portfolio.currency, exact_lookup=True
             )
-        super().save(*args, **kwargs)
 
     class Meta:
         abstract = True

wbportfolio/models/utils.py

@@ -1,6 +1,17 @@
+import logging
+from datetime import date
+from decimal import Decimal
+from typing import Iterator
+
+from celery import shared_task
+from django.db.models import F, QuerySet, Window
+from django.db.models.functions import RowNumber
+from tqdm import tqdm
 from wbfdm.models import Instrument
 
-from wbportfolio.models import Index, Product
+from wbportfolio.models import AssetPosition, Index, Order, OrderProposal, Portfolio, Product
+
+logger = logging.getLogger("pms")
 
 
 def get_casted_portfolio_instrument(instrument: Instrument) -> Product | Index | None:
@@ -11,3 +22,91 @@ def get_casted_portfolio_instrument(instrument: Instrument) -> Product | Index |
             return Index.objects.get(id=instrument.id)
         except Index.DoesNotExist:
             return None
+
+
+def get_adjusted_shares(old_shares: Decimal, old_price: Decimal, new_price: Decimal) -> Decimal:
+    return old_shares * (old_price / new_price)
+
+
+def adjust_assets(qs: Iterator[AssetPosition], underlying_quote: Instrument):
+    objs = []
+    logger.info("adjusting asset positions...")
+    for a in qs:
+        old_price: Decimal = a.initial_price
+        a.initial_price = a.underlying_instrument = a.underlying_quote_price = None
+        a.underlying_quote = underlying_quote
+        a.pre_save()
+        if a.initial_shares and a.initial_price and old_price != a.initial_price:
+            a.initial_shares = get_adjusted_shares(a.initial_shares, old_price, a.initial_price)
+        objs.append(a)
+    AssetPosition.objects.bulk_update(
+        objs,
+        ["underlying_quote", "underlying_quote_price", "underlying_instrument", "initial_price", "initial_shares"],
+        batch_size=1000,
+    )
+
+
+def adjust_orders(qs: Iterator[Order], underlying_quote: Instrument):
+    objs = []
+    logger.info("adjusting orders...")
+    for o in qs:
+        old_price: Decimal = o.price
+        o.underlying_instrument = underlying_quote
+        o.set_price()
+        if o.price and old_price != o.price and o.shares:
+            o.shares = get_adjusted_shares(o.shares, old_price, o.price)
+        objs.append(o)
+    Order.objects.bulk_update(objs, ["price", "shares", "underlying_instrument"], batch_size=1000)
+
+
+def adjust_quote(
+    old_quote: Instrument,
+    new_quote: Instrument,
+    adjust_after: date | None = None,
+    only_portfolios: QuerySet[Portfolio] | None = None,
+    debug: bool = False,
+):
+    if old_quote.currency != new_quote.currency:
+        raise ValueError("cannot safely switch quotes that are not of the same currency")
+    assets_to_change = AssetPosition.objects.filter(underlying_quote=old_quote)
+    orders_to_change = Order.objects.filter(underlying_instrument=old_quote)
+    new_quote.import_prices()
+    if adjust_after:
+        assets_to_change = assets_to_change.filter(date__gt=adjust_after)
+        orders_to_change = orders_to_change.filter(value_date__gt=adjust_after)
+    if only_portfolios is not None:
+        assets_to_change = assets_to_change.filter(portfolio__in=only_portfolios)
+        orders_to_change = orders_to_change.filter(order_proposal__portfolio__in=only_portfolios)
+    if debug:
+        assets_to_change = tqdm(assets_to_change, total=assets_to_change.count())
+        orders_to_change = tqdm(orders_to_change, total=orders_to_change.count())
+
+    # gather the list of order proposal to replay (if the quote led to missing position, we want to replay it to correct automatically the issue)
+    latest_orders = orders_to_change.annotate(
+        row_number=Window(
+            expression=RowNumber(), partition_by=[F("order_proposal__portfolio")], order_by=F("value_date").desc()
+        )
+    ).filter(row_number=1)
+    order_proposals_to_replay = OrderProposal.objects.filter(
+        portfolio__is_manageable=True, id__in=latest_orders.values("order_proposal")
+    )
+
+    # Adjust assets to the new quote
+    adjust_assets(assets_to_change, new_quote)
+
+    # Adjust orders to the new quote
+    adjust_orders(orders_to_change, new_quote)
+
+    # replay latest order proposal
+    for op in order_proposals_to_replay:
+        op.replay(reapply_order_proposal=True)
+
+
+@shared_task(queue="portfolio")
+def adjust_quote_as_task(
+    old_quote_id: int, new_quote_id: int, adjust_after: date | None = None, only_portfolio_ids: list[int] | None = None
+):
+    old_quote = Instrument.objects.get(id=old_quote_id)
+    new_quote = Instrument.objects.get(id=new_quote_id)
+    only_portfolios = Portfolio.objects.filter(id__in=only_portfolio_ids) if only_portfolio_ids else None
+    adjust_quote(old_quote, new_quote, adjust_after=adjust_after, only_portfolios=only_portfolios)

wbportfolio/order_routing/__init__.py

@@ -9,6 +9,22 @@ class ExecutionStatus(TextChoices):
     FAILED = "FAILED", "Failed"
     UNKNOWN = "UNKNOWN", "Unknown"
 
+
+
+class ExecutionInstruction(TextChoices):
+
+    MARKET_ON_CLOSE = "MARKET_ON_CLOSE", "Market On Close" # no parameter
+    GUARANTEED_MARKET_ON_CLOSE = "GUARANTEED_MARKET_ON_CLOSE", "Guaranteed Market On Close" # no parameter
+    GUARANTEED_MARKET_ON_OPEN  = "GUARANTEED_MARKET_ON_OPEN", "Guaranteed Market On Open" # no parameter
+    GPW_MARKET_ON_CLOSE = "GPW_MARKET_ON_CLOSE", "GPW Market On Close" # no parameter
+    MARKET_ON_OPEN = "MARKET_ON_OPEN", "Market On Open" # no parameter
+    IN_LINE_WITH_VOLUME = "IN_LINE_WITH_VOLUME", "In Line With Volume" # 1 parameter "Percentage"
+    LIMIT_ORDER = "LIMIT_ORDER", "Limit Order" # 2 parameters "limit and cutoff"
+    VWAP = "VWAP", "VWAP" # 2 parameters
+    TWAP = "TWAP", "TWAP" # 2 paramters
+
+
+
 class RoutingException(Exception):
     def __init__(self, errors):
         # messages: a list of strings

wbportfolio/order_routing/adapters/__init__.py

@@ -22,21 +22,29 @@ class BaseCustodianAdapter(ABC):
         pass
 
     @abstractmethod
-    def get_rebalance_status(self) -> tuple[ExecutionStatus, str]:
+    def is_valid(self) -> bool:
         """
-        Return the rebalance status as a string (in the custodian format)
+        Check whether the given isin is valid and can be rebalanced
         """
         pass
 
     @abstractmethod
-    def is_valid(self) -> bool:
+    def serialize_orders(self, orders: list[Order]) -> list[dict[str, str]]:
+        pass
+
+    @abstractmethod
+    def deserialize_items(self, items: list[dict[str, str]]) -> list[Order]:
+        pass
+
+    @abstractmethod
+    def get_rebalance_status(self) -> tuple[ExecutionStatus, str]:
         """
-        Check whether the given isin is valid and can be rebalanced
+        Return the rebalance status as a string (in the custodian format)
         """
         pass
 
     @abstractmethod
-    def submit_rebalancing(self, orders: list[Order], as_draft: bool = True) -> tuple[list[Order], str]:
+    def submit_rebalancing(self, items: list[dict[str, str]], as_draft: bool = True) -> tuple[list[dict[str, str]], str]:
         """
         Submit a rebalance order for the certificate.
         """
@@ -50,7 +58,7 @@ class BaseCustodianAdapter(ABC):
         pass
 
     @abstractmethod
-    def get_current_rebalancing(self) -> list[Order]:
+    def get_current_rebalancing(self) -> list[dict[str, str]]:
         """
         Fetch the current rebalance request details for a certificate.
         """

wbportfolio/order_routing/adapters/ubs.py

@@ -7,10 +7,16 @@ from requests import HTTPError
 from wbportfolio.api_clients.ubs import UBSNeoAPIClient
 from wbportfolio.pms.typing import Order
 
-from .. import ExecutionStatus, RoutingException
+from .. import ExecutionInstruction, ExecutionStatus, RoutingException
 from . import BaseCustodianAdapter
 
-ASSET_CLASS_MAP = {Order.AssetType.EQUITY: "EQUITY"}  # API can support BOND, FUTURE, OPTION, and DYNAMIC_STRATEGY
+logger = logging.getLogger("oms")
+
+
+ASSET_CLASS_MAP = {
+    Order.AssetType.EQUITY: "EQUITY",
+    Order.AssetType.AMERICAN_DEPOSITORY_RECEIPT: "EQUITY",
+}  # API can support BOND, FUTURE, OPTION, and DYNAMIC_STRATEGY
 ASSET_CLASS_MAP_INV = {
     v: k for k, v in ASSET_CLASS_MAP.items()
 }  # API can support BOND, FUTURE, OPTION, and DYNAMIC_STRATEGY
@@ -18,68 +24,31 @@ ASSET_CLASS_MAP_INV = {
 STATUS_MAP = {
     "Amend Pending": ExecutionStatus.PENDING,
     "Cancel Pending": ExecutionStatus.PENDING,
-    "Cancelled": ExecutionStatus.PENDING,
-    "Complete": ExecutionStatus.PENDING,
-    "Complete (Order Cancelled)": ExecutionStatus.PENDING,
-    "Complete (Partial Fill)": ExecutionStatus.PENDING,
-    "In Draft": ExecutionStatus.PENDING,
+    "Cancelled": ExecutionStatus.CANCELLED,
+    "Complete": ExecutionStatus.COMPLETED,
+    "Complete (Order Cancelled)": ExecutionStatus.COMPLETED,
+    "Complete (Partial Fill)": ExecutionStatus.COMPLETED,
+    "In Draft": ExecutionStatus.IN_DRAFT,
     "Pending Approval": ExecutionStatus.PENDING,
     "Pending Execution": ExecutionStatus.PENDING,
-    "Rebalance Cancelled": ExecutionStatus.PENDING,
-    "Rebalance Cancelled (Executing partially)": ExecutionStatus.PENDING,
-    "Rejected": ExecutionStatus.PENDING,
+    "Rebalance Cancelled": ExecutionStatus.CANCELLED,
+    "Rebalance Cancelled (Executing partially)": ExecutionStatus.CANCELLED,
+    "Rejected": ExecutionStatus.REJECTED,
     "Rejection Acknowledged": ExecutionStatus.PENDING,
     "Waiting for Response": ExecutionStatus.PENDING,
 }
-logger = logging.getLogger("oms")
-
-
-def _serialize_orders(orders: list[Order], default_execution_instruction=None) -> list[dict[str, str]]:
-    items = []
-    for order in orders:
-        if order.refinitiv_identifier_code:
-            identifier_type, identifier = "RIC", order.refinitiv_identifier_code
-        elif order.bloomberg_ticker:
-            identifier_type, identifier = "BBTICKER", order.bloomberg_ticker
-        else:
-            identifier_type, identifier = "SEDOL", order.sedol
-        item = {
-            "assetClass": ASSET_CLASS_MAP[order.asset_class],
-            "identifierType": identifier_type,
-            "identifier": identifier,
-            "executionInstruction": order.execution_instruction
-            if order.execution_instruction
-            else default_execution_instruction,
-            "userElementId": str(order.id),
-            "tradeDate": order.trade_date.strftime("%Y-%m-%d"),
-        }
-        if order.shares:
-            item["sharesToTrade"] = str(order.shares)
-        else:
-            item["targetWeight"] = str(order.target_weight)
-        items.append(item)
-    return items
-
-
-def _deserialize_items(items: list[dict[str, str]]):
-    orders = []
-    for item in items:
-        orders.append(
-            Order(
-                id=item.get("userElementId"),
-                asset_class=ASSET_CLASS_MAP_INV[item.get("assetClass")],
-                refinitiv_identifier_code=item.get(
-                    "ric", item["identifier"] if item.get("identifierType") == "RIC" else None
-                ),
-                bloomberg_ticker=item["identifier"] if item.get("identifierType") == "BBTICKER" else None,
-                sedol=item["identifier"] if item.get("identifierType") == "SEDOL" else None,
-                trade_date=datetime.strptime(item.get("tradeDate"), "%Y-%m-%d"),
-                target_weight=float(item["targetWeight"]) if "targetWeight" in item else None,
-                shares=float(item["sharesToTrade"]) if "sharesToTrade" in item else None,
-                execution_instruction=item.get("executionInstruction"),
-            )
-        )
-    return orders
+EXECUTION_INSTRUCTION_MAP = {
+    ExecutionInstruction.MARKET_ON_CLOSE: "MARKET_ON_CLOSE",
+    ExecutionInstruction.GUARANTEED_MARKET_ON_CLOSE: "GUARANTEED_MARKET_ON_CLOSE",
+    ExecutionInstruction.GUARANTEED_MARKET_ON_OPEN: "GUARANTEED_MARKET_ON_OPEN",
+    ExecutionInstruction.GPW_MARKET_ON_CLOSE: "GPW_MARKET_ON_CLOSE",
+    ExecutionInstruction.MARKET_ON_OPEN: "MARKET_ON_OPEN",
+    ExecutionInstruction.IN_LINE_WITH_VOLUME: "IN_LINE_WITH_VOLUME",
+    ExecutionInstruction.LIMIT_ORDER: "LIMIT_ORDER",
+    ExecutionInstruction.VWAP: "VWAP",
+    ExecutionInstruction.TWAP: "TWAP",
+}
+EXECUTION_INSTRUCTION_MAP_INV = {v: k for k, v in EXECUTION_INSTRUCTION_MAP.items()}
 
 
 class CustodianAdapter(BaseCustodianAdapter):
@@ -96,6 +65,70 @@ class CustodianAdapter(BaseCustodianAdapter):
             if self.raise_exception:
                 raise RoutingException(errors)
 
+    def _serialize_execution_instruction(
+        self, execution_instruction: ExecutionInstruction, execution_parameters: dict
+    ):
+        repr = EXECUTION_INSTRUCTION_MAP[execution_instruction]
+        if execution_parameters:
+            if execution_instruction == ExecutionInstruction.IN_LINE_WITH_VOLUME:
+                repr += f':{execution_parameters["percent"]:.0f%}'
+            elif execution_instruction == ExecutionInstruction.LIMIT_ORDER:
+                repr += f':{execution_parameters["price"]:.1f}'
+                if good_for_date := execution_parameters.get("good_for_date"):
+                    repr += f",{good_for_date}"
+            elif (
+                execution_instruction == ExecutionInstruction.VWAP
+                or execution_instruction == ExecutionInstruction.TWAP
+            ):
+                repr += f':{execution_parameters["period"]},{execution_parameters["time"]}'
+        return repr
+
+    def serialize_orders(self, orders: list[Order]) -> list[dict[str, str]]:
+        items = []
+        for order in orders:
+            if order.refinitiv_identifier_code:
+                identifier_type, identifier = "RIC", order.refinitiv_identifier_code
+            elif order.bloomberg_ticker:
+                identifier_type, identifier = "BBTICKER", order.bloomberg_ticker
+            else:
+                identifier_type, identifier = "SEDOL", order.sedol
+            item = {
+                "assetClass": ASSET_CLASS_MAP[order.asset_class],
+                "identifierType": identifier_type,
+                "identifier": identifier,
+                "executionInstruction": self._serialize_execution_instruction(
+                    order.execution_instruction, order.execution_instruction_parameters
+                ),
+                "userElementId": str(order.id),
+                "tradeDate": order.trade_date.strftime("%Y-%m-%d"),
+            }
+            if order.shares:
+                item["sharesToTrade"] = str(order.shares)
+            else:
+                item["targetWeight"] = str(order.target_weight * 100)
+            items.append(item)
+        return items
+
+    def deserialize_items(self, items: list[dict[str, str]]):
+        orders = []
+        for item in items:
+            orders.append(
+                Order(
+                    id=item.get("userElementId"),
+                    asset_class=ASSET_CLASS_MAP_INV[item.get("assetClass")],
+                    refinitiv_identifier_code=item.get(
+                        "ric", item["identifier"] if item.get("identifierType") == "RIC" else None
+                    ),
+                    bloomberg_ticker=item["identifier"] if item.get("identifierType") == "BBTICKER" else None,
+                    sedol=item["identifier"] if item.get("identifierType") == "SEDOL" else None,
+                    trade_date=datetime.strptime(item.get("tradeDate"), "%Y-%m-%d"),
+                    target_weight=float(item["targetWeight"]) / 100 if "targetWeight" in item else None,
+                    shares=float(item["sharesToTrade"]) if "sharesToTrade" in item else None,
+                    execution_instruction=EXECUTION_INSTRUCTION_MAP_INV[item["executionInstruction"]],
+                )
+            )
+        return orders
+
     def authenticate(self) -> bool:
         """
         Authenticate or renew tokens with the custodian API.
@@ -104,12 +137,6 @@ class CustodianAdapter(BaseCustodianAdapter):
         self.client = UBSNeoAPIClient(settings.UBS_NEO_API_TOKEN)
         return True
 
-    def get_rebalance_status(self) -> tuple[ExecutionStatus, str]:
-        res = self.client.get_rebalance_status_for_isin(self.isin)
-        self._handle_response(res)
-        status = res["rebalanceStatus"]
-        return STATUS_MAP.get(status, ExecutionStatus.UNKNOWN), status
-
     def is_valid(self) -> bool:
         """
         Check whether the given isin is valid and can be rebalanced
@@ -129,17 +156,18 @@ class CustodianAdapter(BaseCustodianAdapter):
             logger.warning(f"Couldn't validate adapter: {str(e)}")
             return False
 
-    def submit_rebalancing(self, orders: list[Order], as_draft: bool = True) -> tuple[list[Order], str]:
+    def submit_rebalancing(
+        self, items: list[dict[str, str]], as_draft: bool = True
+    ) -> tuple[list[dict[str, str]], str]:
         """
         Submit a rebalance order for the certificate.
         """
-        items = _serialize_orders(orders, default_execution_instruction="MARKET_ON_CLOSE")
         if not as_draft:
             res = self.client.submit_rebalance(self.isin, items)
         else:
             res = self.client.save_draft(self.isin, items)
         self._handle_response(res)
-        return _deserialize_items(res["rebalanceItems"]), res["message"]
+        return res["rebalanceItems"], res["message"]
 
     def cancel_current_rebalancing(self) -> bool:
         """
@@ -152,10 +180,16 @@ class CustodianAdapter(BaseCustodianAdapter):
         except (HTTPError, KeyError):
             return False
 
-    def get_current_rebalancing(self) -> list[Order]:
+    def get_rebalance_status(self) -> tuple[ExecutionStatus, str]:
+        res = self.client.get_rebalance_status_for_isin(self.isin)
+        self._handle_response(res)
+        status = res.get("rebalanceStatus", "")
+        return STATUS_MAP.get(status, ExecutionStatus.UNKNOWN), status
+
+    def get_current_rebalancing(self) -> list[dict[str, str]]:
         """
         Fetch the current rebalance request details for a certificate.
         """
         res = self.client.get_current_rebalance_request(self.isin)
         self._handle_response(res)
-        return _deserialize_items(res["rebalanceItems"])
+        return res["rebalanceItems"]

wbportfolio/order_routing/router.py

@@ -0,0 +1,33 @@
+from django.conf import settings
+
+from wbportfolio.order_routing import ExecutionStatus
+from wbportfolio.order_routing.adapters import BaseCustodianAdapter
+from wbportfolio.pms.typing import Order
+
+
+class Router:
+    def __init__(self, adapter: BaseCustodianAdapter):
+        self.adapter = adapter
+
+    @property
+    def submit_as_draft(self):
+        return getattr(settings, "DEBUG", True) or getattr(settings, "ORDER_ROUTING_AS_DRAFT", True)
+
+    def submit_rebalancing(self, orders: list[Order]) -> tuple[list[Order], tuple[str, str]]:
+        """
+        Submit a rebalance order for the certificate.
+        """
+        items = self.adapter.serialize_orders(orders)
+        confirmed_items, msg = self.adapter.submit_rebalancing(items, as_draft=self.submit_as_draft)
+        status = ExecutionStatus.IN_DRAFT if self.submit_as_draft else ExecutionStatus.PENDING
+        return self.adapter.deserialize_items(confirmed_items), (status, msg)
+
+    def get_rebalance_status(self) -> tuple[ExecutionStatus, str]:
+        return self.adapter.get_rebalance_status()
+
+    def cancel_rebalancing(self) -> bool:
+        return self.adapter.cancel_current_rebalancing()
+
+    def get_current_rebalancing_request(self) -> list[Order]:
+        items = self.adapter.get_current_rebalancing()
+        return self.adapter.deserialize_items(items)

wbportfolio/order_routing/tests/test_router.py

@@ -0,0 +1,110 @@
+from unittest.mock import MagicMock, PropertyMock, patch
+
+import pytest
+from django.conf import settings
+
+from wbportfolio.order_routing import ExecutionStatus
+from wbportfolio.order_routing.router import Router
+from wbportfolio.pms.typing import Order
+
+
+@pytest.fixture
+def mock_adapter():
+    adapter = MagicMock()
+    return adapter
+
+
+@pytest.fixture
+def router(mock_adapter):
+    return Router(adapter=mock_adapter)
+
+
+def test_submit_as_draft_from_settings(monkeypatch, router):
+    # Test default True if settings attribute missing
+    monkeypatch.setattr(settings, "ORDER_ROUTING_AS_DRAFT", True)
+    monkeypatch.setattr(settings, "DEBUG", False)
+    assert router.submit_as_draft is True
+
+    monkeypatch.setattr(settings, "ORDER_ROUTING_AS_DRAFT", False)
+    monkeypatch.setattr(settings, "DEBUG", True)
+    assert router.submit_as_draft is True
+
+    monkeypatch.setattr(settings, "ORDER_ROUTING_AS_DRAFT", True)
+    monkeypatch.setattr(settings, "DEBUG", True)
+    assert router.submit_as_draft is True
+
+    monkeypatch.setattr(settings, "ORDER_ROUTING_AS_DRAFT", False)
+    monkeypatch.setattr(settings, "DEBUG", False)
+    assert router.submit_as_draft is False
+
+
+@patch.object(Router, "submit_as_draft", new_callable=PropertyMock)
+def test_submit_rebalancing_calls_adapter_as_draft(mock_property, router, mock_adapter):
+    mock_property.return_value = True
+    orders = [MagicMock(spec=Order), MagicMock(spec=Order)]
+    serialized_orders = ["serialized_order1", "serialized_order2"]  # simplified serialized orders as items
+    confirmed_items = ["confirmed_order1", "confirmed_order2"]  # simplified deserialized orders from items
+    msg = "Success message"
+
+    mock_adapter.serialize_orders.return_value = serialized_orders
+    mock_adapter.submit_rebalancing.return_value = (confirmed_items, msg)
+    mock_adapter.deserialize_items.return_value = orders
+
+    result_orders, (status, message) = router.submit_rebalancing(orders)
+    assert result_orders == orders
+    assert status == ExecutionStatus.IN_DRAFT
+    assert message == msg
+    mock_adapter.serialize_orders.assert_called_once_with(orders)
+    mock_adapter.submit_rebalancing.assert_called_once_with(serialized_orders, as_draft=True)
+    mock_adapter.deserialize_items.assert_called_once_with(confirmed_items)
+
+
+@patch.object(Router, "submit_as_draft", new_callable=PropertyMock)
+def test_submit_rebalancing_calls_adapter(mock_property, router, mock_adapter):
+    mock_property.return_value = False
+    orders = [MagicMock(spec=Order), MagicMock(spec=Order)]
+    serialized_orders = ["serialized_order1", "serialized_order2"]  # simplified serialized orders as items
+    confirmed_items = ["confirmed_order1", "confirmed_order2"]  # simplified deserialized orders from items
+    msg = "Success message"
+
+    mock_adapter.serialize_orders.return_value = serialized_orders
+    mock_adapter.submit_rebalancing.return_value = (confirmed_items, msg)
+    mock_adapter.deserialize_items.return_value = orders
+
+    result_orders, (status, message) = router.submit_rebalancing(orders)
+    assert result_orders == orders
+    assert status == ExecutionStatus.PENDING
+    assert message == msg
+    mock_adapter.serialize_orders.assert_called_once_with(orders)
+    mock_adapter.submit_rebalancing.assert_called_once_with(serialized_orders, as_draft=False)
+    mock_adapter.deserialize_items.assert_called_once_with(confirmed_items)
+
+
+def test_get_rebalance_status_returns_adapter_status(router, mock_adapter):
+    expected_status = ExecutionStatus.PENDING
+    expected_msg = "Status message"
+    mock_adapter.get_rebalance_status.return_value = (expected_status, expected_msg)
+
+    status, msg = router.get_rebalance_status()
+    assert status == expected_status
+    assert msg == expected_msg
+    mock_adapter.get_rebalance_status.assert_called_once()
+
+
+def test_cancel_rebalancing_returns_adapter_result(router, mock_adapter):
+    mock_adapter.cancel_current_rebalancing.return_value = True
+    result = router.cancel_rebalancing()
+    assert result is True
+    mock_adapter.cancel_current_rebalancing.assert_called_once()
+
+
+def test_get_current_rebalancing_request_returns_deserialized(router, mock_adapter):
+    serialized_orders = ["order1", "order2"]
+    deserialized_orders = [MagicMock(spec=Order), MagicMock(spec=Order)]
+    mock_adapter.get_current_rebalancing.return_value = serialized_orders
+    mock_adapter.deserialize_items.return_value = deserialized_orders
+
+    result = router.get_current_rebalancing_request()
+    assert result == deserialized_orders
+    mock_adapter.get_current_rebalancing.assert_called_once()
+    mock_adapter.deserialize_items.assert_called_once_with(serialized_orders)