Get AuthorizedNetworkSliceInfo from NSSF

src/amf-app/amf_n1.cpp

@@ -3718,18 +3718,21 @@ bool amf_n1::reroute_registration_request(std::shared_ptr<nas_context>& nc) {
     return false;
   }
   // Process NS selection to select the appropriate AMF
-  // TODO: use from OpenAPI
-  authorized_network_slice_info_t authorized_network_slice_info = {};
-
   oai::amf::model::SliceInfoForRegistration slice_info = {};
+  oai::amf::model::AuthorizedNetworkSliceInfo authorized_network_slice_info =
+      {};
+
   if (!get_network_slice_selection(
           nc, amf_app_inst->get_nf_instance(), slice_info,
           authorized_network_slice_info)) {
     return false;
   }
+  // if get_target_amf();
   std::string target_amf = {};
-  // Send N1MessageNotify to the Target AMF
-  send_n1_message_notity(nc, target_amf);
+  if (get_target_amf(nc, target_amf, authorized_network_slice_info)) {
+    // Send N1MessageNotify to the Target AMF
+    send_n1_message_notity(nc, target_amf);
+  }
 
   return true;
 }
@@ -3816,9 +3819,10 @@ bool amf_n1::get_slice_selection_subscription_data_from_conf_file(
 
 //------------------------------------------------------------------------------
 bool amf_n1::get_network_slice_selection(
-    std::shared_ptr<nas_context>& nc, const std::string& nf_instance_id,
-    oai::amf::model::SliceInfoForRegistration& slice_info,
-    authorized_network_slice_info_t& authorized_network_slice_info) {
+    const std::shared_ptr<nas_context>& nc, const std::string& nf_instance_id,
+    const oai::amf::model::SliceInfoForRegistration& slice_info,
+    oai::amf::model::AuthorizedNetworkSliceInfo&
+        authorized_network_slice_info) {
   std::shared_ptr<ue_context> uc = {};
   if (!find_ue_context(
           nc.get()->ran_ue_ngap_id, nc.get()->amf_ue_ngap_id, uc)) {
@@ -3828,7 +3832,6 @@ bool amf_n1::get_network_slice_selection(
 
   if (amf_cfg.support_features.enable_external_nssf) {
     // Get Authorized Network Slice Info from an  external NSSF
-
     std::shared_ptr<itti_n11_network_slice_selection_information> itti_msg =
         std::make_shared<itti_n11_network_slice_selection_information>(
             TASK_AMF_N1, TASK_AMF_N11);
@@ -3856,8 +3859,8 @@ bool amf_n1::get_network_slice_selection(
           itti_msg->get_msg_name());
     }
 
-    bool result = false;
-    boost::future_status status;
+    bool result                 = false;
+    boost::future_status status = {};
     // wait for timeout or ready
     status = f.wait_for(boost::chrono::milliseconds(FUTURE_STATUS_TIMEOUT_MS));
     if (status == boost::future_status::ready) {
@@ -3870,11 +3873,16 @@ bool amf_n1::get_network_slice_selection(
         Logger::ngap().debug(
             "Got Authorized Network Slice Info from NSSF: %s",
             network_slice_info.dump().c_str());
+        from_json(network_slice_info, authorized_network_slice_info);
       } else {
+        Logger::ngap().debug(
+            "Could not get Authorized Network Slice Info from NSSF");
         return false;
       }
 
     } else {
+      Logger::ngap().debug(
+          "Could not get Authorized Network Slice Info from NSSF");
       return false;
     }
 
@@ -3889,13 +3897,23 @@ bool amf_n1::get_network_slice_selection(
 //------------------------------------------------------------------------------
 bool amf_n1::get_network_slice_selection_from_conf_file(
     const std::string& nf_instance_id,
-    oai::amf::model::SliceInfoForRegistration& slice_info,
-    authorized_network_slice_info_t& authorized_network_slice_info) const {
+    const oai::amf::model::SliceInfoForRegistration& slice_info,
+    oai::amf::model::AuthorizedNetworkSliceInfo& authorized_network_slice_info)
+    const {
   // TODO: Get Authorized Network Slice Info from local configuration file
 
   return true;
 }
 
+//------------------------------------------------------------------------------
+bool amf_n1::get_target_amf(
+    const std::shared_ptr<nas_context>& nc, std::string& target_amf,
+    const oai::amf::model::AuthorizedNetworkSliceInfo&
+        authorized_network_slice_info) {
+  // Get Target AMF from AuthorizedNetworkSliceInfo
+  return true;
+}
+
 //------------------------------------------------------------------------------
 void amf_n1::send_n1_message_notity(
     const std::shared_ptr<nas_context>& nc,

src/amf-app/amf_n1.hpp

@@ -51,6 +51,7 @@
 #include "ue_context.hpp"
 #include "itti.hpp"
 #include "SliceInfoForRegistration.h"
+#include "AuthorizedNetworkSliceInfo.h"
 
 namespace amf_application {
 
@@ -228,13 +229,20 @@ class amf_n1 {
   bool check_requested_nssai(
       const std::shared_ptr<nas_context>& nc, const nssai_t& nssai) const;
   bool get_network_slice_selection(
-      std::shared_ptr<nas_context>& nc, const std::string& nf_instance_id,
-      oai::amf::model::SliceInfoForRegistration& slice_info,
-      authorized_network_slice_info_t& authorized_network_slice_info);
+      const std::shared_ptr<nas_context>& nc, const std::string& nf_instance_id,
+      const oai::amf::model::SliceInfoForRegistration& slice_info,
+      oai::amf::model::AuthorizedNetworkSliceInfo&
+          authorized_network_slice_info);
   bool get_network_slice_selection_from_conf_file(
       const std::string& nf_instance_id,
-      oai::amf::model::SliceInfoForRegistration& slice_info,
-      authorized_network_slice_info_t& authorized_network_slice_info) const;
+      const oai::amf::model::SliceInfoForRegistration& slice_info,
+      oai::amf::model::AuthorizedNetworkSliceInfo&
+          authorized_network_slice_info) const;
+
+  bool get_target_amf(
+      const std::shared_ptr<nas_context>& nc, std::string& target_amf,
+      const oai::amf::model::AuthorizedNetworkSliceInfo&
+          authorized_network_slice_info);
 
   void send_n1_message_notity(
       const std::shared_ptr<nas_context>& nc,

src/amf-app/amf_n11.cpp

@@ -618,6 +618,7 @@ void amf_n11::handle_itti_message(
   return;
 }
 
+//------------------------------------------------------------------------------
 void amf_n11::handle_itti_message(
     itti_n11_network_slice_selection_information& itti_msg) {
   Logger::amf_n11().debug(

src/sbi/amf_server/model/AuthorizedNetworkSliceInfo.cpp

+/**
+ * NSSF NS Selection
+ * NSSF Network Slice Selection Service. © 2021, 3GPP Organizational Partners
+ * (ARIB, ATIS, CCSA, ETSI, TSDSI, TTA, TTC). All rights reserved.
+ *
+ * The version of the OpenAPI document: 2.1.2
+ *
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator
+ * (https://openapi-generator.tech). https://openapi-generator.tech Do not edit
+ * the class manually.
+ */
+
+#include "AuthorizedNetworkSliceInfo.h"
+#include "Helpers.h"
+
+#include <sstream>
+
+namespace oai {
+namespace amf {
+namespace model {
+
+AuthorizedNetworkSliceInfo::AuthorizedNetworkSliceInfo() {
+  m_AllowedNssaiListIsSet        = false;
+  m_ConfiguredNssaiIsSet         = false;
+  m_TargetAmfSet                 = "";
+  m_TargetAmfSetIsSet            = false;
+  m_CandidateAmfListIsSet        = false;
+  m_RejectedNssaiInPlmnIsSet     = false;
+  m_RejectedNssaiInTaIsSet       = false;
+  m_NsiInformationIsSet          = false;
+  m_SupportedFeatures            = "";
+  m_SupportedFeaturesIsSet       = false;
+  m_NrfAmfSet                    = "";
+  m_NrfAmfSetIsSet               = false;
+  m_NrfAmfSetNfMgtUri            = "";
+  m_NrfAmfSetNfMgtUriIsSet       = false;
+  m_NrfAmfSetAccessTokenUri      = "";
+  m_NrfAmfSetAccessTokenUriIsSet = false;
+  m_TargetAmfServiceSet          = "";
+  m_TargetAmfServiceSetIsSet     = false;
+}
+
+void AuthorizedNetworkSliceInfo::validate() const {
+  std::stringstream msg;
+  // if (!validate(msg))
+  // {
+  //     throw oai::nssf_server::helpers::ValidationException(msg.str());
+  // }
+}
+
+bool AuthorizedNetworkSliceInfo::validate(std::stringstream& msg) const {
+  return validate(msg, "");
+}
+
+bool AuthorizedNetworkSliceInfo::validate(
+    std::stringstream& msg, const std::string& pathPrefix) const {
+  bool success = true;
+  const std::string _pathPrefix =
+      pathPrefix.empty() ? "AuthorizedNetworkSliceInfo" : pathPrefix;
+
+  if (allowedNssaiListIsSet()) {
+    const std::vector<AllowedNssai>& value = m_AllowedNssaiList;
+    const std::string currentValuePath     = _pathPrefix + ".allowedNssaiList";
+
+    if (value.size() < 1) {
+      success = false;
+      msg << currentValuePath << ": must have at least 1 elements;";
+    }
+    {  // Recursive validation of array elements
+      const std::string oldValuePath = currentValuePath;
+      int i                          = 0;
+      for (const AllowedNssai& value : value) {
+        const std::string currentValuePath =
+            oldValuePath + "[" + std::to_string(i) + "]";
+
+        success = value.validate(msg, currentValuePath + ".allowedNssaiList") &&
+                  success;
+
+        i++;
+      }
+    }
+  }
+
+  if (configuredNssaiIsSet()) {
+    const std::vector<ConfiguredSnssai>& value = m_ConfiguredNssai;
+    const std::string currentValuePath = _pathPrefix + ".configuredNssai";
+
+    if (value.size() < 1) {
+      success = false;
+      msg << currentValuePath << ": must have at least 1 elements;";
+    }
+    {  // Recursive validation of array elements
+      const std::string oldValuePath = currentValuePath;
+      int i                          = 0;
+      for (const ConfiguredSnssai& value : value) {
+        const std::string currentValuePath =
+            oldValuePath + "[" + std::to_string(i) + "]";
+
+        success = value.validate(msg, currentValuePath + ".configuredNssai") &&
+                  success;
+
+        i++;
+      }
+    }
+  }
+
+  if (targetAmfSetIsSet()) {
+    const std::string& value           = m_TargetAmfSet;
+    const std::string currentValuePath = _pathPrefix + ".targetAmfSet";
+  }
+
+  if (candidateAmfListIsSet()) {
+    const std::vector<std::string>& value = m_CandidateAmfList;
+    const std::string currentValuePath    = _pathPrefix + ".candidateAmfList";
+
+    if (value.size() < 1) {
+      success = false;
+      msg << currentValuePath << ": must have at least 1 elements;";
+    }
+    {  // Recursive validation of array elements
+      const std::string oldValuePath = currentValuePath;
+      int i                          = 0;
+      for (const std::string& value : value) {
+        const std::string currentValuePath =
+            oldValuePath + "[" + std::to_string(i) + "]";
+
+        i++;
+      }
+    }
+  }
+
+  if (rejectedNssaiInPlmnIsSet()) {
+    const std::vector<Snssai>& value   = m_RejectedNssaiInPlmn;
+    const std::string currentValuePath = _pathPrefix + ".rejectedNssaiInPlmn";
+
+    if (value.size() < 1) {
+      success = false;
+      msg << currentValuePath << ": must have at least 1 elements;";
+    }
+    {  // Recursive validation of array elements
+      const std::string oldValuePath = currentValuePath;
+      int i                          = 0;
+      for (const Snssai& value : value) {
+        const std::string currentValuePath =
+            oldValuePath + "[" + std::to_string(i) + "]";
+
+        success =
+            value.validate(msg, currentValuePath + ".rejectedNssaiInPlmn") &&
+            success;
+
+        i++;
+      }
+    }
+  }
+
+  if (rejectedNssaiInTaIsSet()) {
+    const std::vector<Snssai>& value   = m_RejectedNssaiInTa;
+    const std::string currentValuePath = _pathPrefix + ".rejectedNssaiInTa";
+
+    if (value.size() < 1) {
+      success = false;
+      msg << currentValuePath << ": must have at least 1 elements;";
+    }
+    {  // Recursive validation of array elements
+      const std::string oldValuePath = currentValuePath;
+      int i                          = 0;
+      for (const Snssai& value : value) {
+        const std::string currentValuePath =
+            oldValuePath + "[" + std::to_string(i) + "]";
+
+        success =
+            value.validate(msg, currentValuePath + ".rejectedNssaiInTa") &&
+            success;
+
+        i++;
+      }
+    }
+  }
+
+  if (supportedFeaturesIsSet()) {
+    const std::string& value           = m_SupportedFeatures;
+    const std::string currentValuePath = _pathPrefix + ".supportedFeatures";
+  }
+
+  return success;
+}
+
+bool AuthorizedNetworkSliceInfo::operator==(
+    const AuthorizedNetworkSliceInfo& rhs) const {
+  return
+
+      ((!allowedNssaiListIsSet() && !rhs.allowedNssaiListIsSet()) ||
+       (allowedNssaiListIsSet() && rhs.allowedNssaiListIsSet() &&
+        getAllowedNssaiList() == rhs.getAllowedNssaiList())) &&
+
+      ((!configuredNssaiIsSet() && !rhs.configuredNssaiIsSet()) ||
+       (configuredNssaiIsSet() && rhs.configuredNssaiIsSet() &&
+        getConfiguredNssai() == rhs.getConfiguredNssai())) &&
+
+      ((!targetAmfSetIsSet() && !rhs.targetAmfSetIsSet()) ||
+       (targetAmfSetIsSet() && rhs.targetAmfSetIsSet() &&
+        getTargetAmfSet() == rhs.getTargetAmfSet())) &&
+
+      ((!candidateAmfListIsSet() && !rhs.candidateAmfListIsSet()) ||
+       (candidateAmfListIsSet() && rhs.candidateAmfListIsSet() &&
+        getCandidateAmfList() == rhs.getCandidateAmfList())) &&
+
+      ((!rejectedNssaiInPlmnIsSet() && !rhs.rejectedNssaiInPlmnIsSet()) ||
+       (rejectedNssaiInPlmnIsSet() && rhs.rejectedNssaiInPlmnIsSet() &&
+        getRejectedNssaiInPlmn() == rhs.getRejectedNssaiInPlmn())) &&
+
+      ((!rejectedNssaiInTaIsSet() && !rhs.rejectedNssaiInTaIsSet()) ||
+       (rejectedNssaiInTaIsSet() && rhs.rejectedNssaiInTaIsSet() &&
+        getRejectedNssaiInTa() == rhs.getRejectedNssaiInTa())) &&
+
+      ((!nsiInformationIsSet() && !rhs.nsiInformationIsSet()) ||
+       (nsiInformationIsSet() && rhs.nsiInformationIsSet() &&
+        getNsiInformation() == rhs.getNsiInformation())) &&
+
+      ((!supportedFeaturesIsSet() && !rhs.supportedFeaturesIsSet()) ||
+       (supportedFeaturesIsSet() && rhs.supportedFeaturesIsSet() &&
+        getSupportedFeatures() == rhs.getSupportedFeatures())) &&
+
+      ((!nrfAmfSetIsSet() && !rhs.nrfAmfSetIsSet()) ||
+       (nrfAmfSetIsSet() && rhs.nrfAmfSetIsSet() &&
+        getNrfAmfSet() == rhs.getNrfAmfSet())) &&
+
+      ((!nrfAmfSetNfMgtUriIsSet() && !rhs.nrfAmfSetNfMgtUriIsSet()) ||
+       (nrfAmfSetNfMgtUriIsSet() && rhs.nrfAmfSetNfMgtUriIsSet() &&
+        getNrfAmfSetNfMgtUri() == rhs.getNrfAmfSetNfMgtUri())) &&
+
+      ((!nrfAmfSetAccessTokenUriIsSet() &&
+        !rhs.nrfAmfSetAccessTokenUriIsSet()) ||
+       (nrfAmfSetAccessTokenUriIsSet() && rhs.nrfAmfSetAccessTokenUriIsSet() &&
+        getNrfAmfSetAccessTokenUri() == rhs.getNrfAmfSetAccessTokenUri())) &&
+
+      ((!targetAmfServiceSetIsSet() && !rhs.targetAmfServiceSetIsSet()) ||
+       (targetAmfServiceSetIsSet() && rhs.targetAmfServiceSetIsSet() &&
+        getTargetAmfServiceSet() == rhs.getTargetAmfServiceSet()))
+
+          ;
+}
+
+bool AuthorizedNetworkSliceInfo::operator!=(
+    const AuthorizedNetworkSliceInfo& rhs) const {
+  return !(*this == rhs);
+}
+
+void to_json(nlohmann::json& j, const AuthorizedNetworkSliceInfo& o) {
+  j = nlohmann::json();
+  if (o.allowedNssaiListIsSet() || !o.m_AllowedNssaiList.empty())
+    j["allowedNssaiList"] = o.m_AllowedNssaiList;
+  if (o.configuredNssaiIsSet() || !o.m_ConfiguredNssai.empty())
+    j["configuredNssai"] = o.m_ConfiguredNssai;
+  if (o.targetAmfSetIsSet()) j["targetAmfSet"] = o.m_TargetAmfSet;
+  if (o.candidateAmfListIsSet() || !o.m_CandidateAmfList.empty())
+    j["candidateAmfList"] = o.m_CandidateAmfList;
+  if (o.rejectedNssaiInPlmnIsSet() || !o.m_RejectedNssaiInPlmn.empty())
+    j["rejectedNssaiInPlmn"] = o.m_RejectedNssaiInPlmn;
+  if (o.rejectedNssaiInTaIsSet() || !o.m_RejectedNssaiInTa.empty())
+    j["rejectedNssaiInTa"] = o.m_RejectedNssaiInTa;
+  if (o.nsiInformationIsSet()) j["nsiInformation"] = o.m_NsiInformation;
+  if (o.supportedFeaturesIsSet())
+    j["supportedFeatures"] = o.m_SupportedFeatures;
+  if (o.nrfAmfSetIsSet()) j["nrfAmfSet"] = o.m_NrfAmfSet;
+  if (o.nrfAmfSetNfMgtUriIsSet())
+    j["nrfAmfSetNfMgtUri"] = o.m_NrfAmfSetNfMgtUri;
+  if (o.nrfAmfSetAccessTokenUriIsSet())
+    j["nrfAmfSetAccessTokenUri"] = o.m_NrfAmfSetAccessTokenUri;
+  if (o.targetAmfServiceSetIsSet())
+    j["targetAmfServiceSet"] = o.m_TargetAmfServiceSet;
+}
+
+void from_json(const nlohmann::json& j, AuthorizedNetworkSliceInfo& o) {
+  if (j.find("allowedNssaiList") != j.end()) {
+    j.at("allowedNssaiList").get_to(o.m_AllowedNssaiList);
+    o.m_AllowedNssaiListIsSet = true;
+  }
+  if (j.find("configuredNssai") != j.end()) {
+    j.at("configuredNssai").get_to(o.m_ConfiguredNssai);
+    o.m_ConfiguredNssaiIsSet = true;
+  }
+  if (j.find("targetAmfSet") != j.end()) {
+    j.at("targetAmfSet").get_to(o.m_TargetAmfSet);
+    o.m_TargetAmfSetIsSet = true;
+  }
+  if (j.find("candidateAmfList") != j.end()) {
+    j.at("candidateAmfList").get_to(o.m_CandidateAmfList);
+    o.m_CandidateAmfListIsSet = true;
+  }
+  if (j.find("rejectedNssaiInPlmn") != j.end()) {
+    j.at("rejectedNssaiInPlmn").get_to(o.m_RejectedNssaiInPlmn);
+    o.m_RejectedNssaiInPlmnIsSet = true;
+  }
+  if (j.find("rejectedNssaiInTa") != j.end()) {
+    j.at("rejectedNssaiInTa").get_to(o.m_RejectedNssaiInTa);
+    o.m_RejectedNssaiInTaIsSet = true;
+  }
+  if (j.find("nsiInformation") != j.end()) {
+    j.at("nsiInformation").get_to(o.m_NsiInformation);
+    o.m_NsiInformationIsSet = true;
+  }
+  if (j.find("supportedFeatures") != j.end()) {
+    j.at("supportedFeatures").get_to(o.m_SupportedFeatures);
+    o.m_SupportedFeaturesIsSet = true;
+  }
+  if (j.find("nrfAmfSet") != j.end()) {
+    j.at("nrfAmfSet").get_to(o.m_NrfAmfSet);
+    o.m_NrfAmfSetIsSet = true;
+  }
+  if (j.find("nrfAmfSetNfMgtUri") != j.end()) {
+    j.at("nrfAmfSetNfMgtUri").get_to(o.m_NrfAmfSetNfMgtUri);
+    o.m_NrfAmfSetNfMgtUriIsSet = true;
+  }
+  if (j.find("nrfAmfSetAccessTokenUri") != j.end()) {
+    j.at("nrfAmfSetAccessTokenUri").get_to(o.m_NrfAmfSetAccessTokenUri);
+    o.m_NrfAmfSetAccessTokenUriIsSet = true;
+  }
+  if (j.find("targetAmfServiceSet") != j.end()) {
+    j.at("targetAmfServiceSet").get_to(o.m_TargetAmfServiceSet);
+    o.m_TargetAmfServiceSetIsSet = true;
+  }
+}
+
+std::vector<AllowedNssai> AuthorizedNetworkSliceInfo::getAllowedNssaiList()
+    const {
+  return m_AllowedNssaiList;
+}
+void AuthorizedNetworkSliceInfo::setAllowedNssaiList(
+    std::vector<AllowedNssai> const& value) {
+  m_AllowedNssaiList      = value;
+  m_AllowedNssaiListIsSet = true;
+}
+bool AuthorizedNetworkSliceInfo::allowedNssaiListIsSet() const {
+  return m_AllowedNssaiListIsSet;
+}
+void AuthorizedNetworkSliceInfo::unsetAllowedNssaiList() {
+  m_AllowedNssaiListIsSet = false;
+}
+std::vector<ConfiguredSnssai> AuthorizedNetworkSliceInfo::getConfiguredNssai()
+    const {
+  return m_ConfiguredNssai;
+}
+void AuthorizedNetworkSliceInfo::setConfiguredNssai(
+    std::vector<ConfiguredSnssai> const& value) {
+  m_ConfiguredNssai      = value;
+  m_ConfiguredNssaiIsSet = true;
+}
+bool AuthorizedNetworkSliceInfo::configuredNssaiIsSet() const {
+  return m_ConfiguredNssaiIsSet;
+}
+void AuthorizedNetworkSliceInfo::unsetConfiguredNssai() {
+  m_ConfiguredNssaiIsSet = false;
+}
+std::string AuthorizedNetworkSliceInfo::getTargetAmfSet() const {
+  return m_TargetAmfSet;
+}
+void AuthorizedNetworkSliceInfo::setTargetAmfSet(std::string const& value) {
+  m_TargetAmfSet      = value;
+  m_TargetAmfSetIsSet = true;
+}
+bool AuthorizedNetworkSliceInfo::targetAmfSetIsSet() const {
+  return m_TargetAmfSetIsSet;
+}
+void AuthorizedNetworkSliceInfo::unsetTargetAmfSet() {
+  m_TargetAmfSetIsSet = false;
+}
+std::vector<std::string> AuthorizedNetworkSliceInfo::getCandidateAmfList()
+    const {
+  return m_CandidateAmfList;
+}
+void AuthorizedNetworkSliceInfo::setCandidateAmfList(
+    std::vector<std::string> const& value) {
+  m_CandidateAmfList      = value;
+  m_CandidateAmfListIsSet = true;
+}
+bool AuthorizedNetworkSliceInfo::candidateAmfListIsSet() const {
+  return m_CandidateAmfListIsSet;
+}
+void AuthorizedNetworkSliceInfo::unsetCandidateAmfList() {
+  m_CandidateAmfListIsSet = false;
+}
+std::vector<Snssai> AuthorizedNetworkSliceInfo::getRejectedNssaiInPlmn() const {
+  return m_RejectedNssaiInPlmn;
+}
+void AuthorizedNetworkSliceInfo::setRejectedNssaiInPlmn(
+    std::vector<Snssai> const& value) {
+  m_RejectedNssaiInPlmn      = value;
+  m_RejectedNssaiInPlmnIsSet = true;
+}
+bool AuthorizedNetworkSliceInfo::rejectedNssaiInPlmnIsSet() const {
+  return m_RejectedNssaiInPlmnIsSet;
+}
+void AuthorizedNetworkSliceInfo::unsetRejectedNssaiInPlmn() {
+  m_RejectedNssaiInPlmnIsSet = false;
+}
+std::vector<Snssai> AuthorizedNetworkSliceInfo::getRejectedNssaiInTa() const {
+  return m_RejectedNssaiInTa;
+}
+void AuthorizedNetworkSliceInfo::setRejectedNssaiInTa(
+    std::vector<Snssai> const& value) {
+  m_RejectedNssaiInTa      = value;
+  m_RejectedNssaiInTaIsSet = true;
+}
+bool AuthorizedNetworkSliceInfo::rejectedNssaiInTaIsSet() const {
+  return m_RejectedNssaiInTaIsSet;
+}
+void AuthorizedNetworkSliceInfo::unsetRejectedNssaiInTa() {
+  m_RejectedNssaiInTaIsSet = false;
+}
+NsiInformation AuthorizedNetworkSliceInfo::getNsiInformation() const {
+  return m_NsiInformation;
+}
+void AuthorizedNetworkSliceInfo::setNsiInformation(
+    NsiInformation const& value) {
+  m_NsiInformation      = value;
+  m_NsiInformationIsSet = true;
+}
+bool AuthorizedNetworkSliceInfo::nsiInformationIsSet() const {
+  return m_NsiInformationIsSet;
+}
+void AuthorizedNetworkSliceInfo::unsetNsiInformation() {
+  m_NsiInformationIsSet = false;
+}
+std::string AuthorizedNetworkSliceInfo::getSupportedFeatures() const {
+  return m_SupportedFeatures;
+}
+void AuthorizedNetworkSliceInfo::setSupportedFeatures(
+    std::string const& value) {
+  m_SupportedFeatures      = value;
+  m_SupportedFeaturesIsSet = true;
+}
+bool AuthorizedNetworkSliceInfo::supportedFeaturesIsSet() const {
+  return m_SupportedFeaturesIsSet;
+}
+void AuthorizedNetworkSliceInfo::unsetSupportedFeatures() {
+  m_SupportedFeaturesIsSet = false;
+}
+std::string AuthorizedNetworkSliceInfo::getNrfAmfSet() const {
+  return m_NrfAmfSet;
+}
+void AuthorizedNetworkSliceInfo::setNrfAmfSet(std::string const& value) {
+  m_NrfAmfSet      = value;
+  m_NrfAmfSetIsSet = true;
+}
+bool AuthorizedNetworkSliceInfo::nrfAmfSetIsSet() const {
+  return m_NrfAmfSetIsSet;
+}
+void AuthorizedNetworkSliceInfo::unsetNrfAmfSet() {
+  m_NrfAmfSetIsSet = false;
+}
+std::string AuthorizedNetworkSliceInfo::getNrfAmfSetNfMgtUri() const {
+  return m_NrfAmfSetNfMgtUri;
+}
+void AuthorizedNetworkSliceInfo::setNrfAmfSetNfMgtUri(
+    std::string const& value) {
+  m_NrfAmfSetNfMgtUri      = value;
+  m_NrfAmfSetNfMgtUriIsSet = true;
+}
+bool AuthorizedNetworkSliceInfo::nrfAmfSetNfMgtUriIsSet() const {
+  return m_NrfAmfSetNfMgtUriIsSet;
+}
+void AuthorizedNetworkSliceInfo::unsetNrfAmfSetNfMgtUri() {
+  m_NrfAmfSetNfMgtUriIsSet = false;
+}
+std::string AuthorizedNetworkSliceInfo::getNrfAmfSetAccessTokenUri() const {
+  return m_NrfAmfSetAccessTokenUri;
+}
+void AuthorizedNetworkSliceInfo::setNrfAmfSetAccessTokenUri(
+    std::string const& value) {
+  m_NrfAmfSetAccessTokenUri      = value;
+  m_NrfAmfSetAccessTokenUriIsSet = true;
+}
+bool AuthorizedNetworkSliceInfo::nrfAmfSetAccessTokenUriIsSet() const {
+  return m_NrfAmfSetAccessTokenUriIsSet;
+}
+void AuthorizedNetworkSliceInfo::unsetNrfAmfSetAccessTokenUri() {
+  m_NrfAmfSetAccessTokenUriIsSet = false;
+}
+std::string AuthorizedNetworkSliceInfo::getTargetAmfServiceSet() const {
+  return m_TargetAmfServiceSet;
+}
+void AuthorizedNetworkSliceInfo::setTargetAmfServiceSet(
+    std::string const& value) {
+  m_TargetAmfServiceSet      = value;
+  m_TargetAmfServiceSetIsSet = true;
+}
+bool AuthorizedNetworkSliceInfo::targetAmfServiceSetIsSet() const {
+  return m_TargetAmfServiceSetIsSet;
+}
+void AuthorizedNetworkSliceInfo::unsetTargetAmfServiceSet() {
+  m_TargetAmfServiceSetIsSet = false;
+}
+
+}  // namespace model
+}  // namespace amf
+}  // namespace oai

src/sbi/amf_server/model/AuthorizedNetworkSliceInfo.h

+/**
+ * NSSF NS Selection
+ * NSSF Network Slice Selection Service. © 2021, 3GPP Organizational Partners
+ * (ARIB, ATIS, CCSA, ETSI, TSDSI, TTA, TTC). All rights reserved.
+ *
+ * The version of the OpenAPI document: 2.1.2
+ *
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator
+ * (https://openapi-generator.tech). https://openapi-generator.tech Do not edit
+ * the class manually.
+ */
+/*
+ * AuthorizedNetworkSliceInfo.h
+ *
+ *
+ */
+
+#ifndef AuthorizedNetworkSliceInfo_H_
+#define AuthorizedNetworkSliceInfo_H_
+
+#include "AllowedNssai.h"
+#include "ConfiguredSnssai.h"
+#include "NsiInformation.h"
+#include "Snssai.h"
+#include <nlohmann/json.hpp>
+#include <string>
+#include <vector>
+
+namespace oai {
+namespace amf {
+namespace model {
+
+/// <summary>
+///
+/// </summary>
+class AuthorizedNetworkSliceInfo {
+ public:
+  AuthorizedNetworkSliceInfo();
+  virtual ~AuthorizedNetworkSliceInfo() = default;
+
+  /// <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 AuthorizedNetworkSliceInfo& rhs) const;
+  bool operator!=(const AuthorizedNetworkSliceInfo& rhs) const;
+
+  /////////////////////////////////////////////
+  /// AuthorizedNetworkSliceInfo members
+
+  /// <summary>
+  ///
+  /// </summary>
+  std::vector<AllowedNssai> getAllowedNssaiList() const;
+  void setAllowedNssaiList(std::vector<AllowedNssai> const& value);
+  bool allowedNssaiListIsSet() const;
+  void unsetAllowedNssaiList();
+  /// <summary>
+  ///
+  /// </summary>
+  std::vector<ConfiguredSnssai> getConfiguredNssai() const;
+  void setConfiguredNssai(std::vector<ConfiguredSnssai> const& value);
+  bool configuredNssaiIsSet() const;
+  void unsetConfiguredNssai();
+  /// <summary>
+  ///
+  /// </summary>
+  std::string getTargetAmfSet() const;
+  void setTargetAmfSet(std::string const& value);
+  bool targetAmfSetIsSet() const;
+  void unsetTargetAmfSet();
+  /// <summary>
+  ///
+  /// </summary>
+  std::vector<std::string> getCandidateAmfList() const;
+  void setCandidateAmfList(std::vector<std::string> const& value);
+  bool candidateAmfListIsSet() const;
+  void unsetCandidateAmfList();
+  /// <summary>
+  ///
+  /// </summary>
+  std::vector<Snssai> getRejectedNssaiInPlmn() const;
+  void setRejectedNssaiInPlmn(std::vector<Snssai> const& value);
+  bool rejectedNssaiInPlmnIsSet() const;
+  void unsetRejectedNssaiInPlmn();
+  /// <summary>
+  ///
+  /// </summary>
+  std::vector<Snssai> getRejectedNssaiInTa() const;
+  void setRejectedNssaiInTa(std::vector<Snssai> const& value);
+  bool rejectedNssaiInTaIsSet() const;
+  void unsetRejectedNssaiInTa();
+  /// <summary>
+  ///
+  /// </summary>
+  NsiInformation getNsiInformation() const;
+  void setNsiInformation(NsiInformation const& value);
+  bool nsiInformationIsSet() const;
+  void unsetNsiInformation();
+  /// <summary>
+  ///
+  /// </summary>
+  std::string getSupportedFeatures() const;
+  void setSupportedFeatures(std::string const& value);
+  bool supportedFeaturesIsSet() const;
+  void unsetSupportedFeatures();
+  /// <summary>
+  ///
+  /// </summary>
+  std::string getNrfAmfSet() const;
+  void setNrfAmfSet(std::string const& value);
+  bool nrfAmfSetIsSet() const;
+  void unsetNrfAmfSet();
+  /// <summary>
+  ///
+  /// </summary>
+  std::string getNrfAmfSetNfMgtUri() const;
+  void setNrfAmfSetNfMgtUri(std::string const& value);
+  bool nrfAmfSetNfMgtUriIsSet() const;
+  void unsetNrfAmfSetNfMgtUri();
+  /// <summary>
+  ///
+  /// </summary>
+  std::string getNrfAmfSetAccessTokenUri() const;
+  void setNrfAmfSetAccessTokenUri(std::string const& value);
+  bool nrfAmfSetAccessTokenUriIsSet() const;
+  void unsetNrfAmfSetAccessTokenUri();
+  /// <summary>
+  ///
+  /// </summary>
+  std::string getTargetAmfServiceSet() const;
+  void setTargetAmfServiceSet(std::string const& value);
+  bool targetAmfServiceSetIsSet() const;
+  void unsetTargetAmfServiceSet();
+
+  friend void to_json(nlohmann::json& j, const AuthorizedNetworkSliceInfo& o);
+  friend void from_json(const nlohmann::json& j, AuthorizedNetworkSliceInfo& o);
+
+ protected:
+  std::vector<AllowedNssai> m_AllowedNssaiList;
+  bool m_AllowedNssaiListIsSet;
+  std::vector<ConfiguredSnssai> m_ConfiguredNssai;
+  bool m_ConfiguredNssaiIsSet;
+  std::string m_TargetAmfSet;
+  bool m_TargetAmfSetIsSet;
+  std::vector<std::string> m_CandidateAmfList;
+  bool m_CandidateAmfListIsSet;
+  std::vector<Snssai> m_RejectedNssaiInPlmn;
+  bool m_RejectedNssaiInPlmnIsSet;
+  std::vector<Snssai> m_RejectedNssaiInTa;
+  bool m_RejectedNssaiInTaIsSet;
+  NsiInformation m_NsiInformation;
+  bool m_NsiInformationIsSet;
+  std::string m_SupportedFeatures;
+  bool m_SupportedFeaturesIsSet;
+  std::string m_NrfAmfSet;
+  bool m_NrfAmfSetIsSet;
+  std::string m_NrfAmfSetNfMgtUri;
+  bool m_NrfAmfSetNfMgtUriIsSet;
+  std::string m_NrfAmfSetAccessTokenUri;
+  bool m_NrfAmfSetAccessTokenUriIsSet;
+  std::string m_TargetAmfServiceSet;
+  bool m_TargetAmfServiceSetIsSet;
+};
+
+}  // namespace model
+}  // namespace amf
+}  // namespace oai
+
+#endif /* AuthorizedNetworkSliceInfo_H_ */

src/sbi/amf_server/model/ConfiguredSnssai.cpp

@@ -12,6 +12,9 @@
  */
 
 #include "ConfiguredSnssai.h"
+#include "Helpers.h"
+
+#include <sstream>
 
 namespace oai {
 namespace amf {
@@ -21,10 +24,41 @@ ConfiguredSnssai::ConfiguredSnssai() {
   m_MappedHomeSnssaiIsSet = false;
 }
 
-ConfiguredSnssai::~ConfiguredSnssai() {}
+void ConfiguredSnssai::validate() const {
+  std::stringstream msg;
+  // if (!validate(msg))
+  // {
+  //     throw oai::nssf_server::helpers::ValidationException(msg.str());
+  // }
+}
+
+bool ConfiguredSnssai::validate(std::stringstream& msg) const {
+  return validate(msg, "");
+}
+
+bool ConfiguredSnssai::validate(
+    std::stringstream& msg, const std::string& pathPrefix) const {
+  bool success = true;
+  const std::string _pathPrefix =
+      pathPrefix.empty() ? "ConfiguredSnssai" : pathPrefix;
+
+  return success;
+}
+
+bool ConfiguredSnssai::operator==(const ConfiguredSnssai& rhs) const {
+  return
+
+      (getConfiguredSnssai() == rhs.getConfiguredSnssai()) &&
+
+      ((!mappedHomeSnssaiIsSet() && !rhs.mappedHomeSnssaiIsSet()) ||
+       (mappedHomeSnssaiIsSet() && rhs.mappedHomeSnssaiIsSet() &&
+        getMappedHomeSnssai() == rhs.getMappedHomeSnssai()))
+
+          ;
+}
 
-void ConfiguredSnssai::validate() {
-  // TODO: implement validation
+bool ConfiguredSnssai::operator!=(const ConfiguredSnssai& rhs) const {
+  return !(*this == rhs);
 }
 
 void to_json(nlohmann::json& j, const ConfiguredSnssai& o) {

src/sbi/amf_server/model/ConfiguredSnssai.h

@@ -32,9 +32,28 @@ namespace model {
 class ConfiguredSnssai {
  public:
   ConfiguredSnssai();
-  virtual ~ConfiguredSnssai();
+  virtual ~ConfiguredSnssai() = default;
 
-  void validate();
+  /// <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 ConfiguredSnssai& rhs) const;
+  bool operator!=(const ConfiguredSnssai& rhs) const;
 
   /////////////////////////////////////////////
   /// ConfiguredSnssai members