219 lines
8.2 KiB
Python
219 lines
8.2 KiB
Python
"""Portfolio service orchestration."""
|
|
|
|
from __future__ import annotations
|
|
|
|
import json
|
|
|
|
from fastapi import Depends
|
|
|
|
from app.core.config import Settings, get_settings
|
|
from app.domain.models import LedgerEntry, Portfolio, StrategySet
|
|
from app.domain.services import (
|
|
apply_buy,
|
|
apply_delete,
|
|
apply_invest,
|
|
apply_reset,
|
|
apply_sell,
|
|
apply_transfer,
|
|
get_portfolio_status,
|
|
)
|
|
from app.repositories.factory import get_portfolio_repository_from_settings
|
|
from app.repositories.portfolio_repository import PortfolioRepository
|
|
from app.schemas.portfolio import (
|
|
BuyRequest,
|
|
CreatePortfolioRequest,
|
|
InvestRequest,
|
|
PortfolioDetailResponse,
|
|
PortfolioListItem,
|
|
ResetPortfolioRequest,
|
|
SellRequest,
|
|
TransferRequest,
|
|
UpdatePortfolioRequest,
|
|
)
|
|
|
|
|
|
def _infer_symbol(portfolio_id: str) -> str:
|
|
parts = [part.strip() for part in portfolio_id.split(":") if part.strip()]
|
|
return parts[0] if parts else ""
|
|
|
|
|
|
def _to_portfolio_summary(portfolio: Portfolio):
|
|
from app.schemas.portfolio import PortfolioSummary
|
|
|
|
return PortfolioSummary(
|
|
portfolio_id=portfolio.portfolio_id,
|
|
broker=portfolio.broker,
|
|
status=portfolio.status,
|
|
symbol=portfolio.symbol,
|
|
strategy_name=portfolio.strategy_name,
|
|
strategy_params=portfolio.strategy_params,
|
|
cash_balance=portfolio.cash_balance,
|
|
asset_quantity=portfolio.asset_quantity,
|
|
price=portfolio.price,
|
|
profit_buffer=portfolio.profit_buffer,
|
|
current_strategy_set_id=portfolio.current_strategy_set_id,
|
|
created_at=portfolio.created_at,
|
|
updated_at=portfolio.updated_at,
|
|
last_trade_at=portfolio.last_trade_at,
|
|
)
|
|
|
|
|
|
def _to_strategy_set_response(strategy_set: StrategySet | None):
|
|
from app.schemas.portfolio import StrategySetResponse
|
|
|
|
if strategy_set is None:
|
|
return None
|
|
return StrategySetResponse(
|
|
id=strategy_set.id,
|
|
strategy_name=strategy_set.strategy_name,
|
|
strategy_config=strategy_set.strategy_config,
|
|
created_at=strategy_set.created_at,
|
|
)
|
|
|
|
|
|
def _to_ledger_entry_response(entry: LedgerEntry):
|
|
from app.schemas.portfolio import LedgerEntryResponse
|
|
|
|
return LedgerEntryResponse(
|
|
portfolio_id=entry.portfolio_id,
|
|
recorded_at=entry.recorded_at,
|
|
action=entry.action,
|
|
price=entry.price,
|
|
quantity=entry.quantity,
|
|
fee_amount=entry.fee_amount,
|
|
tax_amount=entry.tax_amount,
|
|
cash_balance_after=entry.cash_balance_after,
|
|
asset_quantity_after=entry.asset_quantity_after,
|
|
total_value_after=entry.total_value_after,
|
|
profit_buffer_after=entry.profit_buffer_after,
|
|
strategy_set_id=entry.strategy_set_id,
|
|
note=entry.note,
|
|
)
|
|
|
|
|
|
def _to_detail_response(status_result) -> PortfolioDetailResponse:
|
|
return PortfolioDetailResponse(
|
|
portfolio=_to_portfolio_summary(status_result.portfolio),
|
|
recent_entries=[_to_ledger_entry_response(entry) for entry in status_result.recent_entries],
|
|
strategy_set=_to_strategy_set_response(status_result.strategy_set),
|
|
live_quantity=status_result.live_quantity,
|
|
)
|
|
|
|
|
|
def get_portfolio_repository(settings: Settings = Depends(get_settings)) -> PortfolioRepository:
|
|
return get_portfolio_repository_from_settings(settings)
|
|
|
|
|
|
class PortfolioService:
|
|
def __init__(self, repository: PortfolioRepository) -> None:
|
|
self._repository = repository
|
|
|
|
def list_portfolios(self, *, broker: str | None = None, status: str | None = None) -> list[PortfolioListItem]:
|
|
portfolios = self._repository.list_portfolios(broker=broker, status=status)
|
|
return [
|
|
PortfolioListItem(
|
|
**_to_portfolio_summary(portfolio).model_dump(),
|
|
total_value=float(portfolio.cash_balance) + float(portfolio.asset_quantity) * float(portfolio.price),
|
|
)
|
|
for portfolio in portfolios
|
|
]
|
|
|
|
def get_portfolio_status(self, *, portfolio_id: str, recent_trades: int = 5) -> PortfolioDetailResponse:
|
|
status_result = get_portfolio_status(self._repository, portfolio_id, recent_trades=recent_trades)
|
|
return _to_detail_response(status_result)
|
|
|
|
def create_portfolio(self, payload: CreatePortfolioRequest) -> PortfolioDetailResponse:
|
|
strategy_set = self._repository.get_or_create_strategy_set(
|
|
payload.strategy_name,
|
|
json.dumps(payload.strategy_params, sort_keys=True, ensure_ascii=True),
|
|
)
|
|
portfolio = self._repository.create_portfolio(
|
|
payload.portfolio_id,
|
|
broker=payload.broker,
|
|
status=payload.status,
|
|
symbol=payload.symbol,
|
|
strategy_name=payload.strategy_name,
|
|
strategy_params=payload.strategy_params,
|
|
cash_balance=payload.cash_balance,
|
|
asset_quantity=payload.asset_quantity,
|
|
asset_price=payload.asset_price,
|
|
profit_buffer=payload.profit_buffer,
|
|
)
|
|
portfolio = self._repository.update_portfolio(
|
|
payload.portfolio_id,
|
|
current_strategy_set_id=strategy_set.id,
|
|
)
|
|
return self.get_portfolio_status(portfolio_id=portfolio.portfolio_id, recent_trades=5)
|
|
|
|
def update_portfolio(self, portfolio_id: str, payload: UpdatePortfolioRequest) -> PortfolioDetailResponse:
|
|
fields = payload.model_dump(exclude_none=True)
|
|
if "strategy_name" in fields or "strategy_params" in fields:
|
|
current = self._repository.get(portfolio_id)
|
|
strategy_name = fields.get("strategy_name", current.strategy_name)
|
|
strategy_params = fields.get("strategy_params", current.strategy_params)
|
|
strategy_set = self._repository.get_or_create_strategy_set(
|
|
strategy_name,
|
|
json.dumps(strategy_params, sort_keys=True, ensure_ascii=True),
|
|
)
|
|
fields["current_strategy_set_id"] = strategy_set.id
|
|
self._repository.update_portfolio(portfolio_id, **fields)
|
|
return self.get_portfolio_status(portfolio_id=portfolio_id, recent_trades=5)
|
|
|
|
def buy(self, portfolio_id: str, payload: BuyRequest) -> PortfolioDetailResponse:
|
|
apply_buy(
|
|
self._repository,
|
|
portfolio_id,
|
|
quantity=payload.quantity,
|
|
price=payload.price,
|
|
fee=payload.fee,
|
|
tax=payload.tax,
|
|
note=payload.note,
|
|
)
|
|
return self.get_portfolio_status(portfolio_id=portfolio_id, recent_trades=5)
|
|
|
|
def sell(self, portfolio_id: str, payload: SellRequest) -> PortfolioDetailResponse:
|
|
apply_sell(
|
|
self._repository,
|
|
portfolio_id,
|
|
quantity=payload.quantity,
|
|
price=payload.price,
|
|
fee=payload.fee,
|
|
tax=payload.tax,
|
|
note=payload.note,
|
|
)
|
|
return self.get_portfolio_status(portfolio_id=portfolio_id, recent_trades=5)
|
|
|
|
def invest(self, portfolio_id: str, payload: InvestRequest) -> PortfolioDetailResponse:
|
|
apply_invest(
|
|
self._repository,
|
|
portfolio_id,
|
|
movement_type=payload.movement_type,
|
|
amount=payload.amount,
|
|
note=payload.note,
|
|
)
|
|
return self.get_portfolio_status(portfolio_id=portfolio_id, recent_trades=5)
|
|
|
|
def transfer(self, portfolio_id: str, payload: TransferRequest) -> PortfolioDetailResponse:
|
|
apply_transfer(
|
|
self._repository,
|
|
portfolio_id,
|
|
direction=payload.direction,
|
|
amount=payload.amount,
|
|
note=payload.note,
|
|
)
|
|
return self.get_portfolio_status(portfolio_id=portfolio_id, recent_trades=5)
|
|
|
|
def reset(self, portfolio_id: str, payload: ResetPortfolioRequest) -> PortfolioDetailResponse:
|
|
infer_symbol = payload.infer_symbol or _infer_symbol(portfolio_id)
|
|
apply_reset(self._repository, portfolio_id, infer_symbol=lambda _: infer_symbol)
|
|
return self.get_portfolio_status(portfolio_id=portfolio_id, recent_trades=5)
|
|
|
|
def delete(self, portfolio_id: str, *, keep_ledger: bool = False) -> None:
|
|
apply_delete(self._repository, portfolio_id, clear_ledger=not keep_ledger)
|
|
|
|
|
|
def get_portfolio_service(
|
|
repository: PortfolioRepository = Depends(get_portfolio_repository),
|
|
) -> PortfolioService:
|
|
return PortfolioService(repository)
|