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

investing_algorithm_framework/services/order_service/order_service.py

@@ -1,11 +1,7 @@
 import logging
-from datetime import datetime
-from queue import PriorityQueue
-
-from dateutil.tz import tzutc
 
 from investing_algorithm_framework.domain import OrderType, OrderSide, \
-    OperationalException, OrderStatus, MarketService, Order
+    OperationalException, OrderStatus, Order, random_number, INDEX_DATETIME
 from investing_algorithm_framework.services.repository_service \
     import RepositoryService
 
@@ -13,80 +9,221 @@ logger = logging.getLogger("investing_algorithm_framework")
 
 
 class OrderService(RepositoryService):
+    """
+    Service to manage orders. This service will use the provided
+    order executors to execute the orders. The order service is
+    responsible for creating, updating, canceling and deleting orders.
+
+    Attributes:
+        configuration_service (ConfigurationService): The service
+            responsible for managing configurations.
+        order_repository (OrderRepository): The repository
+            responsible for managing orders.
+        position_service (PositionService): The service
+            responsible for managing positions.
+        portfolio_repository (PortfolioRepository): The repository
+            responsible for managing portfolios.
+        portfolio_configuration_service (PortfolioConfigurationService):
+            service responsible for managing portfolio configurations.
+        portfolio_snapshot_service (PortfolioSnapshotService):
+            service responsible for managing portfolio snapshots.
+        market_credential_service (MarketCredentialService):
+            service responsible for managing market credentials.
+        trade_service (TradeService): The service responsible for
+            managing trades.
+    """
 
     def __init__(
         self,
         configuration_service,
         order_repository,
-        market_service: MarketService,
-        position_repository,
+        position_service,
         portfolio_repository,
         portfolio_configuration_service,
         portfolio_snapshot_service,
-        market_credential_service
+        trade_service,
+        portfolio_provider_lookup=None,
+        order_executor_lookup=None,
+        market_credential_service=None
     ):
         super(OrderService, self).__init__(order_repository)
         self.configuration_service = configuration_service
         self.order_repository = order_repository
-        self.market_service: MarketService = market_service
-        self.position_repository = position_repository
+        self.position_service = position_service
         self.portfolio_repository = portfolio_repository
         self.portfolio_configuration_service = portfolio_configuration_service
         self.portfolio_snapshot_service = portfolio_snapshot_service
         self.market_credential_service = market_credential_service
+        self.trade_service = trade_service
+        self._order_executor_lookup = order_executor_lookup
+        self._portfolio_provider_lookup = portfolio_provider_lookup
 
     def create(self, data, execute=True, validate=True, sync=True) -> Order:
+        """
+        Function to create an order. The function will create the order and
+        execute it if execute is set to True. The function will also validate
+        the order if validate is set to True. The function will also sync the
+        portfolio with the order if sync is set to True.
+
+        The following only applies if the order is a sell order:
+
+        If stop_losses, or take_profits are in the data, we assume that the
+        order has been created by a stop loss or take profit. We will then
+        create for the order one or more metadata objects with the
+        amount and stop loss id or take profit id. These objects can later
+        be used to restore the stop loss or take profit to its original state
+        if the order is cancelled or rejected.
+
+        If trades are in the data, we assume that the order has
+        been created by a closing a specific trade. We will then create for
+        the order one metadata object with the amount and trade id. This
+        objects can later be used to restore the trade to its original
+        state if the order is cancelled or rejected.
+
+        If there are no trades in the data, we rely on the trade service to
+        create the metadata objects for the order.
+
+        The metadata objects are needed because for trades, stop losses and
+        take profits we need to know how much of the order has been
+        filled at any given time. If the order is cancelled or rejected we
+        need to add the pending amount back to the trade, stop loss or take
+        profit.
+
+        Args:
+            data: dict - the data to create the order with. Data should have
+                the following format:
+                {
+                    "target_symbol": str,
+                    "trading_symbol": str,
+                    "order_side": str,
+                    "order_type": str,
+                    "amount": float,
+                    "filled" (optional): float, // If set, trades
+                        and positions are synced
+                    "remaining" (optional): float, // Same as filled
+                    "price": float,
+                    "portfolio_id": int
+                    "stop_losses" (optional): list[dict] - list of stop
+                      losses with the following format:
+                        {
+                            "stop_loss_id": float,
+                            "amount": float
+                        }
+                    "take_profits" (optional): list[dict] - list of
+                        take profits with the following format:
+                        {
+                            "take_profit_id": float,
+                            "amount": float
+                        }
+                    "trades" (optional): list[dict] - list of trades
+                        with the following format:
+                        {
+                            "trade_id": int,
+                            "amount": float
+                        }
+                }
+
+            execute: bool - if True the order will be executed
+            validate: bool - if True the order will be validated
+            sync: bool - if True the portfolio will be synced with the order
+
+        Returns:
+            Order: Order object
+        """
         portfolio_id = data["portfolio_id"]
         portfolio = self.portfolio_repository.get(portfolio_id)
+        trades = data.get("trades", [])
+        stop_losses = data.get("stop_losses", [])
+        take_profits = data.get("take_profits", [])
+
+        if "filled" in data:
+            del data["filled"]
+
+        if "remaining" in data:
+            del data["remaining"]
+
+        if "trades" in data:
+            del data["trades"]
+
+        if "stop_losses" in data:
+            del data["stop_losses"]
+
+        if "take_profits" in data:
+            del data["take_profits"]
 
         if validate:
             self.validate_order(data, portfolio)
 
         del data["portfolio_id"]
+        data["target_symbol"] = data["target_symbol"].upper()
         symbol = data["target_symbol"]
+        data["id"] = self._create_order_id()
+
+        order = self.repository.create(data, save=False)
 
         if validate:
             self.validate_order(data, portfolio)
 
+        if execute:
+            order = self.execute_order(order, portfolio)
+
         position = self._create_position_if_not_exists(symbol, portfolio)
-        data["position_id"] = position.id
-        data["remaining"] = data["amount"]
-        data["status"] = OrderStatus.CREATED.value
-        order = self.order_repository.create(data)
+        order.position_id = position.id
+        order = self.order_repository.save(order)
         order_id = order.id
+        order_side = order.order_side
+
+        if OrderSide.SELL.equals(order_side):
+            # Create order metadata if there is a key in the data
+            # for trades, stop_losses or take_profits
+            self.trade_service.create_order_metadata_with_trade_context(
+                sell_order=order,
+                trades=trades,
+                stop_losses=stop_losses,
+                take_profits=take_profits
+            )
+        else:
+            self.trade_service.create_trade_from_buy_order(order)
 
         if sync:
-            if OrderSide.BUY.equals(order.get_order_side()):
+            order = self.get(order_id)
+            if OrderSide.BUY.equals(order_side):
                 self._sync_portfolio_with_created_buy_order(order)
             else:
                 self._sync_portfolio_with_created_sell_order(order)
 
-        self.create_snapshot(portfolio.id, created_at=order.created_at)
-
-        if execute:
-            portfolio.configuration = self.portfolio_configuration_service\
-                .get(portfolio.identifier)
-            self.execute_order(order_id, portfolio)
-
+        order = self.get(order_id)
         return order
 
     def update(self, object_id, data):
+        """
+        Function to update an order. The function will update the order and
+        sync the portfolio, position and trades if the order has been filled.
+
+        If the order has been cancelled, expired or rejected the function will
+        sync the portfolio, position, trades, stop losses, and
+        take profits with the order.
+
+        Args:
+            object_id: int - the id of the order to update
+            data: dict - the data to update the order with
+              the following format:
+                {
+                    "amount": float,
+                    "filled" (optional): float,
+                    "remaining" (optional): float,
+                    "status" (optional): str,
+                }
+
+        Returns:
+            Order: Order object that has been updated
+        """
         previous_order = self.order_repository.get(object_id)
-        trading_symbol_position = self.position_repository.find(
-            {
-                "id": previous_order.position_id,
-                "symbol": previous_order.trading_symbol
-            }
-        )
-        portfolio = self.portfolio_repository.get(
-            trading_symbol_position.portfolio_id
-        )
         new_order = self.order_repository.update(object_id, data)
         filled_difference = new_order.get_filled() \
             - previous_order.get_filled()
 
-        if filled_difference:
-
+        if filled_difference > 0:
             if OrderSide.BUY.equals(new_order.get_order_side()):
                 self._sync_with_buy_order_filled(previous_order, new_order)
             else:
@@ -95,7 +232,6 @@ class OrderService(RepositoryService):
         if "status" in data:
 
             if OrderStatus.CANCELED.equals(new_order.get_status()):
-
                 if OrderSide.BUY.equals(new_order.get_order_side()):
                     self._sync_with_buy_order_cancelled(new_order)
                 else:
@@ -115,65 +251,43 @@ class OrderService(RepositoryService):
                 else:
                     self._sync_with_sell_order_expired(new_order)
 
-        if "updated_at" in data:
-            created_at = data["updated_at"]
-        else:
-            created_at = datetime.now(tz=tzutc())
-
-        self.create_snapshot(portfolio.id, created_at=created_at)
         return new_order
 
-    def execute_order(self, order_id, portfolio):
-        order = self.get(order_id)
+    def execute_order(self, order, portfolio) -> Order:
+        """
+        Function to execute an order. The function will execute the order
+        with a matching order executor. The function will also update
+        the order attributes with the external order attributes.
 
-        try:
-            if OrderType.LIMIT.equals(order.get_order_type()):
-
-                if OrderSide.BUY.equals(order.get_order_side()):
-                    external_order = self.market_service\
-                        .create_limit_buy_order(
-                            target_symbol=order.get_target_symbol(),
-                            trading_symbol=order.get_trading_symbol(),
-                            amount=order.get_amount(),
-                            price=order.get_price(),
-                            market=portfolio.get_market()
-                        )
-                else:
-                    external_order = self.market_service\
-                        .create_limit_sell_order(
-                            target_symbol=order.get_target_symbol(),
-                            trading_symbol=order.get_trading_symbol(),
-                            amount=order.get_amount(),
-                            price=order.get_price(),
-                            market=portfolio.get_market()
-                        )
-            else:
-                if OrderSide.BUY.equals(order.get_order_side()):
-                    raise OperationalException(
-                        "Market buy order not supported"
-                    )
-                else:
-                    external_order = self.market_service\
-                        .create_market_sell_order(
-                            target_symbol=order.get_target_symbol(),
-                            trading_symbol=order.get_trading_symbol(),
-                            amount=order.get_amount(),
-                            market=portfolio.get_market()
-                        )
-
-            data = external_order.to_dict()
-            data["status"] = OrderStatus.OPEN.value
-            data["updated_at"] = datetime.now(tz=tzutc())
-            return self.update(order_id, data)
-        except Exception as e:
-            logger.error("Error executing order: {}".format(e))
-            return self.update(
-                order_id,
-                {
-                    "status": OrderStatus.REJECTED.value,
-                    "updated_at": datetime.now(tz=tzutc())
-                }
-            )
+        Args:
+            order: Order object representing the order to be executed
+            portfolio: Portfolio object representing the portfolio in which
+
+        Returns:
+            order: Order object representing the executed order
+        """
+        logger.info(
+            f"Executing order {order.get_symbol()} with "
+            f"amount {order.get_amount()} "
+            f"and price {order.get_price()}"
+        )
+
+        order_executor = self._order_executor_lookup\
+            .get_order_executor(portfolio.market)
+        market_credential = self.market_credential_service.get(
+            portfolio.market
+        )
+        external_order = order_executor.execute_order(
+            portfolio, order, market_credential
+        )
+        logger.info(f"Executed order: {external_order.to_dict()}")
+        order.set_external_id(external_order.get_external_id())
+        order.set_status(external_order.get_status())
+        order.set_filled(external_order.get_filled())
+        order.set_remaining(external_order.get_remaining())
+        config = self.configuration_service.config
+        order.updated_at = config[INDEX_DATETIME]
+        return order
 
     def validate_order(self, order_data, portfolio):
 
@@ -185,10 +299,13 @@ class OrderService(RepositoryService):
         if OrderType.LIMIT.equals(order_data["order_type"]):
             self.validate_limit_order(order_data, portfolio)
         else:
-            self.validate_market_order(order_data, portfolio)
+            raise OperationalException(
+                f"Order type {order_data['order_type']} is not supported"
+            )
 
     def validate_sell_order(self, order_data, portfolio):
-        if not self.position_repository.exists(
+
+        if not self.position_service.exists(
             {
                 "symbol": order_data["target_symbol"],
                 "portfolio": portfolio.id
@@ -198,7 +315,7 @@ class OrderService(RepositoryService):
                 "Can't add sell order to non existing position"
             )
 
-        position = self.position_repository\
+        position = self.position_service\
             .find(
                 {
                     "symbol": order_data["target_symbol"],
@@ -208,7 +325,8 @@ class OrderService(RepositoryService):
 
         if position.get_amount() < order_data["amount"]:
             raise OperationalException(
-                "Order amount is larger then amount of open position"
+                f"Order amount {order_data['amount']} is larger " +
+                f"then amount of open position {position.get_amount()}"
             )
 
         if not order_data["trading_symbol"] == portfolio.trading_symbol:
@@ -232,13 +350,20 @@ class OrderService(RepositoryService):
 
         if OrderSide.SELL.equals(order_data["order_side"]):
             amount = order_data["amount"]
-            position = self.position_repository\
+            position = self.position_service\
                 .find(
                     {
                         "portfolio": portfolio.id,
                         "symbol": order_data["target_symbol"]
                     }
                 )
+
+            if amount <= 0:
+                raise OperationalException(
+                    f"Order amount: {amount} {position.symbol}, is "
+                    f"less or equal to 0"
+                )
+
             if amount > position.get_amount():
                 raise OperationalException(
                     f"Order amount: {amount} {position.symbol}, is "
@@ -247,16 +372,23 @@ class OrderService(RepositoryService):
                 )
         else:
             total_price = order_data["amount"] * order_data["price"]
-            unallocated_position = self.position_repository\
+            unallocated_position = self.position_service\
                 .find(
                     {
                         "portfolio": portfolio.id,
                         "symbol": portfolio.trading_symbol
                     }
                 )
-            amount = unallocated_position.get_amount()
+            unallocated_amount = unallocated_position.get_amount()
 
-            if amount < total_price:
+            if unallocated_amount is None:
+                raise OperationalException(
+                    "Unallocated amount of the portfolio is None" +
+                    "can't validate limit order. Please check if " +
+                    "the portfolio configuration is correct"
+                )
+
+            if unallocated_amount < total_price:
                 raise OperationalException(
                     f"Order total: {total_price} "
                     f"{portfolio.trading_symbol}, is "
@@ -264,98 +396,106 @@ class OrderService(RepositoryService):
                     f"{portfolio.trading_symbol} of the portfolio"
                 )
 
-    def validate_market_order(self, order_data, portfolio):
-
-        if OrderSide.BUY.equals(order_data["order_side"]):
-
-            if "amount" not in order_data:
-                raise OperationalException(
-                    f"Market order needs an amount specified in the trading "
-                    f"symbol {order_data['trading_symbol']}"
-                )
-
-            if order_data['amount'] > portfolio.unallocated:
-                raise OperationalException(
-                    f"Market order amount "
-                    f"{order_data['amount']}"
-                    f"{portfolio.trading_symbol.upper()} is larger then "
-                    f"unallocated {portfolio.unallocated} "
-                    f"{portfolio.trading_symbol.upper()}"
-                )
+    def check_pending_orders(self, portfolio=None):
+        """
+        Function to check if
+        """
+        if portfolio is not None:
+            pending_orders = self.get_all(
+                {
+                    "status": OrderStatus.OPEN.value,
+                    "portfolio_id": portfolio.id
+                }
+            )
         else:
-            position = self.position_repository\
-                .find(
-                    {
-                        "symbol": order_data["target_symbol"],
-                        "portfolio": portfolio.id
-                    }
-                )
-
-            if position is None:
-                raise OperationalException(
-                    "Can't add market sell order to non existing position"
-                )
-
-            if order_data['amount'] > position.get_amount():
-                raise OperationalException(
-                    "Sell order amount larger then position size"
-                )
-
-    def check_pending_orders(self):
-        pending_orders = self.get_all({"status": OrderStatus.OPEN.value})
-        logger.info(f"Checking {len(pending_orders)} open orders")
+            pending_orders = self.get_all({"status": OrderStatus.OPEN.value})
 
         for order in pending_orders:
-            position = self.position_repository.get(order.position_id)
+            position = self.position_service.get(order.position_id)
             portfolio = self.portfolio_repository.get(position.portfolio_id)
-            external_order = self.market_service\
-                .get_order(order, market=portfolio.get_market())
+            portfolio_provider = self._portfolio_provider_lookup\
+                .get_portfolio_provider(portfolio.market)
+            market_credential = self.market_credential_service.get(
+                portfolio.market
+            )
+            logger.info(
+                f"Checking {order.get_order_side()} order {order.get_id()} "
+                f"with external id: {order.get_external_id()} "
+                f"at market {portfolio.market}"
+            )
+            external_order = portfolio_provider.get_order(
+                portfolio, order, market_credential
+            )
             self.update(order.id, external_order.to_dict())
 
     def _create_position_if_not_exists(self, symbol, portfolio):
-        if not self.position_repository.exists(
+        if not self.position_service.exists(
             {"portfolio": portfolio.id, "symbol": symbol}
         ):
-            self.position_repository \
+            self.position_service \
                 .create({"portfolio_id": portfolio.id, "symbol": symbol})
-            position = self.position_repository \
+            position = self.position_service \
                 .find({"portfolio": portfolio.id, "symbol": symbol})
         else:
-            position = self.position_repository \
+            position = self.position_service \
                 .find({"portfolio": portfolio.id, "symbol": symbol})
 
         return position
 
     def _sync_portfolio_with_created_buy_order(self, order):
-        position = self.position_repository.get(order.position_id)
-        portfolio = self.portfolio_repository.get(position.portfolio_id)
-        size = order.get_amount() * order.get_price()
-        trading_symbol_position = self.position_repository.find(
-            {
-                "portfolio": portfolio.id,
-                "symbol": portfolio.trading_symbol
-            }
-        )
+        """
+        Function to sync the portfolio and positions with a created buy order.
 
+        Args:
+            order: the order object representing the buy order
+
+        Returns:
+            None
+        """
+        self.position_service.update_positions_with_created_buy_order(
+            order
+        )
+        position = self.position_service.get(order.position_id)
+        portfolio = self.portfolio_repository.get(position.portfolio_id)
+        size = order.get_size()
         self.portfolio_repository.update(
             portfolio.id, {"unallocated": portfolio.get_unallocated() - size}
         )
-        self.position_repository.update(
-            trading_symbol_position.id,
-            {
-                "amount": trading_symbol_position.get_amount() - size
-            }
-        )
 
     def _sync_portfolio_with_created_sell_order(self, order):
-        position = self.position_repository.get(order.position_id)
-        self.position_repository.update(
-            position.id,
-            {
-                "amount": position.get_amount() - order.get_amount()
-            }
+        """
+        Function to sync the portfolio with a created sell order. The
+        function will subtract the amount of the order from the position and
+        the trade amount. If the sell order is already filled, then
+        the function will also update the portfolio and the
+        trading symbol position.
+
+        The portfolio will not be updated because the sell order has not been
+        filled.
+
+        Args:
+            order: Order object representing the sell order
+
+        Returns:
+            None
+        """
+        self.position_service.update_positions_with_created_sell_order(
+            order
         )
 
+        filled = order.get_filled()
+
+        if filled > 0:
+            position = self.position_service.get(order.position_id)
+            portfolio = self.portfolio_repository.get(position.portfolio_id)
+            size = filled * order.get_price()
+            self.portfolio_repository.update(
+                portfolio.id,
+                {
+                    "unallocated": portfolio.get_unallocated() + size
+                }
+            )
+
     def cancel_order(self, order):
         self.check_pending_orders()
         order = self.order_repository.get(order.id)
@@ -365,28 +505,39 @@ class OrderService(RepositoryService):
             if OrderStatus.OPEN.equals(order.status):
                 portfolio = self.portfolio_repository\
                     .find({"position": order.position_id})
-                self.market_service.cancel_order(
-                    order, market=portfolio.get_market()
+                market_credential = self.market_credential_service.get(
+                    portfolio.market
                 )
+                order_executor = self._order_executor_lookup\
+                    .get_order_executor(portfolio.market)
+                order = order_executor\
+                    .cancel_order(portfolio, order, market_credential)
+                self.update(order.id, order.to_dict())
 
     def _sync_with_buy_order_filled(self, previous_order, current_order):
+        """
+        Function to sync the portfolio, position and trades with the
+        filled buy order.
+
+        Args:
+            previous_order: the previous order object
+            current_order:  the current order object
+
+        Returns:
+            None
+        """
+        logger.info("Syncing portfolio with filled buy order")
         filled_difference = current_order.get_filled() - \
-                            previous_order.get_filled()
+            previous_order.get_filled()
         filled_size = filled_difference * current_order.get_price()
 
         if filled_difference <= 0:
             return
 
-        # Update position
-        position = self.position_repository.get(current_order.position_id)
-
-        self.position_repository.update(
-            position.id,
-            {
-                "amount": position.get_amount() + filled_difference,
-                "cost": position.get_cost() + filled_size,
-            }
+        self.position_service.update_positions_with_buy_order_filled(
+            current_order, filled_difference
         )
+        position = self.position_service.get(current_order.position_id)
 
         # Update portfolio
         portfolio = self.portfolio_repository.get(position.portfolio_id)
@@ -399,16 +550,39 @@ class OrderService(RepositoryService):
             }
         )
 
+        self.trade_service.update_trade_with_buy_order(
+            filled_difference, current_order
+        )
+
     def _sync_with_sell_order_filled(self, previous_order, current_order):
+        """
+        Function to sync the portfolio, position and trades with the
+        filled sell order. The function will update the portfolio and
+        position with the filled amount of the order. The function will
+        also update the trades with the filled amount of the order.
+
+        Args:
+            previous_order: Order object representing the previous order
+            current_order: Order object representing the current order
+
+        Returns:
+            None
+        """
         filled_difference = current_order.get_filled() - \
-                            previous_order.get_filled()
+            previous_order.get_filled()
         filled_size = filled_difference * current_order.get_price()
 
         if filled_difference <= 0:
             return
 
+        logger.info(
+            f"Syncing portfolio with filled sell "
+            f"order {current_order.get_id()} with filled amount "
+            f"{filled_difference}"
+        )
+
         # Get position
-        position = self.position_repository.get(current_order.position_id)
+        position = self.position_service.get(current_order.position_id)
 
         # Update the portfolio
         portfolio = self.portfolio_repository.get(position.portfolio_id)
@@ -422,21 +596,35 @@ class OrderService(RepositoryService):
         )
 
         # Update the trading symbol position
-        trading_symbol_position = self.position_repository.find(
+        trading_symbol_position = self.position_service.find(
             {
                 "symbol": portfolio.trading_symbol,
                 "portfolio": portfolio.id
             }
         )
-        self.position_repository.update(
+        self.position_service.update(
             trading_symbol_position.id,
             {
-                "amount": trading_symbol_position.get_amount()
-                + filled_size
+                "amount":
+                    trading_symbol_position.get_amount() + filled_size
             }
         )
 
-        self._close_trades(filled_difference, current_order)
+        # Update the position if the amount has changed
+        if current_order.amount != previous_order.amount:
+            difference = current_order.amount - previous_order.amount
+            cost = difference * current_order.get_price()
+            self.position_service.update(
+                position.id,
+                {
+                    "amount": position.get_amount() - difference,
+                    "cost": position.get_cost() - cost
+                }
+            )
+
+        self.trade_service.update_trade_with_filled_sell_order(
+            filled_difference, current_order
+        )
 
     def _sync_with_buy_order_cancelled(self, order):
         remaining = order.get_amount() - order.get_filled()
@@ -456,13 +644,13 @@ class OrderService(RepositoryService):
         )
 
         # Add the remaining amount to the trading symbol position
-        trading_symbol_position = self.position_repository.find(
+        trading_symbol_position = self.position_service.find(
             {
                 "symbol": portfolio.trading_symbol,
                 "portfolio": portfolio.id
             }
         )
-        self.position_repository.update(
+        self.position_service.update(
             trading_symbol_position.id,
             {
                 "amount": trading_symbol_position.get_amount() + remaining
@@ -473,13 +661,14 @@ class OrderService(RepositoryService):
         remaining = order.get_amount() - order.get_filled()
 
         # Add the remaining back to the position
-        position = self.position_repository.get(order.position_id)
-        self.position_repository.update(
+        position = self.position_service.get(order.position_id)
+        self.position_service.update(
             position.id,
             {
                 "amount": position.get_amount() + remaining
             }
         )
+        self.trade_service.update_trade_with_removed_sell_order(order)
 
     def _sync_with_buy_order_failed(self, order):
         remaining = order.get_amount() - order.get_filled()
@@ -499,13 +688,13 @@ class OrderService(RepositoryService):
         )
 
         # Add the remaining amount to the trading symbol position
-        trading_symbol_position = self.position_repository.find(
+        trading_symbol_position = self.position_service.find(
             {
                 "symbol": portfolio.trading_symbol,
                 "portfolio": portfolio.id
             }
         )
-        self.position_repository.update(
+        self.position_service.update(
             trading_symbol_position.id,
             {
                 "amount": trading_symbol_position.get_amount() + remaining
@@ -516,14 +705,16 @@ class OrderService(RepositoryService):
         remaining = order.get_amount() - order.get_filled()
 
         # Add the remaining back to the position
-        position = self.position_repository.get(order.position_id)
-        self.position_repository.update(
+        position = self.position_service.get(order.position_id)
+        self.position_service.update(
             position.id,
             {
                 "amount": position.get_amount() + remaining
             }
         )
 
+        self.trade_service.update_trade_with_removed_sell_order(order)
+
     def _sync_with_buy_order_expired(self, order):
         remaining = order.get_amount() - order.get_filled()
         size = remaining * order.get_price()
@@ -542,13 +733,13 @@ class OrderService(RepositoryService):
         )
 
         # Add the remaining amount to the trading symbol position
-        trading_symbol_position = self.position_repository.find(
+        trading_symbol_position = self.position_service.find(
             {
                 "symbol": portfolio.trading_symbol,
                 "portfolio": portfolio.id
             }
         )
-        self.position_repository.update(
+        self.position_service.update(
             trading_symbol_position.id,
             {
                 "amount": trading_symbol_position.get_amount() + remaining
@@ -559,14 +750,16 @@ class OrderService(RepositoryService):
         remaining = order.get_amount() - order.get_filled()
 
         # Add the remaining back to the position
-        position = self.position_repository.get(order.position_id)
-        self.position_repository.update(
+        position = self.position_service.get(order.position_id)
+        self.position_service.update(
             position.id,
             {
                 "amount": position.get_amount() + remaining
             }
         )
 
+        self.trade_service.update_trade_with_removed_sell_order(order)
+
     def _sync_with_buy_order_rejected(self, order):
         remaining = order.get_amount() - order.get_filled()
         size = remaining * order.get_price()
@@ -585,13 +778,13 @@ class OrderService(RepositoryService):
         )
 
         # Add the remaining amount to the trading symbol position
-        trading_symbol_position = self.position_repository.find(
+        trading_symbol_position = self.position_service.find(
             {
                 "symbol": portfolio.trading_symbol,
                 "portfolio": portfolio.id
             }
         )
-        self.position_repository.update(
+        self.position_service.update(
             trading_symbol_position.id,
             {
                 "amount": trading_symbol_position.get_amount() + remaining
@@ -602,144 +795,32 @@ class OrderService(RepositoryService):
         remaining = order.get_amount() - order.get_filled()
 
         # Add the remaining back to the position
-        position = self.position_repository.get(order.position_id)
-        self.position_repository.update(
+        position = self.position_service.get(order.position_id)
+        self.position_service.update(
             position.id,
             {
                 "amount": position.get_amount() + remaining
             }
         )
 
-    def _close_trades(self, amount_to_close, sell_order):
-        """
-        Close trades for an executed sell order.
+        self.trade_service.update_trade_with_removed_sell_order(order)
 
-        This method will c
+    def _create_order_id(self):
         """
-        matching_buy_orders = self.order_repository.get_all(
-            {
-                "position": sell_order.position_id,
-                "order_side": OrderSide.BUY.value,
-                "status": OrderStatus.CLOSED.value
-            }
-        )
-        matching_buy_orders = [
-            buy_order for buy_order in matching_buy_orders
-            if buy_order.get_trade_closed_at() is None
-        ]
-        order_queue = PriorityQueue()
-
-        for order in matching_buy_orders:
-            order_queue.put(order)
-
-        total_net_gain = 0
-        total_cost = 0
-
-        while amount_to_close > 0 and not order_queue.empty():
-            buy_order = order_queue.get()
-            closed_amount = buy_order.get_trade_closed_amount()
-
-            # Check if the order has been closed
-            if closed_amount is None:
-                closed_amount = 0
-
-            available_to_close = buy_order.get_filled() - closed_amount
-
-            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_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
-                    }
-                )
-            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
+        Function to create a new order id. The function will
+        create a new order id and return it.
 
-                self.order_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
-                    }
-                )
-                amount_to_close = 0
-
-            total_net_gain += net_gain
-            total_cost += cost
-
-        position = self.position_repository.get(sell_order.position_id)
-
-        # Update portfolio
-        portfolio = self.portfolio_repository.get(position.portfolio_id)
-        self.portfolio_repository.update(
-            portfolio.id,
-            {
-                "total_net_gain": portfolio.get_total_net_gain()
-                + total_net_gain,
-                "total_cost": portfolio.get_total_cost() - total_cost,
-                "net_size": portfolio.get_net_size() + total_net_gain
-            }
-        )
-        # Update the position
-        position = self.position_repository.get(sell_order.position_id)
-        self.position_repository.update(
-            position.id,
-            {
-                "cost": position.get_cost() - total_cost
-            }
-        )
+        Returns:
+            int: The new order id
+        """
 
-        # Update the sell order
-        self.order_repository.update(
-            sell_order.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
-            }
-        )
+        unique = False
+        order_id = None
 
-    def create_snapshot(self, portfolio_id, created_at=None):
+        while not unique:
+            order_id = random_number(12)
 
-        if created_at is None:
-            created_at = datetime.now(tz=tzutc())
+            if not self.repository.exists({"id": order_id}):
+                unique = True
 
-        portfolio = self.portfolio_repository.get(portfolio_id)
-        pending_orders = self.get_all(
-            {
-                "order_side": OrderSide.BUY.value,
-                "status": OrderStatus.OPEN.value,
-                "portfolio_id": portfolio.id
-            }
-        )
-        created_orders = self.get_all(
-            {
-                "order_side": OrderSide.BUY.value,
-                "status": OrderStatus.CREATED.value,
-                "portfolio_id": portfolio.id
-            }
-        )
-        return self.portfolio_snapshot_service.create_snapshot(
-            portfolio,
-            pending_orders=pending_orders,
-            created_orders=created_orders,
-            created_at=created_at
-        )
+        return order_id