Firmware: Provisioner now kinda works

firmware/main/main.cpp

@@ -25,7 +25,10 @@ extern "C" void app_main(void)
 
   ESP_ERROR_CHECK(err);
 
-  auto* provisioner = new WifiProvisioner("wifi_settings");
+  auto* provisioner = new WifiProvisioner("wifi_settings", [](const auto& params)
+                                          {
+                                            printf("Settings successfully done.");
+                                          });
   if (!provisioner->addParameter("SSID", "ssid", WifiProvisioner::Parameter::Type::STRING).has_value())
   {
     printf("Error adding parameter.");

firmware/main/static/index.html

@@ -12,11 +12,58 @@
 <h1>ESP Captive Portal</h1>
 <p>Hello World, this is ESP32!</p>
 
-<form action="/configure" method="post" id="submit_form">
+<div id="interface">
-
+    <form id="submit_form">
     </form>
-
+</div>
 <script>
+    function outputSuccess(response_object) {
+        let root = document.getElementById("interface");
+        root.innerHTML = "";
+
+        root.innerHTML = `<b>${response_object.response_str}</b>`;
+    }
+
+    function outputFailure(response_object) {
+        let root = document.getElementById("interface");
+        root.innerHTML = "";
+
+        root.innerHTML = `<p><b>Request failed.</b></br>Reason:${response_object.response_str}</p>`;
+    }
+
+    function submitFormHandler(event) {
+        console.log("In the post handler.");
+        event.preventDefault();
+
+        const form_data = new FormData(document.getElementById("submit_form"));
+        let configuration_data = [];
+        for (const pair of form_data.entries()) {
+            configuration_data.push({
+                nvs_name: pair[0],
+                value: pair[1]
+            });
+        }
+
+        console.log(`Posting data: ${JSON.stringify(configuration_data)}`);
+
+        fetch("configure", {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json"
+            },
+            body: JSON.stringify(configuration_data)
+        }).then((r) => {
+            console.log("Got a response.");
+            console.log(r);
+
+            if (r.ok) {
+                outputSuccess(r.json());
+            } else {
+                outputFailure(r.json());
+            }
+        });
+    }
+
     async function getParameterFields() {
         const response = await fetch("parameters", {
             method: "GET",
@@ -51,7 +98,10 @@
         let submit = document.createElement("input");
         submit.setAttribute("type", "submit");
         submit.setAttribute("value", "Configure");
+
         form_root.appendChild(submit);
+
+        form_root.addEventListener("submit", submitFormHandler, true);
     }
 
     populateSubmitForm(document.getElementById("submit_form"));

firmware/main/wifi_provisioner.cpp

@@ -61,9 +61,12 @@ esp_err_t rootPostHandler_(httpd_req_t* req)
   content.initialize_free_space();
   const std::size_t size = MIN(req->content_len, content.max_size() - 1);
 
+  ESP_LOGI(TAG, "Post handler.");
+
   if (const int ret = httpd_req_recv(req, content.data_end(), size);
       ret <= 0)
   {
+    ESP_LOGE(TAG, "Error, socket timeout.");
     if (ret == HTTPD_SOCK_ERR_TIMEOUT)
       httpd_resp_send_408(req);
 
@@ -72,21 +75,64 @@ esp_err_t rootPostHandler_(httpd_req_t* req)
 
   content.trim_to_terminator();
 
-  etl::string<100> header;
+  auto dispatch_error = [req](const char* error_str)
-  if (const auto err = httpd_req_get_hdr_value_str(req, "Content-Type", header.data(), header.max_size() - 1);
+    {
+      ESP_LOGE(TAG, "Request error: %s", error_str);
+      auto json_root = CJsonPtr(cJSON_CreateObject());
+      cJSON_AddStringToObject(json_root.get(), "response_str", error_str);
+      auto response_str = CJsonStrPtr(cJSON_Print(json_root.get()));
+
+      httpd_resp_set_status(req, "400 Bad Request");
+      httpd_resp_set_type(req, HTTPD_TYPE_JSON);
+      httpd_resp_sendstr(req, response_str.get());
+    };
+
+  etl::string<100> content_type;
+  if (const auto err = httpd_req_get_hdr_value_str(req, "Content-Type", content_type.data(), content_type.max_size() - 1);
       err != ESP_OK)
   {
-    ESP_LOGE(TAG, "Error reading content header.");
+    dispatch_error("Cannot parse header.");
     return ESP_FAIL;
   }
 
-  //httpd_query_key_value
+  content_type.trim_to_terminator();
-  ESP_LOGI(TAG, "Data from post: %s, %s", header.data(), content.data());
+
+  if (content_type != "application/json")
+  {
+    ESP_LOGE(TAG, "Invalid content-type header: %s", content_type.c_str());
+    dispatch_error("Invalid Content-Type header.");
+    return ESP_FAIL;
+  }
+
+  auto json_object = CJsonPtr(cJSON_Parse(content.c_str()));
+  if (!json_object || !cJSON_IsArray(json_object.get()))
+  {
+    dispatch_error("Invalid JSON sent.");
+    return ESP_FAIL;
+  }
+
+  auto* provisioner = static_cast<WifiProvisioner*>(req->user_ctx);
+  std::expected<void, const char*> result = provisioner->tryConfigureParameters(std::move(json_object));
+
+  if (result)
+  {
+    httpd_resp_set_type(req, HTTPD_TYPE_JSON);
+
+    auto json_root = CJsonPtr(cJSON_CreateObject());
+    cJSON_AddStringToObject(json_root.get(), "response_str", "Configuration successful. ESP rebooting.");
+    auto response_str = CJsonStrPtr(cJSON_Print(json_root.get()));
+    httpd_resp_sendstr(req, response_str.get());
+
+    ESP_LOGI(TAG, "Post successful.");
 
-  const char resp[] = "URI POST Response";
-  httpd_resp_send(req, resp, HTTPD_RESP_USE_STRLEN);
     return ESP_OK;
   }
+  else
+  {
+    dispatch_error(result.error());
+    return ESP_FAIL;
+  }
+}
 
 esp_err_t parametersGetHandler_(httpd_req_t* req)
 {
@@ -112,20 +158,20 @@ esp_err_t parametersGetHandler_(httpd_req_t* req)
 
 std::expected<WifiProvisioner::Parameter::Value, esp_err_t> WifiProvisioner::Parameter::getValue(nvs::NVSHandle* file_handle) const
 {
-  if (type == Parameter::Type::INT)
+  if (type == Type::INT)
   {
     std::int32_t value = 0;
     TRY_ESP(file_handle->get_item(nvs_name.c_str(), value));
 
     return value;
   }
-  else if (type == Parameter::Type::FLOAT)
+  else if (type == Type::FLOAT)
   {
     std::int32_t value_raw = 0;
     TRY_ESP(file_handle->get_item(nvs_name.c_str(), value_raw));
     return std::bit_cast<float>(value_raw);
   }
-  else if (type == Parameter::Type::STRING)
+  else if (type == Type::STRING)
   {
     etl::string<100> value;
     value.initialize_free_space();
@@ -139,7 +185,42 @@ std::expected<WifiProvisioner::Parameter::Value, esp_err_t> WifiProvisioner::Par
   return ESP_FAIL;
 }
 
-WifiProvisioner::WifiProvisioner(const char* settings_namespace)
+std::expected<WifiProvisioner::Parameter::Value, const char*> WifiProvisioner::Parameter::tryValidateAndAssign(cJSON* object)
+{
+  if (!cJSON_IsObject(object))
+    return std::unexpected("Invalid parameter JSON.");
+
+  const cJSON* in_nvs_name = cJSON_GetObjectItem(object, "nvs_name");
+  if (!cJSON_IsString(in_nvs_name))
+    return std::unexpected("Invalid parameter JSON.");
+
+  if (cJSON_GetStringValue(in_nvs_name) != nvs_name)
+    return std::unexpected("Mismatching parameter nvs_name. Invalid sequence or invalid parameter.");
+
+  const cJSON* in_value = cJSON_GetObjectItem(object, "value");
+  if (type == Type::INT || type == Type::FLOAT)
+  {
+    if (!cJSON_IsNumber(in_value))
+      return std::unexpected("Mismatching or missing parameter value.");
+
+    const double json_value = cJSON_GetNumberValue(in_value);
+    if (type == Type::INT)
+      return {data = Value{std::int32_t(json_value)}};
+    else
+      return {data = Value{float(json_value)}};
+  }
+  else
+  {
+    if (!cJSON_IsString(in_value))
+      return std::unexpected("Mismatching or missing parameter value.");
+
+    const char* json_value = cJSON_GetStringValue(in_value);
+    return {data = Value{json_value}};
+  }
+}
+
+WifiProvisioner::WifiProvisioner(const char* settings_namespace, etl::delegate<void (const etl::vector<Parameter, 10>&)> success_cb)
+  : success_cb_(success_cb)
 {
   esp_err_t err = ESP_OK;
   file_handle_ = nvs::open_nvs_handle(settings_namespace, NVS_READWRITE, &err);
@@ -154,6 +235,14 @@ WifiProvisioner::WifiProvisioner(const char* settings_namespace)
   }
 }
 
+WifiProvisioner::~WifiProvisioner()
+{
+  if (http_server_)
+  {
+    httpd_stop(http_server_);
+  }
+}
+
 bool WifiProvisioner::parametersAreConfigured()
 {
   if (params_.empty())
@@ -208,6 +297,31 @@ CJsonPtr WifiProvisioner::getParameterObjects() const
   return root;
 }
 
+std::expected<void, const char*> WifiProvisioner::tryConfigureParameters(CJsonPtr json_root)
+{
+  if (params_.size() != cJSON_GetArraySize(json_root.get()))
+    return std::unexpected("Mismatching parameters array sizes.");
+
+  cJSON* entry = nullptr;
+  int i = 0;
+  cJSON_ArrayForEach(entry, json_root)
+  {
+    auto& param = params_[i];
+    TRY(param.tryValidateAndAssign(entry));
+
+    i++;
+  }
+
+  const auto& result = writeAndCommitParameters_();
+  if (!result.has_value())
+    return std::unexpected(esp_err_to_name(result.error()));
+
+  if (settings_initialized_ && success_cb_)
+    success_cb_(params_);
+
+  return {};
+}
+
 esp_err_t WifiProvisioner::initializeNvsNamespace_()
 {
   esp_err_t err = file_handle_->set_item(NVS_IS_INITED, false);
@@ -317,3 +431,31 @@ std::expected<httpd_handle_t, esp_err_t> WifiProvisioner::initializeCaptivePorta
 
   return server;
 }
+
+std::expected<void, esp_err_t> WifiProvisioner::writeAndCommitParameters_()
+{
+  for (const auto& param : params_)
+  {
+    if (param.type == Parameter::Type::INT)
+    {
+      TRY_ESP(file_handle_->set_item(param.nvs_name.c_str(), std::get<std::int32_t>(param.data)));
+    }
+    else if (param.type == Parameter::Type::FLOAT)
+    {
+      const auto temporary = std::bit_cast<std::int32_t>(std::get<float>(param.data));
+      TRY_ESP(file_handle_->set_item(param.nvs_name.c_str(), temporary));
+    }
+    else
+    {
+      const auto temporary = std::get<etl::string<100>>(param.data);
+      TRY_ESP(file_handle_->set_string(param.nvs_name.c_str(), temporary.c_str()));
+    }
+  }
+
+  TRY_ESP(file_handle_->set_item(NVS_IS_INITED, true));
+  TRY_ESP(file_handle_->commit());
+
+  settings_initialized_ = true;
+
+  return {};
+}

firmware/main/wifi_provisioner.hpp

@@ -8,6 +8,7 @@
 #include <esp_http_server.h>
 #include <etl/vector.h>
 #include <etl/string.h>
+#include <etl/delegate.h>
 #include <expected>
 #include <variant>
 #include <memory>
@@ -36,7 +37,6 @@ struct CJsonDeleter
 
 using CJsonPtr = std::unique_ptr<cJSON, CJsonDeleter>;
 
-
 class WifiProvisioner
 {
 public:
@@ -64,9 +64,11 @@ public:
     { }
 
     std::expected<Value, esp_err_t> getValue(nvs::NVSHandle* file_handle) const;
+    std::expected<Value, const char*> tryValidateAndAssign(cJSON* object);
   };
 
-  explicit WifiProvisioner(const char* settings_namespace);
+  explicit WifiProvisioner(const char* settings_namespace, etl::delegate<void (const etl::vector<Parameter, 10>&)> success_cb);
+  ~WifiProvisioner();
 
   WifiProvisioner() = delete;
   WifiProvisioner(const WifiProvisioner&) = delete;
@@ -81,13 +83,17 @@ public:
   std::expected<void, std::error_code> addParameter(const char* name, const char* nvs_name, const Parameter::Type type);
   CJsonPtr getParameterObjects() const;
 
+  std::expected<void, const char*> tryConfigureParameters(CJsonPtr json_root);
+
 private:
   std::unique_ptr<nvs::NVSHandle> file_handle_;
   bool settings_initialized_ = false;
   httpd_handle_t http_server_ = nullptr;
   etl::vector<Parameter, 10> params_;
+  etl::delegate<void (const etl::vector<Parameter, 10>& params)> success_cb_;
 
   esp_err_t initializeNvsNamespace_();
   std::expected<void, esp_err_t> initializeWifiAp_();
   std::expected<httpd_handle_t, esp_err_t> initializeCaptivePortal_();
+  std::expected<void, esp_err_t> writeAndCommitParameters_();
 };