fisk/core/exchanges/oanda.py

from oandapyV20 import API
from oandapyV20.endpoints import accounts, orders, positions, pricing

from core.exchanges import BaseExchange


class OANDAExchange(BaseExchange):
    def call_method(self, request):
        self.client.request(request)
        response = request.response
        if isinstance(response, list):
            response = {"itemlist": response}
        return response

    def connect(self):
        self.client = API(access_token=self.account.api_secret)
        self.account_id = self.account.api_key

    def get_account(self):
        r = accounts.AccountDetails(self.account_id)
        return self.call(r)

    def get_instruments(self):
        r = accounts.AccountInstruments(accountID=self.account_id)
        response = self.call(r)
        return response

    def get_currencies(self, currencies):
        params = {"instruments": ",".join(currencies)}
        r = pricing.PricingInfo(accountID=self.account_id, params=params)
        response = self.call(r)
        return response

    def get_supported_assets(self, response=None):
        if not response:
            response = self.get_instruments()
        return [x["name"] for x in response["itemlist"]]

    def get_balance(self):
        r = accounts.AccountSummary(self.account_id)
        response = self.call(r)
        return float(response["balance"])

    def get_market_value(self, symbol):
        raise NotImplementedError

    def post_trade(self, trade):
        if trade.direction == "sell":
            amount = -trade.amount
        else:
            amount = trade.amount
        data = {
            "order": {
                # "price": "1.5000", - added later
                "stopLossOnFill": {"timeInForce": "GTC", "price": str(trade.stop_loss)},
                "takeProfitOnFill": {"price": str(trade.take_profit)},
                "timeInForce": "GTC",
                "instrument": trade.symbol,
                "units": str(amount),
                "type": trade.type.upper(),
                "positionFill": "DEFAULT",
            }
        }
        if trade.price is not None:
            if trade.type == "limit":
                data["order"]["price"] = str(trade.price)
            elif trade.type == "market":
                data["order"]["priceBound"] = str(trade.price)
        r = orders.OrderCreate(self.account_id, data=data)
        response = self.call(r)
        trade.response = response
        trade.status = "posted"
        trade.order_id = response["id"]
        trade.client_order_id = response["requestID"]
        trade.save()
        return response

    def get_trade(self, trade_id):
        r = accounts.TradeDetails(accountID=self.account_id, tradeID=trade_id)
        return self.call(r)

    def update_trade(self, trade):
        raise NotImplementedError
        # r = orders.OrderReplace(
        #     accountID=self.account_id, orderID=trade.order_id, data=data
        # )
        # self.client.request(r)
        # return r.response

    def cancel_trade(self, trade_id):
        raise NotImplementedError

    def get_position_info(self, symbol):
        r = positions.PositionDetails(self.account_id, symbol)
        return self.call(r)

    def get_all_positions(self):
        items = []
        r = positions.OpenPositions(accountID=self.account_id)
        response = self.call(r)

        for item in response["itemlist"]:
            item["account"] = self.account.name
            item["account_id"] = self.account.id
            item["unrealized_pl"] = float(item["unrealized_pl"])
            items.append(item)
        return items

    def close_all_positions(self):
        # all_positions = self.get_all_positions()

        # for position in all_positions["itemlist"]:
        #     print("POS ITER", position)
        r = positions.PositionClose(accountID=self.account_id)
        response = self.call(r)
        print("CLOSE ALL POSITIONS", response)
        return response