Merge branch 'dev' into dev2

2025-12-09 01:09:51 +03:00 · 2024-03-15 17:43:08 +01:00
parent 7ba330176a 21207f88f3
commit fbfaea6b56
52 changed files with 3584 additions and 4061 deletions
--- a/src/web/WebAPIService.cpp
+++ b/src/web/WebAPIService.cpp
@@ -24,12 +24,11 @@ uint32_t WebAPIService::api_count_ = 0;
 uint16_t WebAPIService::api_fails_ = 0;

 WebAPIService::WebAPIService(AsyncWebServer * server, SecurityManager * securityManager)
-    : _securityManager(securityManager)
-    , _apiHandler(EMSESP_API_SERVICE_PATH, [this](AsyncWebServerRequest * request, JsonVariant json) { webAPIService_post(request, json); }) { // for POSTs
-    server->on(EMSESP_API_SERVICE_PATH, HTTP_GET, [this](AsyncWebServerRequest * request) { webAPIService_get(request); });                    // for GETs
-    server->addHandler(&_apiHandler);
+    : _securityManager(securityManager) {
+    // API
+    server->on(EMSESP_API_SERVICE_PATH, [this](AsyncWebServerRequest * request, JsonVariant json) { webAPIService(request, json); });

-    // for settings
+    // settings
    server->on(GET_SETTINGS_PATH,
               HTTP_GET,
               securityManager->wrapRequest([this](AsyncWebServerRequest * request) { getSettings(request); }, AuthenticationPredicates::IS_ADMIN));
@@ -47,31 +46,30 @@ WebAPIService::WebAPIService(AsyncWebServer * server, SecurityManager * security
               securityManager->wrapRequest([this](AsyncWebServerRequest * request) { getEntities(request); }, AuthenticationPredicates::IS_ADMIN));
 }

-// HTTP GET
-// GET /{device}
-// GET /{device}/{entity}
-void WebAPIService::webAPIService_get(AsyncWebServerRequest * request) {
-    // has no body JSON so create dummy as empty input object
-    JsonDocument input_doc;
-    JsonObject   input = input_doc.to<JsonObject>();
-    parse(request, input);
-}
-
-// For HTTP POSTS with an optional JSON body
-// HTTP_POST | HTTP_PUT | HTTP_PATCH
-// POST /{device}[/{hc|id}][/{name}]
-void WebAPIService::webAPIService_post(AsyncWebServerRequest * request, JsonVariant json) {
+// POST|GET /{device}
+// POST|GET /{device}/{entity}
+void WebAPIService::webAPIService(AsyncWebServerRequest * request, JsonVariant json) {
+    JsonObject input;
    // if no body then treat it as a secure GET
-    if (!json.is<JsonObject>()) {
-        webAPIService_get(request);
-        return;
+    if ((request->method() == HTTP_GET) || (!json.is<JsonObject>())) {
+        // HTTP GET
+        JsonDocument input_doc; // has no body JSON so create dummy as empty input object
+        input = input_doc.to<JsonObject>();
+    } else {
+        // HTTP_POST | HTTP_PUT | HTTP_PATCH
+        input = json.as<JsonObject>(); // extract values from the json. these will be used as default values
    }
-
-    // extract values from the json. these will be used as default values
-    auto && input = json.as<JsonObject>();
    parse(request, input);
 }

+#ifdef EMSESP_TEST
+// for test.cpp so we can invoke GETs to test the API
+void WebAPIService::webAPIService(AsyncWebServerRequest * request) {
+    JsonDocument input_doc;
+    parse(request, input_doc.to<JsonObject>());
+}
+#endif
+
 // parse the URL looking for query or path parameters
 // reporting back any errors
 void WebAPIService::parse(AsyncWebServerRequest * request, JsonObject input) {
@@ -84,7 +82,7 @@ void WebAPIService::parse(AsyncWebServerRequest * request, JsonObject input) {

    // check for query parameters first, the old style from v2
    // api?device={device}&cmd={name}&data={value}&id={hc}
-    if (request->url() == "/api") {
+    if (request->url() == EMSESP_API_SERVICE_PATH) {
        // get the device
        if (request->hasParam(F_(device))) {
            input["device"] = request->getParam(F_(device))->value().c_str();
--- a/src/web/WebAPIService.h
+++ b/src/web/WebAPIService.h
@@ -20,6 +20,7 @@
 #define WebAPIService_h

 #define EMSESP_API_SERVICE_PATH "/api"
+
 #define GET_SETTINGS_PATH "/rest/getSettings"
 #define GET_CUSTOMIZATIONS_PATH "/rest/getCustomizations"
 #define GET_SCHEDULE_PATH "/rest/getSchedule"
@@ -31,8 +32,12 @@ class WebAPIService {
  public:
    WebAPIService(AsyncWebServer * server, SecurityManager * securityManager);

-    void webAPIService_post(AsyncWebServerRequest * request, JsonVariant json); // for POSTs
-    void webAPIService_get(AsyncWebServerRequest * request);                    // for GETs
+    void webAPIService(AsyncWebServerRequest * request, JsonVariant json);
+
+#ifdef EMSESP_TEST
+    // for test.cpp
+    void webAPIService(AsyncWebServerRequest * request);
+#endif

    static uint32_t api_count() {
        return api_count_;
@@ -43,14 +48,12 @@ class WebAPIService {
    }

  private:
-    SecurityManager *           _securityManager;
-    AsyncCallbackJsonWebHandler _apiHandler; // for POSTs
+    SecurityManager * _securityManager;

    static uint32_t api_count_;
    static uint16_t api_fails_;

    void parse(AsyncWebServerRequest * request, JsonObject input);
-
    void getSettings(AsyncWebServerRequest * request);
    void getCustomizations(AsyncWebServerRequest * request);
    void getSchedule(AsyncWebServerRequest * request);
--- a/src/web/WebCustomizationService.cpp
+++ b/src/web/WebCustomizationService.cpp
@@ -23,10 +23,7 @@ namespace emsesp {
 bool WebCustomization::_start = true;

 WebCustomizationService::WebCustomizationService(AsyncWebServer * server, FS * fs, SecurityManager * securityManager)
-    : _fsPersistence(WebCustomization::read, WebCustomization::update, this, fs, EMSESP_CUSTOMIZATION_FILE)
-    , _masked_entities_handler(CUSTOMIZATION_ENTITIES_PATH,
-                               securityManager->wrapCallback([this](AsyncWebServerRequest * request, JsonVariant json) { customization_entities(request, json); },
-                                                             AuthenticationPredicates::IS_AUTHENTICATED)) {
+    : _fsPersistence(WebCustomization::read, WebCustomization::update, this, fs, EMSESP_CUSTOMIZATION_FILE) {
    server->on(DEVICE_ENTITIES_PATH,
               HTTP_GET,
               securityManager->wrapRequest([this](AsyncWebServerRequest * request) { device_entities(request); }, AuthenticationPredicates::IS_AUTHENTICATED));
@@ -39,9 +36,9 @@ WebCustomizationService::WebCustomizationService(AsyncWebServer * server, FS * f
               HTTP_POST,
               securityManager->wrapRequest([this](AsyncWebServerRequest * request) { reset_customization(request); }, AuthenticationPredicates::IS_ADMIN));

-    _masked_entities_handler.setMethod(HTTP_POST);
-    _masked_entities_handler.setMaxContentLength(2048);
-    server->addHandler(&_masked_entities_handler);
+    server->on(CUSTOMIZATION_ENTITIES_PATH,
+               securityManager->wrapCallback([this](AsyncWebServerRequest * request, JsonVariant json) { customization_entities(request, json); },
+                                             AuthenticationPredicates::IS_AUTHENTICATED));
 }

 // this creates the customization file, saving it to the FS
--- a/src/web/WebCustomizationService.h
+++ b/src/web/WebCustomizationService.h
@@ -101,8 +101,6 @@ class WebCustomizationService : public StatefulService<WebCustomization> {
    // POST
    void customization_entities(AsyncWebServerRequest * request, JsonVariant json);
    void reset_customization(AsyncWebServerRequest * request); // command
-
-    AsyncCallbackJsonWebHandler _masked_entities_handler;
 };

 } // namespace emsesp
--- a/src/web/WebDataService.cpp
+++ b/src/web/WebDataService.cpp
@@ -21,16 +21,18 @@
 namespace emsesp {

 WebDataService::WebDataService(AsyncWebServer * server, SecurityManager * securityManager)
-    : _write_value_handler(WRITE_DEVICE_VALUE_SERVICE_PATH,
-                           securityManager->wrapCallback([this](AsyncWebServerRequest * request, JsonVariant json) { write_device_value(request, json); },
-                                                         AuthenticationPredicates::IS_ADMIN))
-    , _write_temperature_handler(WRITE_TEMPERATURE_SENSOR_SERVICE_PATH,
-                                 securityManager->wrapCallback([this](AsyncWebServerRequest * request,
-                                                                      JsonVariant             json) { write_temperature_sensor(request, json); },
-                                                               AuthenticationPredicates::IS_ADMIN))
-    , _write_analog_handler(WRITE_ANALOG_SENSOR_SERVICE_PATH,
-                            securityManager->wrapCallback([this](AsyncWebServerRequest * request, JsonVariant json) { write_analog_sensor(request, json); },
-                                                          AuthenticationPredicates::IS_ADMIN)) {
+
+{
+    // write endpoints
+    server->on(WRITE_DEVICE_VALUE_SERVICE_PATH,
+               securityManager->wrapCallback([this](AsyncWebServerRequest * request, JsonVariant json) { write_device_value(request, json); },
+                                             AuthenticationPredicates::IS_ADMIN));
+    server->on(WRITE_TEMPERATURE_SENSOR_SERVICE_PATH,
+               securityManager->wrapCallback([this](AsyncWebServerRequest * request, JsonVariant json) { write_temperature_sensor(request, json); },
+                                             AuthenticationPredicates::IS_ADMIN));
+    server->on(WRITE_ANALOG_SENSOR_SERVICE_PATH,
+               securityManager->wrapCallback([this](AsyncWebServerRequest * request, JsonVariant json) { write_analog_sensor(request, json); },
+                                             AuthenticationPredicates::IS_ADMIN));
    // GET's
    server->on(DEVICE_DATA_SERVICE_PATH,
               HTTP_GET,
@@ -49,19 +51,6 @@ WebDataService::WebDataService(AsyncWebServer * server, SecurityManager * securi
    server->on(SCAN_DEVICES_SERVICE_PATH,
               HTTP_POST,
               securityManager->wrapRequest([this](AsyncWebServerRequest * request) { scan_devices(request); }, AuthenticationPredicates::IS_ADMIN));
-
-
-    _write_value_handler.setMethod(HTTP_POST);
-    _write_value_handler.setMaxContentLength(256);
-    server->addHandler(&_write_value_handler);
-
-    _write_temperature_handler.setMethod(HTTP_POST);
-    _write_temperature_handler.setMaxContentLength(256);
-    server->addHandler(&_write_temperature_handler);
-
-    _write_analog_handler.setMethod(HTTP_POST);
-    _write_analog_handler.setMaxContentLength(256);
-    server->addHandler(&_write_analog_handler);
 }

 // scan devices service
--- a/src/web/WebDataService.h
+++ b/src/web/WebDataService.h
@@ -51,8 +51,6 @@ class WebDataService {
    void write_temperature_sensor(AsyncWebServerRequest * request, JsonVariant json);
    void write_analog_sensor(AsyncWebServerRequest * request, JsonVariant json);
    void scan_devices(AsyncWebServerRequest * request); // command
-
-    AsyncCallbackJsonWebHandler _write_value_handler, _write_temperature_handler, _write_analog_handler;
 };

 } // namespace emsesp
--- a/src/web/WebLogService.cpp
+++ b/src/web/WebLogService.cpp
@@ -21,17 +21,14 @@
 namespace emsesp {

 WebLogService::WebLogService(AsyncWebServer * server, SecurityManager * securityManager)
-    : events_(EVENT_SOURCE_LOG_PATH)
-    , setValues_(LOG_SETTINGS_PATH, [this](AsyncWebServerRequest * request, JsonVariant json) { setValues(request, json); }) {
-    events_.setFilter(securityManager->filterRequest(AuthenticationPredicates::IS_ADMIN));
-
-    // get settings
-    server->on(LOG_SETTINGS_PATH, HTTP_GET, [this](AsyncWebServerRequest * request) { getValues(request); });
+    : events_(EVENT_SOURCE_LOG_PATH) {
+    // get & set settings
+    server->on(LOG_SETTINGS_PATH, [this](AsyncWebServerRequest * request, JsonVariant json) { getSetValues(request, json); });

    // for bring back the whole log - is a command, hence a POST
    server->on(FETCH_LOG_PATH, HTTP_POST, [this](AsyncWebServerRequest * request) { fetchLog(request); });

-    server->addHandler(&setValues_);
+    events_.setFilter(securityManager->filterRequest(AuthenticationPredicates::IS_ADMIN));
    server->addHandler(&events_);
 }

@@ -204,11 +201,20 @@ void WebLogService::fetchLog(AsyncWebServerRequest * request) {
 }

 // sets the values like level after a POST
-void WebLogService::setValues(AsyncWebServerRequest * request, JsonVariant json) {
-    if (!json.is<JsonObject>()) {
+void WebLogService::getSetValues(AsyncWebServerRequest * request, JsonVariant json) {
+    if ((request->method() == HTTP_GET) || (!json.is<JsonObject>())) {
+        // GET - return the values
+        auto *     response  = new AsyncJsonResponse(false);
+        JsonObject root      = response->getRoot();
+        root["level"]        = log_level();
+        root["max_messages"] = maximum_log_messages();
+        root["compact"]      = compact();
+        response->setLength();
+        request->send(response);
        return;
    }

+    // POST - write the settings
    auto && body = json.as<JsonObject>();

    uuid::log::Level level = body["level"];
@@ -223,15 +229,4 @@ void WebLogService::setValues(AsyncWebServerRequest * request, JsonVariant json)
    request->send(200); // OK
 }

-// return the current value settings after a GET
-void WebLogService::getValues(AsyncWebServerRequest * request) {
-    auto *     response  = new AsyncJsonResponse(false);
-    JsonObject root      = response->getRoot();
-    root["level"]        = log_level();
-    root["max_messages"] = maximum_log_messages();
-    root["compact"]      = compact();
-    response->setLength();
-    request->send(response);
-}
-
 } // namespace emsesp
--- a/src/web/WebLogService.h
+++ b/src/web/WebLogService.h
@@ -60,14 +60,10 @@ class WebLogService : public uuid::log::Handler {

    void transmit(const QueuedLogMessage & message);
    void fetchLog(AsyncWebServerRequest * request);
-    void getValues(AsyncWebServerRequest * request);
+    void getSetValues(AsyncWebServerRequest * request, JsonVariant json);

    char * messagetime(char * out, const uint64_t t, const size_t bufsize);

-    void setValues(AsyncWebServerRequest * request, JsonVariant json);
-
-    AsyncCallbackJsonWebHandler setValues_; // for POSTs
-
    uint64_t                     last_transmit_        = 0;                // Last transmit time
    size_t                       maximum_log_messages_ = MAX_LOG_MESSAGES; // Maximum number of log messages to buffer before they are output
    size_t                       limit_log_messages_   = 1;                // dynamic limit