Almost finish basic functionalities

backend/trading_journal/crud.py

@@ -90,13 +90,10 @@ def create_trade(session: Session, trade_data: Mapping[str, Any] | BaseModel) ->
         raise ValueError("price_cents is required")
     if "commission_cents" not in payload:
         payload["commission_cents"] = 0
-    quantity: int = payload["quantity"]
-    price_cents: int = payload["price_cents"]
-    commission_cents: int = payload["commission_cents"]
     if "gross_cash_flow_cents" not in payload:
-        payload["gross_cash_flow_cents"] = -quantity * price_cents
+        raise ValueError("gross_cash_flow_cents is required")
     if "net_cash_flow_cents" not in payload:
-        payload["net_cash_flow_cents"] = payload["gross_cash_flow_cents"] - commission_cents
+        raise ValueError("net_cash_flow_cents is required")
 
     # If no cycle_id provided, create Cycle instance but don't call create_cycle()
     created_cycle = None
@@ -163,6 +160,21 @@ def get_trades_by_user_id(session: Session, user_id: int) -> list[models.Trades]
     return list(session.exec(statement).all())
 
 
+def update_trade_friendly_name(session: Session, trade_id: int, friendly_name: str) -> models.Trades:
+    trade: models.Trades | None = session.get(models.Trades, trade_id)
+    if trade is None:
+        raise ValueError("trade_id does not exist")
+    trade.friendly_name = friendly_name
+    session.add(trade)
+    try:
+        session.flush()
+    except IntegrityError as e:
+        session.rollback()
+        raise ValueError("update_trade_friendly_name integrity error") from e
+    session.refresh(trade)
+    return trade
+
+
 def update_trade_note(session: Session, trade_id: int, note: str) -> models.Trades:
     trade: models.Trades | None = session.get(models.Trades, trade_id)
     if trade is None:
@@ -240,7 +252,18 @@ def create_cycle(session: Session, cycle_data: Mapping[str, Any] | BaseModel) ->
     return c
 
 
-IMMUTABLE_CYCLE_FIELDS = {"id", "user_id", "start_date", "created_at"}
+IMMUTABLE_CYCLE_FIELDS = {"id", "user_id", "start_date"}
+
+
+def get_cycle_by_id(session: Session, cycle_id: int) -> models.Cycles | None:
+    return session.get(models.Cycles, cycle_id)
+
+
+def get_cycles_by_user_id(session: Session, user_id: int) -> list[models.Cycles]:
+    statement = select(models.Cycles).where(
+        models.Cycles.user_id == user_id,
+    )
+    return list(session.exec(statement).all())
 
 
 def update_cycle(session: Session, cycle_id: int, update_data: Mapping[str, Any] | BaseModel) -> models.Cycles:

backend/trading_journal/dto.py

@@ -64,43 +64,53 @@ class ExchangesRead(ExchangesBase):
 
 class CycleBase(SQLModel):
     friendly_name: str | None = None
-    symbol: str
-    exchange_id: int
-    underlying_currency: UnderlyingCurrency
     status: str
-    start_date: date
     end_date: date | None = None
     funding_source: str | None = None
     capital_exposure_cents: int | None = None
     loan_amount_cents: int | None = None
     loan_interest_rate_bps: int | None = None
     trades: list[TradeRead] | None = None
+    exchange: ExchangesRead | None = None
 
 
 class CycleCreate(CycleBase):
     user_id: int
+    symbol: str
+    exchange_id: int
+    underlying_currency: UnderlyingCurrency
+    start_date: date
+
+
+class CycleUpdate(CycleBase):
+    id: int
+
+
+class CycleRead(CycleCreate):
+    id: int
 
 
 class TradeBase(SQLModel):
-    user_id: int
-    friendly_name: str | None
+    friendly_name: str | None = None
     symbol: str
-    exchange: str
+    exchange_id: int
     underlying_currency: UnderlyingCurrency
     trade_type: TradeType
     trade_strategy: TradeStrategy
     trade_date: date
-    trade_time_utc: datetime
     quantity: int
     price_cents: int
-    gross_cash_flow_cents: int
     commission_cents: int
-    net_cash_flow_cents: int
-    notes: str | None
+    notes: str | None = None
     cycle_id: int | None = None
 
 
 class TradeCreate(TradeBase):
+    user_id: int | None = None
+    trade_time_utc: datetime | None = None
+    gross_cash_flow_cents: int | None = None
+    net_cash_flow_cents: int | None = None
+    quantity_multiplier: int = 1
     expiry_date: date | None = None
     strike_price_cents: int | None = None
     is_invalidated: bool = False
@@ -108,7 +118,19 @@ class TradeCreate(TradeBase):
     replaced_by_trade_id: int | None = None
 
 
-class TradeRead(TradeBase):
+class TradeNoteUpdate(BaseModel):
     id: int
-    is_invalidated: bool
-    invalidated_at: datetime | None
+    notes: str | None = None
+
+
+class TradeFriendlyNameUpdate(BaseModel):
+    id: int
+    friendly_name: str
+
+
+class TradeRead(TradeCreate):
+    id: int
+
+
+SessionsCreate.model_rebuild()
+CycleBase.model_rebuild()

backend/trading_journal/models.py

@@ -82,6 +82,7 @@ class Trades(SQLModel, table=True):
     expiry_date: date | None = Field(default=None, nullable=True)
     strike_price_cents: int | None = Field(default=None, nullable=True)
     quantity: int = Field(sa_column=Column(Integer, nullable=False))
+    quantity_multiplier: int = Field(sa_column=Column(Integer, nullable=False), default=1)
     price_cents: int = Field(sa_column=Column(Integer, nullable=False))
     gross_cash_flow_cents: int = Field(sa_column=Column(Integer, nullable=False))
     commission_cents: int = Field(sa_column=Column(Integer, nullable=False))
@@ -109,7 +110,7 @@ class Cycles(SQLModel, table=True):
     funding_source: FundingSource = Field(sa_column=Column(Text, nullable=True))
     capital_exposure_cents: int | None = Field(default=None, nullable=True)
     loan_amount_cents: int | None = Field(default=None, nullable=True)
-    loan_interest_rate_bps: int | None = Field(default=None, nullable=True)
+    loan_interest_rate_tenth_bps: int | None = Field(default=None, nullable=True)
     start_date: date = Field(sa_column=Column(Date, nullable=False))
     end_date: date | None = Field(default=None, sa_column=Column(Date, nullable=True))
     trades: list["Trades"] = Relationship(back_populates="cycle")

backend/trading_journal/models_v1.py

@@ -82,6 +82,7 @@ class Trades(SQLModel, table=True):
     expiry_date: date | None = Field(default=None, nullable=True)
     strike_price_cents: int | None = Field(default=None, nullable=True)
     quantity: int = Field(sa_column=Column(Integer, nullable=False))
+    quantity_multiplier: int = Field(sa_column=Column(Integer, nullable=False), default=1)
     price_cents: int = Field(sa_column=Column(Integer, nullable=False))
     gross_cash_flow_cents: int = Field(sa_column=Column(Integer, nullable=False))
     commission_cents: int = Field(sa_column=Column(Integer, nullable=False))
@@ -109,7 +110,7 @@ class Cycles(SQLModel, table=True):
     funding_source: FundingSource = Field(sa_column=Column(Text, nullable=True))
     capital_exposure_cents: int | None = Field(default=None, nullable=True)
     loan_amount_cents: int | None = Field(default=None, nullable=True)
-    loan_interest_rate_bps: int | None = Field(default=None, nullable=True)
+    loan_interest_rate_tenth_bps: int | None = Field(default=None, nullable=True)
     start_date: date = Field(sa_column=Column(Date, nullable=False))
     end_date: date | None = Field(default=None, sa_column=Column(Date, nullable=True))
     trades: list["Trades"] = Relationship(back_populates="cycle")

backend/trading_journal/service.py

@@ -13,19 +13,20 @@ from trading_journal import crud, security
 from trading_journal.dto import (
     CycleBase,
     CycleCreate,
+    CycleRead,
+    CycleUpdate,
     ExchangesBase,
     ExchangesCreate,
     ExchangesRead,
     SessionsCreate,
     SessionsUpdate,
+    TradeCreate,
+    TradeRead,
     UserCreate,
     UserLogin,
     UserRead,
 )
 
-SessionsCreate.model_rebuild()
-CycleBase.model_rebuild()
-
 if TYPE_CHECKING:
     from sqlmodel import Session
 
@@ -111,6 +112,22 @@ class ExchangeNotFoundError(ServiceError):
     pass
 
 
+class CycleNotFoundError(ServiceError):
+    pass
+
+
+class TradeNotFoundError(ServiceError):
+    pass
+
+
+class InvalidTradeDataError(ServiceError):
+    pass
+
+
+class InvalidCycleDataError(ServiceError):
+    pass
+
+
 # User service
 def register_user_service(db_session: Session, user_in: UserCreate) -> UserRead:
     if crud.get_user_by_username(db_session, user_in.username):
@@ -211,13 +228,124 @@ def update_exchanges_service(db_session: Session, user_id: int, exchange_id: int
 
 
 # Cycle Service
-def create_cycle_service(db_session: Session, user_id: int, cycle_data: CycleBase) -> CycleBase:
+def create_cycle_service(db_session: Session, user_id: int, cycle_data: CycleBase) -> CycleRead:
     cycle_data_dict = cycle_data.model_dump()
     cycle_data_dict["user_id"] = user_id
     cycle_data_with_user_id: CycleCreate = CycleCreate.model_validate(cycle_data_dict)
-    crud.create_cycle(db_session, cycle_data=cycle_data_with_user_id)
-    return cycle_data
+    created_cycle = crud.create_cycle(db_session, cycle_data=cycle_data_with_user_id)
+    return CycleRead.model_validate(created_cycle)
 
 
-def get_trades_service(db_session: Session, user_id: int) -> list:
-    return crud.get_trades_by_user_id(db_session, user_id)
+def get_cycle_by_id_service(db_session: Session, user_id: int, cycle_id: int) -> CycleRead:
+    cycle = crud.get_cycle_by_id(db_session, cycle_id)
+    if not cycle:
+        raise CycleNotFoundError("Cycle not found")
+    if cycle.user_id != user_id:
+        raise CycleNotFoundError("Cycle not found")
+    return CycleRead.model_validate(cycle)
+
+
+def get_cycles_by_user_service(db_session: Session, user_id: int) -> list[CycleRead]:
+    cycles = crud.get_cycles_by_user_id(db_session, user_id)
+    return [CycleRead.model_validate(cycle) for cycle in cycles]
+
+
+def _validate_cycle_update_data(cycle_data: CycleUpdate) -> tuple[bool, str]:
+    if cycle_data.status == "CLOSED" and cycle_data.end_date is None:
+        return False, "end_date is required when status is CLOSED"
+    if cycle_data.status == "OPEN" and cycle_data.end_date is not None:
+        return False, "end_date must be empty when status is OPEN"
+    return True, ""
+
+
+def update_cycle_service(db_session: Session, user_id: int, cycle_data: CycleUpdate) -> CycleRead:
+    is_valid, err_msg = _validate_cycle_update_data(cycle_data)
+    if not is_valid:
+        raise InvalidCycleDataError(err_msg)
+    cycle_id = cast("int", cycle_data.id)
+    existing_cycle = crud.get_cycle_by_id(db_session, cycle_id)
+    if not existing_cycle:
+        raise CycleNotFoundError("Cycle not found")
+    if existing_cycle.user_id != user_id:
+        raise CycleNotFoundError("Cycle not found")
+
+    provided_data_dict = cycle_data.model_dump(exclude_unset=True)
+    cycle_data_with_user_id: CycleBase = CycleBase.model_validate(provided_data_dict)
+
+    try:
+        updated_cycle = crud.update_cycle(db_session, cycle_id, update_data=cycle_data_with_user_id)
+    except Exception as e:
+        logger.exception("Failed to update cycle: \n")
+        raise ServiceError("Failed to update cycle") from e
+    return CycleRead.model_validate(updated_cycle)
+
+
+# Trades service
+def _append_cashflows(trade_data: TradeCreate) -> TradeCreate:
+    sign_multipler: int
+    if trade_data.trade_type in ("SELL_PUT", "SELL_CALL", "EXERCISE_CALL", "CLOSE_LONG_SPOT", "SHORT_SPOT"):
+        sign_multipler = 1
+    else:
+        sign_multipler = -1
+    quantity = trade_data.quantity * trade_data.quantity_multiplier
+    gross_cash_flow_cents = quantity * trade_data.price_cents * sign_multipler
+    net_cash_flow_cents = gross_cash_flow_cents - trade_data.commission_cents
+    trade_data.gross_cash_flow_cents = gross_cash_flow_cents
+    trade_data.net_cash_flow_cents = net_cash_flow_cents
+    return trade_data
+
+
+def _validate_trade_data(trade_data: TradeCreate) -> bool:
+    return not (
+        trade_data.trade_type in ("SELL_PUT", "SELL_CALL") and (trade_data.expiry_date is None or trade_data.strike_price_cents is None)
+    )
+
+
+def create_trade_service(db_session: Session, user_id: int, trade_data: TradeCreate) -> TradeRead:
+    if not _validate_trade_data(trade_data):
+        raise InvalidTradeDataError("Invalid trade data: expiry_date and strike_price_cents are required for SELL_PUT and SELL_CALL trades")
+    trade_data_dict = trade_data.model_dump()
+    trade_data_dict["user_id"] = user_id
+    trade_data_with_user_id: TradeCreate = TradeCreate.model_validate(trade_data_dict)
+    trade_data_with_user_id = _append_cashflows(trade_data_with_user_id)
+    created_trade = crud.create_trade(db_session, trade_data=trade_data_with_user_id)
+    return TradeRead.model_validate(created_trade)
+
+
+def get_trade_by_id_service(db_session: Session, user_id: int, trade_id: int) -> TradeRead:
+    trade = crud.get_trade_by_id(db_session, trade_id)
+    if not trade:
+        raise TradeNotFoundError("Trade not found")
+    if trade.user_id != user_id:
+        raise TradeNotFoundError("Trade not found")
+    return TradeRead.model_validate(trade)
+
+
+def update_trade_friendly_name_service(db_session: Session, user_id: int, trade_id: int, friendly_name: str) -> TradeRead:
+    existing_trade = crud.get_trade_by_id(db_session, trade_id)
+    if not existing_trade:
+        raise TradeNotFoundError("Trade not found")
+    if existing_trade.user_id != user_id:
+        raise TradeNotFoundError("Trade not found")
+    try:
+        updated_trade = crud.update_trade_friendly_name(db_session, trade_id, friendly_name)
+    except Exception as e:
+        logger.exception("Failed to update trade friendly name: \n")
+        raise ServiceError("Failed to update trade friendly name") from e
+    return TradeRead.model_validate(updated_trade)
+
+
+def update_trade_note_service(db_session: Session, user_id: int, trade_id: int, note: str | None) -> TradeRead:
+    existing_trade = crud.get_trade_by_id(db_session, trade_id)
+    if not existing_trade:
+        raise TradeNotFoundError("Trade not found")
+    if existing_trade.user_id != user_id:
+        raise TradeNotFoundError("Trade not found")
+    if note is None:
+        note = ""
+    try:
+        updated_trade = crud.update_trade_note(db_session, trade_id, note)
+    except Exception as e:
+        logger.exception("Failed to update trade notes: \n")
+        raise ServiceError("Failed to update trade notes") from e
+    return TradeRead.model_validate(updated_trade)