config/config.cpp

@@ -42,6 +42,7 @@ config::config(
     : m_register_nrf_feature("register_nf", nf_name, false),
       m_log_level_feature("log_level", nf_name, std::string("info")),
       m_http_version(),
+      m_curl_timeout(),
       m_database(DATABASE_CONFIG) {
   logger::logger_registry::register_logger(
       nf_name, LOGGER_NAME, log_stdout, log_rot_file);
@@ -67,6 +68,8 @@ void config::read_from_file(const std::string& file_path) {
           m_register_nrf_feature.from_yaml(elem.second);
         } else if (key == NF_CONFIG_HTTP_NAME) {
           m_http_version.from_yaml(elem.second);
+        } else if (key == NF_CONFIG_CURL_TIMEOUT) {
+          m_curl_timeout.from_yaml(elem.second);
         } else if (key == m_nf_name) {
           const auto nf_ptr = m_nf_map.find(m_nf_name);
           if (nf_ptr == m_nf_map.end()) {
@@ -145,6 +148,7 @@ void config::to_json(nlohmann::json& json_data) {
       m_log_level_feature.to_json();
   json_data[m_register_nrf_feature.get_config_name()] =
       m_register_nrf_feature.to_json();
+  json_data[m_curl_timeout.get_config_name()] = m_curl_timeout.to_json();
   if (m_database.is_set()) {
     json_data[m_database.get_config_name()] = m_database.to_json();
   }
@@ -167,6 +171,10 @@ bool config::from_json(const nlohmann::json& json_data) {
           json_data[m_register_nrf_feature.get_config_name()]);
     }
 
+    if (json_data.find(m_curl_timeout.get_config_name()) != json_data.end()) {
+      m_curl_timeout.from_json(json_data[m_curl_timeout.get_config_name()]);
+    }
+
   } catch (nlohmann::detail::exception& e) {
     // TODO:
   } catch (std::exception& e) {
@@ -187,6 +195,7 @@ bool config::validate() {
   }
   success &= safe_validate_field(m_register_nrf_feature);
   success &= safe_validate_field(m_http_version);
+  success &= safe_validate_field(m_curl_timeout);
   for (auto& nf : m_nf_map) {
     success &= safe_validate_field(*nf.second);
   }
@@ -229,6 +238,8 @@ std::string config::to_string() const {
   out.append(m_log_level_feature.to_string(indent));
   out.append(m_register_nrf_feature.to_string(indent));
   out.append(m_http_version.to_string(indent));
+  out.append(m_curl_timeout.to_string(indent));
+
   out.append(m_local_nf->to_string(indent));
   if (m_database.is_set()) {
     out.append(indent).append("Database:\n");
@@ -334,6 +345,10 @@ int config::get_http_version() const {
   return 1;
 }
 
+const uint32_t config::get_curl_timeout() {
+  return m_curl_timeout.get();
+}
+
 bool config::add_nf(
     const std::string& name, const std::shared_ptr<nf>& nf_ptr) {
   m_nf_map.insert(std::make_pair(name, nf_ptr));

config/config.hpp

@@ -104,6 +104,14 @@ const std::string DNNS_CONFIG_NAME = "dnns";
 constexpr auto NF_CONFIG_HTTP_NAME  = "http_version";
 constexpr auto NF_CONFIG_HTTP_LABEL = "HTTP Version";
 
+// HTTP Version
+constexpr auto NF_CONFIG_CURL_TIMEOUT       = "curl_timeout";
+constexpr auto NF_CONFIG_CURL_TIMEOUT_LABEL = "Curl Timeout";
+constexpr uint32_t NF_CONFIG_CURL_TIMEOUT_DEFAULT_VALUE =
+    3000;                                                     // in milliseconds
+constexpr uint32_t NF_CONFIG_CURL_TIMEOUT_MIN_VALUE = 10;     // in milliseconds
+constexpr uint32_t NF_CONFIG_CURL_TIMEOUT_MAX_VALUE = 20000;  // in milliseconds
+
 static std::string get_value_formatter(int level) {
   // TODO use this function everywhere, it is much simpler
   int indent_width        = level * INDENT_WIDTH;
@@ -197,6 +205,7 @@ class config : public config_iface {
   [[nodiscard]] const std::vector<dnn_config>& get_dnns() const override;
 
   [[nodiscard]] int get_http_version() const override;
+  [[nodiscard]] const uint32_t get_curl_timeout();
 
   bool init() override;
 
@@ -222,6 +231,7 @@ class config : public config_iface {
 
   nf_features_config m_log_level_feature;
   nf_http_version m_http_version;
+  curl_timeout m_curl_timeout;
 
   std::shared_ptr<nf> m_local_nf;
 

config/config_types.cpp

@@ -1290,3 +1290,52 @@ void nf_http_version::validate() {
 const std::string& nf_http_version::get_http_version() const {
   return m_version.get_value();
 }
+
+curl_timeout::curl_timeout() {
+  m_set          = false;
+  m_curl_timeout = int_config_value(
+      NF_CONFIG_CURL_TIMEOUT, NF_CONFIG_CURL_TIMEOUT_DEFAULT_VALUE);
+  m_curl_timeout.set_validation_interval(
+      NF_CONFIG_CURL_TIMEOUT_MIN_VALUE, NF_CONFIG_CURL_TIMEOUT_MAX_VALUE);
+  m_config_name = NF_CONFIG_CURL_TIMEOUT;
+}
+
+void curl_timeout::from_yaml(const YAML::Node& node) {
+  m_set = true;
+  m_curl_timeout.from_yaml(node);
+}
+
+nlohmann::json curl_timeout::to_json() {
+  nlohmann::json json_data = {};
+  json_data                = m_curl_timeout.to_json();
+  return json_data;
+}
+
+bool curl_timeout::from_json(const nlohmann::json& json_data) {
+  try {
+    m_curl_timeout.from_json(json_data);
+  } catch (nlohmann::detail::exception& e) {
+    // TODO:
+  } catch (std::exception& e) {
+    // TODO:
+  }
+  return false;
+}
+
+std::string curl_timeout::to_string(const std::string& indent) const {
+  std::string out;
+  unsigned int inner_width = get_inner_width(indent.length());
+  out.append(indent).append(fmt::format(
+      BASE_FORMATTER, OUTER_LIST_ELEM, NF_CONFIG_CURL_TIMEOUT_LABEL,
+      inner_width, std::to_string(m_curl_timeout.get_value()) + " (ms)"));
+  return out;
+}
+
+void curl_timeout::validate() {
+  if (!m_set) return;
+  m_curl_timeout.validate();
+}
+
+const uint32_t curl_timeout::get() const {
+  return m_curl_timeout.get_value();
+}

config/config_types.hpp

@@ -441,4 +441,20 @@ class nf_http_version : public config_type {
   [[nodiscard]] const std::string& get_http_version() const;
 };
 
+class curl_timeout : public config_type {
+ private:
+  int_config_value m_curl_timeout{};
+
+ public:
+  explicit curl_timeout();
+
+  void from_yaml(const YAML::Node& node) override;
+  nlohmann::json to_json() override;
+  bool from_json(const nlohmann::json& json_data) override;
+
+  [[nodiscard]] std::string to_string(const std::string& indent) const override;
+  void validate() override;
+  [[nodiscard]] const uint32_t get() const;
+};
+
 }  // namespace oai::config

model/common_model/Helpers.cpp

@@ -141,6 +141,35 @@ bool fromStringValue(const std::string& inStr, double& value) {
   return true;
 }
 
+bool fromStringValue(
+    const std::string& inStr, oai::model::common::PlmnId& value) {
+  nlohmann::json json_value = nlohmann::json::parse(inStr);
+  from_json(json_value, value);
+  return true;
+}
+bool fromStringValue(
+    const std::string& inStr, oai::model::common::Snssai& value) {
+  nlohmann::json json_value = nlohmann::json::parse(inStr);
+  from_json(json_value, value);
+  return true;
+}
+
+bool fromStringValue(
+    const std::string& inStr, oai::model::common::NFType& value) {
+  nlohmann::json json_value = nlohmann::json::parse(inStr);
+  from_json(json_value, value);
+  if (value.getEnumValue() ==
+      NFType_anyOf::eNFType_anyOf::INVALID_VALUE_OPENAPI_GENERATED)
+    return false;
+
+  return true;
+}
+
+bool fromStringValue(const std::string& inStr, oai::model::common::Tai& value) {
+  nlohmann::json::parse(inStr.c_str()).get_to(value);
+  return true;
+}
+
 bool validate_regex(
     const std::string& regex, const std::string& value, std::stringstream& msg,
     const std::string& pathPrefix) {

model/common_model/Helpers.h

@@ -25,6 +25,10 @@
 #include <vector>
 #include <map>
 #include <nlohmann/json.hpp>
+#include "PlmnId.h"
+#include "Snssai.h"
+#include "NFType.h"
+#include "Tai.h"
 
 namespace oai::model::common::helpers {
 
@@ -105,6 +109,14 @@ bool fromStringValue(const std::string& inStr, int64_t& value);
 bool fromStringValue(const std::string& inStr, bool& value);
 bool fromStringValue(const std::string& inStr, float& value);
 bool fromStringValue(const std::string& inStr, double& value);
+bool fromStringValue(
+    const std::string& inStr, oai::model::common::PlmnId& value);
+bool fromStringValue(
+    const std::string& inStr, oai::model::common::Snssai& value);
+bool fromStringValue(
+    const std::string& inStr, oai::model::common::NFType& value);
+bool fromStringValue(const std::string& inStr, oai::model::common::Tai& value);
+
 template<typename T>
 bool fromStringValue(
     const std::vector<std::string>& inStr, std::vector<T>& value) {

model/common_model/LoggingIntervalNrMdt_anyOf.cpp

@@ -96,7 +96,7 @@ void to_json(nlohmann::json& j, const LoggingIntervalNrMdt_anyOf& o) {
     case LoggingIntervalNrMdt_anyOf::eLoggingIntervalNrMdt_anyOf::_640:
       j = "640";
       break;
-    case LoggingIntervalNrMdt_anyOf::eLoggingIntervalNrMdt_anyOf::INFINITY:
+    case LoggingIntervalNrMdt_anyOf::eLoggingIntervalNrMdt_anyOf::_INFINITY:
       j = "infinity";
       break;
   }
@@ -126,7 +126,7 @@ void from_json(const nlohmann::json& j, LoggingIntervalNrMdt_anyOf& o) {
     o.setValue(LoggingIntervalNrMdt_anyOf::eLoggingIntervalNrMdt_anyOf::_640);
   } else if (s == "infinity") {
     o.setValue(
-        LoggingIntervalNrMdt_anyOf::eLoggingIntervalNrMdt_anyOf::INFINITY);
+        LoggingIntervalNrMdt_anyOf::eLoggingIntervalNrMdt_anyOf::_INFINITY);
   } else {
     std::stringstream ss;
     ss << "Unexpected value " << s << " in json"

model/common_model/LoggingIntervalNrMdt_anyOf.h

@@ -46,7 +46,7 @@ class LoggingIntervalNrMdt_anyOf {
     _6144,
     _320,
     _640,
-    INFINITY
+    _INFINITY
   };
 
   /// <summary>

model/common_model/OdbPacketServices.cpp

@@ -37,13 +37,16 @@ bool OdbPacketServices::validate(
   const std::string _pathPrefix =
       pathPrefix.empty() ? "OdbPacketServices" : pathPrefix;
 
+  if (!m_value.validate(msg)) {
+    success = false;
+    msg << _pathPrefix << ": has no value;";
+  }
+
   return success;
 }
 
 bool OdbPacketServices::operator==(const OdbPacketServices& rhs) const {
-  return
-
-      ;
+  return getValue() == rhs.getValue();
 }
 
 bool OdbPacketServices::operator!=(const OdbPacketServices& rhs) const {
@@ -56,4 +59,22 @@ void to_json(nlohmann::json& j, const OdbPacketServices& o) {
 
 void from_json(const nlohmann::json& j, OdbPacketServices& o) {}
 
+OdbPacketServices_anyOf OdbPacketServices::getValue() const {
+  return m_value;
+}
+
+void OdbPacketServices::setValue(OdbPacketServices_anyOf value) {
+  m_value = value;
+}
+
+OdbPacketServices_anyOf::eOdbPacketServices_anyOf
+OdbPacketServices::getEnumValue() const {
+  return m_value.getValue();
+}
+
+void OdbPacketServices::setEnumValue(
+    OdbPacketServices_anyOf::eOdbPacketServices_anyOf value) {
+  m_value.setValue(value);
+}
+
 }  // namespace oai::model::common

model/common_model/OdbPacketServices.h

@@ -19,6 +19,7 @@
 #ifndef OdbPacketServices_H_
 #define OdbPacketServices_H_
 
+#include "OdbPacketServices_anyOf.h"
 #include "NullValue.h"
 #include <nlohmann/json.hpp>
 
@@ -59,7 +60,13 @@ class OdbPacketServices {
   friend void to_json(nlohmann::json& j, const OdbPacketServices& o);
   friend void from_json(const nlohmann::json& j, OdbPacketServices& o);
 
+  OdbPacketServices_anyOf getValue() const;
+  void setValue(OdbPacketServices_anyOf value);
+  OdbPacketServices_anyOf::eOdbPacketServices_anyOf getEnumValue() const;
+  void setEnumValue(OdbPacketServices_anyOf::eOdbPacketServices_anyOf value);
+
  protected:
+  OdbPacketServices_anyOf m_value;
 };
 
 }  // namespace oai::model::common

model/common_model/OdbPacketServices_anyOf.cpp

+/**
+ * Common Data Types
+ * Common Data Types for Service Based Interfaces. © 2022, 3GPP Organizational
+ * Partners (ARIB, ATIS, CCSA, ETSI, TSDSI, TTA, TTC). All rights reserved.
+ *
+ * The version of the OpenAPI document: 1.2.7
+ *
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator
+ * (https://openapi-generator.tech). https://openapi-generator.tech Do not edit
+ * the class manually.
+ */
+
+#include "OdbPacketServices_anyOf.h"
+#include "Helpers.h"
+#include <stdexcept>
+#include <sstream>
+
+namespace oai::model::common {
+
+OdbPacketServices_anyOf::OdbPacketServices_anyOf() {}
+
+void OdbPacketServices_anyOf::validate() const {
+  std::stringstream msg;
+  if (!validate(msg)) {
+    throw oai::model::common::helpers::ValidationException(msg.str());
+  }
+}
+
+bool OdbPacketServices_anyOf::validate(std::stringstream& msg) const {
+  return validate(msg, "");
+}
+
+bool OdbPacketServices_anyOf::validate(
+    std::stringstream& msg, const std::string& pathPrefix) const {
+  bool success = true;
+  const std::string _pathPrefix =
+      pathPrefix.empty() ? "OdbPacketServices_anyOf" : pathPrefix;
+
+  if (m_value == OdbPacketServices_anyOf::eOdbPacketServices_anyOf::
+                     INVALID_VALUE_OPENAPI_GENERATED) {
+    success = false;
+    msg << _pathPrefix << ": has no value;";
+  }
+
+  return success;
+}
+
+bool OdbPacketServices_anyOf::operator==(
+    const OdbPacketServices_anyOf& rhs) const {
+  return getValue() == rhs.getValue();
+}
+
+bool OdbPacketServices_anyOf::operator!=(
+    const OdbPacketServices_anyOf& rhs) const {
+  return !(*this == rhs);
+}
+
+void to_json(nlohmann::json& j, const OdbPacketServices_anyOf& o) {
+  j = nlohmann::json();
+
+  switch (o.getValue()) {
+    case OdbPacketServices_anyOf::eOdbPacketServices_anyOf::
+        INVALID_VALUE_OPENAPI_GENERATED:
+      j = "INVALID_VALUE_OPENAPI_GENERATED";
+      break;
+    case OdbPacketServices_anyOf::eOdbPacketServices_anyOf::ALL_PACKET_SERVICES:
+      j = "ALL_PACKET_SERVICES";
+      break;
+    case OdbPacketServices_anyOf::eOdbPacketServices_anyOf::
+        ROAMER_ACCESS_HPLMN_AP:
+      j = "ROAMER_ACCESS_HPLMN_AP";
+      break;
+    case OdbPacketServices_anyOf::eOdbPacketServices_anyOf::
+        ROAMER_ACCESS_VPLMN_AP:
+      j = "ROAMER_ACCESS_VPLMN_AP";
+      break;
+    case OdbPacketServices_anyOf::eOdbPacketServices_anyOf::NULL_VALUE:
+      j = nullptr;
+      break;
+  }
+}
+
+void from_json(const nlohmann::json& j, OdbPacketServices_anyOf& o) {
+  if (j.is_null()) {
+    o.setValue(OdbPacketServices_anyOf::eOdbPacketServices_anyOf::NULL_VALUE);
+    return;
+  }
+
+  auto s = j.get<std::string>();
+  if (s == "ALL_PACKET_SERVICES") {
+    o.setValue(
+        OdbPacketServices_anyOf::eOdbPacketServices_anyOf::ALL_PACKET_SERVICES);
+  } else if (s == "ROAMER_ACCESS_HPLMN_AP") {
+    o.setValue(OdbPacketServices_anyOf::eOdbPacketServices_anyOf::
+                   ROAMER_ACCESS_HPLMN_AP);
+  } else if (s == "ROAMER_ACCESS_VPLMN_AP") {
+    o.setValue(OdbPacketServices_anyOf::eOdbPacketServices_anyOf::
+                   ROAMER_ACCESS_VPLMN_AP);
+  } else if (s == "null") {
+    o.setValue(OdbPacketServices_anyOf::eOdbPacketServices_anyOf::NULL_VALUE);
+  }
+
+  else {
+    std::stringstream ss;
+    ss << "Unexpected value " << s << " in json"
+       << " cannot be converted to enum of type"
+       << " OdbPacketServices_anyOf::eOdbPacketServices_anyOf";
+    throw std::invalid_argument(ss.str());
+  }
+}
+
+OdbPacketServices_anyOf::eOdbPacketServices_anyOf
+OdbPacketServices_anyOf::getValue() const {
+  return m_value;
+}
+
+void OdbPacketServices_anyOf::setValue(
+    OdbPacketServices_anyOf::eOdbPacketServices_anyOf value) {
+  m_value = value;
+}
+
+}  // namespace oai::model::common

model/common_model/OdbPacketServices_anyOf.h

+/**
+ * Common Data Types
+ * Common Data Types for Service Based Interfaces. © 2022, 3GPP Organizational
+ * Partners (ARIB, ATIS, CCSA, ETSI, TSDSI, TTA, TTC). All rights reserved.
+ *
+ * The version of the OpenAPI document: 1.2.7
+ *
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator
+ * (https://openapi-generator.tech). https://openapi-generator.tech Do not edit
+ * the class manually.
+ */
+/*
+ * OdbPacketServices_anyOf.h
+ *
+ *
+ */
+#ifndef OdbPacketServices_anyOf_H_
+#define OdbPacketServices_anyOf_H_
+
+#include <nlohmann/json.hpp>
+
+namespace oai::model::common {
+
+/// <summary>
+///
+/// </summary>
+class OdbPacketServices_anyOf {
+ public:
+  OdbPacketServices_anyOf();
+  virtual ~OdbPacketServices_anyOf() = default;
+
+  enum class eOdbPacketServices_anyOf {
+    // To have a valid default value.
+    // Avoiding name clashes with user defined
+    // enum values
+    INVALID_VALUE_OPENAPI_GENERATED = 0,
+    ALL_PACKET_SERVICES,
+    NULL_VALUE,
+    ROAMER_ACCESS_HPLMN_AP,
+    ROAMER_ACCESS_VPLMN_AP
+  };
+
+  /// <summary>
+  /// Validate the current data in the model. Throws a ValidationException on
+  /// failure.
+  /// </summary>
+  void validate() const;
+
+  /// <summary>
+  /// Validate the current data in the model. Returns false on error and writes
+  /// an error message into the given stringstream.
+  /// </summary>
+  bool validate(std::stringstream& msg) const;
+
+  /// <summary>
+  /// Helper overload for validate. Used when one model stores another model and
+  /// calls it's validate. Not meant to be called outside that case.
+  /// </summary>
+  bool validate(std::stringstream& msg, const std::string& pathPrefix) const;
+
+  bool operator==(const OdbPacketServices_anyOf& rhs) const;
+  bool operator!=(const OdbPacketServices_anyOf& rhs) const;
+
+  /////////////////////////////////////////////
+  /// OdbPacketServices_anyOf members
+
+  OdbPacketServices_anyOf::eOdbPacketServices_anyOf getValue() const;
+  void setValue(OdbPacketServices_anyOf::eOdbPacketServices_anyOf value);
+
+  friend void to_json(nlohmann::json& j, const OdbPacketServices_anyOf& o);
+  friend void from_json(const nlohmann::json& j, OdbPacketServices_anyOf& o);
+
+ protected:
+  OdbPacketServices_anyOf::eOdbPacketServices_anyOf m_value =
+      OdbPacketServices_anyOf::eOdbPacketServices_anyOf::
+          INVALID_VALUE_OPENAPI_GENERATED;
+};
+
+}  // namespace oai::model::common
+
+#endif /* OdbPacketServices_anyOf_H_ */

model/common_model/PatchItem.cpp

@@ -110,10 +110,10 @@ bool PatchItem::fromIsSet() const {
 void PatchItem::unsetFrom() {
   m_FromIsSet = false;
 }
-nlohmann::json PatchItem::getValue() const {
+std::string PatchItem::getValue() const {
   return m_Value;
 }
-void PatchItem::setValue(nlohmann::json const& value) {
+void PatchItem::setValue(std::string const& value) {
   m_Value      = value;
   m_ValueIsSet = true;
 }

model/common_model/PatchItem.h

@@ -78,8 +78,8 @@ class PatchItem {
   /// <summary>
   ///
   /// </summary>
-  nlohmann::json getValue() const;
-  void setValue(nlohmann::json const& value);
+  std::string getValue() const;
+  void setValue(std::string const& value);
   bool valueIsSet() const;
   void unsetValue();
 
@@ -93,7 +93,7 @@ class PatchItem {
 
   std::string m_From;
   bool m_FromIsSet;
-  nlohmann::json m_Value;
+  std::string m_Value;
   bool m_ValueIsSet;
 };
 

utils/conv.hpp

@@ -65,7 +65,9 @@ static void fix_primitive_json_values(
             continue;
           }
         } else {
-          int val       = std::stoi(e);
+          size_t chars_processed = 0;
+          int val                = std::stoi(e, &chars_processed);
+          if (chars_processed != e.length()) throw std::invalid_argument("");
           j[elem.key()] = val;  // replace with int
         }
       } catch (std::invalid_argument& ex) {