More robust API request/response handling (#70)

* Add `User-Agent` header to all requests. * Put all GET request parameters in URL as query params. * Check response MIME type and throw an error if not JSON.
krazkidd · Jul 31, 2024 · c340558 · c340558
1 parent 7246a3a
commit c340558
Show file tree

Hide file tree

Showing 9 changed files with 190 additions and 101 deletions.
diff --git a/include/api/Api.hpp b/include/api/Api.hpp
@@ -3,6 +3,7 @@
 
 #include <map>
 #include <memory>
+#include <string>
 #include <string_view>
 #include <list>
 #include <variant>
@@ -60,6 +61,7 @@ namespace kdeck
         std::list<std::shared_ptr<MarketPosition>> GetMarketPositions(std::string_view eventTicker = "");
 
     private:
+        std::string userAgent;
         std::string basePath;
         std::shared_ptr<oatpp::parser::json::mapping::ObjectMapper> objectMapper;
         std::shared_ptr<_Api> _api;

diff --git a/include/api/Api.hxx b/include/api/Api.hxx
@@ -35,16 +35,35 @@ namespace kdeck
             case 404:
             case 500:
             case 503:
-                auto errorResponse = response->readBodyToDto<oatpp::Object<ErrorResponse>>(objectMapper.get());
+                oatpp::String contentType = response->getHeaders().get("Content-Type");
 
-                if (errorResponse->error->message)
+                // the MIME type could contain parameters (e.g. "application/json; charset=utf-8")
+                if (contentType->find("application/json") != std::string::npos)
                 {
-                    OATPP_LOGE("Api", "Error => %s", errorResponse->error->message->c_str());
+                    auto errorResponse = response->readBodyToDto<oatpp::Object<ErrorResponse>>(objectMapper.get());
+
+                    if (errorResponse->error->message)
+                    {
+                        OATPP_LOGE("Api", "Error => %s", errorResponse->error->message->c_str());
+                    }
+
+                    return errorResponse.getPtr();
                 }
+                else
+                {
+                    // NOTE: It appears the API may be behind a Web Application Firewall (WAF)
+                    //       and in some cases is rejecting requests with an HTML response. We
+                    //       consider this a hard error and throw, since it violates the spec.
+                    //       Source: https://github.com/krazkidd/kdeck/issues/69
 
-                return errorResponse.getPtr();
+                    oatpp::String errorBody = response->readBodyToString();
+
+                    OATPP_LOGE("Api", "Error => (%s)\n%s", contentType->c_str(), errorBody->c_str());
+
+                    throw std::runtime_error("Unknown API error.");
+                }
         }
 
-        throw std::runtime_error("Unknown JSON error.");
+        throw std::runtime_error("Unknown API error.");
     }
 }
diff --git a/include/api/_Api.hpp b/include/api/_Api.hpp
@@ -1,6 +1,7 @@
 #ifndef _API_HPP
 #define _API_HPP
 
+#include "oatpp/core/Types.hpp"
 #include "oatpp/core/macro/codegen.hpp"
 #include "oatpp/parser/json/mapping/ObjectMapper.hpp"
 #include "oatpp/web/client/ApiClient.hpp"
@@ -26,14 +27,14 @@ namespace kdeck
             headers.put("Content-Type", "application/json");
             headers.put("Accept", "application/json");
         }
-        API_CALL("POST", "{basePath}/login", Login, PATH(String, basePath), BODY_DTO(Object<LoginRequest>, req))
+        API_CALL("POST", "{basePath}/login", Login, HEADER(String, userAgent, "User-Agent"), PATH(String, basePath), BODY_DTO(Object<LoginRequest>, req))
 
         API_CALL_HEADERS(Logout)
         {
             headers.put("Content-Type", "application/json");
             headers.put("Accept", "application/json");
         }
-        API_CALL("POST", "{basePath}/logout", Logout, PATH(String, basePath), AUTHORIZATION(String, authString, "Bearer"))
+        API_CALL("POST", "{basePath}/logout", Logout, HEADER(String, userAgent, "User-Agent"), PATH(String, basePath), AUTHORIZATION(String, authString, "Bearer"))
 
         // exchange /////////////////////////////////////////////////////////////////////
         /////////////////////////////////////////////////////////////////////////////////
@@ -42,19 +43,19 @@ namespace kdeck
         {
             headers.put("Accept", "application/json");
         }
-        API_CALL("GET", "{basePath}/exchange/announcements", GetExchangeAnnouncements, PATH(String, basePath))
+        API_CALL("GET", "{basePath}/exchange/announcements", GetExchangeAnnouncements, HEADER(String, userAgent, "User-Agent"), PATH(String, basePath))
 
         API_CALL_HEADERS(GetExchangeSchedule)
         {
             headers.put("Accept", "application/json");
         }
-        API_CALL("GET", "{basePath}/exchange/schedule", GetExchangeSchedule, PATH(String, basePath))
+        API_CALL("GET", "{basePath}/exchange/schedule", GetExchangeSchedule, HEADER(String, userAgent, "User-Agent"), PATH(String, basePath))
 
         API_CALL_HEADERS(GetExchangeStatus)
         {
             headers.put("Accept", "application/json");
         }
-        API_CALL("GET", "{basePath}/exchange/status", GetExchangeStatus, PATH(String, basePath))
+        API_CALL("GET", "{basePath}/exchange/status", GetExchangeStatus, HEADER(String, userAgent, "User-Agent"), PATH(String, basePath))
 
         // market ///////////////////////////////////////////////////////////////////////
         /////////////////////////////////////////////////////////////////////////////////
@@ -64,54 +65,119 @@ namespace kdeck
             headers.put("Content-Type", "application/json");
             headers.put("Accept", "application/json");
         }
-        API_CALL("GET", "{basePath}/events", GetEvents, PATH(String, basePath), BODY_DTO(Object<EventsRequest>, req))
+        API_CALL(
+            "GET",
+            "{basePath}/events",
+            GetEvents,
+            HEADER(String, userAgent, "User-Agent"),
+            PATH(String, basePath),
+            QUERY(String, cursor),
+            QUERY(Int32, limit),
+            QUERY(String, status),
+            QUERY(String, series_ticker),
+            QUERY(Boolean, with_nested_markets)
+        )
 
         API_CALL_HEADERS(GetEvent)
         {
             headers.put("Content-Type", "application/json");
             headers.put("Accept", "application/json");
         }
-        API_CALL("GET", "{basePath}/events/{event_ticker}", GetEvent, PATH(String, basePath), PATH(String, event_ticker), BODY_DTO(Object<EventRequest>, req))
+        API_CALL(
+            "GET",
+            "{basePath}/events/{event_ticker}",
+            GetEvent,
+            HEADER(String, userAgent, "User-Agent"),
+            PATH(String, basePath),
+            PATH(String, event_ticker),
+            QUERY(Boolean, with_nested_markets)
+        )
 
         API_CALL_HEADERS(GetMarkets)
         {
             headers.put("Content-Type", "application/json");
             headers.put("Accept", "application/json");
         }
-        API_CALL("GET", "{basePath}/markets", GetMarkets, PATH(String, basePath), AUTHORIZATION(String, authString, "Bearer"), BODY_DTO(Object<MarketsRequest>, req))
+        API_CALL(
+            "GET",
+            "{basePath}/markets",
+            GetMarkets,
+            HEADER(String, userAgent, "User-Agent"),
+            PATH(String, basePath),
+            AUTHORIZATION(String, authString, "Bearer"),
+            QUERY(String, cursor),
+            QUERY(Int32, limit),
+            QUERY(String, event_ticker),
+            QUERY(String, series_ticker),
+            QUERY(Int64, max_close_ts),
+            QUERY(Int64, min_close_ts),
+            QUERY(String, status),
+            QUERY(String, tickers)
+        )
 
         API_CALL_HEADERS(GetTrades)
         {
             headers.put("Content-Type", "application/json");
             headers.put("Accept", "application/json");
         }
-        API_CALL("GET", "{basePath}/markets/trades", GetTrades, PATH(String, basePath), BODY_DTO(Object<TradesRequest>, req))
+        API_CALL(
+            "GET",
+            "{basePath}/markets/trades",
+            GetTrades,
+            HEADER(String, userAgent, "User-Agent"),
+            PATH(String, basePath),
+            QUERY(String, cursor),
+            QUERY(Int32, limit),
+            QUERY(String, ticker),
+            QUERY(Int64, min_ts),
+            QUERY(Int64, max_ts)
+        )
 
         API_CALL_HEADERS(GetMarket)
         {
             headers.put("Accept", "application/json");
         }
-        API_CALL("GET", "{basePath}/markets/{ticker}", GetMarket, PATH(String, basePath), PATH(String, ticker))
+        API_CALL("GET", "{basePath}/markets/{ticker}", GetMarket, HEADER(String, userAgent, "User-Agent"), PATH(String, basePath), PATH(String, ticker))
 
         API_CALL_HEADERS(GetMarketOrderbook)
         {
             headers.put("Content-Type", "application/json");
             headers.put("Accept", "application/json");
         }
-        API_CALL("GET", "{basePath}/markets/{ticker}/orderbook", GetMarketOrderbook, PATH(String, basePath), AUTHORIZATION(String, authString, "Bearer"), QUERY(String, ticker), BODY_DTO(Object<MarketOrderbookRequest>, req))
+        API_CALL(
+            "GET",
+            "{basePath}/markets/{ticker}/orderbook",
+            GetMarketOrderbook,
+            HEADER(String, userAgent, "User-Agent"),
+            PATH(String, basePath),
+            AUTHORIZATION(String, authString, "Bearer"),
+            QUERY(String, ticker),
+            QUERY(Int32, depth)
+        )
 
         API_CALL_HEADERS(GetSeries)
         {
             headers.put("Accept", "application/json");
         }
-        API_CALL("GET", "{basePath}/series/{series_ticker}", GetSeries, PATH(String, basePath), PATH(String, series_ticker))
+        API_CALL("GET", "{basePath}/series/{series_ticker}", GetSeries, HEADER(String, userAgent, "User-Agent"), PATH(String, basePath), PATH(String, series_ticker))
 
         API_CALL_HEADERS(GetMarketCandlesticks)
         {
             headers.put("Content-Type", "application/json");
             headers.put("Accept", "application/json");
         }
-        API_CALL("GET", "{basePath}/series/{series_ticker}/markets/{ticker}/candlesticks", GetMarketCandlesticks, PATH(String, basePath), AUTHORIZATION(String, authString, "Bearer"), PATH(String, series_ticker), PATH(String, ticker), BODY_DTO(Object<MarketCandlesticksRequest>, req))
+        API_CALL(
+            "GET",
+            "{basePath}/series/{series_ticker}/markets/{ticker}/candlesticks",
+            GetMarketCandlesticks,
+            HEADER(String, userAgent, "User-Agent"),
+            PATH(String, basePath),
+            AUTHORIZATION(String, authString, "Bearer"),
+            PATH(String, series_ticker), PATH(String, ticker),
+            QUERY(Int64, start_ts),
+            QUERY(Int64, end_ts),
+            QUERY(Int64, period_interval)
+        )
 
         // portfolio ////////////////////////////////////////////////////////////////////
         /////////////////////////////////////////////////////////////////////////////////
@@ -120,70 +186,119 @@ namespace kdeck
         {
             headers.put("Accept", "application/json");
         }
-        API_CALL("GET", "{basePath}/portfolio/balance", GetBalance, PATH(String, basePath), AUTHORIZATION(String, authString, "Bearer"))
+        API_CALL("GET", "{basePath}/portfolio/balance", GetBalance, HEADER(String, userAgent, "User-Agent"), PATH(String, basePath), AUTHORIZATION(String, authString, "Bearer"))
 
         API_CALL_HEADERS(GetFills)
         {
             headers.put("Content-Type", "application/json");
             headers.put("Accept", "application/json");
         }
-        API_CALL("GET", "{basePath}/portfolio/fills", GetFills, PATH(String, basePath), AUTHORIZATION(String, authString, "Bearer"), BODY_DTO(Object<FillsRequest>, req))
+        API_CALL(
+            "GET",
+            "{basePath}/portfolio/fills",
+            GetFills,
+            HEADER(String, userAgent, "User-Agent"),
+            PATH(String, basePath),
+            AUTHORIZATION(String, authString, "Bearer"),
+            QUERY(String, ticker),
+            QUERY(String, order_id),
+            QUERY(Int64, min_ts),
+            QUERY(Int64, max_ts),
+            QUERY(Int32, limit),
+            QUERY(String, cursor)
+        )
 
         API_CALL_HEADERS(GetOrders)
         {
             headers.put("Content-Type", "application/json");
             headers.put("Accept", "application/json");
         }
-        API_CALL("GET", "{basePath}/portfolio/orders", GetOrders, PATH(String, basePath), AUTHORIZATION(String, authString, "Bearer"), BODY_DTO(Object<OrdersRequest>, req))
+        API_CALL(
+            "GET",
+            "{basePath}/portfolio/orders",
+            GetOrders,
+            HEADER(String, userAgent, "User-Agent"),
+            PATH(String, basePath),
+            AUTHORIZATION(String, authString, "Bearer"),
+            QUERY(String, ticker),
+            QUERY(String, event_ticker),
+            QUERY(Int64, min_ts),
+            QUERY(Int64, max_ts),
+            QUERY(String, status),
+            QUERY(String, cursor),
+            QUERY(Int32, limit)
+        )
 
         API_CALL_HEADERS(CreateOrder)
         {
             headers.put("Content-Type", "application/json");
             headers.put("Accept", "application/json");
         }
-        API_CALL("POST", "{basePath}/portfolio/orders", CreateOrder, PATH(String, basePath), AUTHORIZATION(String, authString, "Bearer"), BODY_DTO(Object<CreateOrderRequest>, req))
+        API_CALL("POST", "{basePath}/portfolio/orders", CreateOrder, HEADER(String, userAgent, "User-Agent"), PATH(String, basePath), AUTHORIZATION(String, authString, "Bearer"), BODY_DTO(Object<CreateOrderRequest>, req))
 
         API_CALL_HEADERS(GetOrder)
         {
             headers.put("Content-Type", "application/json");
             headers.put("Accept", "application/json");
         }
-        API_CALL("GET", "{basePath}/portfolio/orders/{order_id}", GetOrder, PATH(String, basePath), AUTHORIZATION(String, authString, "Bearer"), PATH(String, order_id))
+        API_CALL("GET", "{basePath}/portfolio/orders/{order_id}", GetOrder, HEADER(String, userAgent, "User-Agent"), PATH(String, basePath), AUTHORIZATION(String, authString, "Bearer"), PATH(String, order_id))
 
         API_CALL_HEADERS(CancelOrder)
         {
             headers.put("Content-Type", "application/json");
             headers.put("Accept", "application/json");
         }
-        API_CALL("DELETE", "{basePath}/portfolio/orders/{order_id}", CancelOrder, PATH(String, basePath), AUTHORIZATION(String, authString, "Bearer"), PATH(String, order_id))
+        API_CALL("DELETE", "{basePath}/portfolio/orders/{order_id}", CancelOrder, HEADER(String, userAgent, "User-Agent"), PATH(String, basePath), AUTHORIZATION(String, authString, "Bearer"), PATH(String, order_id))
 
         API_CALL_HEADERS(AmendOrder)
         {
             headers.put("Content-Type", "application/json");
             headers.put("Accept", "application/json");
         }
-        API_CALL("POST", "{basePath}/portfolio/orders/{order_id}/amend", AmendOrder, PATH(String, basePath), AUTHORIZATION(String, authString, "Bearer"), PATH(String, order_id), BODY_DTO(Object<AmendOrderRequest>, req))
+        API_CALL("POST", "{basePath}/portfolio/orders/{order_id}/amend", AmendOrder, HEADER(String, userAgent, "User-Agent"), PATH(String, basePath), AUTHORIZATION(String, authString, "Bearer"), PATH(String, order_id), BODY_DTO(Object<AmendOrderRequest>, req))
 
         API_CALL_HEADERS(DecreaseOrder)
         {
             headers.put("Content-Type", "application/json");
             headers.put("Accept", "application/json");
         }
-        API_CALL("POST", "{basePath}/portfolio/orders/{order_id}/decrease", DecreaseOrder, PATH(String, basePath), AUTHORIZATION(String, authString, "Bearer"), PATH(String, order_id), BODY_DTO(Object<DecreaseOrderRequest>, req))
+        API_CALL("POST", "{basePath}/portfolio/orders/{order_id}/decrease", DecreaseOrder, HEADER(String, userAgent, "User-Agent"), PATH(String, basePath), AUTHORIZATION(String, authString, "Bearer"), PATH(String, order_id), BODY_DTO(Object<DecreaseOrderRequest>, req))
 
         API_CALL_HEADERS(GetPositions)
         {
             headers.put("Content-Type", "application/json");
             headers.put("Accept", "application/json");
         }
-        API_CALL("GET", "{basePath}/portfolio/positions", GetPositions, PATH(String, basePath), AUTHORIZATION(String, authString, "Bearer"), BODY_DTO(Object<PositionsRequest>, req))
+        API_CALL(
+            "GET",
+            "{basePath}/portfolio/positions",
+            GetPositions,
+            HEADER(String, userAgent, "User-Agent"),
+            PATH(String, basePath),
+            AUTHORIZATION(String, authString, "Bearer"),
+            QUERY(String, cursor),
+            QUERY(Int32, limit),
+            QUERY(String, count_filter),
+            QUERY(String, settlement_status),
+            QUERY(String, ticker),
+            QUERY(String, event_ticker)
+        )
 
         API_CALL_HEADERS(GetPortfolioSettlements)
         {
             headers.put("Content-Type", "application/json");
             headers.put("Accept", "application/json");
         }
-        API_CALL("GET", "{basePath}/portfolio/settlements", GetPortfolioSettlements, PATH(String, basePath), AUTHORIZATION(String, authString, "Bearer"), BODY_DTO(Object<PortfolioSettlementsRequest>, req))
+        API_CALL(
+            "GET",
+            "{basePath}/portfolio/settlements",
+            GetPortfolioSettlements,
+            HEADER(String, userAgent, "User-Agent"),
+            PATH(String, basePath),
+            AUTHORIZATION(String, authString, "Bearer"),
+            QUERY(Int64, limit),
+            QUERY(String, cursor)
+        )
 
     };