polycubed: further fix to list validation

18becf4 fixed some problems with the list validation, however this also
introduced another problems as the that fix was not complete.

This commit adds some logic to fill the keys in a list request according to its
type.

Fixes: 18becf4 ("polycubed: fix list validation")

Signed-off-by: Mauricio Vasquez B <mauriciovasquezbernal@gmail.com>

Author: mauriciovasquezbernal

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);