errors.hpp

#pragma once
 
#include "../../core/types.hpp"
 
#include <boost/json.hpp>
 
#include <optional>
#include <string>
#include <string_view>
 
namespace algotradelib::kiwoom {

enum class KiwoomRateLimitLayer {
  NONE,
  ENDPOINT,
  TOTAL,
  GROUP,
};

inline KiwoomRateLimitLayer kiwoom_rate_limit_layer(std::string_view code) noexcept {
  if (code == "1700") {
    return KiwoomRateLimitLayer::ENDPOINT;
  }
  if (code == "1701") {
    return KiwoomRateLimitLayer::TOTAL;
  }
  if (code == "1702") {
    return KiwoomRateLimitLayer::GROUP;
  }
  return KiwoomRateLimitLayer::NONE;
}

inline ErrorCategory kiwoom_error_category(std::string_view code) noexcept {
  // Header-level authentication faults: the authorization field is missing or malformed.
  if (code == "1512" || code == "1513" || code == "1514" || code == "1515" || code == "1516") {
    return ErrorCategory::AUTHENTICATION;
  }
  // Availability, not authentication. Checked before the 80xx sweep below, which it sits inside.
  if (code == "8104" || code == "8200") {
    return ErrorCategory::INVALID_ARGUMENT;
  }
  // The key, the token, the terminal, or the registered IP.
  if (code.size() == 4 && code.front() == '8') {
    return ErrorCategory::AUTHENTICATION;
  }
  if (kiwoom_rate_limit_layer(code) != KiwoomRateLimitLayer::NONE) {
    return ErrorCategory::RATE_LIMIT;
  }
  // 재귀 호출이 발생하여 API 호출을 제한합니다: a throttle, stated as one.
  if (code == "1687") {
    return ErrorCategory::RATE_LIMIT;
  }
  if (code == "1501" || code == "1504" || code == "1505" || code == "1511" || code == "1517" ||
      code == "1901" || code == "1902" || code == "1903") {
    return ErrorCategory::INVALID_ARGUMENT;
  }
  return ErrorCategory::PROTOCOL;
}

inline std::optional<BrokerError> kiwoom_declared_error(const boost::json::object& document) {
  const auto code = document.if_contains("return_code");
  if (!code) {
    return std::nullopt;
  }
  std::string text;
  if (code->is_int64()) {
    text = std::to_string(code->as_int64());
  } else if (code->is_uint64()) {
    text = std::to_string(code->as_uint64());
  } else if (code->is_string()) {
    text = std::string(code->as_string());
  } else {
    BrokerError error;
    error.category_ = ErrorCategory::PROTOCOL;
    error.broker_code_ = "invalid_return_code";
    error.message_ = "return_code is neither a number nor a string";
    return error;
  }
  if (text == "0") {
    return std::nullopt;
  }
 
  BrokerError error;
  error.broker_code_ = text;
  error.reached_broker_ = true;
  if (const auto message = document.if_contains("return_msg"); message && message->is_string()) {
    error.message_ = std::string(message->as_string());
  } else {
    error.message_ = "Kiwoom declared return_code " + text;
  }
  error.category_ = kiwoom_error_category(text);
  return error;
}

enum class KiwoomOrderOperation {
  UNCLASSIFIED,
  PLACE,
  AMEND,
  CANCEL,
};

inline std::string_view kiwoom_refusal_code(std::string_view message) noexcept {
  constexpr std::string_view prefix = "[2000](";
  if (message.size() < prefix.size() || message.substr(0, prefix.size()) != prefix || message.back() != ')') {
    return {};
  }
  const auto inner = message.substr(prefix.size(), message.size() - prefix.size() - 1);
  const auto colon = inner.find(':');
  if (colon == std::string_view::npos || colon == 0 || colon + 1 == inner.size()) {
    return {};
  }
  const auto code = inner.substr(0, colon);
  for (const char character : code) {
    if (!((character >= 'A' && character <= 'Z') || (character >= '0' && character <= '9'))) {
      return {};
    }
  }
  return code;
}

inline std::optional<BrokerError> kiwoom_recognized_refusal(
  int http_status,
  const boost::json::object& document,
  KiwoomOrderOperation operation,
  bool demo
) {
  if (http_status != 200) {
    return std::nullopt;
  }
  const auto code = document.if_contains("return_code");
  const bool generic = code && (
    (code->is_int64() && code->as_int64() == 20) || (code->is_uint64() && code->as_uint64() == 20) ||
    (code->is_string() && code->as_string() == "20")
  );
  const auto message = document.if_contains("return_msg");
  if (!generic || !message || !message->is_string()) {
    return std::nullopt;
  }
  const std::string stated(kiwoom_refusal_code(std::string_view(message->as_string())));
  const char* name = "";
  const bool placement = operation == KiwoomOrderOperation::PLACE &&
    (demo ? (stated == "800033" || stated == "RC4057" || stated == "RC4058") : stated == "571445");
  const bool cancellation = operation == KiwoomOrderOperation::CANCEL &&
    (demo ? stated == "RC4033" : stated == "506550");
  if (placement) {
    name = "placement";
  } else if (cancellation) {
    name = "cancellation";
  } else {
    return std::nullopt;
  }
  if (const auto number = document.if_contains("ord_no");
      number && !(number->is_string() && number->as_string().empty())) {
    return std::nullopt;
  }
  for (const char* field : {"cncl_qty", "mdfy_qty"}) {
    const auto quantity = document.if_contains(field);
    if (!quantity) {
      continue;
    }
    if (!quantity->is_string() ||
        std::string_view(quantity->as_string()).find_first_not_of('0') != std::string_view::npos) {
      return std::nullopt;
    }
  }
  BrokerError error;
  error.category_ = ErrorCategory::INVALID_ARGUMENT;
  error.reached_broker_ = true;
  error.http_status_ = http_status;
  error.broker_code_ = stated;
  error.message_ = std::string(message->as_string()) + " (return_code 20; recognized refusal: Kiwoom " +
    (demo ? "demo" : "real") + ", cash " + name + ", " + stated + ")";
  return error;
}
 
} // namespace algotradelib::kiwoom