306 lines
8.7 KiB
C++
306 lines
8.7 KiB
C++
#include "webserver_settings.h"
|
|
|
|
// system includes
|
|
#include <limits>
|
|
|
|
// esp-idf includes
|
|
#include <esp_http_server.h>
|
|
#include <esp_log.h>
|
|
|
|
// 3rdparty lib includes
|
|
#include <htmlbuilder.h>
|
|
#include <fmt/core.h>
|
|
#include <espcppmacros.h>
|
|
#include <esphttpdutils.h>
|
|
#include <numberparsing.h>
|
|
#include <lockhelper.h>
|
|
#include <tickchrono.h>
|
|
|
|
// local includes
|
|
#include "globals.h"
|
|
#include "webserver_lock.h"
|
|
|
|
using namespace std::chrono_literals;
|
|
using esphttpdutils::HtmlTag;
|
|
|
|
namespace {
|
|
constexpr const char * const TAG = "BOBBYWEB";
|
|
|
|
template<typename T>
|
|
typename std::enable_if<
|
|
!std::is_same<T, bool>::value &&
|
|
!std::is_integral<T>::value &&
|
|
!std::is_same<T, std::array<int8_t, 4>>::value
|
|
, bool>::type
|
|
showInputForSetting(std::string_view key, T value, std::string &body)
|
|
{
|
|
HtmlTag spanTag{"span", "style=\"color: red;\"", body};
|
|
body += "Unsupported config type";
|
|
return false;
|
|
}
|
|
|
|
template<typename T>
|
|
typename std::enable_if<
|
|
std::is_same<T, bool>::value
|
|
, bool>::type
|
|
showInputForSetting(std::string_view key, T value, std::string &body)
|
|
{
|
|
body += fmt::format("<input type=\"checkbox\" name=\"{}\" value=\"true\" {}/>"
|
|
"<input type=\"hidden\" name=\"{}\" value=\"false\" />",
|
|
esphttpdutils::htmlentities(key),
|
|
value ? "checked " : "",
|
|
esphttpdutils::htmlentities(key));
|
|
return true;
|
|
}
|
|
|
|
template<typename T>
|
|
typename std::enable_if<
|
|
!std::is_same<T, bool>::value &&
|
|
std::is_integral<T>::value
|
|
, bool>::type
|
|
showInputForSetting(std::string_view key, T value, std::string &body)
|
|
{
|
|
body += fmt::format("<input type=\"number\" name=\"{}\" value=\"{}\" min=\"{}\" max=\"{}\" step=\"1\" />",
|
|
esphttpdutils::htmlentities(key),
|
|
value,
|
|
std::numeric_limits<T>::min(),
|
|
std::numeric_limits<T>::max());
|
|
return true;
|
|
}
|
|
|
|
template<typename T>
|
|
typename std::enable_if<
|
|
std::is_same<T, std::array<int8_t, 4>>::value
|
|
, bool>::type
|
|
showInputForSetting(std::string_view key, T value, std::string &body)
|
|
{
|
|
body += fmt::format("<input type=\"text\" name=\"{}\" value=\"{}{}{}{}\" pattern=\"[0-9]{{4}}\" />",
|
|
esphttpdutils::htmlentities(key),
|
|
value[0],
|
|
value[1],
|
|
value[2],
|
|
value[3]);
|
|
return true;
|
|
}
|
|
} // namespace
|
|
|
|
esp_err_t webserver_settings_handler(httpd_req_t *req)
|
|
{
|
|
|
|
std::string body;
|
|
|
|
{
|
|
HtmlTag htmlTag{"html", body};
|
|
|
|
{
|
|
HtmlTag headTag{"head", body};
|
|
|
|
{
|
|
HtmlTag titleTag{"title", body};
|
|
body += "Settings";
|
|
}
|
|
|
|
body += "<meta name=\"viewport\" content=\"width=device-width, initial-scale=1, shrink-to-fit=no\" />";
|
|
|
|
HtmlTag styleTag{"style", "type=\"text/css\"", body};
|
|
body +=
|
|
".form-table {"
|
|
"display: table;"
|
|
"border-collapse: separate;"
|
|
"border-spacing: 10px 0;"
|
|
"}"
|
|
|
|
".form-table .form-table-row {"
|
|
"display: table-row;"
|
|
"}"
|
|
|
|
".form-table .form-table-row .form-table-cell {"
|
|
"display: table-cell;"
|
|
"}";
|
|
}
|
|
|
|
{
|
|
HtmlTag bodyTag{"body", body};
|
|
|
|
{
|
|
HtmlTag h1Tag{"h1", body};
|
|
body += "Settings";
|
|
}
|
|
|
|
{
|
|
HtmlTag pTag{"p", body};
|
|
body += "<a href=\"/\">Display control</a> - "
|
|
"<a href=\"/ota\">Update</a> - "
|
|
"<b>Settings</b> - "
|
|
"<a href=\"/newSettings\">New Settings</a> - "
|
|
"<a href=\"/dumpnvs\">Dump NVS</a>";
|
|
}
|
|
|
|
HtmlTag divTag{"div", "class=\"form-table\"", body};
|
|
profileSettings.executeForEveryProfileSetting([&](std::string_view key, const auto &value){
|
|
HtmlTag formTag{"form", "class=\"form-table-row\" action=\"/saveSettings\" method=\"GET\"", body};
|
|
|
|
{
|
|
HtmlTag divTag{"div", "class=\"form-table\"", body};
|
|
HtmlTag bTag{"b", body};
|
|
body += esphttpdutils::htmlentities(key);
|
|
}
|
|
|
|
{
|
|
HtmlTag divTag{"div", "class=\"form-table-cell\"", body};
|
|
showInputForSetting(key, value, body);
|
|
}
|
|
|
|
{
|
|
HtmlTag divTag{"div", "class=\"form-table-cell\"", body};
|
|
HtmlTag buttonTag{"button", "type=\"submit\"", body};
|
|
body += "Save";
|
|
}
|
|
});
|
|
}
|
|
}
|
|
|
|
CALL_AND_EXIT(esphttpdutils::webserver_resp_send, req, esphttpdutils::ResponseStatus::Ok, "text/html", body)
|
|
}
|
|
|
|
namespace {
|
|
template<typename T>
|
|
typename std::enable_if<
|
|
!std::is_same<T, bool>::value &&
|
|
!std::is_integral<T>::value &&
|
|
!std::is_same<T, std::array<int8_t, 4>>::value
|
|
, bool>::type
|
|
saveSetting(T &value, std::string_view newValue, std::string &body)
|
|
{
|
|
body += "Unsupported config type";
|
|
return false;
|
|
}
|
|
|
|
template<typename T>
|
|
typename std::enable_if<
|
|
std::is_same<T, bool>::value
|
|
, bool>::type
|
|
saveSetting(T &value, std::string_view newValue, std::string &body)
|
|
{
|
|
if (newValue == "true")
|
|
{
|
|
value = true;
|
|
body += "applied";
|
|
return true;
|
|
}
|
|
else if (newValue == "false")
|
|
{
|
|
value = false;
|
|
body += "applied";
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
body += fmt::format("only true and false allowed, not {}", newValue);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
template<typename T>
|
|
typename std::enable_if<
|
|
!std::is_same<T, bool>::value &&
|
|
std::is_integral<T>::value
|
|
, bool>::type
|
|
saveSetting(T &value, std::string_view newValue, std::string &body)
|
|
{
|
|
if (auto parsed = cpputils::fromString<T>(newValue))
|
|
{
|
|
value = *parsed;
|
|
body += "applied";
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
body += fmt::format("could not parse {}", newValue);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
template<typename T>
|
|
typename std::enable_if<
|
|
std::is_same<T, std::array<int8_t, 4>>::value
|
|
, bool>::type
|
|
saveSetting(T &value, std::string_view newValue, std::string &body)
|
|
{
|
|
if (std::array<int8_t, 4> parsed; std::sscanf(newValue.data(), "%1hhi%1hhi%1hhi%1hhi", &parsed[0], &parsed[1], &parsed[2], &parsed[3]) == 4)
|
|
{
|
|
value = parsed;
|
|
body += "applied";
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
body += fmt::format("could not parse {}", newValue);
|
|
return false;
|
|
}
|
|
}
|
|
} // namespace
|
|
|
|
esp_err_t webserver_saveSettings_handler(httpd_req_t *req)
|
|
{
|
|
|
|
std::string query;
|
|
if (auto result = esphttpdutils::webserver_get_query(req))
|
|
query = *result;
|
|
else
|
|
{
|
|
ESP_LOGE(TAG, "%.*s", result.error().size(), result.error().data());
|
|
CALL_AND_EXIT(esphttpdutils::webserver_resp_send, req, esphttpdutils::ResponseStatus::BadRequest, "text/plain", result.error());
|
|
}
|
|
|
|
std::string body;
|
|
bool success{true};
|
|
|
|
profileSettings.executeForEveryProfileSetting([&](std::string_view key, auto &value){
|
|
char valueBufEncoded[256];
|
|
if (const auto result = httpd_query_key_value(query.data(), key.data(), valueBufEncoded, 256); result != ESP_OK)
|
|
{
|
|
if (result != ESP_ERR_NOT_FOUND)
|
|
{
|
|
const auto msg = fmt::format("{}: httpd_query_key_value() failed with {}", key, esp_err_to_name(result));
|
|
ESP_LOGE(TAG, "%.*s", msg.size(), msg.data());
|
|
body += msg;
|
|
body += '\n';
|
|
success = false;
|
|
}
|
|
return;
|
|
}
|
|
|
|
char valueBuf[257];
|
|
esphttpdutils::urldecode(valueBuf, valueBufEncoded);
|
|
|
|
body += key;
|
|
if (!saveSetting(value, valueBuf, body))
|
|
success = false;
|
|
body += '\n';
|
|
});
|
|
|
|
if (body.empty())
|
|
CALL_AND_EXIT(esphttpdutils::webserver_resp_send, req, esphttpdutils::ResponseStatus::Ok, "text/plain", "nothing changed?!")
|
|
|
|
if (settingsPersister.save(profileSettings))
|
|
body += "settings persisted successfully";
|
|
else
|
|
{
|
|
body += "error while persisting settings";
|
|
success = false;
|
|
}
|
|
|
|
if (success)
|
|
{
|
|
CALL_AND_EXIT_ON_ERROR(httpd_resp_set_hdr, req, "Location", "/settings")
|
|
body += "\nOk, continue at /settings";
|
|
}
|
|
|
|
CALL_AND_EXIT(esphttpdutils::webserver_resp_send,
|
|
req,
|
|
success ? esphttpdutils::ResponseStatus::TemporaryRedirect : esphttpdutils::ResponseStatus::BadRequest,
|
|
"text/plain",
|
|
body)
|
|
}
|