first commit using PsychicHttp

2025-12-07 08:19:52 +03:00 · 2023-12-25 13:27:02 +01:00
parent 68cb94547e
commit 73a51ae4ad
169 changed files with 7162 additions and 12208 deletions
--- a/lib/framework/HttpEndpoint.h
+++ b/lib/framework/HttpEndpoint.h
@@ -3,12 +3,13 @@

 #include <functional>

-#include <ESPAsyncWebServer.h>
+#include <PsychicHttp.h>

 #include <SecurityManager.h>
 #include <StatefulService.h>

 #define HTTP_ENDPOINT_ORIGIN_ID "http"
+#define HTTPS_ENDPOINT_ORIGIN_ID "https"

 using namespace std::placeholders; // for `_1` etc

@@ -17,40 +18,43 @@ class HttpGetEndpoint {
  public:
    HttpGetEndpoint(JsonStateReader<T>      stateReader,
                    StatefulService<T> *    statefulService,
-                    AsyncWebServer *        server,
-                    const String &          servicePath,
+                    PsychicHttpServer *     server,
+                    const char *            servicePath,
                    SecurityManager *       securityManager,
                    AuthenticationPredicate authenticationPredicate = AuthenticationPredicates::IS_ADMIN,
                    size_t                  bufferSize              = DEFAULT_BUFFER_SIZE)
        : _stateReader(stateReader)
        , _statefulService(statefulService)
-        , _bufferSize(bufferSize) {
-        server->on(servicePath.c_str(), HTTP_GET, securityManager->wrapRequest(std::bind(&HttpGetEndpoint::fetchSettings, this, _1), authenticationPredicate));
-    }
-
-    HttpGetEndpoint(JsonStateReader<T>   stateReader,
-                    StatefulService<T> * statefulService,
-                    AsyncWebServer *     server,
-                    const String &       servicePath,
-                    size_t               bufferSize = DEFAULT_BUFFER_SIZE)
-        : _stateReader(stateReader)
-        , _statefulService(statefulService)
-        , _bufferSize(bufferSize) {
-        server->on(servicePath.c_str(), HTTP_GET, std::bind(&HttpGetEndpoint::fetchSettings, this, _1));
+        , _bufferSize(bufferSize)
+        , _server(server)
+        , _servicePath(servicePath)
+        , _securityManager(securityManager)
+        , _authenticationPredicate(authenticationPredicate) {
    }

  protected:
-    JsonStateReader<T>   _stateReader;
-    StatefulService<T> * _statefulService;
-    size_t               _bufferSize;
+    JsonStateReader<T>      _stateReader;
+    StatefulService<T> *    _statefulService;
+    size_t                  _bufferSize;
+    PsychicHttpServer *     _server;
+    const char *            _servicePath;
+    SecurityManager *       _securityManager;
+    AuthenticationPredicate _authenticationPredicate;

-    void fetchSettings(AsyncWebServerRequest * request) {
-        AsyncJsonResponse * response   = new AsyncJsonResponse(false, _bufferSize);
-        JsonObject          jsonObject = response->getRoot().to<JsonObject>();
-        _statefulService->read(jsonObject, _stateReader);
-
-        response->setLength();
-        request->send(response);
+    void registerURI() {
+#ifdef EMSESP_DEBUG
+        ESP_LOGE("HttpGetEndpoint", "Addding GET endpoint %s", _servicePath);
+#endif
+        _server->on(_servicePath,
+                    HTTP_GET,
+                    _securityManager->wrapRequest(
+                        [this](PsychicRequest * request) {
+                            PsychicJsonResponse response   = PsychicJsonResponse(request, false, _bufferSize);
+                            JsonObject          jsonObject = response.getRoot();
+                            _statefulService->read(jsonObject, _stateReader);
+                            return response.send();
+                        },
+                        _authenticationPredicate));
    }
 };

@@ -60,63 +64,67 @@ class HttpPostEndpoint {
    HttpPostEndpoint(JsonStateReader<T>      stateReader,
                     JsonStateUpdater<T>     stateUpdater,
                     StatefulService<T> *    statefulService,
-                     AsyncWebServer *        server,
-                     const String &          servicePath,
+                     PsychicHttpServer *     server,
+                     const char *            servicePath,
                     SecurityManager *       securityManager,
                     AuthenticationPredicate authenticationPredicate = AuthenticationPredicates::IS_ADMIN,
                     size_t                  bufferSize              = DEFAULT_BUFFER_SIZE)
        : _stateReader(stateReader)
        , _stateUpdater(stateUpdater)
        , _statefulService(statefulService)
-        , _updateHandler(servicePath, securityManager->wrapCallback(std::bind(&HttpPostEndpoint::updateSettings, this, _1, _2), authenticationPredicate), bufferSize)
+        , _server(server)
+        , _servicePath(servicePath)
+        , _securityManager(securityManager)
+        , _authenticationPredicate(authenticationPredicate)
        , _bufferSize(bufferSize) {
-        _updateHandler.setMethod(HTTP_POST);
-        server->addHandler(&_updateHandler);
    }

-    HttpPostEndpoint(JsonStateReader<T>   stateReader,
-                     JsonStateUpdater<T>  stateUpdater,
-                     StatefulService<T> * statefulService,
-                     AsyncWebServer *     server,
-                     const String &       servicePath,
-                     size_t               bufferSize = DEFAULT_BUFFER_SIZE)
-        : _stateReader(stateReader)
-        , _stateUpdater(stateUpdater)
-        , _statefulService(statefulService)
-        , _updateHandler(servicePath, std::bind(&HttpPostEndpoint::updateSettings, this, _1, _2), bufferSize)
-        , _bufferSize(bufferSize) {
-        _updateHandler.setMethod(HTTP_POST);
-        server->addHandler(&_updateHandler);
-    }

  protected:
-    JsonStateReader<T>          _stateReader;
-    JsonStateUpdater<T>         _stateUpdater;
-    StatefulService<T> *        _statefulService;
-    AsyncCallbackJsonWebHandler _updateHandler;
-    size_t                      _bufferSize;
+    JsonStateReader<T>      _stateReader;
+    JsonStateUpdater<T>     _stateUpdater;
+    StatefulService<T> *    _statefulService;
+    size_t                  _bufferSize;
+    SecurityManager *       _securityManager;
+    AuthenticationPredicate _authenticationPredicate;
+    PsychicHttpServer *     _server;
+    const char *            _servicePath;

-    void updateSettings(AsyncWebServerRequest * request, JsonVariant & json) {
-        if (!json.is<JsonObject>()) {
-            request->send(400);
-            return;
-        }
-        JsonObject        jsonObject = json.as<JsonObject>();
-        StateUpdateResult outcome    = _statefulService->updateWithoutPropagation(jsonObject, _stateUpdater);
-        if (outcome == StateUpdateResult::ERROR) {
-            request->send(400);
-            return;
-        } else if ((outcome == StateUpdateResult::CHANGED) || (outcome == StateUpdateResult::CHANGED_RESTART)) {
-            request->onDisconnect([this]() { _statefulService->callUpdateHandlers(HTTP_ENDPOINT_ORIGIN_ID); });
-        }
-        AsyncJsonResponse * response = new AsyncJsonResponse(false, _bufferSize);
-        jsonObject                   = response->getRoot().to<JsonObject>();
-        _statefulService->read(jsonObject, _stateReader);
-        if (outcome == StateUpdateResult::CHANGED_RESTART) {
-            response->setCode(205); // reboot required
-        }
-        response->setLength();
-        request->send(response);
+    void registerURI() {
+#ifdef EMSESP_DEBUG
+        ESP_LOGE("HttpPostEndpoint", "Addding POST endpoint %s", _servicePath);
+#endif
+        _server->on(_servicePath,
+                    HTTP_POST,
+                    _securityManager->wrapCallback(
+                        [this](PsychicRequest * request, JsonVariant & json) {
+                            if (!json.is<JsonObject>()) {
+                                return request->reply(400);
+                            }
+
+                            JsonObject        jsonObject = json.as<JsonObject>();
+                            StateUpdateResult outcome    = _statefulService->updateWithoutPropagation(jsonObject, _stateUpdater);
+
+                            if (outcome == StateUpdateResult::ERROR) {
+                                return request->reply(400);
+                            } else if ((outcome == StateUpdateResult::CHANGED) || (outcome == StateUpdateResult::CHANGED_RESTART)) {
+                                // TODO see if this works as intended. Before the stat was updated on an onDisconnect
+                                // request->onDisconnect([this]() { _statefulService->callUpdateHandlers(HTTP_ENDPOINT_ORIGIN_ID); });
+                                // TODO add https
+                                _statefulService->callUpdateHandlers(HTTP_ENDPOINT_ORIGIN_ID); // persist the changes to the FS
+                            }
+
+                            PsychicJsonResponse response = PsychicJsonResponse(request, false, _bufferSize);
+                            jsonObject                   = response.getRoot();
+
+                            _statefulService->read(jsonObject, _stateReader);
+
+                            if (outcome == StateUpdateResult::CHANGED_RESTART) {
+                                return request->reply(205); // reboot required
+                            }
+                            return response.send();
+                        },
+                        _authenticationPredicate));
    }
 };

@@ -126,8 +134,8 @@ class HttpEndpoint : public HttpGetEndpoint<T>, public HttpPostEndpoint<T> {
    HttpEndpoint(JsonStateReader<T>      stateReader,
                 JsonStateUpdater<T>     stateUpdater,
                 StatefulService<T> *    statefulService,
-                 AsyncWebServer *        server,
-                 const String &          servicePath,
+                 PsychicHttpServer *     server,
+                 const char *            servicePath,
                 SecurityManager *       securityManager,
                 AuthenticationPredicate authenticationPredicate = AuthenticationPredicates::IS_ADMIN,
                 size_t                  bufferSize              = DEFAULT_BUFFER_SIZE)
@@ -135,14 +143,10 @@ class HttpEndpoint : public HttpGetEndpoint<T>, public HttpPostEndpoint<T> {
        , HttpPostEndpoint<T>(stateReader, stateUpdater, statefulService, server, servicePath, securityManager, authenticationPredicate, bufferSize) {
    }

-    HttpEndpoint(JsonStateReader<T>   stateReader,
-                 JsonStateUpdater<T>  stateUpdater,
-                 StatefulService<T> * statefulService,
-                 AsyncWebServer *     server,
-                 const String &       servicePath,
-                 size_t               bufferSize = DEFAULT_BUFFER_SIZE)
-        : HttpGetEndpoint<T>(stateReader, statefulService, server, servicePath, bufferSize)
-        , HttpPostEndpoint<T>(stateReader, stateUpdater, statefulService, server, servicePath, bufferSize) {
+    // register the web server on() endpoints
+    void registerURI() {
+        HttpGetEndpoint<T>::registerURI();
+        HttpPostEndpoint<T>::registerURI();
    }
 };