Merge pull request #111 from polycube-network/pr/fix_list_validation2

polycubed: further fix to list validation

Author: frisso

src/polycubed/src/server/Resources/Body/ListResource.cpp

@@ -25,6 +25,8 @@
 #include "JsonNodeField.h"
 #include "ListKey.h"
 
+#include "../../Types/lexical_cast.h"
+
 namespace polycube::polycubed::Rest::Resources::Body {
 ListResource::ListResource(const std::string &name,
                            const std::string &description,
@@ -107,11 +109,41 @@ void ListResource::SetDefaultIfMissing(nlohmann::json &body,
 
 void ListResource::FillKeys(nlohmann::json &body, const ListKeyValues &keys) {
   // TODO: is there a more efficient implementation of this?
-  for (auto &key: keys_) {
+  for (auto &key : keys_) {
     for (auto &kv : keys) {
       if (key.Name() == kv.name) {
         // TODO: check if the key is present in the body and compare the data
-        body[key.OriginalName()] = kv.value;
+        switch (key.Type()) {
+        case ListType::kBool:
+          body[key.OriginalName()] = Types::lexical_cast<bool>(kv.value);
+          break;
+        case ListType::kInt8:
+          body[key.OriginalName()] = Types::lexical_cast<int8_t>(kv.value);
+          break;
+        case ListType::kInt16:
+          body[key.OriginalName()] = Types::lexical_cast<int16_t>(kv.value);
+          break;
+        case ListType::kInt32:
+          body[key.OriginalName()] = Types::lexical_cast<int32_t>(kv.value);
+          break;
+        case ListType::kInt64:
+          body[key.OriginalName()] = Types::lexical_cast<int64_t>(kv.value);
+          break;
+        case ListType::kUint8:
+          body[key.OriginalName()] = Types::lexical_cast<uint8_t>(kv.value);
+          break;
+        case ListType::kUint16:
+          body[key.OriginalName()] = Types::lexical_cast<uint16_t>(kv.value);
+          break;
+        case ListType::kUint32:
+          body[key.OriginalName()] = Types::lexical_cast<uint32_t>(kv.value);
+          break;
+        case ListType::kUint64:
+          body[key.OriginalName()] = Types::lexical_cast<uint64_t>(kv.value);
+          break;
+        default:
+          body[key.OriginalName()] = kv.value;
+        }
         break;
       }
     }

src/polycubed/src/server/Resources/Endpoint/ListResource.h

@@ -73,7 +73,7 @@ class ListResource : public ParentResource, public Body::ListResource {
  private:
   // try to get as much as possible Keys
   void GetListKeys(const Pistache::Rest::Request &request,
-                  ListKeyValues &parsed) const;
+                   ListKeyValues &parsed) const;
 
   std::vector<PathParamField> key_params_;
   std::string multiple_endpoint_;

src/polycubed/src/server/Resources/Endpoint/ParentResource.cpp

@@ -107,7 +107,7 @@ void ParentResource::CreateReplaceUpdate(
   Keys(request, keys);
 
   // fill keys if they are missing
-  if (auto list = dynamic_cast<ListResource*>(this)) {
+  if (auto list = dynamic_cast<ListResource *>(this)) {
     list->FillKeys(jbody, keys);
   }
 

src/polycubed/src/server/Types/lexical_cast.cpp

@@ -15,7 +15,30 @@
  */
 #include "lexical_cast.h"
 
+#include <algorithm>
+#include <string>
+
 namespace polycube::polycubed::Rest::Types {
+template <>
+bool lexical_cast<bool>(const std::string &value) {
+  try {
+    std::string lower;
+    lower.reserve(value.length());
+    std::transform(std::begin(value), std::end(value),
+                   std::back_inserter(lower),
+                   static_cast<int (*)(int)>(std::tolower));
+    if (lower == "false") {
+      return false;
+    } else if (lower == "true") {
+      return true;
+    } else {
+      throw bad_lexical_cast();
+    }
+  } catch (...) {
+    throw bad_lexical_cast();
+  }
+}
+
 template <>
 int8_t lexical_cast<int8_t>(const std::string &value) {
   try {

src/polycubed/src/server/Types/lexical_cast.h

@@ -25,6 +25,9 @@ struct bad_lexical_cast : public std::exception {};
 template <class T>
 T lexical_cast(const std::string &value) = delete;
 
+template <>
+bool lexical_cast<bool>(const std::string &value);
+
 template <>
 int8_t lexical_cast<int8_t>(const std::string &value);