Add entity License Type

Author: yushkevich

include/netlicensing/converters.h

@@ -13,6 +13,7 @@
 #include "netlicensing/token.h"
 #include "netlicensing/transaction.h"
 #include "netlicensing/licensing_model.h"
+#include "netlicensing/license_type.h"
 
 namespace netlicensing {
 
@@ -134,6 +135,13 @@ namespace netlicensing {
     return params;
   }
 
+  template<>
+  inline parameters_type toParametersList<LicenseType>(LicenseType value) {
+    parameters_type params;
+    params.push_back(std::make_pair(NAME, value.getName()));
+    return params;
+  }
+
 }  // namespace netlicensing
 
 #endif  // __CONVERTERS_H__

include/netlicensing/license_type.h

@@ -0,0 +1,40 @@
+#ifndef __LICENSE_TYPES_H__
+#define __LICENSE_TYPES_H__
+
+#include <list>
+
+#include "netlicensing/entity.h"
+
+namespace netlicensing {
+
+  class LicenseType {
+  private:
+    String_t name_i;
+
+  public:
+    LicenseType() : name_i() { }
+
+    void setName(const String_t& name) {
+      name_i = name;
+    }
+
+    const String_t& getName() const {
+      return name_i;
+    }
+
+    String_t toString() const {
+      std::string name(this->getName());
+
+      std::stringstream ss;
+      ss << "LicenseType [";
+      ss << "name: ";
+      ss << name;
+      ss << "]";
+      return ss.str();
+    }
+
+  };
+
+}
+
+#endif // __LICENSE_TYPES_H__

include/netlicensing/mapper.h

@@ -260,6 +260,21 @@ namespace netlicensing {
     }
   };
 
+  class LicenseTypeWrapper : public ItemWrapper {
+    LicenseType item_i;
+
+  public:
+    const LicenseType& getItem() {
+      return item_i;
+    }
+
+    virtual void addProperty(const std::string& key, const std::string& value) {
+      if (key == "name") {
+        item_i.setName(value);
+      }
+    }
+  };
+
   class PaymentMethodWrapper : public ItemWrapper {
     PaymentMethod item_i;
 
@@ -376,6 +391,12 @@ namespace netlicensing {
     static std::string getType() { return "LicensingModelProperties"; }
   };
 
+  template<>
+  struct ItemTraits<LicenseType> {
+    typedef LicenseTypeWrapper Wrapper_t;
+    static std::string getType() { return "LicenseType"; }
+  };
+
   template<>
   struct ItemTraits<PaymentMethod> {
     typedef PaymentMethodWrapper Wrapper_t;

include/netlicensing/netlicensing.h

@@ -106,7 +106,7 @@ class UtilityService {
 public:
   static std::list<Country> listCountries(Context& ctx);
   static std::list<LicensingModel> listLicensingModels(Context& ctx);
-  //static std::list<Product> listLicenseTypes(Context& ctx);
+  static std::list<LicenseType> listLicenseTypes(Context& ctx);
 };
 
 

include/netlicensing/service.h

@@ -18,6 +18,7 @@ template<> inline std::string endpoint<Token>() { return std::string("token"); }
 template<> inline std::string endpoint<Transaction>() { return std::string("transaction"); }
 template<> inline std::string endpoint<Country>() { return std::string("utility/countries"); }
 template<> inline std::string endpoint<LicensingModel>() { return std::string("utility/licensingModels"); }
+template<> inline std::string endpoint<LicenseType>() { return std::string("utility/licenseTypes"); }
 
 template<typename M>
 void getEntity(Context& ctx, M& mapper, const std::string& number) {

src/netlicensing.cc

@@ -531,4 +531,14 @@ namespace netlicensing {
     netlicensing::list(ctx, licensingModelsMapper, "");
     return licensingModelsMapper.getItems();
   }
+
+  /**
+   * Returns all license types. See NetLicensingAPI for details:
+   * https://www.labs64.de/confluence/display/NLICPUB/Utility+Services#UtilityServices-LicenseTypeslist
+   */
+  std::list<LicenseType> UtilityService::listLicenseTypes(Context& ctx) {
+    StandardMapper<LicenseType> licenseTypeMapper;
+    netlicensing::list(ctx, licenseTypeMapper, "");
+    return licenseTypeMapper.getItems();
+  }
 }