Merge branch 'TechToast-master'

Author: kkorotkov

client_demo/netlicensing_client_demo.cc

@@ -5,8 +5,9 @@
 #include "netlicensing/netlicensing.h"
 
 int main(int argc, char* argv[]) {
-  using netlicensing::Product;
-  std::string licensee_number = "I2C3VN7NA-DEMO";
+  using namespace netlicensing;
+  
+  std::string licensee_number = "I5-DEMO";
   if (argc > 1) {
     licensee_number = argv[1];
   }
@@ -18,43 +19,39 @@ int main(int argc, char* argv[]) {
   std::string productNumber = ss.str();
 
   std::cout << "Hello, this is NetLicensing demo client\n";
-  std::cout << "Product endpoint " << netlicensing::endpoint<Product>() << std::endl;
+  std::cout << "Product endpoint " << endpoint<Product>() << std::endl;
   std::cout << "Product test number " << productNumber << std::endl;
 
-  using netlicensing::Context;
   try {
     Context ctx;
     ctx.set_base_url("https://go.netlicensing.io/core/v2/rest/");
     ctx.set_username("demo");
     ctx.set_password("demo");
 
     // product section
-    netlicensing::Product p;
+    Product p;
     p.setName("Test name");
     p.setNumber(productNumber);
-    netlicensing::Product newp = netlicensing::ProductService::create(ctx, p);
+    Product newp = ProductService::create(ctx, p);
 
     newp.setName("Updated name");
-    netlicensing::Product newp2 = netlicensing::ProductService::update(ctx, newp.getNumber(), newp);
+    Product newp2 = ProductService::update(ctx, newp.getNumber(), newp);
 
-    std::list<netlicensing::Product> products = netlicensing::ProductService::list(ctx, "");
+    std::list<Product> products = ProductService::list(ctx, "");
     std::cout << "before delete products count " << products.size() << std::endl;
 
-    netlicensing::ProductService::del(ctx, newp2.getNumber(), false);
+    ProductService::del(ctx, newp2.getNumber(), false);
 
-    products = netlicensing::ProductService::list(ctx, "");
+    products = ProductService::list(ctx, "");
     std::cout << "after delete products count " << products.size() << std::endl;
 
     if (!licensee_number.empty()) {
       std::cout << "start validation for " << licensee_number << std::endl;
-      std::list<netlicensing::ValidationResult> vres = netlicensing::ValidationService::validate(ctx, licensee_number);
-      std::cout << "got validation results: " << vres.size() << std::endl;
-      for (auto val_res : vres) {
-        std::cout << val_res.to_string() << std::endl;
-      }
+      ValidationResult vres = LicenseeService::validate(ctx, licensee_number);
+      std::cout << "got validation results:\n" << vres.toString() << std::endl;
     }
   }
-  catch (const netlicensing::RestException& e) {
+  catch (const RestException& e) {
     std::cerr << e.what() << " code " << e.http_code() << std::endl;
     for (auto det : e.get_details()) {
       std::cerr << det.to_string() << std::endl;

include/netlicensing/constants.h

@@ -10,6 +10,9 @@ namespace netlicensing {
     static const char* NUMBER  = "number";
     static const char* NAME    = "name";
     static const char* VERSION = "version";
+    static const char* LICENSEE_AUTOCREATE = "licenseeAutoCreate";
+    static const char* DESCRIPTION = "description";
+    static const char* LICENSING_INFO = "licensingInfo";
     static const char* DELETED = "deleted";
     static const char* CASCADE = "forceCascade";
     static const char* PRICE   = "price";
@@ -23,8 +26,6 @@ namespace netlicensing {
     static const char* SECURITY_MODE = "securityMode";
     static const char* PROP_ID     = "ID";
     static const char* PROP_TTL    = "TTL";
-
-    typedef std::list<std::pair<std::string, std::string> > parameters_type;
 }
 
 #endif //__CONSTANTS_H__

include/netlicensing/context.h

@@ -1,7 +1,7 @@
 #ifndef __CONTEXT_H__
 #define __CONTEXT_H__
 
-#include "netlicensing/constants.h"
+#include "netlicensing/converters.h"
 
 namespace netlicensing {
 

include/netlicensing/converters.h

@@ -0,0 +1,52 @@
+#ifndef __CONVERTERS_H__
+#define __CONVERTERS_H__
+
+#include "netlicensing/constants.h"
+#include "netlicensing/datatypes.h"
+#include "netlicensing/entity.h"
+#include "netlicensing/licensee.h"
+#include "netlicensing/product.h"
+
+namespace netlicensing {
+
+  template<typename T>
+  parameters_type toParametersList(T value);
+
+  template<>
+  inline parameters_type toParametersList<BaseEntity>(BaseEntity value) {
+    parameters_type params;
+    params.push_back(std::make_pair(NUMBER, value.getNumber()));
+    params.push_back(std::make_pair(ACTIVE, value.getActive().toString()));
+    for (const auto& prop : value.getProperties()) {
+      params.push_back(prop);
+    }
+    return params;
+  }
+  
+  template<>
+  inline parameters_type toParametersList<Product>(Product value) {
+    parameters_type params = toParametersList<BaseEntity>(value);
+    params.push_back(std::make_pair(NAME, value.getName()));
+    params.push_back(std::make_pair(VERSION, value.getVersion()));
+    params.push_back(std::make_pair(LICENSEE_AUTOCREATE, value.getLicenseeAutoCreate().toString()));
+    params.push_back(std::make_pair(DESCRIPTION, value.getDescription()));
+    params.push_back(std::make_pair(LICENSING_INFO, value.getLicensingInfo()));
+    // TODO(2K): convert discounts
+    /*
+    for (const auto& discount : value.getDiscounts()) {
+      // ...
+    }
+    */
+    return params;    
+  }
+
+  template<>
+  inline parameters_type toParametersList<Licensee>(Licensee value) {
+    parameters_type params = toParametersList<BaseEntity>(value);
+    params.push_back(std::make_pair(NAME, value.getName()));
+    return params;    
+  }
+
+}  // namespace netlicensing
+
+#endif  // __CONVERTERS_H__

include/netlicensing/datatypes.h

@@ -0,0 +1,92 @@
+#ifndef __DATATYPES_H__
+#define __DATATYPES_H__
+
+#include <stdint.h>
+#include <sstream>
+#include <string>
+
+#include "netlicensing/exception.h"
+
+namespace netlicensing {
+
+  // This is a simplified version of std::optional (or boost::optional) to avoid dependency
+  // on not yet widely supported C++17 or external library (boost).
+  template <typename T>
+  class Optional {
+    bool available_i;
+    T value_i;
+
+  public:
+    Optional() : available_i(false), value_i() {}
+    Optional(T value) : available_i(true), value_i(value) {}
+    Optional(const char* value);
+
+    bool operator()() const { return available_i; }
+
+    operator T() const { return value_i; }
+
+    std::string toString() const;
+  };
+
+
+  // TODO(2K): Precision is currently fixed at 2 digits after decimal point, make variable
+  class FixedPoint {
+    int64_t value_i;
+
+  public:
+    FixedPoint(const std::string& value) {
+      if (value == "0") {
+        value_i = 0;
+      } else if ((value.length() > 3) && (value[value.length() - 3] == '.')) {
+        // TODO(2K): too primitive parsing - improve
+        std::string rawValue = value;
+        rawValue.erase(value.length() - 3, 1);
+        auto is = std::istringstream(rawValue);
+        is >> value_i;
+      } else {
+        throw MalformedArgumentsException("Not supported formatting for fixed point value");
+      }
+    }
+
+    std::string toString() const {
+      std::ostringstream os;
+      os << value_i;
+      std::string sValue = os.str();
+      sValue.insert(sValue.length() - 2, ".");
+      return sValue;
+    }
+  };
+
+
+  typedef Optional<std::string> String_t;
+  typedef Optional<FixedPoint> Decimal_t;
+  typedef Optional<bool> Boolean_t;
+
+  template<>
+  inline Optional<std::string>::Optional(const char* value)
+    : available_i(true), value_i(value) { }
+
+  template<>
+  inline std::string Optional<std::string>::toString() const {
+    return value_i;
+  }
+
+  template<>
+  inline std::string Optional<FixedPoint>::toString() const {
+    return value_i.toString();
+  }
+
+  template<>
+  inline Optional<bool>::Optional(const char* value)
+    : available_i(true), value_i(std::string(value) == "true") { }
+
+  template<>
+  inline std::string Optional<bool>::toString() const {
+    return value_i ? "true" : "false";
+  }
+
+  typedef std::list<std::pair<std::string, std::string> > parameters_type;
+
+}  // namespace netlicensing
+
+#endif  // __DATATYPES_H__

include/netlicensing/entity.h

@@ -1,44 +1,15 @@
 #ifndef __ENTITY_H__
 #define __ENTITY_H__
 
-#include "netlicensing/constants.h"
 #include <map>
-#include <memory>
-#include <stdexcept>
 #include <sstream>
-#include <cassert>
+#include <string>
 
-namespace netlicensing {
-
-struct NamedList {
-  std::string name_;
-
-  bool add_property(const std::string& name, const std::string& value) {
-    if (name == "name") {
-      name_ = value;
-      return true;
-    }
-
-    return false;
-  }
-};
-
-template<class T>
-struct RecursiveList : public NamedList {
-  std::list<std::shared_ptr<RecursiveList<T> > >  nested_lists_;
+#include "netlicensing/datatypes.h"
 
-  void add_list(std::shared_ptr<RecursiveList<T> > ptr) {
-    nested_lists_.push_back(ptr);
-  }
-};
-
-template<class T>
-struct FlatList : public NamedList {
-  void add_list(std::shared_ptr<FlatList<T> > ptr) {
-    throw std::logic_error("Flat list is not support nested levels");
-  }
-};
+namespace netlicensing {
 
+/*
 template<typename S, typename T>
 void lexical_cast(T& t, const S& s) {
   std::stringstream stream;
@@ -60,17 +31,67 @@ inline void assign(bool& target, const std::string& source) {
 inline void assign(int& target, const std::string& source) {
   lexical_cast(target, source);
 }
+*/
 
-class Entity {
+class BaseEntity {
 private:
-  typedef std::map<std::string, std::string> user_properties_map;
-  user_properties_map user_defined_properties_;
+  String_t number_i;
+  Boolean_t active_i;
+  std::map<std::string, String_t> properties_i;
+
+public:
+  void setNumber(const String_t& number) {
+    number_i = number;
+  }
+
+  const String_t& getNumber() const {
+    return number_i;
+  }
+  
+  void setActive(Boolean_t active) {
+    active_i = active;
+  }
+
+  Boolean_t getActive() const {
+    return active_i;
+  }
+
+  // Methods for working with custom properties
+
+  const std::map<std::string, String_t>& getProperties() const {
+    return properties_i;
+  }
+
+  void addProperty(const std::string& property, String_t value) {
+    properties_i[property] = value;
+  }
+
+  void removeProperty(const std::string& property) {
+    properties_i.erase(property);
+  }
+};
+
+/*
+class BaseEntityConverter {
+  BaseEntity& baseEntity_i;
 public:
-  bool add_property(const std::string& key, const std::string& value);
-  std::string get_property(const std::string& key) const;
-  std::string to_string() const;
-  parameters_type to_parameters_list() const;
+  BaseEntityConverter(BaseEntity& baseEntity) : baseEntity_i(baseEntity) {}
+  bool convert(const std::string& property, const std::string value) {
+    if (property == "number") {
+      baseEntity_i.setNumber(value);
+      return true;
+    } else if (property == "active") {
+      baseEntity_i.setActive(value == "true");
+      return true;
+    }
+    return false;
+  }
+};
+
+template<typename E>
+class EntityConverter : public BaseEntityConverter {
 };
+*/
 
 }
 

include/netlicensing/exception.h

@@ -1,6 +1,7 @@
 #ifndef __EXCEPTION_H__
 #define __EXCEPTION_H__
 
+#include <list>
 #include <stdexcept>
 #include "netlicensing/info.h"
 
@@ -57,6 +58,6 @@ class MalformedArgumentsException : public std::runtime_error {
    MalformedArgumentsException(const std::string& msg) : std::runtime_error(msg) {}
 };
 
-};
+}  // namespace netlicensing
 
-#endif //__EXCEPTION_H__
+#endif  // __EXCEPTION_H__