investing-algorithm-framework 3.7.0__py3-none-any.whl → 7.19.15__py3-none-any.whl

investing_algorithm_framework/services/trade_service/trade_service.py

@@ -1,401 +1,1099 @@
 import logging
+from datetime import datetime, timezone
 from queue import PriorityQueue
-from typing import List
+from typing import Union
 
-from investing_algorithm_framework.domain import OrderStatus, OrderSide, \
-    Trade, PeekableQueue, OrderType, TradeStatus, \
-    OperationalException, Order, RoundingService
-from investing_algorithm_framework.services.market_data_source_service import \
-    MarketDataSourceService
-from investing_algorithm_framework.services.position_service import \
-    PositionService
+from investing_algorithm_framework.domain import OrderStatus, TradeStatus, \
+    Trade, OperationalException, OrderType, TradeTakeProfit, \
+    TradeStopLoss, OrderSide, Environment, ENVIRONMENT, PeekableQueue, \
+    DataType, INDEX_DATETIME, random_number, random_string
+from investing_algorithm_framework.services.repository_service import \
+    RepositoryService
 
 logger = logging.getLogger(__name__)
 
 
-class TradeService:
+class TradeService(RepositoryService):
     """
-    Service for managing trades
+    Trade service class to handle trade related operations. This class
+    is responsible for creating, updating, and deleting trades. It also
+    takes care of keeping track of all sell transactions that are
+    associated with a trade.
     """
 
     def __init__(
         self,
+        trade_repository,
+        order_repository,
+        trade_stop_loss_repository,
+        trade_take_profit_repository,
+        position_repository,
         portfolio_repository,
-        order_service,
-        position_service,
-        market_data_source_service
+        configuration_service,
+        order_metadata_repository
     ):
+        super(TradeService, self).__init__(trade_repository)
+        self.order_repository = order_repository
         self.portfolio_repository = portfolio_repository
-        self.order_service = order_service
-        self.market_data_source_service: MarketDataSourceService = \
-            market_data_source_service
-        self.position_service: PositionService = position_service
+        self.position_repository = position_repository
+        self.configuration_service = configuration_service
+        self.trade_stop_loss_repository = trade_stop_loss_repository
+        self.trade_take_profit_repository = trade_take_profit_repository
+        self.order_metadata_repository = order_metadata_repository
 
-    def get_open_trades(self, target_symbol=None, market=None) -> List[Trade]:
+    def create_trade_from_buy_order(self, buy_order) -> Union[Trade, None]:
         """
-        Get open trades method
+        Function to create a trade from a buy order. If the given buy
+        order has its status set to CANCELED, EXPIRED, or REJECTED,
+        the trade object will not be created. If the given buy
+        order has its status set to CLOSED or OPEN, the trade object
+        will be created. The amount will be set to the filled amount.
 
-        :param target_symbol: str representing the target symbol
-        :param market: str representing the market
-        :return: list of Trade objects
+        Args:
+            buy_order: Order object representing the buy order
+
+        Returns:
+            Union[Trade, None] Representing the created trade object or None
         """
 
-        portfolios = self.portfolio_repository.get_all()
-        trades = []
+        if buy_order.status in \
+                [
+                    OrderStatus.CANCELED.value,
+                    OrderStatus.EXPIRED.value,
+                    OrderStatus.REJECTED.value
+                ]:
+            return None
 
-        for portfolio in portfolios:
+        data = {
+            "buy_order": buy_order,
+            "target_symbol": buy_order.target_symbol,
+            "trading_symbol": buy_order.trading_symbol,
+            "amount": buy_order.get_amount(),
+            "available_amount": buy_order.get_filled(),
+            "filled_amount": buy_order.get_filled(),
+            "remaining": buy_order.get_remaining(),
+            "opened_at": buy_order.created_at,
+            "cost": buy_order.get_filled() * buy_order.price
+        }
 
-            if target_symbol is not None:
-                buy_orders = self.order_service.get_all({
-                    "status": OrderStatus.CLOSED.value,
-                    "order_side": OrderSide.BUY.value,
-                    "portfolio_id": portfolio.id,
-                    "target_symbol": target_symbol
-                })
-                sell_orders = self.order_service.get_all({
-                    "status": OrderStatus.OPEN.value,
-                    "order_side": OrderSide.SELL.value,
-                    "portfolio_id": portfolio.id,
-                    "target_symbol": target_symbol
-                })
+        if buy_order.get_filled() > 0:
+            data["status"] = TradeStatus.OPEN.value
+            data["cost"] = buy_order.filled * buy_order.price
+
+        return self.create(data)
+
+    def _create_trade_metadata_with_sell_order(self, sell_order):
+        """
+        Function to create trade metadata with only a sell order.
+        This function will create all metadata objects for the trades
+        that are closed with the sell order amount.
+
+        Args:
+            sell_order: Order object representing the sell order
+
+        Returns:
+            None
+        """
+        position = self.position_repository.find({
+            "order_id": sell_order.id
+        })
+        portfolio_id = position.portfolio_id
+        matching_trades = self.get_all({
+            "status": TradeStatus.OPEN.value,
+            "target_symbol": sell_order.target_symbol,
+            "portfolio_id": portfolio_id
+        })
+        updated_at = sell_order.updated_at
+        total_available_to_close = 0
+        amount_to_close = sell_order.amount
+        trade_queue = PriorityQueue()
+        sell_order_id = sell_order.id
+        sell_price = sell_order.price
+
+        for trade in matching_trades:
+            if trade.available_amount > 0:
+                total_available_to_close += trade.available_amount
+                trade_queue.put(trade)
+
+        if total_available_to_close < amount_to_close:
+            raise OperationalException(
+                "Not enough amount to close in trades."
+            )
+
+        # Create order metadata object
+        while amount_to_close > 0 and not trade_queue.empty():
+            trade = trade_queue.get()
+            trade_id = trade.id
+            available_to_close = trade.available_amount
+
+            if amount_to_close >= available_to_close:
+                amount_to_close = amount_to_close - available_to_close
+                cost = trade.open_price * available_to_close
+                net_gain = (sell_price * available_to_close) - cost
+                update_data = {
+                    "available_amount": 0,
+                    "orders": trade.orders.append(sell_order),
+                    "updated_at": updated_at,
+                    "closed_at": updated_at,
+                    "net_gain": trade.net_gain + net_gain
+                }
+
+                if trade.remaining == 0:
+                    update_data["status"] = TradeStatus.CLOSED.value
+
+                self.update(trade_id, update_data)
+                self.repository.add_order_to_trade(trade, sell_order)
+
+                # Create metadata object
+                self.order_metadata_repository.\
+                    create({
+                        "order_id": sell_order_id,
+                        "trade_id": trade_id,
+                        "amount": available_to_close,
+                        "amount_pending": available_to_close,
+                    })
             else:
-                buy_orders = self.order_service.get_all({
-                    "status": OrderStatus.CLOSED.value,
-                    "order_side": OrderSide.BUY.value,
-                    "portfolio_id": portfolio.id
+                to_be_closed = amount_to_close
+                cost = trade.open_price * to_be_closed
+                net_gain = (sell_price * to_be_closed) - cost
+
+                self.update(
+                    trade_id, {
+                        "available_amount":
+                            trade.available_amount - to_be_closed,
+                        "orders": trade.orders.append(sell_order),
+                        "updated_at": updated_at,
+                        "net_gain": trade.net_gain + net_gain
+                    }
+                )
+                self.repository.add_order_to_trade(trade, sell_order)
+
+                # Create an order metadata object
+                self.order_metadata_repository.\
+                    create({
+                        "order_id": sell_order_id,
+                        "trade_id": trade_id,
+                        "amount": to_be_closed,
+                        "amount_pending": to_be_closed,
+                    })
+
+                amount_to_close = 0
+
+    def _create_stop_loss_metadata_with_sell_order(
+        self, sell_order_id, stop_losses
+    ):
+        """
+        """
+        sell_order = self.order_repository.get(sell_order_id)
+
+        for stop_loss_data in stop_losses:
+
+            self.order_metadata_repository.\
+                create({
+                    "order_id": sell_order.id,
+                    "stop_loss_id": stop_loss_data["stop_loss_id"],
+                    "amount": stop_loss_data["amount"],
+                    "amount_pending": stop_loss_data["amount"]
                 })
-                sell_orders = self.order_service.get_all({
-                    "status": OrderStatus.OPEN.value,
-                    "order_side": OrderSide.SELL.value,
-                    "portfolio_id": portfolio.id
+
+    def _create_take_profit_metadata_with_sell_order(
+        self, sell_order_id, take_profits
+    ):
+        """
+        """
+        sell_order = self.order_repository.get(sell_order_id)
+
+        for take_profit_data in take_profits:
+
+            self.order_metadata_repository.\
+                create({
+                    "order_id": sell_order.id,
+                    "take_profit_id": take_profit_data["take_profit_id"],
+                    "amount": take_profit_data["amount"],
+                    "amount_pending": take_profit_data["amount"]
                 })
 
-            buy_orders = [
-                buy_order for buy_order in buy_orders
-                if buy_order.get_trade_closed_at() is None
-            ]
-            sell_amount = sum([order.amount for order in sell_orders])
+    def update(self, trade_id, data) -> Trade:
+        """
+        Function to update a trade object. This function will update
+        the trade object with the given data.
+
+        Args:
+            trade_id: int representing the id of the trade object
+            data: dict representing the data that should be updated
 
-            # Subtract the amount of the open sell orders
-            # from the amount of the buy orders
-            buy_orders_queue = PeekableQueue()
+        Returns:
+            Trade object
+        """
 
-            for buy_order in buy_orders:
-                buy_orders_queue.enqueue(buy_order)
+        # Update the stop losses and take profits if last reported price
+        # is updated
+        if "last_reported_price" in data:
+            trade = self.get(trade_id)
+            stop_losses = trade.stop_losses
+            to_be_saved_stop_losses = []
+            take_profits = trade.take_profits
+            to_be_saved_take_profits = []
+
+            # Check if 'update_at' attribute is in data
+
+            if 'last_reported_price_date' in data:
+                last_reported_price_date = data["last_reported_price_date"]
+            else:
 
-            while sell_amount > 0 and not buy_orders_queue.is_empty():
-                first_buy_order = buy_orders_queue.peek()
-                available = first_buy_order.get_filled() \
-                    - first_buy_order.get_trade_closed_amount()
+                # Check if config environment has value BACKTEST
+                config = self.configuration_service.get_config()
+                environment = config[ENVIRONMENT]
 
-                if available > sell_amount:
-                    remaining = available - sell_amount
-                    sell_amount = 0
-                    first_buy_order.set_filled(remaining)
+                if Environment.BACKTEST.equals(environment):
+                    last_reported_price_date = \
+                        config[INDEX_DATETIME]
                 else:
-                    sell_amount = sell_amount - available
-                    buy_orders_queue.dequeue()
-
-            for buy_order in buy_orders_queue:
-                symbol = buy_order.get_symbol()
-                current_price = buy_order.get_price()
-                try:
-                    ticker = self.market_data_source_service.get_ticker(
-                        symbol=symbol, market=market
+                    last_reported_price_date = \
+                        datetime.now(tz=timezone.utc)
+
+            for stop_loss in stop_losses:
+
+                if stop_loss.active:
+                    stop_loss.update_with_last_reported_price(
+                        data["last_reported_price"], last_reported_price_date
                     )
-                    current_price = ticker["bid"]
-                except Exception as e:
-                    logger.error(e)
-
-                amount = buy_order.get_filled()
-                closed_amount = buy_order.get_trade_closed_amount()
-
-                if closed_amount is not None:
-                    amount = amount - closed_amount
-
-                trades.append(
-                    Trade(
-                        buy_order_id=buy_order.id,
-                        target_symbol=buy_order.get_target_symbol(),
-                        trading_symbol=buy_order.get_trading_symbol(),
-                        amount=amount,
-                        open_price=buy_order.get_price(),
-                        opened_at=buy_order.get_created_at(),
-                        current_price=current_price
+                    to_be_saved_stop_losses.append(stop_loss)
+
+            for take_profit in take_profits:
+
+                if take_profit.active:
+                    take_profit.update_with_last_reported_price(
+                        data["last_reported_price"], last_reported_price_date
                     )
-                )
+                    to_be_saved_take_profits.append(take_profit)
+
+            self.trade_stop_loss_repository\
+                .save_objects(to_be_saved_stop_losses)
+
+            self.trade_take_profit_repository\
+                .save_objects(to_be_saved_take_profits)
 
-        return trades
+        return super(TradeService, self).update(trade_id, data)
 
-    def get_trades(self, market=None) -> List[Trade]:
+    def _create_trade_metadata_with_sell_order_and_trades(
+        self, sell_order, trades
+    ):
         """
-        Get trades method
+        Function to create trade metadata with a sell order and trades.
+
+        The metadata objects function as a link between the trades and
+        the sell order. The metadata objects are used to keep track
+        of the trades that are closed with the sell order.
+
+        A single sell order can close or partially close multiple trades.
+        Therefore it is important to keep track of the trades that are
+        closed with the sell order. The metadata objects are used to
+        keep track of this relationship.
+
 
-        :param market: str representing the market
-        :param portfolio_id: str representing the portfolio id
-        :return: list of Trade objects
         """
+        sell_order_id = sell_order.id
+        updated_at = sell_order.updated_at
+        sell_amount = sell_order.amount
+        sell_price = sell_order.price
 
-        portfolios = self.portfolio_repository.get_all()
-        trades = []
+        for trade_data in trades:
+            trade = self.get(trade_data["trade_id"])
+            trade_id = trade.id
+            open_price = trade.open_price
+            old_net_gain = trade.net_gain
+            available_amount = trade.available_amount
+            filled_amount = trade.filled_amount
+            amount = trade.amount
 
-        for portfolio in portfolios:
-            buy_orders = self.order_service.get_all({
-                "status": OrderStatus.CLOSED.value,
-                "order_side": OrderSide.BUY.value,
-                "portfolio_id": portfolio.id
-            })
+            self.order_metadata_repository.\
+                create({
+                    "order_id": sell_order_id,
+                    "trade_id": trade_data["trade_id"],
+                    "amount": trade_data["amount"],
+                    "amount_pending": trade_data["amount"]
+                })
 
-            for buy_order in buy_orders:
-                symbol = buy_order.get_symbol()
-                current_price = buy_order.get_price()
-                try:
-                    ticker = self.market_data_source_service.get_ticker(
-                        symbol=symbol, market=market
-                    )
-                    current_price = ticker["bid"]
-                except Exception as e:
-                    logger.error(e)
-
-                trades.append(
-                    Trade(
-                        buy_order_id=buy_order.id,
-                        target_symbol=buy_order.get_target_symbol(),
-                        trading_symbol=buy_order.get_trading_symbol(),
-                        amount=buy_order.get_amount(),
-                        open_price=buy_order.get_price(),
-                        closed_price=buy_order.get_trade_closed_price(),
-                        closed_at=buy_order.get_trade_closed_at(),
-                        opened_at=buy_order.get_created_at(),
-                        current_price=current_price
-                    )
+            # Add the sell order to the trade
+            self.repository.add_order_to_trade(trade, sell_order)
+
+            # Update the trade
+            net_gain = (sell_price * sell_amount) - open_price * sell_amount
+            available_amount = available_amount - trade_data["amount"]
+            trade_updated_data = {
+                "available_amount": available_amount,
+                "updated_at": updated_at,
+                "net_gain": old_net_gain + net_gain
+            }
+
+            if available_amount == 0 and filled_amount == amount:
+                trade_updated_data["status"] = TradeStatus.CLOSED.value
+                trade_updated_data["closed_at"] = updated_at
+            else:
+                trade_updated_data["status"] = TradeStatus.OPEN.value
+
+            # Update the trade object
+            self.update(trade_id, trade_updated_data)
+
+    def create_order_metadata_with_trade_context(
+        self, sell_order, trades=None, stop_losses=None, take_profits=None
+    ):
+        """
+        Function to create order metadata for trade related models.
+
+        If only the sell order is provided, we assume that the sell order
+        is initiated by a client of the order service. In this case we
+        create only metadata objects for the trades based on size of the
+        sell order.
+
+        If also stop losses and take profits are provided, we assume that
+        the sell order is initiated a stop loss or take profit. In this case
+        we create metadata objects for the trades, stop losses,
+        and take profits.
+
+        If the trades param is provided, we assume that the sell order is
+        based on either a stop loss or take profit or a closing of a trade.
+        In this case we create also the metadata objects for the trades,
+
+        As part of this function, we will also update the position cost.
+
+        Scenario 1: Sell order without trades, stop losses, and take profits
+        - Use the sell amount to create all trade metadata objects
+        - Update the position cost
+
+        Scenario 2: Sell order with trades
+        - We assume that the sell amount is same as the total amount
+            of the trades
+        - Use the trades to create all trade metadata objects
+        - Update trade object remaining amount
+        - Update the position cost
+
+        Scenario 3: Sell order with trades, stop losses, and take profits
+        - We assume that the sell amount is same as the total
+            amount of the trades
+        - Use the trades to create all metadata objects
+        - Update trade object remaining amount
+        - Use the stop losses to create all metadata objects
+        - Use the take profits to create all metadata objects
+        - Update the position cost
+
+        Args:
+            sell_order: Order object representing the sell order that has
+                been created
+            trades: List of Trade objects representing the trades that
+                are associated with the sell order. Default is None.
+            stop_losses: List of StopLoss objects representing the stop
+                losses that are associated with the sell order. Default
+                is None.
+            take_profits: List of TakeProfit objects representing the take
+                profits that are associated with the sell order. Default
+                is None.
+
+        Returns:
+            None
+        """
+        sell_order_id = sell_order.id
+        sell_price = sell_order.price
+        sell_amount = sell_order.amount
+
+        if (trades is None or len(trades) == 0) \
+                and (stop_losses is None or len(stop_losses) == 0) \
+                and (take_profits is None or len(take_profits) == 0):
+            self._create_trade_metadata_with_sell_order(sell_order)
+        else:
+
+            if stop_losses is not None:
+                self._create_stop_loss_metadata_with_sell_order(
+                    sell_order_id, stop_losses
                 )
 
-        return trades
+            if take_profits is not None:
+                self._create_take_profit_metadata_with_sell_order(
+                    sell_order_id, take_profits
+                )
+
+            if trades is not None:
+                self._create_trade_metadata_with_sell_order_and_trades(
+                    sell_order, trades
+                )
+
+        # Retrieve all trades metadata objects
+        order_metadatas = self.order_metadata_repository.get_all({
+            "order_id": sell_order_id
+        })
+
+        # Update the position cost
+        position = self.position_repository.find({
+            "order_id": sell_order_id
+        })
 
-    def get_closed_trades(self, portfolio_id=None) -> List[Trade]:
+        # Update position
+        cost = 0
+        net_gain = 0
+        for metadata in order_metadatas:
+            if metadata.trade_id is not None:
+                trade = self.get(metadata.trade_id)
+                cost += trade.open_price * metadata.amount
+                net_gain += (sell_price * metadata.amount) - cost
+
+        position.cost -= cost
+        self.position_repository.save(position)
+
+        # Update the net gain, net size of the portfolio
+        portfolio = self.portfolio_repository.get(position.portfolio_id)
+        portfolio.total_net_gain += net_gain
+        portfolio.net_size += net_gain
+        portfolio.total_revenue += sell_price * sell_amount
+        self.portfolio_repository.save(portfolio)
+
+    def update_trade_with_removed_sell_order(
+        self, sell_order
+    ) -> Trade:
         """
-        Get closed trades method
+        This function updates a trade with a removed sell order that belongs
+        to the trade. This function uses the order metadata objects to
+        update the trade object. The function will update the trade object
+        available amount, cost, and net gain. The function will also
+        update the stop loss and take profit objects that are associated
+        with the trade object. The function will update the position cost
+        and the portfolio net gain.
+
+        Args:
+            sell_order (Order): Order object representing the sell order
+                that has been removed
 
-        :param portfolio_id: str representing the portfolio id
-        :return: list of Trade objects
+        Returns:
+            Trade: Trade object representing the updated trade object
         """
-        buy_orders = self.order_service.get_all({
-            "status": OrderStatus.CLOSED.value,
-            "order_side": OrderSide.BUY.value,
-            "portfolio_id": portfolio_id
+        position_cost = 0
+        total_net_gain = 0
+
+        # Get all order metadata objects that are associated with
+        # the sell order
+        order_metadatas = self.order_metadata_repository.get_all({
+            "order_id": sell_order.id
         })
-        return [
-            Trade(
-                buy_order_id=order.id,
-                target_symbol=order.get_target_symbol(),
-                trading_symbol=order.get_trading_symbol(),
-                amount=order.get_amount(),
-                open_price=order.get_price(),
-                closed_price=order.get_trade_closed_price(),
-                closed_at=order.get_trade_closed_at(),
-                opened_at=order.get_created_at()
-            ) for order in buy_orders
-            if order.get_trade_closed_at() is not None
-        ]
 
-    def close_trade(self, trade, market=None, precision=None) -> None:
+        for metadata in order_metadatas:
+            # If trade id is not None, update the trade object
+            if metadata.trade_id is not None:
+                trade = self.get(metadata.trade_id)
+                cost = metadata.amount_pending * trade.open_price
+                net_gain = (sell_order.price * metadata.amount_pending) - cost
+                trade.available_amount += metadata.amount_pending
+                trade.status = TradeStatus.OPEN.value
+                trade.updated_at = sell_order.updated_at
+                trade.net_gain -= net_gain
+                trade.cost += cost
+                trade = self.save(trade)
+
+                # Update the position cost
+                position_cost += cost
+                total_net_gain += net_gain
+
+            if metadata.stop_loss_id is not None:
+                stop_loss = self.trade_stop_loss_repository\
+                    .get(metadata.stop_loss_id)
+                stop_loss.sold_amount -= metadata.amount_pending
+                stop_loss.remove_sell_price(
+                    sell_order.price, sell_order.created_at
+                )
+
+                if stop_loss.sold_amount < stop_loss.sell_amount:
+                    stop_loss.active = True
+                    stop_loss.high_water_mark = None
+
+                self.trade_stop_loss_repository.save(stop_loss)
+
+            if metadata.take_profit_id is not None:
+                take_profit = self.trade_take_profit_repository\
+                    .get(metadata.take_profit_id)
+                take_profit.sold_amount -= metadata.amount_pending
+                take_profit.remove_sell_price(
+                    sell_order.price, sell_order.created_at
+                )
+
+                if take_profit.sold_amount < take_profit.sell_amount:
+                    take_profit.active = True
+                    take_profit.high_water_mark = None
+
+                self.trade_take_profit_repository.save(take_profit)
+
+        # Update the position cost
+        position = self.position_repository.find({
+            "order_id": sell_order.id
+        })
+        position.cost += position_cost
+        self.position_repository.save(position)
+
+        # Update the net gain of the portfolio
+        portfolio = self.portfolio_repository.get(position.portfolio_id)
+        portfolio.total_net_gain -= total_net_gain
+        portfolio.net_size -= total_net_gain
+        self.portfolio_repository.save(portfolio)
+        return trade
+
+    def update_trade_with_buy_order(
+        self, filled_difference, buy_order
+    ) -> Trade:
         """
-        Close trade method
+        Function to update a trade from a buy order. This function
+        checks if a trade exists for the buy order. If the given buy
+        order has its status set to CANCLED, EXPIRED, or REJECTED, the
+        trade will object will be removed. If the given buy order has
+        its status set to CLOSED or OPEN, the amount and
+        remaining of the trade object will be updated.
 
-        param trade: Trade object
-        param market: str representing the market
-        raises OperationalException: if trade is already closed
-        or if the buy order belonging to the trade has no amount
+        Args:
+            filled_difference: float representing the difference between the
+                filled amount of the buy order and the filled amount
+                of the trade
+            buy_order: Order object representing the buy order
 
-        return: None
+        Returns:
+            Trade object
         """
+        trade = self.find({"buy_order": buy_order.id})
+        filled = buy_order.get_filled()
+        amount = buy_order.get_amount()
 
-        if trade.closed_at is not None:
-            raise OperationalException("Trade already closed.")
+        if filled is None:
+            filled = trade.filled_amount + filled_difference
 
-        order = self.order_service.get(trade.buy_order_id)
+        remaining = buy_order.get_remaining()
 
-        if order.get_filled() <= 0:
+        if remaining is None:
+            remaining = trade.remaining - filled_difference
+
+        if trade is None:
             raise OperationalException(
-                "Buy order belonging to the trade has no amount."
+                "Trade does not exist for buy order."
+            )
+
+        status = buy_order.get_status()
+
+        if status in \
+                [
+                    OrderStatus.CANCELED.value,
+                    OrderStatus.EXPIRED.value,
+                    OrderStatus.REJECTED.value
+                ]:
+            return self.delete(trade.id)
+
+        trade = self.find({"order_id": buy_order.id})
+        updated_data = {
+            "available_amount": trade.available_amount + filled_difference,
+            "filled_amount": filled,
+            "remaining": remaining,
+            "cost": trade.cost + filled_difference * buy_order.price
+        }
+
+        if amount != trade.amount:
+            updated_data["amount"] = amount
+            updated_data["cost"] = amount * buy_order.price
+
+        if filled_difference > 0:
+            updated_data["status"] = TradeStatus.OPEN.value
+
+        trade = self.update(trade.id, updated_data)
+        return trade
+
+    def update_trade_with_filled_sell_order(
+        self, filled_difference, sell_order
+    ) -> Trade:
+        """
+        Function to update a trade with a filled sell order. This
+        function will update all the metadata objects that where
+        created by the sell order.
+
+        Args:
+            filled_difference: float representing the difference between
+                the filled amount of the sell order and the filled amount
+                of the trade
+            sell_order: Order object representing the sell order
+
+        Returns:
+            Trade object
+        """
+        # Update all metadata objects
+        metadata_objects = self.order_metadata_repository.get_all({
+            "order_id": sell_order.id
+        })
+
+        trade_filled_difference = filled_difference
+        stop_loss_filled_difference = filled_difference
+        take_profit_filled_difference = filled_difference
+        total_amount_in_metadata = 0
+        trade_metadata_objects = []
+
+        for metadata_object in metadata_objects:
+            # Update the trade metadata object
+            if metadata_object.trade_id is not None \
+                    and trade_filled_difference > 0:
+
+                trade_metadata_objects.append(metadata_object)
+                total_amount_in_metadata += metadata_object.amount
+
+                if metadata_object.amount_pending >= trade_filled_difference:
+                    amount = trade_filled_difference
+                    trade_filled_difference = 0
+                else:
+                    amount = metadata_object.amount_pending
+                    trade_filled_difference -= amount
+
+                metadata_object.amount_pending -= amount
+                self.order_metadata_repository.save(metadata_object)
+
+            if metadata_object.stop_loss_id is not None \
+                    and stop_loss_filled_difference > 0:
+
+                if (
+                    metadata_object.amount_pending >=
+                    stop_loss_filled_difference
+                ):
+                    amount = stop_loss_filled_difference
+                    stop_loss_filled_difference = 0
+                else:
+                    amount = metadata_object.amount_pending
+                    stop_loss_filled_difference -= amount
+
+                metadata_object.amount_pending -= amount
+                self.order_metadata_repository.save(metadata_object)
+
+            if metadata_object.take_profit_id is not None \
+                    and take_profit_filled_difference > 0:
+
+                if (
+                    metadata_object.amount_pending >=
+                    take_profit_filled_difference
+                ):
+                    amount = take_profit_filled_difference
+                    take_profit_filled_difference = 0
+                else:
+                    amount = metadata_object.amount_pending
+                    take_profit_filled_difference -= amount
+
+                metadata_object.amount_pending -= amount
+                self.order_metadata_repository.save(metadata_object)
+
+        # Update trade available amount if the total amount in metadata
+        # is not equal to the sell order amount
+        if total_amount_in_metadata != sell_order.amount:
+            difference = sell_order.amount - total_amount_in_metadata
+            trades = []
+
+            for metadata_object in trade_metadata_objects:
+                trade = self.get(metadata_object.trade_id)
+                trades.append(trade)
+
+            # Sort trades by created_at with the most recent first
+            trades = sorted(
+                trades,
+                key=lambda x: x.updated_at,
+                reverse=True
             )
+            queue = PeekableQueue(trades)
+
+            while difference != 0 and not queue.is_empty():
+                trade = queue.dequeue()
+                trade.available_amount -= difference
+                self.save(trade)
+
+    def update_trades_with_market_data(self, market_data):
+        """
+        Function to update trades with market data. This function will
+        update the last reported price and last reported price date of the
+        trade.
+
+        Args:
+            market_data: dict representing the market data
+                that will be used to update the trades
 
-        portfolio = self.portfolio_repository\
-            .find({"position": order.position_id})
-        position = self.position_service.find(
-            {"portfolio": portfolio.id, "symbol": order.get_target_symbol()}
-        )
-        amount = order.get_amount()
-
-        if precision is not None:
-            amount = RoundingService.round_down(amount, precision)
-
-        if position.get_amount() < amount:
-            logger.warning(
-                f"Order amount {amount} is larger then amount "
-                f"of available {position.symbol} "
-                f"position: {position.get_amount()}, "
-                f"changing order amount to size of position"
+        Returns:
+            None
+        """
+        open_trades = self.get_all({"status": TradeStatus.OPEN.value})
+        meta_data = market_data["metadata"]
+
+        for open_trade in open_trades:
+            ohlcv_meta_data = meta_data[DataType.OHLCV]
+
+            if open_trade.symbol not in ohlcv_meta_data:
+                continue
+
+            timeframes = ohlcv_meta_data[open_trade.symbol].keys()
+            sorted_timeframes = sorted(timeframes)
+            most_granular_interval = sorted_timeframes[0]
+            identifier = (
+                ohlcv_meta_data[open_trade.symbol][most_granular_interval]
             )
-            amount = position.get_amount()
-
-        symbol = order.get_symbol()
-        ticker = self.market_data_source_service.get_ticker(
-            symbol=symbol, market=market
-        )
-        self.order_service.create(
-            {
-                "portfolio_id": portfolio.id,
-                "trading_symbol": order.get_trading_symbol(),
-                "target_symbol": order.get_target_symbol(),
-                "amount": amount,
-                "order_side": OrderSide.SELL.value,
-                "order_type": OrderType.LIMIT.value,
-                "price": ticker["bid"],
+            data = market_data[identifier]
+
+            # Get last row of data
+            last_row = data.tail(1)
+            update_data = {
+                "last_reported_price": last_row["Close"][0],
+                "last_reported_price_datetime": last_row["Datetime"][0],
+                "updated_at": last_row["Datetime"][0]
             }
-        )
+            self.update(open_trade.id, update_data)
 
-    def count(self, query_params=None) -> int:
+    def add_stop_loss(
+        self,
+        trade,
+        percentage: float,
+        trailing: bool = False,
+        sell_percentage: float = 100,
+        created_at: datetime = None
+    ) -> TradeStopLoss:
         """
-        Count method
+        Function to add a stop loss to a trade.
+
+        Example of fixed stop loss:
+            * You buy BTC at $40,000.
+            * You set a SL of 5% → SL level at $38,000 (40,000 - 5%).
+            * BTC price increases to $42,000 → SL level remains at $38,000.
+            * BTC price drops to $38,000 → SL level reached, trade closes.
 
-        :param query_params: dict representing the query parameters
-        :return: int representing the count
+        Example of trailing stop loss:
+            * You buy BTC at $40,000.
+            * You set a TSL of 5%, setting the sell price at $38,000.
+            * BTC price increases to $42,000 → New TSL level at
+                $39,900 (42,000 - 5%).
+            * BTC price drops to $39,900 → SL level reached, trade closes.
+
+        Args:
+            trade: Trade object representing the trade
+            percentage: float representing the percentage of the open price
+                that the stop loss should be set at
+            trailing (bool): representing whether the stop loss is a
+                trailing stop loss or not. Default is False.
+            sell_percentage: float representing the percentage of the trade
+                that should be sold if the stop loss is triggered.
+            created_at: datetime representing the creation date of the
+                stop loss. If None, the current datetime will be used.
+
+        Returns:
+            None
         """
+        trade = self.get(trade.id)
 
-        portfolios = self.portfolio_repository.get_all()
-        trades = []
+        # Check if the sell percentage + the existing stop losses is
+        # greater than 100
+        existing_sell_percentage = 0
+        for stop_loss in trade.stop_losses:
+            existing_sell_percentage += stop_loss.sell_percentage
 
-        for portfolio in portfolios:
-            buy_orders = self.order_service.get_all({
-                "status": OrderStatus.CLOSED.value,
-                "order_side": OrderSide.BUY.value,
-                "portfolio_id": portfolio.id
-            })
+        if existing_sell_percentage + sell_percentage > 100:
+            raise OperationalException(
+                "Combined sell percentages of stop losses belonging "
+                "to trade exceeds 100."
+            )
 
-            for buy_order in buy_orders:
-                trades.append(
-                    Trade(
-                        buy_order_id=buy_order.id,
-                        target_symbol=buy_order.get_target_symbol(),
-                        trading_symbol=buy_order.get_trading_symbol(),
-                        amount=buy_order.get_amount(),
-                        open_price=buy_order.get_price(),
-                        closed_price=buy_order.get_trade_closed_price(),
-                        closed_at=buy_order.get_trade_closed_at(),
-                        opened_at=buy_order.get_created_at(),
-                    )
-                )
+        creation_data = {
+            "trade_id": trade.id,
+            "trailing": trailing,
+            "percentage": percentage,
+            "open_price": trade.open_price,
+            "total_amount_trade": trade.amount,
+            "sell_percentage": sell_percentage,
+            "active": True,
+            "created_at": created_at if created_at is not None
+            else datetime.now(tz=timezone.utc)
+        }
+        return self.trade_stop_loss_repository.create(creation_data)
 
-            if query_params is not None:
-                if "status" in query_params:
+    def add_take_profit(
+        self,
+        trade,
+        percentage: float,
+        trailing: bool = False,
+        sell_percentage: float = 100,
+        created_at: datetime = None
+    ) -> TradeTakeProfit:
+        """
+        Function to add a take profit to a trade. This function will add a
+        take profit to the specified trade. If the take profit is triggered,
+        the trade will be closed.
 
-                    trade_status = TradeStatus\
-                        .from_value(query_params["status"])
+        Example of take profit:
+            * You buy BTC at $40,000.
+            * You set a TP of 5% → TP level at $42,000 (40,000 + 5%).
+            * BTC rises to $42,000 → TP level reached, trade
+                closes, securing profit.
 
-                    if trade_status == TradeStatus.OPEN:
-                        trades = [
-                            trade for trade in trades
-                            if trade.closed_at is None
-                        ]
-                    else:
-                        trades = [
-                            trade for trade in trades
-                            if trade.closed_at is not None
-                        ]
+        Example of trailing take profit:
+            * You buy BTC at $40,000
+            * You set a TTP of 5%, setting the sell price at $42,000.
+            * BTC rises to $42,000 → TTP level stays at $42,000.
+            * BTC rises to $45,000 → New TTP level at $42,750.
+            * BTC drops to $42,750 → Trade closes, securing profit.
 
-        return len(trades)
+        Args:
+            trade: Trade object representing the trade
+            percentage (float): representing the percentage of the open price
+                that the stop loss should be set at. This must be a positive
+                number, e.g. 5 for 5%, or 10 for 10%.
+            trailing (bool): representing whether the take profit is a
+                trailing take profit or not. Default is False.
+            sell_percentage (float): representing the percentage of the trade
+                that should be sold if the stop loss is triggered
+            created_at (datetime): datetime representing the creation
+                date of the take profit. If None, the current datetime
+                will be used.
 
-    def close_trades(self, sell_order: Order, amount_to_close: float) -> None:
+        Returns:
+            None
         """
-        Close trades method
+        trade = self.get(trade.id)
+
+        # Check if the sell percentage + the existing stop losses is
+        # greater than 100
+        existing_sell_percentage = 0
+        for take_profit in trade.take_profits:
+            existing_sell_percentage += take_profit.sell_percentage
+
+        if existing_sell_percentage + sell_percentage > 100:
+            raise OperationalException(
+                "Combined sell percentages of stop losses belonging "
+                "to trade exceeds 100."
+            )
+        creation_data = {
+            "trade_id": trade.id,
+            "trailing": trailing,
+            "percentage": percentage,
+            "open_price": trade.open_price,
+            "total_amount_trade": trade.amount,
+            "sell_percentage": sell_percentage,
+            "active": True,
+            "created_at": created_at if created_at is not None
+            else datetime.now(tz=timezone.utc)
+        }
+        return self.trade_take_profit_repository.create(creation_data)
 
-        :param sell_order: Order object representing the sell order
-        :param amount_to_close: float representing the amount to close
-        :return: None
+    def get_triggered_stop_loss_orders(self):
         """
-        logger.info(
-            f"Closing trades for sell order {sell_order.get_id()} "
-            f"amount to close: {amount_to_close}"
-        )
+        Function to get all triggered stop loss orders. This function will
+        return a list of trade ids that have triggered stop losses.
 
-        matching_buy_orders = self.order_service.get_all(
-            {
-                "position": sell_order.position_id,
-                "order_side": OrderSide.BUY.value,
-                "status": OrderStatus.CLOSED.value,
-                "order_by_created_at_asc": True
-            }
-        )
-        matching_buy_orders = [
-            buy_order for buy_order in matching_buy_orders
-            if buy_order.get_trade_closed_at() is None
-        ]
-        order_queue = PriorityQueue()
+        Returns:
+            List of trade ids
+        """
+        sell_orders_data = []
+        query = {"status": TradeStatus.OPEN.value}
+        open_trades = self.get_all(query)
+        to_be_saved_stop_loss_objects = []
 
-        for order in matching_buy_orders:
-            order_queue.put(order)
+        # Group trades by target symbol
+        stop_losses_by_target_symbol = {}
 
-        total_net_gain = 0
-        total_cost = 0
+        for open_trade in open_trades:
+            triggered_stop_losses = []
 
-        while amount_to_close > 0 and not order_queue.empty():
-            buy_order = order_queue.get()
-            closed_amount = buy_order.get_trade_closed_amount()
+            for stop_loss in open_trade.stop_losses:
 
-            # Check if the order has been closed
-            if closed_amount is None:
-                closed_amount = 0
+                if (
+                    stop_loss.active
+                    and stop_loss.has_triggered(open_trade.last_reported_price)
+                ):
+                    triggered_stop_losses.append(stop_loss)
 
-            available_to_close = buy_order.get_filled() - closed_amount
+                to_be_saved_stop_loss_objects.append(stop_loss)
 
-            if amount_to_close >= available_to_close:
-                to_be_closed = available_to_close
-                remaining = amount_to_close - to_be_closed
-                cost = buy_order.get_price() * to_be_closed
-                net_gain = (sell_order.get_price() - buy_order.get_price()) \
-                    * to_be_closed
-                amount_to_close = remaining
-                self.order_service.repository.update(
-                    buy_order.id,
-                    {
-                        "trade_closed_amount": buy_order.get_filled(),
-                        "trade_closed_at": sell_order.get_updated_at(),
-                        "trade_closed_price": sell_order.get_price(),
-                        "net_gain": buy_order.get_net_gain() + net_gain
-                    }
+            if len(triggered_stop_losses) > 0:
+                stop_losses_by_target_symbol[open_trade] = \
+                    triggered_stop_losses
+
+        for trade in stop_losses_by_target_symbol:
+            stop_losses = stop_losses_by_target_symbol[trade]
+            available_amount = trade.available_amount
+            stop_loss_que = PeekableQueue(stop_losses)
+            order_amount = 0
+            stop_loss_metadata = []
+
+            # While there is an available amount and there are stop losses
+            # to process
+            while not stop_loss_que.is_empty() and available_amount > 0:
+                stop_loss = stop_loss_que.dequeue()
+                stop_loss_sell_amount = stop_loss.get_sell_amount()
+
+                if stop_loss_sell_amount <= available_amount:
+                    available_amount = available_amount - stop_loss_sell_amount
+                    stop_loss.active = False
+                    stop_loss.sold_amount += stop_loss_sell_amount
+                    order_amount += stop_loss_sell_amount
+                else:
+                    stop_loss.sold_amount += available_amount
+
+                    # Deactivate stop loss if the filled amount is equal
+                    # to the amount of the trade, meaning that there is
+                    # nothing left to sell
+                    if trade.filled_amount == trade.amount:
+                        stop_loss.active = False
+                    else:
+                        stop_loss.active = True
+
+                    order_amount += available_amount
+                    stop_loss_sell_amount = available_amount
+                    available_amount = 0
+
+                stop_loss_metadata.append({
+                    "stop_loss_id": stop_loss.id,
+                    "amount": stop_loss_sell_amount
+                })
+                stop_loss.add_sell_price(
+                    trade.last_reported_price,
+                    trade.last_reported_price_datetime
                 )
-            else:
-                to_be_closed = amount_to_close
-                net_gain = (sell_order.get_price() - buy_order.get_price()) \
-                    * to_be_closed
-                cost = buy_order.get_price() * amount_to_close
-                closed_amount = buy_order.get_trade_closed_amount()
-
-                if closed_amount is None:
-                    closed_amount = 0
-
-                self.order_service.repository.update(
-                    buy_order.id,
-                    {
-                        "trade_closed_amount": closed_amount + to_be_closed,
-                        "trade_closed_price": sell_order.get_price(),
-                        "net_gain": buy_order.get_net_gain() + net_gain
-                    }
+
+            position = self.position_repository.find({
+                "order_id": trade.orders[0].id
+            })
+            portfolio_id = position.portfolio_id
+            sell_orders_data.append(
+                {
+                    "target_symbol": trade.target_symbol,
+                    "trading_symbol": trade.trading_symbol,
+                    "amount": order_amount,
+                    "price": trade.last_reported_price,
+                    "order_type": OrderType.LIMIT.value,
+                    "order_side": OrderSide.SELL.value,
+                    "portfolio_id": portfolio_id,
+                    "stop_losses": stop_loss_metadata,
+                    "trades": [{
+                        "trade_id": trade.id,
+                        "amount": order_amount
+                    }]
+                }
+            )
+
+        self.trade_stop_loss_repository\
+            .save_objects(to_be_saved_stop_loss_objects)
+        return sell_orders_data
+
+    def get_triggered_take_profit_orders(self):
+        """
+        Function to get all triggered stop loss orders. This function will
+        return a list of trade ids that have triggered stop losses.
+
+        Returns:
+            List of trade objects. A trade object is a dictionary
+        """
+        sell_orders_data = []
+        query = {"status": TradeStatus.OPEN.value}
+        open_trades = self.get_all(query)
+        to_be_saved_take_profit_objects = []
+
+        # Group trades by target symbol
+        take_profits_by_target_symbol = {}
+
+        for open_trade in open_trades:
+            triggered_take_profits = []
+            available_amount = open_trade.available_amount
+
+            # Skip if there is no available amount
+            if available_amount == 0:
+                continue
+
+            for take_profit in open_trade.take_profits:
+                if (
+                    take_profit.active and
+                    take_profit.has_triggered(open_trade.last_reported_price)
+                ):
+                    triggered_take_profits.append(take_profit)
+
+                to_be_saved_take_profit_objects.append(take_profit)
+
+            if len(triggered_take_profits) > 0:
+                take_profits_by_target_symbol[open_trade] = \
+                    triggered_take_profits
+
+        for trade in take_profits_by_target_symbol:
+            take_profits = take_profits_by_target_symbol[trade]
+            available_amount = trade.available_amount
+            take_profit_que = PeekableQueue(take_profits)
+            order_amount = 0
+            take_profit_metadata = []
+
+            # While there is an available amount and there are take profits
+            # to process
+            while not take_profit_que.is_empty() and available_amount > 0:
+                take_profit = take_profit_que.dequeue()
+                take_profit_sell_amount = take_profit.get_sell_amount()
+
+                if take_profit_sell_amount <= available_amount:
+                    available_amount = available_amount - \
+                        take_profit_sell_amount
+                    take_profit.active = False
+                    take_profit.sold_amount += take_profit_sell_amount
+                    order_amount += take_profit_sell_amount
+                else:
+                    take_profit.sold_amount += available_amount
+
+                    # Deactivate take profit if the filled amount is equal
+                    # to the amount of the trade, meaning that there is
+                    # nothing left to sell
+                    if trade.filled_amount == trade.amount:
+                        take_profit.active = False
+                    else:
+                        take_profit.active = True
+
+                    order_amount += available_amount
+                    take_profit_sell_amount = available_amount
+                    available_amount = 0
+
+                take_profit_metadata.append({
+                    "take_profit_id": take_profit.id,
+                    "amount": take_profit_sell_amount
+                })
+
+                take_profit.add_sell_price(
+                    trade.last_reported_price,
+                    trade.last_reported_price_datetime
                 )
-                amount_to_close = 0
 
-            total_net_gain += net_gain
-            total_cost += cost
-
-        # Update the sell order
-        self.order_service.repository.update(
-            sell_order.get_id(),
-            {
-                "trade_closed_amount": sell_order.get_filled(),
-                "trade_closed_at": sell_order.get_updated_at(),
-                "trade_closed_price": sell_order.get_price(),
-                "net_gain": sell_order.get_net_gain() + total_net_gain
-            }
-        )
+            position = self.position_repository.find({
+                "order_id": trade.orders[0].id
+            })
+            portfolio_id = position.portfolio_id
+            sell_orders_data.append(
+                {
+                    "target_symbol": trade.target_symbol,
+                    "trading_symbol": trade.trading_symbol,
+                    "amount": order_amount,
+                    "price": trade.last_reported_price,
+                    "order_type": OrderType.LIMIT.value,
+                    "order_side": OrderSide.SELL.value,
+                    "portfolio_id": portfolio_id,
+                    "take_profits": take_profit_metadata,
+                    "trades": [{
+                        "trade_id": trade.id,
+                        "amount": order_amount
+                    }]
+                }
+            )
+
+        self.trade_take_profit_repository\
+            .save_objects(to_be_saved_take_profit_objects)
+        return sell_orders_data
+
+    def _create_order_id(self) -> str:
+        """
+        Function to create a unique order id. This function will
+        create a unique order id based on the current time and
+        the order id counter.
+
+        Returns:
+            str: Unique order id
+        """
+        unique = False
+        order_id = None
+
+        while not unique:
+            order_id = f"{random_number(8)}-{random_string(8)}"
+
+            if not self.exists({"order_id": order_id}):
+                unique = True
+
+        return order_id