diff --git a/lib/framework/APSettingsService.cpp b/lib/framework/APSettingsService.cpp
index 57339cde7..41350f2f9 100644
--- a/lib/framework/APSettingsService.cpp
+++ b/lib/framework/APSettingsService.cpp
@@ -1,83 +1,81 @@
 #include <APSettingsService.h>
 
-APSettingsService::APSettingsService(AsyncWebServer* server, FS* fs, SecurityManager* securityManager) :
-    _httpEndpoint(APSettings::read, APSettings::update, this, server, AP_SETTINGS_SERVICE_PATH, securityManager),
-    _fsPersistence(APSettings::read, APSettings::update, this, fs, AP_SETTINGS_FILE),
-    _dnsServer(nullptr),
-    _lastManaged(0),
-    _reconfigureAp(false) {
-  addUpdateHandler([&](const String& originId) { reconfigureAP(); }, false);
+APSettingsService::APSettingsService(AsyncWebServer * server, FS * fs, SecurityManager * securityManager)
+    : _httpEndpoint(APSettings::read, APSettings::update, this, server, AP_SETTINGS_SERVICE_PATH, securityManager)
+    , _fsPersistence(APSettings::read, APSettings::update, this, fs, AP_SETTINGS_FILE)
+    , _dnsServer(nullptr)
+    , _lastManaged(0)
+    , _reconfigureAp(false) {
+    addUpdateHandler([&](const String & originId) { reconfigureAP(); }, false);
 }
 
 void APSettingsService::begin() {
-  _fsPersistence.readFromFS();
-  reconfigureAP();
+    _fsPersistence.readFromFS();
+    reconfigureAP();
 }
 
 void APSettingsService::reconfigureAP() {
-  _lastManaged = uuid::get_uptime() - MANAGE_NETWORK_DELAY;
-  _reconfigureAp = true;
+    _lastManaged   = uuid::get_uptime() - MANAGE_NETWORK_DELAY;
+    _reconfigureAp = true;
 }
 
 void APSettingsService::loop() {
-  unsigned long currentMillis = uuid::get_uptime();
-  unsigned long manageElapsed = (unsigned long)(currentMillis - _lastManaged);
-  if (manageElapsed >= MANAGE_NETWORK_DELAY) {
-    _lastManaged = currentMillis;
-    manageAP();
-  }
-  handleDNS();
+    unsigned long currentMillis = uuid::get_uptime();
+    unsigned long manageElapsed = (unsigned long)(currentMillis - _lastManaged);
+    if (manageElapsed >= MANAGE_NETWORK_DELAY) {
+        _lastManaged = currentMillis;
+        manageAP();
+    }
+    handleDNS();
 }
 
 void APSettingsService::manageAP() {
-  WiFiMode_t currentWiFiMode = WiFi.getMode();
-  if (_state.provisionMode == AP_MODE_ALWAYS ||
-      (_state.provisionMode == AP_MODE_DISCONNECTED && WiFi.status() != WL_CONNECTED)) {
-    if (_reconfigureAp || currentWiFiMode == WIFI_OFF || currentWiFiMode == WIFI_STA) {
-      startAP();
+    WiFiMode_t currentWiFiMode = WiFi.getMode();
+    if (_state.provisionMode == AP_MODE_ALWAYS || (_state.provisionMode == AP_MODE_DISCONNECTED && WiFi.status() != WL_CONNECTED)) {
+        if (_reconfigureAp || currentWiFiMode == WIFI_OFF || currentWiFiMode == WIFI_STA) {
+            startAP();
+        }
+    } else if ((currentWiFiMode == WIFI_AP || currentWiFiMode == WIFI_AP_STA) && (_reconfigureAp || !WiFi.softAPgetStationNum())) {
+        stopAP();
     }
-  } else if ((currentWiFiMode == WIFI_AP || currentWiFiMode == WIFI_AP_STA) &&
-             (_reconfigureAp || !WiFi.softAPgetStationNum())) {
-    stopAP();
-  }
-  _reconfigureAp = false;
+    _reconfigureAp = false;
 }
 
 void APSettingsService::startAP() {
-  // Serial.println(F("Starting software access point"));
-  WiFi.softAPConfig(_state.localIP, _state.gatewayIP, _state.subnetMask);
-  WiFi.softAP(_state.ssid.c_str(), _state.password.c_str());
-  if (!_dnsServer) {
-    IPAddress apIp = WiFi.softAPIP();
-    // Serial.print(F("Starting captive portal on "));
-    // Serial.println(apIp);
-    _dnsServer = new DNSServer;
-    _dnsServer->start(DNS_PORT, "*", apIp);
-  }
+    // Serial.println(F("Starting software access point"));
+    WiFi.softAPConfig(_state.localIP, _state.gatewayIP, _state.subnetMask);
+    WiFi.softAP(_state.ssid.c_str(), _state.password.c_str());
+    if (!_dnsServer) {
+        IPAddress apIp = WiFi.softAPIP();
+        // Serial.print(F("Starting captive portal on "));
+        // Serial.println(apIp);
+        _dnsServer = new DNSServer;
+        _dnsServer->start(DNS_PORT, "*", apIp);
+    }
 }
 
 void APSettingsService::stopAP() {
-  if (_dnsServer) {
-    // Serial.println(F("Stopping captive portal"));
-    _dnsServer->stop();
-    delete _dnsServer;
-    _dnsServer = nullptr;
-  }
-  // Serial.println(F("Stopping software access point"));
-  WiFi.softAPdisconnect(true);
+    if (_dnsServer) {
+        // Serial.println(F("Stopping captive portal"));
+        _dnsServer->stop();
+        delete _dnsServer;
+        _dnsServer = nullptr;
+    }
+    // Serial.println(F("Stopping software access point"));
+    WiFi.softAPdisconnect(true);
 }
 
 void APSettingsService::handleDNS() {
-  if (_dnsServer) {
-    _dnsServer->processNextRequest();
-  }
+    if (_dnsServer) {
+        _dnsServer->processNextRequest();
+    }
 }
 
 APNetworkStatus APSettingsService::getAPNetworkStatus() {
-  WiFiMode_t currentWiFiMode = WiFi.getMode();
-  bool apActive = currentWiFiMode == WIFI_AP || currentWiFiMode == WIFI_AP_STA;
-  if (apActive && _state.provisionMode != AP_MODE_ALWAYS && WiFi.status() == WL_CONNECTED) {
-    return APNetworkStatus::LINGERING;
-  }
-  return apActive ? APNetworkStatus::ACTIVE : APNetworkStatus::INACTIVE;
+    WiFiMode_t currentWiFiMode = WiFi.getMode();
+    bool       apActive        = currentWiFiMode == WIFI_AP || currentWiFiMode == WIFI_AP_STA;
+    if (apActive && _state.provisionMode != AP_MODE_ALWAYS && WiFi.status() == WL_CONNECTED) {
+        return APNetworkStatus::LINGERING;
+    }
+    return apActive ? APNetworkStatus::ACTIVE : APNetworkStatus::INACTIVE;
 }
diff --git a/lib/framework/APSettingsService.h b/lib/framework/APSettingsService.h
index 991edb23d..abc6aca9a 100644
--- a/lib/framework/APSettingsService.h
+++ b/lib/framework/APSettingsService.h
@@ -48,78 +48,78 @@
 enum APNetworkStatus { ACTIVE = 0, INACTIVE, LINGERING };
 
 class APSettings {
- public:
-  uint8_t provisionMode;
-  String ssid;
-  String password;
-  IPAddress localIP;
-  IPAddress gatewayIP;
-  IPAddress subnetMask;
+  public:
+    uint8_t   provisionMode;
+    String    ssid;
+    String    password;
+    IPAddress localIP;
+    IPAddress gatewayIP;
+    IPAddress subnetMask;
 
-  bool operator==(const APSettings& settings) const {
-    return provisionMode == settings.provisionMode && ssid == settings.ssid && password == settings.password &&
-           localIP == settings.localIP && gatewayIP == settings.gatewayIP && subnetMask == settings.subnetMask;
-  }
-
-  static void read(APSettings& settings, JsonObject& root) {
-    root["provision_mode"] = settings.provisionMode;
-    root["ssid"] = settings.ssid;
-    root["password"] = settings.password;
-    root["local_ip"] = settings.localIP.toString();
-    root["gateway_ip"] = settings.gatewayIP.toString();
-    root["subnet_mask"] = settings.subnetMask.toString();
-  }
-
-  static StateUpdateResult update(JsonObject& root, APSettings& settings) {
-    APSettings newSettings = {};
-    newSettings.provisionMode = root["provision_mode"] | FACTORY_AP_PROVISION_MODE;
-    switch (settings.provisionMode) {
-      case AP_MODE_ALWAYS:
-      case AP_MODE_DISCONNECTED:
-      case AP_MODE_NEVER:
-        break;
-      default:
-        newSettings.provisionMode = AP_MODE_ALWAYS;
+    bool operator==(const APSettings & settings) const {
+        return provisionMode == settings.provisionMode && ssid == settings.ssid && password == settings.password && localIP == settings.localIP
+               && gatewayIP == settings.gatewayIP && subnetMask == settings.subnetMask;
     }
-    newSettings.ssid = root["ssid"] | FACTORY_AP_SSID;
-    newSettings.password = root["password"] | FACTORY_AP_PASSWORD;
 
-    JsonUtils::readIP(root, "local_ip", newSettings.localIP, FACTORY_AP_LOCAL_IP);
-    JsonUtils::readIP(root, "gateway_ip", newSettings.gatewayIP, FACTORY_AP_GATEWAY_IP);
-    JsonUtils::readIP(root, "subnet_mask", newSettings.subnetMask, FACTORY_AP_SUBNET_MASK);
-
-    if (newSettings == settings) {
-      return StateUpdateResult::UNCHANGED;
+    static void read(APSettings & settings, JsonObject & root) {
+        root["provision_mode"] = settings.provisionMode;
+        root["ssid"]           = settings.ssid;
+        root["password"]       = settings.password;
+        root["local_ip"]       = settings.localIP.toString();
+        root["gateway_ip"]     = settings.gatewayIP.toString();
+        root["subnet_mask"]    = settings.subnetMask.toString();
+    }
+
+    static StateUpdateResult update(JsonObject & root, APSettings & settings) {
+        APSettings newSettings    = {};
+        newSettings.provisionMode = root["provision_mode"] | FACTORY_AP_PROVISION_MODE;
+        switch (settings.provisionMode) {
+        case AP_MODE_ALWAYS:
+        case AP_MODE_DISCONNECTED:
+        case AP_MODE_NEVER:
+            break;
+        default:
+            newSettings.provisionMode = AP_MODE_ALWAYS;
+        }
+        newSettings.ssid     = root["ssid"] | FACTORY_AP_SSID;
+        newSettings.password = root["password"] | FACTORY_AP_PASSWORD;
+
+        JsonUtils::readIP(root, "local_ip", newSettings.localIP, FACTORY_AP_LOCAL_IP);
+        JsonUtils::readIP(root, "gateway_ip", newSettings.gatewayIP, FACTORY_AP_GATEWAY_IP);
+        JsonUtils::readIP(root, "subnet_mask", newSettings.subnetMask, FACTORY_AP_SUBNET_MASK);
+
+        if (newSettings == settings) {
+            return StateUpdateResult::UNCHANGED;
+        }
+        settings = newSettings;
+        return StateUpdateResult::CHANGED;
     }
-    settings = newSettings;
-    return StateUpdateResult::CHANGED;
-  }
 };
 
 class APSettingsService : public StatefulService<APSettings> {
- public:
-  APSettingsService(AsyncWebServer* server, FS* fs, SecurityManager* securityManager);
+  public:
+    APSettingsService(AsyncWebServer * server, FS * fs, SecurityManager * securityManager);
 
-  void begin();
-  void loop();
-  APNetworkStatus getAPNetworkStatus();
+    void            begin();
+    void            loop();
+    APNetworkStatus getAPNetworkStatus();
 
- private:
-  HttpEndpoint<APSettings> _httpEndpoint;
-  FSPersistence<APSettings> _fsPersistence;
+  private:
+    HttpEndpoint<APSettings>  _httpEndpoint;
+    FSPersistence<APSettings> _fsPersistence;
 
-  // for the captive portal
-  DNSServer* _dnsServer;
+    // for the captive portal
+    DNSServer * _dnsServer;
 
-  // for the mangement delay loop
-  volatile unsigned long _lastManaged;
-  volatile boolean _reconfigureAp;
+    // for the mangement delay loop
+    volatile unsigned long _lastManaged;
+    volatile boolean       _reconfigureAp;
 
-  void reconfigureAP();
-  void manageAP();
-  void startAP();
-  void stopAP();
-  void handleDNS();
+    void reconfigureAP();
+    void manageAP();
+    void startAP();
+    void stopAP();
+    void handleDNS();
 };
 
-#endif  // end APSettingsConfig_h
+#endif // end APSettingsConfig_h
diff --git a/lib/framework/APStatus.cpp b/lib/framework/APStatus.cpp
index 5bfe30080..76a4eb16c 100644
--- a/lib/framework/APStatus.cpp
+++ b/lib/framework/APStatus.cpp
@@ -1,22 +1,21 @@
 #include <APStatus.h>
 
-APStatus::APStatus(AsyncWebServer* server, SecurityManager* securityManager, APSettingsService* apSettingsService) :
-    _apSettingsService(apSettingsService) {
-  server->on(AP_STATUS_SERVICE_PATH,
-             HTTP_GET,
-             securityManager->wrapRequest(std::bind(&APStatus::apStatus, this, std::placeholders::_1),
-                                          AuthenticationPredicates::IS_AUTHENTICATED));
+APStatus::APStatus(AsyncWebServer * server, SecurityManager * securityManager, APSettingsService * apSettingsService)
+    : _apSettingsService(apSettingsService) {
+    server->on(AP_STATUS_SERVICE_PATH,
+               HTTP_GET,
+               securityManager->wrapRequest(std::bind(&APStatus::apStatus, this, std::placeholders::_1), AuthenticationPredicates::IS_AUTHENTICATED));
 }
 
-void APStatus::apStatus(AsyncWebServerRequest* request) {
-  AsyncJsonResponse* response = new AsyncJsonResponse(false, MAX_AP_STATUS_SIZE);
-  JsonObject root = response->getRoot();
+void APStatus::apStatus(AsyncWebServerRequest * request) {
+    AsyncJsonResponse * response = new AsyncJsonResponse(false, MAX_AP_STATUS_SIZE);
+    JsonObject          root     = response->getRoot();
 
-  root["status"] = _apSettingsService->getAPNetworkStatus();
-  root["ip_address"] = WiFi.softAPIP().toString();
-  root["mac_address"] = WiFi.softAPmacAddress();
-  root["station_num"] = WiFi.softAPgetStationNum();
+    root["status"]      = _apSettingsService->getAPNetworkStatus();
+    root["ip_address"]  = WiFi.softAPIP().toString();
+    root["mac_address"] = WiFi.softAPmacAddress();
+    root["station_num"] = WiFi.softAPgetStationNum();
 
-  response->setLength();
-  request->send(response);
+    response->setLength();
+    request->send(response);
 }
diff --git a/lib/framework/APStatus.h b/lib/framework/APStatus.h
index 12620b081..e5164b7ac 100644
--- a/lib/framework/APStatus.h
+++ b/lib/framework/APStatus.h
@@ -20,12 +20,12 @@
 #define AP_STATUS_SERVICE_PATH "/rest/apStatus"
 
 class APStatus {
- public:
-  APStatus(AsyncWebServer* server, SecurityManager* securityManager, APSettingsService* apSettingsService);
+  public:
+    APStatus(AsyncWebServer * server, SecurityManager * securityManager, APSettingsService * apSettingsService);
 
- private:
-  APSettingsService* _apSettingsService;
-  void apStatus(AsyncWebServerRequest* request);
+  private:
+    APSettingsService * _apSettingsService;
+    void                apStatus(AsyncWebServerRequest * request);
 };
 
-#endif  // end APStatus_h
+#endif // end APStatus_h
diff --git a/lib/framework/ArduinoJsonJWT.cpp b/lib/framework/ArduinoJsonJWT.cpp
index 8b449e1b4..577948cb4 100644
--- a/lib/framework/ArduinoJsonJWT.cpp
+++ b/lib/framework/ArduinoJsonJWT.cpp
@@ -1,14 +1,15 @@
 #include "ArduinoJsonJWT.h"
 
-ArduinoJsonJWT::ArduinoJsonJWT(String secret) : _secret(secret) {
+ArduinoJsonJWT::ArduinoJsonJWT(String secret)
+    : _secret(secret) {
 }
 
 void ArduinoJsonJWT::setSecret(String secret) {
-  _secret = secret;
+    _secret = secret;
 }
 
 String ArduinoJsonJWT::getSecret() {
-  return _secret;
+    return _secret;
 }
 
 /*
@@ -18,127 +19,127 @@ String ArduinoJsonJWT::getSecret() {
  *
  * No need to pull in additional crypto libraries - lets use what we already have.
  */
-String ArduinoJsonJWT::sign(String& payload) {
-  unsigned char hmacResult[32];
-  {
+String ArduinoJsonJWT::sign(String & payload) {
+    unsigned char hmacResult[32];
+    {
 #ifdef ESP32
-    mbedtls_md_context_t ctx;
-    mbedtls_md_type_t md_type = MBEDTLS_MD_SHA256;
-    mbedtls_md_init(&ctx);
-    mbedtls_md_setup(&ctx, mbedtls_md_info_from_type(md_type), 1);
-    mbedtls_md_hmac_starts(&ctx, (unsigned char*)_secret.c_str(), _secret.length());
-    mbedtls_md_hmac_update(&ctx, (unsigned char*)payload.c_str(), payload.length());
-    mbedtls_md_hmac_finish(&ctx, hmacResult);
-    mbedtls_md_free(&ctx);
+        mbedtls_md_context_t ctx;
+        mbedtls_md_type_t    md_type = MBEDTLS_MD_SHA256;
+        mbedtls_md_init(&ctx);
+        mbedtls_md_setup(&ctx, mbedtls_md_info_from_type(md_type), 1);
+        mbedtls_md_hmac_starts(&ctx, (unsigned char *)_secret.c_str(), _secret.length());
+        mbedtls_md_hmac_update(&ctx, (unsigned char *)payload.c_str(), payload.length());
+        mbedtls_md_hmac_finish(&ctx, hmacResult);
+        mbedtls_md_free(&ctx);
 #elif defined(ESP8266)
-    br_hmac_key_context keyCtx;
-    br_hmac_key_init(&keyCtx, &br_sha256_vtable, _secret.c_str(), _secret.length());
-    br_hmac_context hmacCtx;
-    br_hmac_init(&hmacCtx, &keyCtx, 0);
-    br_hmac_update(&hmacCtx, payload.c_str(), payload.length());
-    br_hmac_out(&hmacCtx, hmacResult);
+        br_hmac_key_context keyCtx;
+        br_hmac_key_init(&keyCtx, &br_sha256_vtable, _secret.c_str(), _secret.length());
+        br_hmac_context hmacCtx;
+        br_hmac_init(&hmacCtx, &keyCtx, 0);
+        br_hmac_update(&hmacCtx, payload.c_str(), payload.length());
+        br_hmac_out(&hmacCtx, hmacResult);
 #endif
-  }
-  return encode((char*)hmacResult, 32);
+    }
+    return encode((char *)hmacResult, 32);
 }
 
-String ArduinoJsonJWT::buildJWT(JsonObject& payload) {
-  // serialize, then encode payload
-  String jwt;
-  serializeJson(payload, jwt);
-  jwt = encode(jwt.c_str(), jwt.length());
+String ArduinoJsonJWT::buildJWT(JsonObject & payload) {
+    // serialize, then encode payload
+    String jwt;
+    serializeJson(payload, jwt);
+    jwt = encode(jwt.c_str(), jwt.length());
 
-  // add the header to payload
-  jwt = JWT_HEADER + '.' + jwt;
+    // add the header to payload
+    jwt = JWT_HEADER + '.' + jwt;
 
-  // add signature
-  jwt += '.' + sign(jwt);
+    // add signature
+    jwt += '.' + sign(jwt);
 
-  return jwt;
+    return jwt;
 }
 
-void ArduinoJsonJWT::parseJWT(String jwt, JsonDocument& jsonDocument) {
-  // clear json document before we begin, jsonDocument wil be null on failure
-  jsonDocument.clear();
-
-  // must have the correct header and delimiter
-  if (!jwt.startsWith(JWT_HEADER) || jwt.indexOf('.') != JWT_HEADER_SIZE) {
-    return;
-  }
-
-  // check there is a signature delimieter
-  int signatureDelimiterIndex = jwt.lastIndexOf('.');
-  if (signatureDelimiterIndex == JWT_HEADER_SIZE) {
-    return;
-  }
-
-  // check the signature is valid
-  String signature = jwt.substring(signatureDelimiterIndex + 1);
-  jwt = jwt.substring(0, signatureDelimiterIndex);
-  if (sign(jwt) != signature) {
-    return;
-  }
-
-  // decode payload
-  jwt = jwt.substring(JWT_HEADER_SIZE + 1);
-  jwt = decode(jwt);
-
-  // parse payload, clearing json document after failure
-  DeserializationError error = deserializeJson(jsonDocument, jwt);
-  if (error != DeserializationError::Ok || !jsonDocument.is<JsonObject>()) {
+void ArduinoJsonJWT::parseJWT(String jwt, JsonDocument & jsonDocument) {
+    // clear json document before we begin, jsonDocument wil be null on failure
     jsonDocument.clear();
-  }
+
+    // must have the correct header and delimiter
+    if (!jwt.startsWith(JWT_HEADER) || jwt.indexOf('.') != JWT_HEADER_SIZE) {
+        return;
+    }
+
+    // check there is a signature delimieter
+    int signatureDelimiterIndex = jwt.lastIndexOf('.');
+    if (signatureDelimiterIndex == JWT_HEADER_SIZE) {
+        return;
+    }
+
+    // check the signature is valid
+    String signature = jwt.substring(signatureDelimiterIndex + 1);
+    jwt              = jwt.substring(0, signatureDelimiterIndex);
+    if (sign(jwt) != signature) {
+        return;
+    }
+
+    // decode payload
+    jwt = jwt.substring(JWT_HEADER_SIZE + 1);
+    jwt = decode(jwt);
+
+    // parse payload, clearing json document after failure
+    DeserializationError error = deserializeJson(jsonDocument, jwt);
+    if (error != DeserializationError::Ok || !jsonDocument.is<JsonObject>()) {
+        jsonDocument.clear();
+    }
 }
 
-String ArduinoJsonJWT::encode(const char* cstr, int inputLen) {
-  // prepare encoder
-  base64_encodestate _state;
+String ArduinoJsonJWT::encode(const char * cstr, int inputLen) {
+    // prepare encoder
+    base64_encodestate _state;
 #ifdef ESP32
-  base64_init_encodestate(&_state);
-  size_t encodedLength = base64_encode_expected_len(inputLen) + 1;
+    base64_init_encodestate(&_state);
+    size_t encodedLength = base64_encode_expected_len(inputLen) + 1;
 #elif defined(ESP8266)
-  base64_init_encodestate_nonewlines(&_state);
-  size_t encodedLength = base64_encode_expected_len_nonewlines(inputLen) + 1;
+    base64_init_encodestate_nonewlines(&_state);
+    size_t encodedLength = base64_encode_expected_len_nonewlines(inputLen) + 1;
 #endif
-  // prepare buffer of correct length, returning an empty string on failure
-  char* buffer = (char*)malloc(encodedLength * sizeof(char));
-  if (buffer == nullptr) {
-    return "";
-  }
+    // prepare buffer of correct length, returning an empty string on failure
+    char * buffer = (char *)malloc(encodedLength * sizeof(char));
+    if (buffer == nullptr) {
+        return "";
+    }
 
-  // encode to buffer
-  int len = base64_encode_block(cstr, inputLen, &buffer[0], &_state);
-  len += base64_encode_blockend(&buffer[len], &_state);
-  buffer[len] = 0;
+    // encode to buffer
+    int len = base64_encode_block(cstr, inputLen, &buffer[0], &_state);
+    len += base64_encode_blockend(&buffer[len], &_state);
+    buffer[len] = 0;
 
-  // convert to arduino string, freeing buffer
-  String value = String(buffer);
-  free(buffer);
-  buffer = nullptr;
+    // convert to arduino string, freeing buffer
+    String value = String(buffer);
+    free(buffer);
+    buffer = nullptr;
 
-  // remove padding and convert to URL safe form
-  while (value.length() > 0 && value.charAt(value.length() - 1) == '=') {
-    value.remove(value.length() - 1);
-  }
-  value.replace('+', '-');
-  value.replace('/', '_');
+    // remove padding and convert to URL safe form
+    while (value.length() > 0 && value.charAt(value.length() - 1) == '=') {
+        value.remove(value.length() - 1);
+    }
+    value.replace('+', '-');
+    value.replace('/', '_');
 
-  // return as string
-  return value;
+    // return as string
+    return value;
 }
 
 String ArduinoJsonJWT::decode(String value) {
-  // convert to standard base64
-  value.replace('-', '+');
-  value.replace('_', '/');
+    // convert to standard base64
+    value.replace('-', '+');
+    value.replace('_', '/');
 
-  // prepare buffer of correct length
-  char buffer[base64_decode_expected_len(value.length()) + 1];
+    // prepare buffer of correct length
+    char buffer[base64_decode_expected_len(value.length()) + 1];
 
-  // decode
-  int len = base64_decode_chars(value.c_str(), value.length(), &buffer[0]);
-  buffer[len] = 0;
+    // decode
+    int len     = base64_decode_chars(value.c_str(), value.length(), &buffer[0]);
+    buffer[len] = 0;
 
-  // return as string
-  return String(buffer);
+    // return as string
+    return String(buffer);
 }
diff --git a/lib/framework/ArduinoJsonJWT.h b/lib/framework/ArduinoJsonJWT.h
index beeedc067..edad6e92e 100644
--- a/lib/framework/ArduinoJsonJWT.h
+++ b/lib/framework/ArduinoJsonJWT.h
@@ -13,25 +13,25 @@
 #endif
 
 class ArduinoJsonJWT {
- private:
-  String _secret;
+  private:
+    String _secret;
 
-  const String JWT_HEADER = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9";
-  const int JWT_HEADER_SIZE = JWT_HEADER.length();
+    const String JWT_HEADER      = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9";
+    const int    JWT_HEADER_SIZE = JWT_HEADER.length();
 
-  String sign(String& value);
+    String sign(String & value);
 
-  static String encode(const char* cstr, int len);
-  static String decode(String value);
+    static String encode(const char * cstr, int len);
+    static String decode(String value);
 
- public:
-  ArduinoJsonJWT(String secret);
+  public:
+    ArduinoJsonJWT(String secret);
 
-  void setSecret(String secret);
-  String getSecret();
+    void   setSecret(String secret);
+    String getSecret();
 
-  String buildJWT(JsonObject& payload);
-  void parseJWT(String jwt, JsonDocument& jsonDocument);
+    String buildJWT(JsonObject & payload);
+    void   parseJWT(String jwt, JsonDocument & jsonDocument);
 };
 
 #endif
diff --git a/lib/framework/AuthenticationService.cpp b/lib/framework/AuthenticationService.cpp
index 84c347cc5..c0a4ab601 100644
--- a/lib/framework/AuthenticationService.cpp
+++ b/lib/framework/AuthenticationService.cpp
@@ -2,47 +2,44 @@
 
 #if FT_ENABLED(FT_SECURITY)
 
-AuthenticationService::AuthenticationService(AsyncWebServer* server, SecurityManager* securityManager) :
-    _securityManager(securityManager),
-    _signInHandler(SIGN_IN_PATH,
-                   std::bind(&AuthenticationService::signIn, this, std::placeholders::_1, std::placeholders::_2)) {
-  server->on(VERIFY_AUTHORIZATION_PATH,
-             HTTP_GET,
-             std::bind(&AuthenticationService::verifyAuthorization, this, std::placeholders::_1));
-  _signInHandler.setMethod(HTTP_POST);
-  _signInHandler.setMaxContentLength(MAX_AUTHENTICATION_SIZE);
-  server->addHandler(&_signInHandler);
+AuthenticationService::AuthenticationService(AsyncWebServer * server, SecurityManager * securityManager)
+    : _securityManager(securityManager)
+    , _signInHandler(SIGN_IN_PATH, std::bind(&AuthenticationService::signIn, this, std::placeholders::_1, std::placeholders::_2)) {
+    server->on(VERIFY_AUTHORIZATION_PATH, HTTP_GET, std::bind(&AuthenticationService::verifyAuthorization, this, std::placeholders::_1));
+    _signInHandler.setMethod(HTTP_POST);
+    _signInHandler.setMaxContentLength(MAX_AUTHENTICATION_SIZE);
+    server->addHandler(&_signInHandler);
 }
 
 /**
  * Verifys that the request supplied a valid JWT.
  */
-void AuthenticationService::verifyAuthorization(AsyncWebServerRequest* request) {
-  Authentication authentication = _securityManager->authenticateRequest(request);
-  request->send(authentication.authenticated ? 200 : 401);
+void AuthenticationService::verifyAuthorization(AsyncWebServerRequest * request) {
+    Authentication authentication = _securityManager->authenticateRequest(request);
+    request->send(authentication.authenticated ? 200 : 401);
 }
 
 /**
  * Signs in a user if the username and password match. Provides a JWT to be used in the Authorization header in
  * subsequent requests.
  */
-void AuthenticationService::signIn(AsyncWebServerRequest* request, JsonVariant& json) {
-  if (json.is<JsonObject>()) {
-    String username = json["username"];
-    String password = json["password"];
-    Authentication authentication = _securityManager->authenticate(username, password);
-    if (authentication.authenticated) {
-      User* user = authentication.user;
-      AsyncJsonResponse* response = new AsyncJsonResponse(false, MAX_AUTHENTICATION_SIZE);
-      JsonObject jsonObject = response->getRoot();
-      jsonObject["access_token"] = _securityManager->generateJWT(user);
-      response->setLength();
-      request->send(response);
-      return;
+void AuthenticationService::signIn(AsyncWebServerRequest * request, JsonVariant & json) {
+    if (json.is<JsonObject>()) {
+        String         username       = json["username"];
+        String         password       = json["password"];
+        Authentication authentication = _securityManager->authenticate(username, password);
+        if (authentication.authenticated) {
+            User *              user       = authentication.user;
+            AsyncJsonResponse * response   = new AsyncJsonResponse(false, MAX_AUTHENTICATION_SIZE);
+            JsonObject          jsonObject = response->getRoot();
+            jsonObject["access_token"]     = _securityManager->generateJWT(user);
+            response->setLength();
+            request->send(response);
+            return;
+        }
     }
-  }
-  AsyncWebServerResponse* response = request->beginResponse(401);
-  request->send(response);
+    AsyncWebServerResponse * response = request->beginResponse(401);
+    request->send(response);
 }
 
 #endif // end FT_ENABLED(FT_SECURITY)
diff --git a/lib/framework/AuthenticationService.h b/lib/framework/AuthenticationService.h
index 852022379..520170063 100644
--- a/lib/framework/AuthenticationService.h
+++ b/lib/framework/AuthenticationService.h
@@ -14,17 +14,17 @@
 #if FT_ENABLED(FT_SECURITY)
 
 class AuthenticationService {
- public:
-  AuthenticationService(AsyncWebServer* server, SecurityManager* securityManager);
+  public:
+    AuthenticationService(AsyncWebServer * server, SecurityManager * securityManager);
 
- private:
-  SecurityManager* _securityManager;
-  AsyncCallbackJsonWebHandler _signInHandler;
+  private:
+    SecurityManager *           _securityManager;
+    AsyncCallbackJsonWebHandler _signInHandler;
 
-  // endpoint functions
-  void signIn(AsyncWebServerRequest* request, JsonVariant& json);
-  void verifyAuthorization(AsyncWebServerRequest* request);
+    // endpoint functions
+    void signIn(AsyncWebServerRequest * request, JsonVariant & json);
+    void verifyAuthorization(AsyncWebServerRequest * request);
 };
 
-#endif  // end FT_ENABLED(FT_SECURITY)
-#endif  // end SecurityManager_h
+#endif // end FT_ENABLED(FT_SECURITY)
+#endif // end SecurityManager_h
diff --git a/lib/framework/ESP8266React.h b/lib/framework/ESP8266React.h
index 1bb23a7d7..3698298fb 100644
--- a/lib/framework/ESP8266React.h
+++ b/lib/framework/ESP8266React.h
@@ -34,84 +34,84 @@
 #endif
 
 class ESP8266React {
- public:
-  ESP8266React(AsyncWebServer* server, FS* fs);
+  public:
+    ESP8266React(AsyncWebServer * server, FS * fs);
 
-  void begin();
-  void loop();
+    void begin();
+    void loop();
 
-  SecurityManager* getSecurityManager() {
-    return &_securitySettingsService;
-  }
+    SecurityManager * getSecurityManager() {
+        return &_securitySettingsService;
+    }
 
 #if FT_ENABLED(FT_SECURITY)
-  StatefulService<SecuritySettings>* getSecuritySettingsService() {
-    return &_securitySettingsService;
-  }
+    StatefulService<SecuritySettings> * getSecuritySettingsService() {
+        return &_securitySettingsService;
+    }
 #endif
 
-  StatefulService<WiFiSettings>* getWiFiSettingsService() {
-    return &_wifiSettingsService;
-  }
+    StatefulService<WiFiSettings> * getWiFiSettingsService() {
+        return &_wifiSettingsService;
+    }
 
-  StatefulService<APSettings>* getAPSettingsService() {
-    return &_apSettingsService;
-  }
+    StatefulService<APSettings> * getAPSettingsService() {
+        return &_apSettingsService;
+    }
 
 #if FT_ENABLED(FT_NTP)
-  StatefulService<NTPSettings>* getNTPSettingsService() {
-    return &_ntpSettingsService;
-  }
+    StatefulService<NTPSettings> * getNTPSettingsService() {
+        return &_ntpSettingsService;
+    }
 #endif
 
 #if FT_ENABLED(FT_OTA)
-  StatefulService<OTASettings>* getOTASettingsService() {
-    return &_otaSettingsService;
-  }
+    StatefulService<OTASettings> * getOTASettingsService() {
+        return &_otaSettingsService;
+    }
 #endif
 
 #if FT_ENABLED(FT_MQTT)
-  StatefulService<MqttSettings>* getMqttSettingsService() {
-    return &_mqttSettingsService;
-  }
+    StatefulService<MqttSettings> * getMqttSettingsService() {
+        return &_mqttSettingsService;
+    }
 
-  AsyncMqttClient* getMqttClient() {
-    return _mqttSettingsService.getMqttClient();
-  }
+    AsyncMqttClient * getMqttClient() {
+        return _mqttSettingsService.getMqttClient();
+    }
 #endif
 
-  void factoryReset() {
-    _factoryResetService.factoryReset();
-  }
+    void factoryReset() {
+        _factoryResetService.factoryReset();
+    }
 
- private:
-  FeaturesService _featureService;
-  SecuritySettingsService _securitySettingsService;
-  WiFiSettingsService _wifiSettingsService;
-  WiFiScanner _wifiScanner;
-  WiFiStatus _wifiStatus;
-  APSettingsService _apSettingsService;
-  APStatus _apStatus;
+  private:
+    FeaturesService         _featureService;
+    SecuritySettingsService _securitySettingsService;
+    WiFiSettingsService     _wifiSettingsService;
+    WiFiScanner             _wifiScanner;
+    WiFiStatus              _wifiStatus;
+    APSettingsService       _apSettingsService;
+    APStatus                _apStatus;
 #if FT_ENABLED(FT_NTP)
-  NTPSettingsService _ntpSettingsService;
-  NTPStatus _ntpStatus;
+    NTPSettingsService _ntpSettingsService;
+    NTPStatus          _ntpStatus;
 #endif
 #if FT_ENABLED(FT_OTA)
-  OTASettingsService _otaSettingsService;
+    OTASettingsService _otaSettingsService;
 #endif
 #if FT_ENABLED(FT_UPLOAD_FIRMWARE)
-  UploadFirmwareService _uploadFirmwareService;
+    UploadFirmwareService _uploadFirmwareService;
 #endif
 #if FT_ENABLED(FT_MQTT)
-  MqttSettingsService _mqttSettingsService;
-  MqttStatus _mqttStatus;
+    MqttSettingsService _mqttSettingsService;
+    MqttStatus          _mqttStatus;
 #endif
 #if FT_ENABLED(FT_SECURITY)
-  AuthenticationService _authenticationService;
+    AuthenticationService _authenticationService;
 #endif
-  RestartService _restartService;
-  FactoryResetService _factoryResetService;
-  SystemStatus _systemStatus;
+    RestartService      _restartService;
+    FactoryResetService _factoryResetService;
+    SystemStatus        _systemStatus;
 };
 
 #endif
diff --git a/lib/framework/ESPUtils.h b/lib/framework/ESPUtils.h
index 834459dfc..e24952ce6 100644
--- a/lib/framework/ESPUtils.h
+++ b/lib/framework/ESPUtils.h
@@ -4,14 +4,14 @@
 #include <Arduino.h>
 
 class ESPUtils {
- public:
-  static String defaultDeviceValue(String prefix = "") {
+  public:
+    static String defaultDeviceValue(String prefix = "") {
 #ifdef ESP32
-    return prefix + String((unsigned long)ESP.getEfuseMac(), HEX);
+        return prefix + String((unsigned long)ESP.getEfuseMac(), HEX);
 #elif defined(ESP8266)
-    return prefix + String(ESP.getChipId(), HEX);
+        return prefix + String(ESP.getChipId(), HEX);
 #endif
-  }
+    }
 };
 
-#endif  // end ESPUtils
+#endif // end ESPUtils
diff --git a/lib/framework/FSPersistence.h b/lib/framework/FSPersistence.h
index f0da8cc57..b43a6c7f9 100644
--- a/lib/framework/FSPersistence.h
+++ b/lib/framework/FSPersistence.h
@@ -11,7 +11,7 @@ class FSPersistence {
                   JsonStateUpdater<T>  stateUpdater,
                   StatefulService<T> * statefulService,
                   FS *                 fs,
-                  char const *         filePath,
+                  const char *         filePath,
                   size_t               bufferSize = DEFAULT_BUFFER_SIZE)
         : _stateReader(stateReader)
         , _stateUpdater(stateUpdater)
@@ -97,7 +97,7 @@ class FSPersistence {
     JsonStateUpdater<T>  _stateUpdater;
     StatefulService<T> * _statefulService;
     FS *                 _fs;
-    char const *         _filePath;
+    const char *         _filePath;
     size_t               _bufferSize;
     update_handler_id_t  _updateHandlerId;
 
diff --git a/lib/framework/FactoryResetService.h b/lib/framework/FactoryResetService.h
index 2336e6f38..bf065a073 100644
--- a/lib/framework/FactoryResetService.h
+++ b/lib/framework/FactoryResetService.h
@@ -18,15 +18,15 @@
 #define FACTORY_RESET_SERVICE_PATH "/rest/factoryReset"
 
 class FactoryResetService {
-  FS* fs;
+    FS * fs;
 
- public:
-  FactoryResetService(AsyncWebServer* server, FS* fs, SecurityManager* securityManager);
+  public:
+    FactoryResetService(AsyncWebServer * server, FS * fs, SecurityManager * securityManager);
 
-  void factoryReset();
+    void factoryReset();
 
- private:
-  void handleRequest(AsyncWebServerRequest* request);
+  private:
+    void handleRequest(AsyncWebServerRequest * request);
 };
 
-#endif  // end FactoryResetService_h
+#endif // end FactoryResetService_h
diff --git a/lib/framework/FeaturesService.cpp b/lib/framework/FeaturesService.cpp
index 095f1f2dc..98953048a 100644
--- a/lib/framework/FeaturesService.cpp
+++ b/lib/framework/FeaturesService.cpp
@@ -1,42 +1,42 @@
 #include <FeaturesService.h>
 
-FeaturesService::FeaturesService(AsyncWebServer* server) {
-  server->on(FEATURES_SERVICE_PATH, HTTP_GET, std::bind(&FeaturesService::features, this, std::placeholders::_1));
+FeaturesService::FeaturesService(AsyncWebServer * server) {
+    server->on(FEATURES_SERVICE_PATH, HTTP_GET, std::bind(&FeaturesService::features, this, std::placeholders::_1));
 }
 
-void FeaturesService::features(AsyncWebServerRequest* request) {
-  AsyncJsonResponse* response = new AsyncJsonResponse(false, MAX_FEATURES_SIZE);
-  JsonObject root = response->getRoot();
+void FeaturesService::features(AsyncWebServerRequest * request) {
+    AsyncJsonResponse * response = new AsyncJsonResponse(false, MAX_FEATURES_SIZE);
+    JsonObject          root     = response->getRoot();
 #if FT_ENABLED(FT_PROJECT)
-  root["project"] = true;
+    root["project"] = true;
 #else
-  root["project"] = false;
+    root["project"]         = false;
 #endif
 #if FT_ENABLED(FT_SECURITY)
-  root["security"] = true;
+    root["security"] = true;
 #else
-  root["security"] = false;
+    root["security"]        = false;
 #endif
 #if FT_ENABLED(FT_MQTT)
-  root["mqtt"] = true;
+    root["mqtt"] = true;
 #else
-  root["mqtt"] = false;
+    root["mqtt"]            = false;
 #endif
 #if FT_ENABLED(FT_NTP)
-  root["ntp"] = true;
+    root["ntp"] = true;
 #else
-  root["ntp"] = false;
+    root["ntp"]             = false;
 #endif
 #if FT_ENABLED(FT_OTA)
-  root["ota"] = true;
+    root["ota"] = true;
 #else
-  root["ota"] = false;
+    root["ota"]             = false;
 #endif
 #if FT_ENABLED(FT_UPLOAD_FIRMWARE)
-  root["upload_firmware"] = true;
+    root["upload_firmware"] = true;
 #else
-  root["upload_firmware"] = false;
+    root["upload_firmware"] = false;
 #endif
-  response->setLength();
-  request->send(response);
+    response->setLength();
+    request->send(response);
 }
diff --git a/lib/framework/FeaturesService.h b/lib/framework/FeaturesService.h
index 867101ece..7caa42d94 100644
--- a/lib/framework/FeaturesService.h
+++ b/lib/framework/FeaturesService.h
@@ -19,11 +19,11 @@
 #define FEATURES_SERVICE_PATH "/rest/features"
 
 class FeaturesService {
- public:
-  FeaturesService(AsyncWebServer* server);
+  public:
+    FeaturesService(AsyncWebServer * server);
 
- private:
-  void features(AsyncWebServerRequest* request);
+  private:
+    void features(AsyncWebServerRequest * request);
 };
 
 #endif
diff --git a/lib/framework/HttpEndpoint.h b/lib/framework/HttpEndpoint.h
index f45e716a2..851e5350b 100644
--- a/lib/framework/HttpEndpoint.h
+++ b/lib/framework/HttpEndpoint.h
@@ -13,153 +13,139 @@
 
 template <class T>
 class HttpGetEndpoint {
- public:
-  HttpGetEndpoint(JsonStateReader<T> stateReader,
-                  StatefulService<T>* statefulService,
-                  AsyncWebServer* server,
-                  const String& 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, std::placeholders::_1),
-                                            authenticationPredicate));
-  }
+  public:
+    HttpGetEndpoint(JsonStateReader<T>      stateReader,
+                    StatefulService<T> *    statefulService,
+                    AsyncWebServer *        server,
+                    const String &          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, std::placeholders::_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, std::placeholders::_1));
-  }
+    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, std::placeholders::_1));
+    }
 
- protected:
-  JsonStateReader<T> _stateReader;
-  StatefulService<T>* _statefulService;
-  size_t _bufferSize;
+  protected:
+    JsonStateReader<T>   _stateReader;
+    StatefulService<T> * _statefulService;
+    size_t               _bufferSize;
 
-  void fetchSettings(AsyncWebServerRequest* request) {
-    AsyncJsonResponse* response = new AsyncJsonResponse(false, _bufferSize);
-    JsonObject jsonObject = response->getRoot().to<JsonObject>();
-    _statefulService->read(jsonObject, _stateReader);
+    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);
-  }
+        response->setLength();
+        request->send(response);
+    }
 };
 
 template <class T>
 class HttpPostEndpoint {
- public:
-  HttpPostEndpoint(JsonStateReader<T> stateReader,
-                   JsonStateUpdater<T> stateUpdater,
-                   StatefulService<T>* statefulService,
-                   AsyncWebServer* server,
-                   const String& 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, std::placeholders::_1, std::placeholders::_2),
-              authenticationPredicate),
-          bufferSize),
-      _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, std::placeholders::_1, std::placeholders::_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;
-
-  void updateSettings(AsyncWebServerRequest* request, JsonVariant& json) {
-    if (!json.is<JsonObject>()) {
-      request->send(400);
-      return;
+  public:
+    HttpPostEndpoint(JsonStateReader<T>      stateReader,
+                     JsonStateUpdater<T>     stateUpdater,
+                     StatefulService<T> *    statefulService,
+                     AsyncWebServer *        server,
+                     const String &          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, std::placeholders::_1, std::placeholders::_2),
+                                                       authenticationPredicate),
+                         bufferSize)
+        , _bufferSize(bufferSize) {
+        _updateHandler.setMethod(HTTP_POST);
+        server->addHandler(&_updateHandler);
     }
-    JsonObject jsonObject = json.as<JsonObject>();
-    StateUpdateResult outcome = _statefulService->updateWithoutPropagation(jsonObject, _stateUpdater);
-    if (outcome == StateUpdateResult::ERROR) {
-      request->send(400);
-      return;
+
+    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, std::placeholders::_1, std::placeholders::_2), bufferSize)
+        , _bufferSize(bufferSize) {
+        _updateHandler.setMethod(HTTP_POST);
+        server->addHandler(&_updateHandler);
     }
-    if (outcome == StateUpdateResult::CHANGED) {
-      request->onDisconnect([this]() { _statefulService->callUpdateHandlers(HTTP_ENDPOINT_ORIGIN_ID); });
+
+  protected:
+    JsonStateReader<T>          _stateReader;
+    JsonStateUpdater<T>         _stateUpdater;
+    StatefulService<T> *        _statefulService;
+    AsyncCallbackJsonWebHandler _updateHandler;
+    size_t                      _bufferSize;
+
+    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;
+        }
+        if (outcome == StateUpdateResult::CHANGED) {
+            request->onDisconnect([this]() { _statefulService->callUpdateHandlers(HTTP_ENDPOINT_ORIGIN_ID); });
+        }
+        AsyncJsonResponse * response = new AsyncJsonResponse(false, _bufferSize);
+        jsonObject                   = response->getRoot().to<JsonObject>();
+        _statefulService->read(jsonObject, _stateReader);
+        response->setLength();
+        request->send(response);
     }
-    AsyncJsonResponse* response = new AsyncJsonResponse(false, _bufferSize);
-    jsonObject = response->getRoot().to<JsonObject>();
-    _statefulService->read(jsonObject, _stateReader);
-    response->setLength();
-    request->send(response);
-  }
 };
 
 template <class T>
 class HttpEndpoint : public HttpGetEndpoint<T>, public HttpPostEndpoint<T> {
- public:
-  HttpEndpoint(JsonStateReader<T> stateReader,
-               JsonStateUpdater<T> stateUpdater,
-               StatefulService<T>* statefulService,
-               AsyncWebServer* server,
-               const String& servicePath,
-               SecurityManager* securityManager,
-               AuthenticationPredicate authenticationPredicate = AuthenticationPredicates::IS_ADMIN,
-               size_t bufferSize = DEFAULT_BUFFER_SIZE) :
-      HttpGetEndpoint<T>(stateReader,
-                         statefulService,
-                         server,
-                         servicePath,
-                         securityManager,
-                         authenticationPredicate,
-                         bufferSize),
-      HttpPostEndpoint<T>(stateReader,
-                          stateUpdater,
-                          statefulService,
-                          server,
-                          servicePath,
-                          securityManager,
-                          authenticationPredicate,
-                          bufferSize) {
-  }
+  public:
+    HttpEndpoint(JsonStateReader<T>      stateReader,
+                 JsonStateUpdater<T>     stateUpdater,
+                 StatefulService<T> *    statefulService,
+                 AsyncWebServer *        server,
+                 const String &          servicePath,
+                 SecurityManager *       securityManager,
+                 AuthenticationPredicate authenticationPredicate = AuthenticationPredicates::IS_ADMIN,
+                 size_t                  bufferSize              = DEFAULT_BUFFER_SIZE)
+        : HttpGetEndpoint<T>(stateReader, statefulService, server, servicePath, securityManager, authenticationPredicate, bufferSize)
+        , 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) {
-  }
+    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) {
+    }
 };
 
-#endif  // end HttpEndpoint
+#endif // end HttpEndpoint
diff --git a/lib/framework/JsonUtils.h b/lib/framework/JsonUtils.h
index 0c4089831..b1272376a 100644
--- a/lib/framework/JsonUtils.h
+++ b/lib/framework/JsonUtils.h
@@ -6,24 +6,24 @@
 #include <ArduinoJson.h>
 
 class JsonUtils {
- public:
-  static void readIP(JsonObject& root, const String& key, IPAddress& ip, const String& def) {
-    IPAddress defaultIp = {};
-    if (!defaultIp.fromString(def)) {
-      defaultIp = INADDR_NONE;
+  public:
+    static void readIP(JsonObject & root, const String & key, IPAddress & ip, const String & def) {
+        IPAddress defaultIp = {};
+        if (!defaultIp.fromString(def)) {
+            defaultIp = INADDR_NONE;
+        }
+        readIP(root, key, ip, defaultIp);
     }
-    readIP(root, key, ip, defaultIp);
-  }
-  static void readIP(JsonObject& root, const String& key, IPAddress& ip, const IPAddress& defaultIp = INADDR_NONE) {
-    if (!root[key].is<String>() || !ip.fromString(root[key].as<String>())) {
-      ip = defaultIp;
+    static void readIP(JsonObject & root, const String & key, IPAddress & ip, const IPAddress & defaultIp = INADDR_NONE) {
+        if (!root[key].is<String>() || !ip.fromString(root[key].as<String>())) {
+            ip = defaultIp;
+        }
     }
-  }
-  static void writeIP(JsonObject& root, const String& key, const IPAddress& ip) {
-    if (ip != INADDR_NONE) {
-      root[key] = ip.toString();
+    static void writeIP(JsonObject & root, const String & key, const IPAddress & ip) {
+        if (ip != INADDR_NONE) {
+            root[key] = ip.toString();
+        }
     }
-  }
 };
 
-#endif  // end JsonUtils
+#endif // end JsonUtils
diff --git a/lib/framework/MqttPubSub.h b/lib/framework/MqttPubSub.h
index c3ed3f146..f28c0c7b3 100644
--- a/lib/framework/MqttPubSub.h
+++ b/lib/framework/MqttPubSub.h
@@ -8,160 +8,161 @@
 
 template <class T>
 class MqttConnector {
- protected:
-  StatefulService<T>* _statefulService;
-  AsyncMqttClient* _mqttClient;
-  size_t _bufferSize;
+  protected:
+    StatefulService<T> * _statefulService;
+    AsyncMqttClient *    _mqttClient;
+    size_t               _bufferSize;
 
-  MqttConnector(StatefulService<T>* statefulService, AsyncMqttClient* mqttClient, size_t bufferSize) :
-      _statefulService(statefulService), _mqttClient(mqttClient), _bufferSize(bufferSize) {
-    _mqttClient->onConnect(std::bind(&MqttConnector::onConnect, this));
-  }
+    MqttConnector(StatefulService<T> * statefulService, AsyncMqttClient * mqttClient, size_t bufferSize)
+        : _statefulService(statefulService)
+        , _mqttClient(mqttClient)
+        , _bufferSize(bufferSize) {
+        _mqttClient->onConnect(std::bind(&MqttConnector::onConnect, this));
+    }
 
-  virtual void onConnect() = 0;
+    virtual void onConnect() = 0;
 
- public:
-  inline AsyncMqttClient* getMqttClient() const {
-    return _mqttClient;
-  }
+  public:
+    inline AsyncMqttClient * getMqttClient() const {
+        return _mqttClient;
+    }
 };
 
 template <class T>
 class MqttPub : virtual public MqttConnector<T> {
- public:
-  MqttPub(JsonStateReader<T> stateReader,
-          StatefulService<T>* statefulService,
-          AsyncMqttClient* mqttClient,
-          const String& pubTopic = "",
-          size_t bufferSize = DEFAULT_BUFFER_SIZE) :
-      MqttConnector<T>(statefulService, mqttClient, bufferSize), _stateReader(stateReader), _pubTopic(pubTopic) {
-    MqttConnector<T>::_statefulService->addUpdateHandler([&](const String& originId) { publish(); }, false);
-  }
-
-  void setPubTopic(const String& pubTopic) {
-    _pubTopic = pubTopic;
-    publish();
-  }
-
- protected:
-  virtual void onConnect() {
-    publish();
-  }
-
- private:
-  JsonStateReader<T> _stateReader;
-  String _pubTopic;
-
-  void publish() {
-    if (_pubTopic.length() > 0 && MqttConnector<T>::_mqttClient->connected()) {
-      // serialize to json doc
-      DynamicJsonDocument json(MqttConnector<T>::_bufferSize);
-      JsonObject jsonObject = json.to<JsonObject>();
-      MqttConnector<T>::_statefulService->read(jsonObject, _stateReader);
-
-      // serialize to string
-      String payload;
-      serializeJson(json, payload);
-
-      // publish the payload
-      MqttConnector<T>::_mqttClient->publish(_pubTopic.c_str(), 0, false, payload.c_str());
+  public:
+    MqttPub(JsonStateReader<T>   stateReader,
+            StatefulService<T> * statefulService,
+            AsyncMqttClient *    mqttClient,
+            const String &       pubTopic   = "",
+            size_t               bufferSize = DEFAULT_BUFFER_SIZE)
+        : MqttConnector<T>(statefulService, mqttClient, bufferSize)
+        , _stateReader(stateReader)
+        , _pubTopic(pubTopic) {
+        MqttConnector<T>::_statefulService->addUpdateHandler([&](const String & originId) { publish(); }, false);
+    }
+
+    void setPubTopic(const String & pubTopic) {
+        _pubTopic = pubTopic;
+        publish();
+    }
+
+  protected:
+    virtual void onConnect() {
+        publish();
+    }
+
+  private:
+    JsonStateReader<T> _stateReader;
+    String             _pubTopic;
+
+    void publish() {
+        if (_pubTopic.length() > 0 && MqttConnector<T>::_mqttClient->connected()) {
+            // serialize to json doc
+            DynamicJsonDocument json(MqttConnector<T>::_bufferSize);
+            JsonObject          jsonObject = json.to<JsonObject>();
+            MqttConnector<T>::_statefulService->read(jsonObject, _stateReader);
+
+            // serialize to string
+            String payload;
+            serializeJson(json, payload);
+
+            // publish the payload
+            MqttConnector<T>::_mqttClient->publish(_pubTopic.c_str(), 0, false, payload.c_str());
+        }
     }
-  }
 };
 
 template <class T>
 class MqttSub : virtual public MqttConnector<T> {
- public:
-  MqttSub(JsonStateUpdater<T> stateUpdater,
-          StatefulService<T>* statefulService,
-          AsyncMqttClient* mqttClient,
-          const String& subTopic = "",
-          size_t bufferSize = DEFAULT_BUFFER_SIZE) :
-      MqttConnector<T>(statefulService, mqttClient, bufferSize), _stateUpdater(stateUpdater), _subTopic(subTopic) {
-    MqttConnector<T>::_mqttClient->onMessage(std::bind(&MqttSub::onMqttMessage,
-                                                       this,
-                                                       std::placeholders::_1,
-                                                       std::placeholders::_2,
-                                                       std::placeholders::_3,
-                                                       std::placeholders::_4,
-                                                       std::placeholders::_5,
-                                                       std::placeholders::_6));
-  }
-
-  void setSubTopic(const String& subTopic) {
-    if (!_subTopic.equals(subTopic)) {
-      // unsubscribe from the existing topic if one was set
-      if (_subTopic.length() > 0) {
-        MqttConnector<T>::_mqttClient->unsubscribe(_subTopic.c_str());
-      }
-      // set the new topic and re-configure the subscription
-      _subTopic = subTopic;
-      subscribe();
-    }
-  }
-
- protected:
-  virtual void onConnect() {
-    subscribe();
-  }
-
- private:
-  JsonStateUpdater<T> _stateUpdater;
-  String _subTopic;
-
-  void subscribe() {
-    if (_subTopic.length() > 0) {
-      MqttConnector<T>::_mqttClient->subscribe(_subTopic.c_str(), 2);
-    }
-  }
-
-  void onMqttMessage(char* topic,
-                     char* payload,
-                     AsyncMqttClientMessageProperties properties,
-                     size_t len,
-                     size_t index,
-                     size_t total) {
-    // we only care about the topic we are watching in this class
-    if (strcmp(_subTopic.c_str(), topic)) {
-      return;
+  public:
+    MqttSub(JsonStateUpdater<T>  stateUpdater,
+            StatefulService<T> * statefulService,
+            AsyncMqttClient *    mqttClient,
+            const String &       subTopic   = "",
+            size_t               bufferSize = DEFAULT_BUFFER_SIZE)
+        : MqttConnector<T>(statefulService, mqttClient, bufferSize)
+        , _stateUpdater(stateUpdater)
+        , _subTopic(subTopic) {
+        MqttConnector<T>::_mqttClient->onMessage(std::bind(&MqttSub::onMqttMessage,
+                                                           this,
+                                                           std::placeholders::_1,
+                                                           std::placeholders::_2,
+                                                           std::placeholders::_3,
+                                                           std::placeholders::_4,
+                                                           std::placeholders::_5,
+                                                           std::placeholders::_6));
     }
 
-    // deserialize from string
-    DynamicJsonDocument json(MqttConnector<T>::_bufferSize);
-    DeserializationError error = deserializeJson(json, payload, len);
-    if (!error && json.is<JsonObject>()) {
-      JsonObject jsonObject = json.as<JsonObject>();
-      MqttConnector<T>::_statefulService->update(jsonObject, _stateUpdater, MQTT_ORIGIN_ID);
+    void setSubTopic(const String & subTopic) {
+        if (!_subTopic.equals(subTopic)) {
+            // unsubscribe from the existing topic if one was set
+            if (_subTopic.length() > 0) {
+                MqttConnector<T>::_mqttClient->unsubscribe(_subTopic.c_str());
+            }
+            // set the new topic and re-configure the subscription
+            _subTopic = subTopic;
+            subscribe();
+        }
+    }
+
+  protected:
+    virtual void onConnect() {
+        subscribe();
+    }
+
+  private:
+    JsonStateUpdater<T> _stateUpdater;
+    String              _subTopic;
+
+    void subscribe() {
+        if (_subTopic.length() > 0) {
+            MqttConnector<T>::_mqttClient->subscribe(_subTopic.c_str(), 2);
+        }
+    }
+
+    void onMqttMessage(char * topic, char * payload, AsyncMqttClientMessageProperties properties, size_t len, size_t index, size_t total) {
+        // we only care about the topic we are watching in this class
+        if (strcmp(_subTopic.c_str(), topic)) {
+            return;
+        }
+
+        // deserialize from string
+        DynamicJsonDocument  json(MqttConnector<T>::_bufferSize);
+        DeserializationError error = deserializeJson(json, payload, len);
+        if (!error && json.is<JsonObject>()) {
+            JsonObject jsonObject = json.as<JsonObject>();
+            MqttConnector<T>::_statefulService->update(jsonObject, _stateUpdater, MQTT_ORIGIN_ID);
+        }
     }
-  }
 };
 
 template <class T>
 class MqttPubSub : public MqttPub<T>, public MqttSub<T> {
- public:
-  MqttPubSub(JsonStateReader<T> stateReader,
-             JsonStateUpdater<T> stateUpdater,
-             StatefulService<T>* statefulService,
-             AsyncMqttClient* mqttClient,
-             const String& pubTopic = "",
-             const String& subTopic = "",
-             size_t bufferSize = DEFAULT_BUFFER_SIZE) :
-      MqttConnector<T>(statefulService, mqttClient, bufferSize),
-      MqttPub<T>(stateReader, statefulService, mqttClient, pubTopic, bufferSize),
-      MqttSub<T>(stateUpdater, statefulService, mqttClient, subTopic, bufferSize) {
-  }
+  public:
+    MqttPubSub(JsonStateReader<T>   stateReader,
+               JsonStateUpdater<T>  stateUpdater,
+               StatefulService<T> * statefulService,
+               AsyncMqttClient *    mqttClient,
+               const String &       pubTopic   = "",
+               const String &       subTopic   = "",
+               size_t               bufferSize = DEFAULT_BUFFER_SIZE)
+        : MqttConnector<T>(statefulService, mqttClient, bufferSize)
+        , MqttPub<T>(stateReader, statefulService, mqttClient, pubTopic, bufferSize)
+        , MqttSub<T>(stateUpdater, statefulService, mqttClient, subTopic, bufferSize) {
+    }
 
- public:
-  void configureTopics(const String& pubTopic, const String& subTopic) {
-    MqttSub<T>::setSubTopic(subTopic);
-    MqttPub<T>::setPubTopic(pubTopic);
-  }
+  public:
+    void configureTopics(const String & pubTopic, const String & subTopic) {
+        MqttSub<T>::setSubTopic(subTopic);
+        MqttPub<T>::setPubTopic(pubTopic);
+    }
 
- protected:
-  void onConnect() {
-    MqttSub<T>::onConnect();
-    MqttPub<T>::onConnect();
-  }
+  protected:
+    void onConnect() {
+        MqttSub<T>::onConnect();
+        MqttPub<T>::onConnect();
+    }
 };
 
-#endif  // end MqttPubSub
+#endif // end MqttPubSub
diff --git a/lib/framework/NTPSettingsService.cpp b/lib/framework/NTPSettingsService.cpp
index ec3a1efa0..202a82c8c 100644
--- a/lib/framework/NTPSettingsService.cpp
+++ b/lib/framework/NTPSettingsService.cpp
@@ -1,90 +1,85 @@
 #include <NTPSettingsService.h>
 
-NTPSettingsService::NTPSettingsService(AsyncWebServer* server, FS* fs, SecurityManager* securityManager) :
-    _httpEndpoint(NTPSettings::read, NTPSettings::update, this, server, NTP_SETTINGS_SERVICE_PATH, securityManager),
-    _fsPersistence(NTPSettings::read, NTPSettings::update, this, fs, NTP_SETTINGS_FILE),
-    _timeHandler(TIME_PATH,
-                 securityManager->wrapCallback(
-                     std::bind(&NTPSettingsService::configureTime, this, std::placeholders::_1, std::placeholders::_2),
-                     AuthenticationPredicates::IS_ADMIN)) {
-  _timeHandler.setMethod(HTTP_POST);
-  _timeHandler.setMaxContentLength(MAX_TIME_SIZE);
-  server->addHandler(&_timeHandler);
+NTPSettingsService::NTPSettingsService(AsyncWebServer * server, FS * fs, SecurityManager * securityManager)
+    : _httpEndpoint(NTPSettings::read, NTPSettings::update, this, server, NTP_SETTINGS_SERVICE_PATH, securityManager)
+    , _fsPersistence(NTPSettings::read, NTPSettings::update, this, fs, NTP_SETTINGS_FILE)
+    , _timeHandler(TIME_PATH,
+                   securityManager->wrapCallback(std::bind(&NTPSettingsService::configureTime, this, std::placeholders::_1, std::placeholders::_2),
+                                                 AuthenticationPredicates::IS_ADMIN)) {
+    _timeHandler.setMethod(HTTP_POST);
+    _timeHandler.setMaxContentLength(MAX_TIME_SIZE);
+    server->addHandler(&_timeHandler);
 #ifdef ESP32
-  WiFi.onEvent(
-      std::bind(&NTPSettingsService::onStationModeDisconnected, this, std::placeholders::_1, std::placeholders::_2),
-      WiFiEvent_t::SYSTEM_EVENT_STA_DISCONNECTED);
-  WiFi.onEvent(std::bind(&NTPSettingsService::onStationModeGotIP, this, std::placeholders::_1, std::placeholders::_2),
-               WiFiEvent_t::SYSTEM_EVENT_STA_GOT_IP);
+    WiFi.onEvent(std::bind(&NTPSettingsService::onStationModeDisconnected, this, std::placeholders::_1, std::placeholders::_2),
+                 WiFiEvent_t::SYSTEM_EVENT_STA_DISCONNECTED);
+    WiFi.onEvent(std::bind(&NTPSettingsService::onStationModeGotIP, this, std::placeholders::_1, std::placeholders::_2), WiFiEvent_t::SYSTEM_EVENT_STA_GOT_IP);
 #elif defined(ESP8266)
-  _onStationModeDisconnectedHandler = WiFi.onStationModeDisconnected(
-      std::bind(&NTPSettingsService::onStationModeDisconnected, this, std::placeholders::_1));
-  _onStationModeGotIPHandler =
-      WiFi.onStationModeGotIP(std::bind(&NTPSettingsService::onStationModeGotIP, this, std::placeholders::_1));
+    _onStationModeDisconnectedHandler = WiFi.onStationModeDisconnected(std::bind(&NTPSettingsService::onStationModeDisconnected, this, std::placeholders::_1));
+    _onStationModeGotIPHandler        = WiFi.onStationModeGotIP(std::bind(&NTPSettingsService::onStationModeGotIP, this, std::placeholders::_1));
 #endif
-  addUpdateHandler([&](const String& originId) { configureNTP(); }, false);
+    addUpdateHandler([&](const String & originId) { configureNTP(); }, false);
 }
 
 void NTPSettingsService::begin() {
-  _fsPersistence.readFromFS();
-  configureNTP();
+    _fsPersistence.readFromFS();
+    configureNTP();
 }
 
 #ifdef ESP32
 void NTPSettingsService::onStationModeGotIP(WiFiEvent_t event, WiFiEventInfo_t info) {
-  // Serial.println(F("Got IP address, starting NTP Synchronization"));
-  configureNTP();
+    // Serial.println(F("Got IP address, starting NTP Synchronization"));
+    configureNTP();
 }
 
 void NTPSettingsService::onStationModeDisconnected(WiFiEvent_t event, WiFiEventInfo_t info) {
-  // Serial.println(F("WiFi connection dropped, stopping NTP."));
-  configureNTP();
+    // Serial.println(F("WiFi connection dropped, stopping NTP."));
+    configureNTP();
 }
 #elif defined(ESP8266)
-void NTPSettingsService::onStationModeGotIP(const WiFiEventStationModeGotIP& event) {
-  // Serial.println(F("Got IP address, starting NTP Synchronization"));
-  configureNTP();
+void NTPSettingsService::onStationModeGotIP(const WiFiEventStationModeGotIP & event) {
+    // Serial.println(F("Got IP address, starting NTP Synchronization"));
+    configureNTP();
 }
 
-void NTPSettingsService::onStationModeDisconnected(const WiFiEventStationModeDisconnected& event) {
-  // Serial.println(F("WiFi connection dropped, stopping NTP."));
-  configureNTP();
+void NTPSettingsService::onStationModeDisconnected(const WiFiEventStationModeDisconnected & event) {
+    // Serial.println(F("WiFi connection dropped, stopping NTP."));
+    configureNTP();
 }
 #endif
 
 void NTPSettingsService::configureNTP() {
-  if (WiFi.isConnected() && _state.enabled) {
-    // Serial.println(F("Starting NTP..."));
+    if (WiFi.isConnected() && _state.enabled) {
+        // Serial.println(F("Starting NTP..."));
 #ifdef ESP32
-    configTzTime(_state.tzFormat.c_str(), _state.server.c_str());
+        configTzTime(_state.tzFormat.c_str(), _state.server.c_str());
 #elif defined(ESP8266)
-    configTime(_state.tzFormat.c_str(), _state.server.c_str());
+        configTime(_state.tzFormat.c_str(), _state.server.c_str());
 #endif
-  } else {
+    } else {
 #ifdef ESP32
-    setenv("TZ", _state.tzFormat.c_str(), 1);
-    tzset();
+        setenv("TZ", _state.tzFormat.c_str(), 1);
+        tzset();
 #elif defined(ESP8266)
-    setTZ(_state.tzFormat.c_str());
+        setTZ(_state.tzFormat.c_str());
 #endif
-    sntp_stop();
-  }
+        sntp_stop();
+    }
 }
 
-void NTPSettingsService::configureTime(AsyncWebServerRequest* request, JsonVariant& json) {
-  if (!sntp_enabled() && json.is<JsonObject>()) {
-    String timeUtc = json["time_utc"];
-    struct tm tm = {0};
-    char* s = strptime(timeUtc.c_str(), "%Y-%m-%dT%H:%M:%SZ", &tm);
-    if (s != nullptr) {
-      time_t time = mktime(&tm);
-      struct timeval now = {.tv_sec = time};
-      settimeofday(&now, nullptr);
-      AsyncWebServerResponse* response = request->beginResponse(200);
-      request->send(response);
-      return;
+void NTPSettingsService::configureTime(AsyncWebServerRequest * request, JsonVariant & json) {
+    if (!sntp_enabled() && json.is<JsonObject>()) {
+        String    timeUtc = json["time_utc"];
+        struct tm tm      = {0};
+        char *    s       = strptime(timeUtc.c_str(), "%Y-%m-%dT%H:%M:%SZ", &tm);
+        if (s != nullptr) {
+            time_t         time = mktime(&tm);
+            struct timeval now  = {.tv_sec = time};
+            settimeofday(&now, nullptr);
+            AsyncWebServerResponse * response = request->beginResponse(200);
+            request->send(response);
+            return;
+        }
     }
-  }
-  AsyncWebServerResponse* response = request->beginResponse(400);
-  request->send(response);
+    AsyncWebServerResponse * response = request->beginResponse(400);
+    request->send(response);
 }
diff --git a/lib/framework/NTPSettingsService.h b/lib/framework/NTPSettingsService.h
index bf25ca49d..efd4ee3d0 100644
--- a/lib/framework/NTPSettingsService.h
+++ b/lib/framework/NTPSettingsService.h
@@ -34,51 +34,51 @@
 #define TIME_PATH "/rest/time"
 
 class NTPSettings {
- public:
-  bool enabled;
-  String tzLabel;
-  String tzFormat;
-  String server;
+  public:
+    bool   enabled;
+    String tzLabel;
+    String tzFormat;
+    String server;
 
-  static void read(NTPSettings& settings, JsonObject& root) {
-    root["enabled"] = settings.enabled;
-    root["server"] = settings.server;
-    root["tz_label"] = settings.tzLabel;
-    root["tz_format"] = settings.tzFormat;
-  }
+    static void read(NTPSettings & settings, JsonObject & root) {
+        root["enabled"]   = settings.enabled;
+        root["server"]    = settings.server;
+        root["tz_label"]  = settings.tzLabel;
+        root["tz_format"] = settings.tzFormat;
+    }
 
-  static StateUpdateResult update(JsonObject& root, NTPSettings& settings) {
-    settings.enabled = root["enabled"] | FACTORY_NTP_ENABLED;
-    settings.server = root["server"] | FACTORY_NTP_SERVER;
-    settings.tzLabel = root["tz_label"] | FACTORY_NTP_TIME_ZONE_LABEL;
-    settings.tzFormat = root["tz_format"] | FACTORY_NTP_TIME_ZONE_FORMAT;
-    return StateUpdateResult::CHANGED;
-  }
+    static StateUpdateResult update(JsonObject & root, NTPSettings & settings) {
+        settings.enabled  = root["enabled"] | FACTORY_NTP_ENABLED;
+        settings.server   = root["server"] | FACTORY_NTP_SERVER;
+        settings.tzLabel  = root["tz_label"] | FACTORY_NTP_TIME_ZONE_LABEL;
+        settings.tzFormat = root["tz_format"] | FACTORY_NTP_TIME_ZONE_FORMAT;
+        return StateUpdateResult::CHANGED;
+    }
 };
 
 class NTPSettingsService : public StatefulService<NTPSettings> {
- public:
-  NTPSettingsService(AsyncWebServer* server, FS* fs, SecurityManager* securityManager);
+  public:
+    NTPSettingsService(AsyncWebServer * server, FS * fs, SecurityManager * securityManager);
 
-  void begin();
+    void begin();
 
- private:
-  HttpEndpoint<NTPSettings> _httpEndpoint;
-  FSPersistence<NTPSettings> _fsPersistence;
-  AsyncCallbackJsonWebHandler _timeHandler;
+  private:
+    HttpEndpoint<NTPSettings>   _httpEndpoint;
+    FSPersistence<NTPSettings>  _fsPersistence;
+    AsyncCallbackJsonWebHandler _timeHandler;
 
 #ifdef ESP32
-  void onStationModeGotIP(WiFiEvent_t event, WiFiEventInfo_t info);
-  void onStationModeDisconnected(WiFiEvent_t event, WiFiEventInfo_t info);
+    void onStationModeGotIP(WiFiEvent_t event, WiFiEventInfo_t info);
+    void onStationModeDisconnected(WiFiEvent_t event, WiFiEventInfo_t info);
 #elif defined(ESP8266)
-  WiFiEventHandler _onStationModeDisconnectedHandler;
-  WiFiEventHandler _onStationModeGotIPHandler;
+    WiFiEventHandler _onStationModeDisconnectedHandler;
+    WiFiEventHandler _onStationModeGotIPHandler;
 
-  void onStationModeGotIP(const WiFiEventStationModeGotIP& event);
-  void onStationModeDisconnected(const WiFiEventStationModeDisconnected& event);
+    void onStationModeGotIP(const WiFiEventStationModeGotIP & event);
+    void onStationModeDisconnected(const WiFiEventStationModeDisconnected & event);
 #endif
-  void configureNTP();
-  void configureTime(AsyncWebServerRequest* request, JsonVariant& json);
+    void configureNTP();
+    void configureTime(AsyncWebServerRequest * request, JsonVariant & json);
 };
 
-#endif  // end NTPSettingsService_h
+#endif // end NTPSettingsService_h
diff --git a/lib/framework/NTPStatus.cpp b/lib/framework/NTPStatus.cpp
index 5afb93b23..f210532a4 100644
--- a/lib/framework/NTPStatus.cpp
+++ b/lib/framework/NTPStatus.cpp
@@ -1,40 +1,39 @@
 #include <NTPStatus.h>
 
-NTPStatus::NTPStatus(AsyncWebServer* server, SecurityManager* securityManager) {
-  server->on(NTP_STATUS_SERVICE_PATH,
-             HTTP_GET,
-             securityManager->wrapRequest(std::bind(&NTPStatus::ntpStatus, this, std::placeholders::_1),
-                                          AuthenticationPredicates::IS_AUTHENTICATED));
+NTPStatus::NTPStatus(AsyncWebServer * server, SecurityManager * securityManager) {
+    server->on(NTP_STATUS_SERVICE_PATH,
+               HTTP_GET,
+               securityManager->wrapRequest(std::bind(&NTPStatus::ntpStatus, this, std::placeholders::_1), AuthenticationPredicates::IS_AUTHENTICATED));
 }
 
-String toISOString(tm* time, bool incOffset) {
-  char time_string[25];
-  strftime(time_string, 25, incOffset ? "%FT%T%z" : "%FT%TZ", time);
-  return String(time_string);
+String toISOString(tm * time, bool incOffset) {
+    char time_string[25];
+    strftime(time_string, 25, incOffset ? "%FT%T%z" : "%FT%TZ", time);
+    return String(time_string);
 }
 
-void NTPStatus::ntpStatus(AsyncWebServerRequest* request) {
-  AsyncJsonResponse* response = new AsyncJsonResponse(false, MAX_NTP_STATUS_SIZE);
-  JsonObject root = response->getRoot();
+void NTPStatus::ntpStatus(AsyncWebServerRequest * request) {
+    AsyncJsonResponse * response = new AsyncJsonResponse(false, MAX_NTP_STATUS_SIZE);
+    JsonObject          root     = response->getRoot();
 
-  // grab the current instant in unix seconds
-  time_t now = time(nullptr);
+    // grab the current instant in unix seconds
+    time_t now = time(nullptr);
 
-  // only provide enabled/disabled status for now
-  root["status"] = sntp_enabled() ? 1 : 0;
+    // only provide enabled/disabled status for now
+    root["status"] = sntp_enabled() ? 1 : 0;
 
-  // the current time in UTC
-  root["time_utc"] = toISOString(gmtime(&now), false);
+    // the current time in UTC
+    root["time_utc"] = toISOString(gmtime(&now), false);
 
-  // local time as ISO String with TZ
-  root["time_local"] = toISOString(localtime(&now), true);
+    // local time as ISO String with TZ
+    root["time_local"] = toISOString(localtime(&now), true);
 
-  // the sntp server name
-  root["server"] = sntp_getservername(0);
+    // the sntp server name
+    root["server"] = sntp_getservername(0);
 
-  // device uptime in seconds
-  root["uptime"] = uuid::get_uptime() / 1000;
+    // device uptime in seconds
+    root["uptime"] = uuid::get_uptime() / 1000;
 
-  response->setLength();
-  request->send(response);
+    response->setLength();
+    request->send(response);
 }
diff --git a/lib/framework/NTPStatus.h b/lib/framework/NTPStatus.h
index 893435847..ad599b76b 100644
--- a/lib/framework/NTPStatus.h
+++ b/lib/framework/NTPStatus.h
@@ -23,11 +23,11 @@
 #define NTP_STATUS_SERVICE_PATH "/rest/ntpStatus"
 
 class NTPStatus {
- public:
-  NTPStatus(AsyncWebServer* server, SecurityManager* securityManager);
+  public:
+    NTPStatus(AsyncWebServer * server, SecurityManager * securityManager);
 
- private:
-  void ntpStatus(AsyncWebServerRequest* request);
+  private:
+    void ntpStatus(AsyncWebServerRequest * request);
 };
 
-#endif  // end NTPStatus_h
+#endif // end NTPStatus_h
diff --git a/lib/framework/OTASettingsService.h b/lib/framework/OTASettingsService.h
index 8a0bcaad8..e977cd5e7 100644
--- a/lib/framework/OTASettingsService.h
+++ b/lib/framework/OTASettingsService.h
@@ -31,44 +31,44 @@
 #define OTA_SETTINGS_SERVICE_PATH "/rest/otaSettings"
 
 class OTASettings {
- public:
-  bool enabled;
-  int port;
-  String password;
+  public:
+    bool   enabled;
+    int    port;
+    String password;
 
-  static void read(OTASettings& settings, JsonObject& root) {
-    root["enabled"] = settings.enabled;
-    root["port"] = settings.port;
-    root["password"] = settings.password;
-  }
+    static void read(OTASettings & settings, JsonObject & root) {
+        root["enabled"]  = settings.enabled;
+        root["port"]     = settings.port;
+        root["password"] = settings.password;
+    }
 
-  static StateUpdateResult update(JsonObject& root, OTASettings& settings) {
-    settings.enabled = root["enabled"] | FACTORY_OTA_ENABLED;
-    settings.port = root["port"] | FACTORY_OTA_PORT;
-    settings.password = root["password"] | FACTORY_OTA_PASSWORD;
-    return StateUpdateResult::CHANGED;
-  }
+    static StateUpdateResult update(JsonObject & root, OTASettings & settings) {
+        settings.enabled  = root["enabled"] | FACTORY_OTA_ENABLED;
+        settings.port     = root["port"] | FACTORY_OTA_PORT;
+        settings.password = root["password"] | FACTORY_OTA_PASSWORD;
+        return StateUpdateResult::CHANGED;
+    }
 };
 
 class OTASettingsService : public StatefulService<OTASettings> {
- public:
-  OTASettingsService(AsyncWebServer* server, FS* fs, SecurityManager* securityManager);
+  public:
+    OTASettingsService(AsyncWebServer * server, FS * fs, SecurityManager * securityManager);
 
-  void begin();
-  void loop();
+    void begin();
+    void loop();
 
- private:
-  HttpEndpoint<OTASettings> _httpEndpoint;
-  FSPersistence<OTASettings> _fsPersistence;
-  ArduinoOTAClass* _arduinoOTA;
+  private:
+    HttpEndpoint<OTASettings>  _httpEndpoint;
+    FSPersistence<OTASettings> _fsPersistence;
+    ArduinoOTAClass *          _arduinoOTA;
 
-  void configureArduinoOTA();
+    void configureArduinoOTA();
 #ifdef ESP32
-  void onStationModeGotIP(WiFiEvent_t event, WiFiEventInfo_t info);
+    void onStationModeGotIP(WiFiEvent_t event, WiFiEventInfo_t info);
 #elif defined(ESP8266)
-  WiFiEventHandler _onStationModeGotIPHandler;
-  void onStationModeGotIP(const WiFiEventStationModeGotIP& event);
+    WiFiEventHandler _onStationModeGotIPHandler;
+    void             onStationModeGotIP(const WiFiEventStationModeGotIP & event);
 #endif
 };
 
-#endif  // end OTASettingsService_h
+#endif // end OTASettingsService_h
diff --git a/lib/framework/RestartService.cpp b/lib/framework/RestartService.cpp
index 9036e40a7..67669040f 100644
--- a/lib/framework/RestartService.cpp
+++ b/lib/framework/RestartService.cpp
@@ -1,13 +1,12 @@
 #include <RestartService.h>
 
-RestartService::RestartService(AsyncWebServer* server, SecurityManager* securityManager) {
-  server->on(RESTART_SERVICE_PATH,
-             HTTP_POST,
-             securityManager->wrapRequest(std::bind(&RestartService::restart, this, std::placeholders::_1),
-                                          AuthenticationPredicates::IS_ADMIN));
+RestartService::RestartService(AsyncWebServer * server, SecurityManager * securityManager) {
+    server->on(RESTART_SERVICE_PATH,
+               HTTP_POST,
+               securityManager->wrapRequest(std::bind(&RestartService::restart, this, std::placeholders::_1), AuthenticationPredicates::IS_ADMIN));
 }
 
-void RestartService::restart(AsyncWebServerRequest* request) {
-  request->onDisconnect(RestartService::restartNow);
-  request->send(200);
+void RestartService::restart(AsyncWebServerRequest * request) {
+    request->onDisconnect(RestartService::restartNow);
+    request->send(200);
 }
diff --git a/lib/framework/RestartService.h b/lib/framework/RestartService.h
index 45a10084e..beae4a0dc 100644
--- a/lib/framework/RestartService.h
+++ b/lib/framework/RestartService.h
@@ -15,17 +15,17 @@
 #define RESTART_SERVICE_PATH "/rest/restart"
 
 class RestartService {
- public:
-  RestartService(AsyncWebServer* server, SecurityManager* securityManager);
+  public:
+    RestartService(AsyncWebServer * server, SecurityManager * securityManager);
 
-  static void restartNow() {
-    WiFi.disconnect(true);
-    delay(500);
-    ESP.restart();
-  }
+    static void restartNow() {
+        WiFi.disconnect(true);
+        delay(500);
+        ESP.restart();
+    }
 
- private:
-  void restart(AsyncWebServerRequest* request);
+  private:
+    void restart(AsyncWebServerRequest * request);
 };
 
-#endif  // end RestartService_h
+#endif // end RestartService_h
diff --git a/lib/framework/SecurityManager.h b/lib/framework/SecurityManager.h
index 530ab81a5..82eb516b1 100644
--- a/lib/framework/SecurityManager.h
+++ b/lib/framework/SecurityManager.h
@@ -21,82 +21,87 @@
 #define MAX_JWT_SIZE 128
 
 class User {
- public:
-  String username;
-  String password;
-  bool admin;
+  public:
+    String username;
+    String password;
+    bool   admin;
 
- public:
-  User(String username, String password, bool admin) : username(username), password(password), admin(admin) {
-  }
+  public:
+    User(String username, String password, bool admin)
+        : username(username)
+        , password(password)
+        , admin(admin) {
+    }
 };
 
 class Authentication {
- public:
-  User* user;
-  boolean authenticated;
+  public:
+    User *  user;
+    boolean authenticated;
 
- public:
-  Authentication(User& user) : user(new User(user)), authenticated(true) {
-  }
-  Authentication() : user(nullptr), authenticated(false) {
-  }
-  ~Authentication() {
-    delete (user);
-  }
+  public:
+    Authentication(User & user)
+        : user(new User(user))
+        , authenticated(true) {
+    }
+    Authentication()
+        : user(nullptr)
+        , authenticated(false) {
+    }
+    ~Authentication() {
+        delete (user);
+    }
 };
 
-typedef std::function<boolean(Authentication& authentication)> AuthenticationPredicate;
+typedef std::function<boolean(Authentication & authentication)> AuthenticationPredicate;
 
 class AuthenticationPredicates {
- public:
-  static bool NONE_REQUIRED(Authentication& authentication) {
-    return true;
-  };
-  static bool IS_AUTHENTICATED(Authentication& authentication) {
-    return authentication.authenticated;
-  };
-  static bool IS_ADMIN(Authentication& authentication) {
-    return authentication.authenticated && authentication.user->admin;
-  };
+  public:
+    static bool NONE_REQUIRED(Authentication & authentication) {
+        return true;
+    };
+    static bool IS_AUTHENTICATED(Authentication & authentication) {
+        return authentication.authenticated;
+    };
+    static bool IS_ADMIN(Authentication & authentication) {
+        return authentication.authenticated && authentication.user->admin;
+    };
 };
 
 class SecurityManager {
- public:
+  public:
 #if FT_ENABLED(FT_SECURITY)
-  /*
+    /*
    * Authenticate, returning the user if found
    */
-  virtual Authentication authenticate(const String& username, const String& password) = 0;
+    virtual Authentication authenticate(const String & username, const String & password) = 0;
 
-  /*
+    /*
    * Generate a JWT for the user provided
    */
-  virtual String generateJWT(User* user) = 0;
+    virtual String generateJWT(User * user) = 0;
 
 #endif
 
-  /*
+    /*
    * Check the request header for the Authorization token
    */
-  virtual Authentication authenticateRequest(AsyncWebServerRequest* request) = 0;
+    virtual Authentication authenticateRequest(AsyncWebServerRequest * request) = 0;
 
-  /**
+    /**
    * Filter a request with the provided predicate, only returning true if the predicate matches.
    */
-  virtual ArRequestFilterFunction filterRequest(AuthenticationPredicate predicate) = 0;
+    virtual ArRequestFilterFunction filterRequest(AuthenticationPredicate predicate) = 0;
 
-  /**
+    /**
    * Wrap the provided request to provide validation against an AuthenticationPredicate.
    */
-  virtual ArRequestHandlerFunction wrapRequest(ArRequestHandlerFunction onRequest,
-                                               AuthenticationPredicate predicate) = 0;
+    virtual ArRequestHandlerFunction wrapRequest(ArRequestHandlerFunction onRequest, AuthenticationPredicate predicate) = 0;
 
-  /**
+    /**
    * Wrap the provided json request callback to provide validation against an AuthenticationPredicate.
    */
-  virtual ArJsonRequestHandlerFunction wrapCallback(ArJsonRequestHandlerFunction onRequest,
-                                                    AuthenticationPredicate predicate) = 0;
+    virtual ArJsonRequestHandlerFunction wrapCallback(ArJsonRequestHandlerFunction onRequest, AuthenticationPredicate predicate) = 0;
 };
 
-#endif  // end SecurityManager_h
+#endif // end SecurityManager_h
diff --git a/lib/framework/SecuritySettingsService.cpp b/lib/framework/SecuritySettingsService.cpp
index 08ba401d8..bdce27505 100644
--- a/lib/framework/SecuritySettingsService.cpp
+++ b/lib/framework/SecuritySettingsService.cpp
@@ -2,140 +2,137 @@
 
 #if FT_ENABLED(FT_SECURITY)
 
-SecuritySettingsService::SecuritySettingsService(AsyncWebServer* server, FS* fs) :
-    _httpEndpoint(SecuritySettings::read, SecuritySettings::update, this, server, SECURITY_SETTINGS_PATH, this),
-    _fsPersistence(SecuritySettings::read, SecuritySettings::update, this, fs, SECURITY_SETTINGS_FILE),
-    _jwtHandler(FACTORY_JWT_SECRET) {
-  addUpdateHandler([&](const String& originId) { configureJWTHandler(); }, false);
+SecuritySettingsService::SecuritySettingsService(AsyncWebServer * server, FS * fs)
+    : _httpEndpoint(SecuritySettings::read, SecuritySettings::update, this, server, SECURITY_SETTINGS_PATH, this)
+    , _fsPersistence(SecuritySettings::read, SecuritySettings::update, this, fs, SECURITY_SETTINGS_FILE)
+    , _jwtHandler(FACTORY_JWT_SECRET) {
+    addUpdateHandler([&](const String & originId) { configureJWTHandler(); }, false);
 }
 
 void SecuritySettingsService::begin() {
-  _fsPersistence.readFromFS();
-  configureJWTHandler();
+    _fsPersistence.readFromFS();
+    configureJWTHandler();
 }
 
-Authentication SecuritySettingsService::authenticateRequest(AsyncWebServerRequest* request) {
-  AsyncWebHeader* authorizationHeader = request->getHeader(AUTHORIZATION_HEADER);
-  if (authorizationHeader) {
-    String value = authorizationHeader->value();
-    if (value.startsWith(AUTHORIZATION_HEADER_PREFIX)) {
-      value = value.substring(AUTHORIZATION_HEADER_PREFIX_LEN);
-      return authenticateJWT(value);
+Authentication SecuritySettingsService::authenticateRequest(AsyncWebServerRequest * request) {
+    AsyncWebHeader * authorizationHeader = request->getHeader(AUTHORIZATION_HEADER);
+    if (authorizationHeader) {
+        String value = authorizationHeader->value();
+        if (value.startsWith(AUTHORIZATION_HEADER_PREFIX)) {
+            value = value.substring(AUTHORIZATION_HEADER_PREFIX_LEN);
+            return authenticateJWT(value);
+        }
+    } else if (request->hasParam(ACCESS_TOKEN_PARAMATER)) {
+        AsyncWebParameter * tokenParamater = request->getParam(ACCESS_TOKEN_PARAMATER);
+        String              value          = tokenParamater->value();
+        return authenticateJWT(value);
     }
-  } else if (request->hasParam(ACCESS_TOKEN_PARAMATER)) {
-    AsyncWebParameter* tokenParamater = request->getParam(ACCESS_TOKEN_PARAMATER);
-    String value = tokenParamater->value();
-    return authenticateJWT(value);
-  }
-  return Authentication();
+    return Authentication();
 }
 
 void SecuritySettingsService::configureJWTHandler() {
-  _jwtHandler.setSecret(_state.jwtSecret);
+    _jwtHandler.setSecret(_state.jwtSecret);
 }
 
-Authentication SecuritySettingsService::authenticateJWT(String& jwt) {
-  DynamicJsonDocument payloadDocument(MAX_JWT_SIZE);
-  _jwtHandler.parseJWT(jwt, payloadDocument);
-  if (payloadDocument.is<JsonObject>()) {
-    JsonObject parsedPayload = payloadDocument.as<JsonObject>();
-    String username = parsedPayload["username"];
+Authentication SecuritySettingsService::authenticateJWT(String & jwt) {
+    DynamicJsonDocument payloadDocument(MAX_JWT_SIZE);
+    _jwtHandler.parseJWT(jwt, payloadDocument);
+    if (payloadDocument.is<JsonObject>()) {
+        JsonObject parsedPayload = payloadDocument.as<JsonObject>();
+        String     username      = parsedPayload["username"];
+        for (User _user : _state.users) {
+            if (_user.username == username && validatePayload(parsedPayload, &_user)) {
+                return Authentication(_user);
+            }
+        }
+    }
+    return Authentication();
+}
+
+Authentication SecuritySettingsService::authenticate(const String & username, const String & password) {
     for (User _user : _state.users) {
-      if (_user.username == username && validatePayload(parsedPayload, &_user)) {
-        return Authentication(_user);
-      }
+        if (_user.username == username && _user.password == password) {
+            return Authentication(_user);
+        }
     }
-  }
-  return Authentication();
+    return Authentication();
 }
 
-Authentication SecuritySettingsService::authenticate(const String& username, const String& password) {
-  for (User _user : _state.users) {
-    if (_user.username == username && _user.password == password) {
-      return Authentication(_user);
-    }
-  }
-  return Authentication();
+inline void populateJWTPayload(JsonObject & payload, User * user) {
+    payload["username"] = user->username;
+    payload["admin"]    = user->admin;
+    payload["version"]  = EMSESP_APP_VERSION; // proddy added
 }
 
-inline void populateJWTPayload(JsonObject& payload, User* user) {
-  payload["username"] = user->username;
-  payload["admin"] = user->admin;
-  payload["version"] = EMSESP_APP_VERSION; // proddy added
+boolean SecuritySettingsService::validatePayload(JsonObject & parsedPayload, User * user) {
+    DynamicJsonDocument jsonDocument(MAX_JWT_SIZE);
+    JsonObject          payload = jsonDocument.to<JsonObject>();
+    populateJWTPayload(payload, user);
+    return payload == parsedPayload;
 }
 
-boolean SecuritySettingsService::validatePayload(JsonObject& parsedPayload, User* user) {
-  DynamicJsonDocument jsonDocument(MAX_JWT_SIZE);
-  JsonObject payload = jsonDocument.to<JsonObject>();
-  populateJWTPayload(payload, user);
-  return payload == parsedPayload;
-}
-
-String SecuritySettingsService::generateJWT(User* user) {
-  DynamicJsonDocument jsonDocument(MAX_JWT_SIZE);
-  JsonObject payload = jsonDocument.to<JsonObject>();
-  populateJWTPayload(payload, user);
-  return _jwtHandler.buildJWT(payload);
+String SecuritySettingsService::generateJWT(User * user) {
+    DynamicJsonDocument jsonDocument(MAX_JWT_SIZE);
+    JsonObject          payload = jsonDocument.to<JsonObject>();
+    populateJWTPayload(payload, user);
+    return _jwtHandler.buildJWT(payload);
 }
 
 ArRequestFilterFunction SecuritySettingsService::filterRequest(AuthenticationPredicate predicate) {
-  return [this, predicate](AsyncWebServerRequest* request) {
-    Authentication authentication = authenticateRequest(request);
-    return predicate(authentication);
-  };
+    return [this, predicate](AsyncWebServerRequest * request) {
+        Authentication authentication = authenticateRequest(request);
+        return predicate(authentication);
+    };
 }
 
-ArRequestHandlerFunction SecuritySettingsService::wrapRequest(ArRequestHandlerFunction onRequest,
-                                                              AuthenticationPredicate predicate) {
-  return [this, onRequest, predicate](AsyncWebServerRequest* request) {
-    Authentication authentication = authenticateRequest(request);
-    if (!predicate(authentication)) {
-      request->send(401);
-      return;
-    }
-    onRequest(request);
-  };
+ArRequestHandlerFunction SecuritySettingsService::wrapRequest(ArRequestHandlerFunction onRequest, AuthenticationPredicate predicate) {
+    return [this, onRequest, predicate](AsyncWebServerRequest * request) {
+        Authentication authentication = authenticateRequest(request);
+        if (!predicate(authentication)) {
+            request->send(401);
+            return;
+        }
+        onRequest(request);
+    };
 }
 
-ArJsonRequestHandlerFunction SecuritySettingsService::wrapCallback(ArJsonRequestHandlerFunction onRequest,
-                                                                   AuthenticationPredicate predicate) {
-  return [this, onRequest, predicate](AsyncWebServerRequest* request, JsonVariant& json) {
-    Authentication authentication = authenticateRequest(request);
-    if (!predicate(authentication)) {
-      request->send(401);
-      return;
-    }
-    onRequest(request, json);
-  };
+ArJsonRequestHandlerFunction SecuritySettingsService::wrapCallback(ArJsonRequestHandlerFunction onRequest, AuthenticationPredicate predicate) {
+    return [this, onRequest, predicate](AsyncWebServerRequest * request, JsonVariant & json) {
+        Authentication authentication = authenticateRequest(request);
+        if (!predicate(authentication)) {
+            request->send(401);
+            return;
+        }
+        onRequest(request, json);
+    };
 }
 
 #else
 
 User ADMIN_USER = User(FACTORY_ADMIN_USERNAME, FACTORY_ADMIN_PASSWORD, true);
 
-SecuritySettingsService::SecuritySettingsService(AsyncWebServer* server, FS* fs) : SecurityManager() {
+SecuritySettingsService::SecuritySettingsService(AsyncWebServer * server, FS * fs)
+    : SecurityManager() {
 }
 SecuritySettingsService::~SecuritySettingsService() {
 }
 
 ArRequestFilterFunction SecuritySettingsService::filterRequest(AuthenticationPredicate predicate) {
-  return [this, predicate](AsyncWebServerRequest* request) { return true; };
+    return [this, predicate](AsyncWebServerRequest * request) { return true; };
 }
 
 // Return the admin user on all request - disabling security features
-Authentication SecuritySettingsService::authenticateRequest(AsyncWebServerRequest* request) {
-  return Authentication(ADMIN_USER);
+Authentication SecuritySettingsService::authenticateRequest(AsyncWebServerRequest * request) {
+    return Authentication(ADMIN_USER);
 }
 
 // Return the function unwrapped
-ArRequestHandlerFunction SecuritySettingsService::wrapRequest(ArRequestHandlerFunction onRequest,
-                                                              AuthenticationPredicate predicate) {
-  return onRequest;
+ArRequestHandlerFunction SecuritySettingsService::wrapRequest(ArRequestHandlerFunction onRequest, AuthenticationPredicate predicate) {
+    return onRequest;
 }
 
-ArJsonRequestHandlerFunction SecuritySettingsService::wrapCallback(ArJsonRequestHandlerFunction onRequest,
-                                                                   AuthenticationPredicate predicate) {
-  return onRequest;
+ArJsonRequestHandlerFunction SecuritySettingsService::wrapCallback(ArJsonRequestHandlerFunction onRequest, AuthenticationPredicate predicate) {
+    return onRequest;
 }
 
 #endif
diff --git a/lib/framework/SecuritySettingsService.h b/lib/framework/SecuritySettingsService.h
index 801e44a3e..fa273b4e1 100644
--- a/lib/framework/SecuritySettingsService.h
+++ b/lib/framework/SecuritySettingsService.h
@@ -30,87 +30,87 @@
 #if FT_ENABLED(FT_SECURITY)
 
 class SecuritySettings {
- public:
-  String jwtSecret;
-  std::list<User> users;
+  public:
+    String          jwtSecret;
+    std::list<User> users;
 
-  static void read(SecuritySettings& settings, JsonObject& root) {
-    // secret
-    root["jwt_secret"] = settings.jwtSecret;
+    static void read(SecuritySettings & settings, JsonObject & root) {
+        // secret
+        root["jwt_secret"] = settings.jwtSecret;
 
-    // users
-    JsonArray users = root.createNestedArray("users");
-    for (User user : settings.users) {
-      JsonObject userRoot = users.createNestedObject();
-      userRoot["username"] = user.username;
-      userRoot["password"] = user.password;
-      userRoot["admin"] = user.admin;
+        // users
+        JsonArray users = root.createNestedArray("users");
+        for (User user : settings.users) {
+            JsonObject userRoot  = users.createNestedObject();
+            userRoot["username"] = user.username;
+            userRoot["password"] = user.password;
+            userRoot["admin"]    = user.admin;
+        }
     }
-  }
 
-  static StateUpdateResult update(JsonObject& root, SecuritySettings& settings) {
-    // secret
-    settings.jwtSecret = root["jwt_secret"] | FACTORY_JWT_SECRET;
+    static StateUpdateResult update(JsonObject & root, SecuritySettings & settings) {
+        // secret
+        settings.jwtSecret = root["jwt_secret"] | FACTORY_JWT_SECRET;
 
-    // users
-    settings.users.clear();
-    if (root["users"].is<JsonArray>()) {
-      for (JsonVariant user : root["users"].as<JsonArray>()) {
-        settings.users.push_back(User(user["username"], user["password"], user["admin"]));
-      }
-    } else {
-      settings.users.push_back(User(FACTORY_ADMIN_USERNAME, FACTORY_ADMIN_PASSWORD, true));
-      settings.users.push_back(User(FACTORY_GUEST_USERNAME, FACTORY_GUEST_PASSWORD, false));
+        // users
+        settings.users.clear();
+        if (root["users"].is<JsonArray>()) {
+            for (JsonVariant user : root["users"].as<JsonArray>()) {
+                settings.users.push_back(User(user["username"], user["password"], user["admin"]));
+            }
+        } else {
+            settings.users.push_back(User(FACTORY_ADMIN_USERNAME, FACTORY_ADMIN_PASSWORD, true));
+            settings.users.push_back(User(FACTORY_GUEST_USERNAME, FACTORY_GUEST_PASSWORD, false));
+        }
+        return StateUpdateResult::CHANGED;
     }
-    return StateUpdateResult::CHANGED;
-  }
 };
 
 class SecuritySettingsService : public StatefulService<SecuritySettings>, public SecurityManager {
- public:
-  SecuritySettingsService(AsyncWebServer* server, FS* fs);
+  public:
+    SecuritySettingsService(AsyncWebServer * server, FS * fs);
 
-  void begin();
+    void begin();
 
-  // Functions to implement SecurityManager
-  Authentication authenticate(const String& username, const String& password);
-  Authentication authenticateRequest(AsyncWebServerRequest* request);
-  String generateJWT(User* user);
-  ArRequestFilterFunction filterRequest(AuthenticationPredicate predicate);
-  ArRequestHandlerFunction wrapRequest(ArRequestHandlerFunction onRequest, AuthenticationPredicate predicate);
-  ArJsonRequestHandlerFunction wrapCallback(ArJsonRequestHandlerFunction callback, AuthenticationPredicate predicate);
+    // Functions to implement SecurityManager
+    Authentication               authenticate(const String & username, const String & password);
+    Authentication               authenticateRequest(AsyncWebServerRequest * request);
+    String                       generateJWT(User * user);
+    ArRequestFilterFunction      filterRequest(AuthenticationPredicate predicate);
+    ArRequestHandlerFunction     wrapRequest(ArRequestHandlerFunction onRequest, AuthenticationPredicate predicate);
+    ArJsonRequestHandlerFunction wrapCallback(ArJsonRequestHandlerFunction callback, AuthenticationPredicate predicate);
 
- private:
-  HttpEndpoint<SecuritySettings> _httpEndpoint;
-  FSPersistence<SecuritySettings> _fsPersistence;
-  ArduinoJsonJWT _jwtHandler;
+  private:
+    HttpEndpoint<SecuritySettings>  _httpEndpoint;
+    FSPersistence<SecuritySettings> _fsPersistence;
+    ArduinoJsonJWT                  _jwtHandler;
 
-  void configureJWTHandler();
+    void configureJWTHandler();
 
-  /*
+    /*
    * Lookup the user by JWT
    */
-  Authentication authenticateJWT(String& jwt);
+    Authentication authenticateJWT(String & jwt);
 
-  /*
+    /*
    * Verify the payload is correct
    */
-  boolean validatePayload(JsonObject& parsedPayload, User* user);
+    boolean validatePayload(JsonObject & parsedPayload, User * user);
 };
 
 #else
 
 class SecuritySettingsService : public SecurityManager {
- public:
-  SecuritySettingsService(AsyncWebServer* server, FS* fs);
-  ~SecuritySettingsService();
+  public:
+    SecuritySettingsService(AsyncWebServer * server, FS * fs);
+    ~SecuritySettingsService();
 
-  // minimal set of functions to support framework with security settings disabled  
-  Authentication authenticateRequest(AsyncWebServerRequest* request);
-  ArRequestFilterFunction filterRequest(AuthenticationPredicate predicate);
-  ArRequestHandlerFunction wrapRequest(ArRequestHandlerFunction onRequest, AuthenticationPredicate predicate);
-  ArJsonRequestHandlerFunction wrapCallback(ArJsonRequestHandlerFunction onRequest, AuthenticationPredicate predicate);
+    // minimal set of functions to support framework with security settings disabled
+    Authentication               authenticateRequest(AsyncWebServerRequest * request);
+    ArRequestFilterFunction      filterRequest(AuthenticationPredicate predicate);
+    ArRequestHandlerFunction     wrapRequest(ArRequestHandlerFunction onRequest, AuthenticationPredicate predicate);
+    ArJsonRequestHandlerFunction wrapCallback(ArJsonRequestHandlerFunction onRequest, AuthenticationPredicate predicate);
 };
 
-#endif  // end FT_ENABLED(FT_SECURITY)
-#endif  // end SecuritySettingsService_h
+#endif // end FT_ENABLED(FT_SECURITY)
+#endif // end SecuritySettingsService_h
diff --git a/lib/framework/StatefulService.h b/lib/framework/StatefulService.h
index 9a38e66a1..ba5a3c5e6 100644
--- a/lib/framework/StatefulService.h
+++ b/lib/framework/StatefulService.h
@@ -16,133 +16,137 @@
 #endif
 
 enum class StateUpdateResult {
-  CHANGED = 0,  // The update changed the state and propagation should take place if required
-  UNCHANGED,    // The state was unchanged, propagation should not take place
-  ERROR         // There was a problem updating the state, propagation should not take place
+    CHANGED = 0, // The update changed the state and propagation should take place if required
+    UNCHANGED,   // The state was unchanged, propagation should not take place
+    ERROR        // There was a problem updating the state, propagation should not take place
 };
 
 template <typename T>
-using JsonStateUpdater = std::function<StateUpdateResult(JsonObject& root, T& settings)>;
+using JsonStateUpdater = std::function<StateUpdateResult(JsonObject & root, T & settings)>;
 
 template <typename T>
-using JsonStateReader = std::function<void(T& settings, JsonObject& root)>;
+using JsonStateReader = std::function<void(T & settings, JsonObject & root)>;
 
-typedef size_t update_handler_id_t;
-typedef std::function<void(const String& originId)> StateUpdateCallback;
+typedef size_t                                       update_handler_id_t;
+typedef std::function<void(const String & originId)> StateUpdateCallback;
 
 typedef struct StateUpdateHandlerInfo {
-  static update_handler_id_t currentUpdatedHandlerId;
-  update_handler_id_t _id;
-  StateUpdateCallback _cb;
-  bool _allowRemove;
-  StateUpdateHandlerInfo(StateUpdateCallback cb, bool allowRemove) :
-      _id(++currentUpdatedHandlerId), _cb(cb), _allowRemove(allowRemove){};
+    static update_handler_id_t currentUpdatedHandlerId;
+    update_handler_id_t        _id;
+    StateUpdateCallback        _cb;
+    bool                       _allowRemove;
+    StateUpdateHandlerInfo(StateUpdateCallback cb, bool allowRemove)
+        : _id(++currentUpdatedHandlerId)
+        , _cb(cb)
+        , _allowRemove(allowRemove){};
 } StateUpdateHandlerInfo_t;
 
 template <class T>
 class StatefulService {
- public:
-  template <typename... Args>
+  public:
+    template <typename... Args>
 #ifdef ESP32
-  StatefulService(Args&&... args) :
-      _state(std::forward<Args>(args)...), _accessMutex(xSemaphoreCreateRecursiveMutex()) {
-  }
+    StatefulService(Args &&... args)
+        : _state(std::forward<Args>(args)...)
+        , _accessMutex(xSemaphoreCreateRecursiveMutex()) {
+    }
 #else
-  StatefulService(Args&&... args) : _state(std::forward<Args>(args)...) {
-  }
+    StatefulService(Args &&... args)
+        : _state(std::forward<Args>(args)...) {
+    }
 #endif
 
-  update_handler_id_t addUpdateHandler(StateUpdateCallback cb, bool allowRemove = true) {
-    if (!cb) {
-      return 0;
+    update_handler_id_t addUpdateHandler(StateUpdateCallback cb, bool allowRemove = true) {
+        if (!cb) {
+            return 0;
+        }
+        StateUpdateHandlerInfo_t updateHandler(cb, allowRemove);
+        _updateHandlers.push_back(updateHandler);
+        return updateHandler._id;
     }
-    StateUpdateHandlerInfo_t updateHandler(cb, allowRemove);
-    _updateHandlers.push_back(updateHandler);
-    return updateHandler._id;
-  }
 
-  void removeUpdateHandler(update_handler_id_t id) {
-    for (auto i = _updateHandlers.begin(); i != _updateHandlers.end();) {
-      if ((*i)._allowRemove && (*i)._id == id) {
-        i = _updateHandlers.erase(i);
-      } else {
-        ++i;
-      }
+    void removeUpdateHandler(update_handler_id_t id) {
+        for (auto i = _updateHandlers.begin(); i != _updateHandlers.end();) {
+            if ((*i)._allowRemove && (*i)._id == id) {
+                i = _updateHandlers.erase(i);
+            } else {
+                ++i;
+            }
+        }
     }
-  }
 
-  StateUpdateResult update(std::function<StateUpdateResult(T&)> stateUpdater, const String& originId) {
-    beginTransaction();
-    StateUpdateResult result = stateUpdater(_state);
-    endTransaction();
-    if (result == StateUpdateResult::CHANGED) {
-      callUpdateHandlers(originId);
+    StateUpdateResult update(std::function<StateUpdateResult(T &)> stateUpdater, const String & originId) {
+        beginTransaction();
+        StateUpdateResult result = stateUpdater(_state);
+        endTransaction();
+        if (result == StateUpdateResult::CHANGED) {
+            callUpdateHandlers(originId);
+        }
+        return result;
     }
-    return result;
-  }
 
-  StateUpdateResult updateWithoutPropagation(std::function<StateUpdateResult(T&)> stateUpdater) {
-    beginTransaction();
-    StateUpdateResult result = stateUpdater(_state);
-    endTransaction();
-    return result;
-  }
-
-  StateUpdateResult update(JsonObject& jsonObject, JsonStateUpdater<T> stateUpdater, const String& originId) {
-    beginTransaction();
-    StateUpdateResult result = stateUpdater(jsonObject, _state);
-    endTransaction();
-    if (result == StateUpdateResult::CHANGED) {
-      callUpdateHandlers(originId);
+    StateUpdateResult updateWithoutPropagation(std::function<StateUpdateResult(T &)> stateUpdater) {
+        beginTransaction();
+        StateUpdateResult result = stateUpdater(_state);
+        endTransaction();
+        return result;
     }
-    return result;
-  }
 
-  StateUpdateResult updateWithoutPropagation(JsonObject& jsonObject, JsonStateUpdater<T> stateUpdater) {
-    beginTransaction();
-    StateUpdateResult result = stateUpdater(jsonObject, _state);
-    endTransaction();
-    return result;
-  }
-
-  void read(std::function<void(T&)> stateReader) {
-    beginTransaction();
-    stateReader(_state);
-    endTransaction();
-  }
-
-  void read(JsonObject& jsonObject, JsonStateReader<T> stateReader) {
-    beginTransaction();
-    stateReader(_state, jsonObject);
-    endTransaction();
-  }
-
-  void callUpdateHandlers(const String& originId) {
-    for (const StateUpdateHandlerInfo_t& updateHandler : _updateHandlers) {
-      updateHandler._cb(originId);
+    StateUpdateResult update(JsonObject & jsonObject, JsonStateUpdater<T> stateUpdater, const String & originId) {
+        beginTransaction();
+        StateUpdateResult result = stateUpdater(jsonObject, _state);
+        endTransaction();
+        if (result == StateUpdateResult::CHANGED) {
+            callUpdateHandlers(originId);
+        }
+        return result;
     }
-  }
 
- protected:
-  T _state;
+    StateUpdateResult updateWithoutPropagation(JsonObject & jsonObject, JsonStateUpdater<T> stateUpdater) {
+        beginTransaction();
+        StateUpdateResult result = stateUpdater(jsonObject, _state);
+        endTransaction();
+        return result;
+    }
 
-  inline void beginTransaction() {
+    void read(std::function<void(T &)> stateReader) {
+        beginTransaction();
+        stateReader(_state);
+        endTransaction();
+    }
+
+    void read(JsonObject & jsonObject, JsonStateReader<T> stateReader) {
+        beginTransaction();
+        stateReader(_state, jsonObject);
+        endTransaction();
+    }
+
+    void callUpdateHandlers(const String & originId) {
+        for (const StateUpdateHandlerInfo_t & updateHandler : _updateHandlers) {
+            updateHandler._cb(originId);
+        }
+    }
+
+  protected:
+    T _state;
+
+    inline void beginTransaction() {
 #ifdef ESP32
-    xSemaphoreTakeRecursive(_accessMutex, portMAX_DELAY);
+        xSemaphoreTakeRecursive(_accessMutex, portMAX_DELAY);
 #endif
-  }
+    }
 
-  inline void endTransaction() {
+    inline void endTransaction() {
 #ifdef ESP32
-    xSemaphoreGiveRecursive(_accessMutex);
+        xSemaphoreGiveRecursive(_accessMutex);
 #endif
-  }
+    }
 
- private:
+  private:
 #ifdef ESP32
-  SemaphoreHandle_t _accessMutex;
+    SemaphoreHandle_t _accessMutex;
 #endif
-  std::list<StateUpdateHandlerInfo_t> _updateHandlers;
+    std::list<StateUpdateHandlerInfo_t> _updateHandlers;
 };
 
-#endif  // end StatefulService_h
+#endif // end StatefulService_h
diff --git a/lib/framework/SystemStatus.h b/lib/framework/SystemStatus.h
index 1ea61ae1e..04a09bf3a 100644
--- a/lib/framework/SystemStatus.h
+++ b/lib/framework/SystemStatus.h
@@ -17,7 +17,7 @@
 #include <ESPAsyncWebServer.h>
 #include <SecurityManager.h>
 
-#include <uuid/log.h> // proddy added
+#include <uuid/log.h>         // proddy added
 #include "../../src/system.h" // proddy added
 
 #define MAX_ESP_STATUS_SIZE 1024
diff --git a/lib/framework/UploadFirmwareService.cpp b/lib/framework/UploadFirmwareService.cpp
index 1858ace2a..d7b547a3b 100644
--- a/lib/framework/UploadFirmwareService.cpp
+++ b/lib/framework/UploadFirmwareService.cpp
@@ -1,85 +1,80 @@
 #include <UploadFirmwareService.h>
 
-UploadFirmwareService::UploadFirmwareService(AsyncWebServer* server, SecurityManager* securityManager) :
-    _securityManager(securityManager) {
-  server->on(UPLOAD_FIRMWARE_PATH,
-             HTTP_POST,
-             std::bind(&UploadFirmwareService::uploadComplete, this, std::placeholders::_1),
-             std::bind(&UploadFirmwareService::handleUpload,
-                       this,
-                       std::placeholders::_1,
-                       std::placeholders::_2,
-                       std::placeholders::_3,
-                       std::placeholders::_4,
-                       std::placeholders::_5,
-                       std::placeholders::_6));
+UploadFirmwareService::UploadFirmwareService(AsyncWebServer * server, SecurityManager * securityManager)
+    : _securityManager(securityManager) {
+    server->on(UPLOAD_FIRMWARE_PATH,
+               HTTP_POST,
+               std::bind(&UploadFirmwareService::uploadComplete, this, std::placeholders::_1),
+               std::bind(&UploadFirmwareService::handleUpload,
+                         this,
+                         std::placeholders::_1,
+                         std::placeholders::_2,
+                         std::placeholders::_3,
+                         std::placeholders::_4,
+                         std::placeholders::_5,
+                         std::placeholders::_6));
 #ifdef ESP8266
-  Update.runAsync(true);
+    Update.runAsync(true);
 #endif
 }
 
-void UploadFirmwareService::handleUpload(AsyncWebServerRequest* request,
-                                         const String& filename,
-                                         size_t index,
-                                         uint8_t* data,
-                                         size_t len,
-                                         bool final) {
-  if (!index) {
-    Authentication authentication = _securityManager->authenticateRequest(request);
-    if (AuthenticationPredicates::IS_ADMIN(authentication)) {
-      if (Update.begin(request->contentLength())) {
-        // success, let's make sure we end the update if the client hangs up
-        request->onDisconnect(UploadFirmwareService::handleEarlyDisconnect);
-      } else {
-        // failed to begin, send an error response
-        Update.printError(Serial);
-        handleError(request, 500);
-      }
-    } else {
-      // send the forbidden response
-      handleError(request, 403);
+void UploadFirmwareService::handleUpload(AsyncWebServerRequest * request, const String & filename, size_t index, uint8_t * data, size_t len, bool final) {
+    if (!index) {
+        Authentication authentication = _securityManager->authenticateRequest(request);
+        if (AuthenticationPredicates::IS_ADMIN(authentication)) {
+            if (Update.begin(request->contentLength())) {
+                // success, let's make sure we end the update if the client hangs up
+                request->onDisconnect(UploadFirmwareService::handleEarlyDisconnect);
+            } else {
+                // failed to begin, send an error response
+                Update.printError(Serial);
+                handleError(request, 500);
+            }
+        } else {
+            // send the forbidden response
+            handleError(request, 403);
+        }
     }
-  }
 
-  // if we haven't delt with an error, continue with the update
-  if (!request->_tempObject) {
-    if (Update.write(data, len) != len) {
-      Update.printError(Serial);
-      handleError(request, 500);
+    // if we haven't delt with an error, continue with the update
+    if (!request->_tempObject) {
+        if (Update.write(data, len) != len) {
+            Update.printError(Serial);
+            handleError(request, 500);
+        }
+        if (final) {
+            if (!Update.end(true)) {
+                Update.printError(Serial);
+                handleError(request, 500);
+            }
+        }
     }
-    if (final) {
-      if (!Update.end(true)) {
-        Update.printError(Serial);
-        handleError(request, 500);
-      }
-    }
-  }
 }
 
-void UploadFirmwareService::uploadComplete(AsyncWebServerRequest* request) {
-  // if no error, send the success response
-  if (!request->_tempObject) {
-    request->onDisconnect(RestartService::restartNow);
-    AsyncWebServerResponse* response = request->beginResponse(200);
+void UploadFirmwareService::uploadComplete(AsyncWebServerRequest * request) {
+    // if no error, send the success response
+    if (!request->_tempObject) {
+        request->onDisconnect(RestartService::restartNow);
+        AsyncWebServerResponse * response = request->beginResponse(200);
+        request->send(response);
+    }
+}
+
+void UploadFirmwareService::handleError(AsyncWebServerRequest * request, int code) {
+    // if we have had an error already, do nothing
+    if (request->_tempObject) {
+        return;
+    }
+    // send the error code to the client and record the error code in the temp object
+    request->_tempObject              = new int(code);
+    AsyncWebServerResponse * response = request->beginResponse(code);
     request->send(response);
-  }
-}
-
-void UploadFirmwareService::handleError(AsyncWebServerRequest* request, int code) {
-  // if we have had an error already, do nothing
-  if (request->_tempObject) {
-    return;
-  }
-  // send the error code to the client and record the error code in the temp object
-  request->_tempObject = new int(code);
-  AsyncWebServerResponse* response = request->beginResponse(code);
-  request->send(response);
 }
 
 void UploadFirmwareService::handleEarlyDisconnect() {
 #ifdef ESP32
-  Update.abort();
+    Update.abort();
 #elif defined(ESP8266)
-  Update.end();
+    Update.end();
 #endif
 }
diff --git a/lib/framework/UploadFirmwareService.h b/lib/framework/UploadFirmwareService.h
index 6312af159..f24b7aa38 100644
--- a/lib/framework/UploadFirmwareService.h
+++ b/lib/framework/UploadFirmwareService.h
@@ -19,20 +19,15 @@
 #define UPLOAD_FIRMWARE_PATH "/rest/uploadFirmware"
 
 class UploadFirmwareService {
- public:
-  UploadFirmwareService(AsyncWebServer* server, SecurityManager* securityManager);
+  public:
+    UploadFirmwareService(AsyncWebServer * server, SecurityManager * securityManager);
 
- private:
-  SecurityManager* _securityManager;
-  void handleUpload(AsyncWebServerRequest* request,
-                    const String& filename,
-                    size_t index,
-                    uint8_t* data,
-                    size_t len,
-                    bool final);
-  void uploadComplete(AsyncWebServerRequest* request);
-  void handleError(AsyncWebServerRequest* request, int code);
-  static void handleEarlyDisconnect();
+  private:
+    SecurityManager * _securityManager;
+    void              handleUpload(AsyncWebServerRequest * request, const String & filename, size_t index, uint8_t * data, size_t len, bool final);
+    void              uploadComplete(AsyncWebServerRequest * request);
+    void              handleError(AsyncWebServerRequest * request, int code);
+    static void       handleEarlyDisconnect();
 };
 
-#endif  // end UploadFirmwareService_h
+#endif // end UploadFirmwareService_h
diff --git a/lib/framework/WebSocketTxRx.h b/lib/framework/WebSocketTxRx.h
index 02a1a7d19..07aecc306 100644
--- a/lib/framework/WebSocketTxRx.h
+++ b/lib/framework/WebSocketTxRx.h
@@ -12,262 +12,217 @@
 
 template <class T>
 class WebSocketConnector {
- protected:
-  StatefulService<T>* _statefulService;
-  AsyncWebServer* _server;
-  AsyncWebSocket _webSocket;
-  size_t _bufferSize;
+  protected:
+    StatefulService<T> * _statefulService;
+    AsyncWebServer *     _server;
+    AsyncWebSocket       _webSocket;
+    size_t               _bufferSize;
 
-  WebSocketConnector(StatefulService<T>* statefulService,
-                     AsyncWebServer* server,
-                     char const* webSocketPath,
-                     SecurityManager* securityManager,
-                     AuthenticationPredicate authenticationPredicate,
-                     size_t bufferSize) :
-      _statefulService(statefulService), _server(server), _webSocket(webSocketPath), _bufferSize(bufferSize) {
-    _webSocket.setFilter(securityManager->filterRequest(authenticationPredicate));
-    _webSocket.onEvent(std::bind(&WebSocketConnector::onWSEvent,
-                                 this,
-                                 std::placeholders::_1,
-                                 std::placeholders::_2,
-                                 std::placeholders::_3,
-                                 std::placeholders::_4,
-                                 std::placeholders::_5,
-                                 std::placeholders::_6));
-    _server->addHandler(&_webSocket);
-    _server->on(webSocketPath, HTTP_GET, std::bind(&WebSocketConnector::forbidden, this, std::placeholders::_1));
-  }
+    WebSocketConnector(StatefulService<T> *    statefulService,
+                       AsyncWebServer *        server,
+                       const char *            webSocketPath,
+                       SecurityManager *       securityManager,
+                       AuthenticationPredicate authenticationPredicate,
+                       size_t                  bufferSize)
+        : _statefulService(statefulService)
+        , _server(server)
+        , _webSocket(webSocketPath)
+        , _bufferSize(bufferSize) {
+        _webSocket.setFilter(securityManager->filterRequest(authenticationPredicate));
+        _webSocket.onEvent(std::bind(&WebSocketConnector::onWSEvent,
+                                     this,
+                                     std::placeholders::_1,
+                                     std::placeholders::_2,
+                                     std::placeholders::_3,
+                                     std::placeholders::_4,
+                                     std::placeholders::_5,
+                                     std::placeholders::_6));
+        _server->addHandler(&_webSocket);
+        _server->on(webSocketPath, HTTP_GET, std::bind(&WebSocketConnector::forbidden, this, std::placeholders::_1));
+    }
 
-  WebSocketConnector(StatefulService<T>* statefulService,
-                     AsyncWebServer* server,
-                     char const* webSocketPath,
-                     size_t bufferSize) :
-      _statefulService(statefulService), _server(server), _webSocket(webSocketPath), _bufferSize(bufferSize) {
-    _webSocket.onEvent(std::bind(&WebSocketConnector::onWSEvent,
-                                 this,
-                                 std::placeholders::_1,
-                                 std::placeholders::_2,
-                                 std::placeholders::_3,
-                                 std::placeholders::_4,
-                                 std::placeholders::_5,
-                                 std::placeholders::_6));
-    _server->addHandler(&_webSocket);
-  }
+    WebSocketConnector(StatefulService<T> * statefulService, AsyncWebServer * server, const char * webSocketPath, size_t bufferSize)
+        : _statefulService(statefulService)
+        , _server(server)
+        , _webSocket(webSocketPath)
+        , _bufferSize(bufferSize) {
+        _webSocket.onEvent(std::bind(&WebSocketConnector::onWSEvent,
+                                     this,
+                                     std::placeholders::_1,
+                                     std::placeholders::_2,
+                                     std::placeholders::_3,
+                                     std::placeholders::_4,
+                                     std::placeholders::_5,
+                                     std::placeholders::_6));
+        _server->addHandler(&_webSocket);
+    }
 
-  virtual void onWSEvent(AsyncWebSocket* server,
-                         AsyncWebSocketClient* client,
-                         AwsEventType type,
-                         void* arg,
-                         uint8_t* data,
-                         size_t len) = 0;
+    virtual void onWSEvent(AsyncWebSocket * server, AsyncWebSocketClient * client, AwsEventType type, void * arg, uint8_t * data, size_t len) = 0;
 
-  String clientId(AsyncWebSocketClient* client) {
-    return WEB_SOCKET_ORIGIN_CLIENT_ID_PREFIX + String(client->id());
-  }
+    String clientId(AsyncWebSocketClient * client) {
+        return WEB_SOCKET_ORIGIN_CLIENT_ID_PREFIX + String(client->id());
+    }
 
- private:
-  void forbidden(AsyncWebServerRequest* request) {
-    request->send(403);
-  }
+  private:
+    void forbidden(AsyncWebServerRequest * request) {
+        request->send(403);
+    }
 };
 
 template <class T>
 class WebSocketTx : virtual public WebSocketConnector<T> {
- public:
-  WebSocketTx(JsonStateReader<T> stateReader,
-              StatefulService<T>* statefulService,
-              AsyncWebServer* server,
-              char const* webSocketPath,
-              SecurityManager* securityManager,
-              AuthenticationPredicate authenticationPredicate = AuthenticationPredicates::IS_ADMIN,
-              size_t bufferSize = DEFAULT_BUFFER_SIZE) :
-      WebSocketConnector<T>(statefulService,
-                            server,
-                            webSocketPath,
-                            securityManager,
-                            authenticationPredicate,
-                            bufferSize),
-      _stateReader(stateReader) {
-    WebSocketConnector<T>::_statefulService->addUpdateHandler(
-        [&](const String& originId) { transmitData(nullptr, originId); }, false);
-  }
-
-  WebSocketTx(JsonStateReader<T> stateReader,
-              StatefulService<T>* statefulService,
-              AsyncWebServer* server,
-              char const* webSocketPath,
-              size_t bufferSize = DEFAULT_BUFFER_SIZE) :
-      WebSocketConnector<T>(statefulService, server, webSocketPath, bufferSize), _stateReader(stateReader) {
-    WebSocketConnector<T>::_statefulService->addUpdateHandler(
-        [&](const String& originId) { transmitData(nullptr, originId); }, false);
-  }
-
- protected:
-  virtual void onWSEvent(AsyncWebSocket* server,
-                         AsyncWebSocketClient* client,
-                         AwsEventType type,
-                         void* arg,
-                         uint8_t* data,
-                         size_t len) {
-    if (type == WS_EVT_CONNECT) {
-      // when a client connects, we transmit it's id and the current payload
-      transmitId(client);
-      transmitData(client, WEB_SOCKET_ORIGIN);
+  public:
+    WebSocketTx(JsonStateReader<T>      stateReader,
+                StatefulService<T> *    statefulService,
+                AsyncWebServer *        server,
+                const char *            webSocketPath,
+                SecurityManager *       securityManager,
+                AuthenticationPredicate authenticationPredicate = AuthenticationPredicates::IS_ADMIN,
+                size_t                  bufferSize              = DEFAULT_BUFFER_SIZE)
+        : WebSocketConnector<T>(statefulService, server, webSocketPath, securityManager, authenticationPredicate, bufferSize)
+        , _stateReader(stateReader) {
+        WebSocketConnector<T>::_statefulService->addUpdateHandler([&](const String & originId) { transmitData(nullptr, originId); }, false);
     }
-  }
 
- private:
-  JsonStateReader<T> _stateReader;
-
-  void transmitId(AsyncWebSocketClient* client) {
-    DynamicJsonDocument jsonDocument = DynamicJsonDocument(WEB_SOCKET_CLIENT_ID_MSG_SIZE);
-    JsonObject root = jsonDocument.to<JsonObject>();
-    root["type"] = "id";
-    root["id"] = WebSocketConnector<T>::clientId(client);
-    size_t len = measureJson(jsonDocument);
-    AsyncWebSocketMessageBuffer* buffer = WebSocketConnector<T>::_webSocket.makeBuffer(len);
-    if (buffer) {
-      serializeJson(jsonDocument, (char*)buffer->get(), len + 1);
-      client->text(buffer);
+    WebSocketTx(JsonStateReader<T>   stateReader,
+                StatefulService<T> * statefulService,
+                AsyncWebServer *     server,
+                const char *         webSocketPath,
+                size_t               bufferSize = DEFAULT_BUFFER_SIZE)
+        : WebSocketConnector<T>(statefulService, server, webSocketPath, bufferSize)
+        , _stateReader(stateReader) {
+        WebSocketConnector<T>::_statefulService->addUpdateHandler([&](const String & originId) { transmitData(nullptr, originId); }, false);
     }
-  }
 
-  /**
+  protected:
+    virtual void onWSEvent(AsyncWebSocket * server, AsyncWebSocketClient * client, AwsEventType type, void * arg, uint8_t * data, size_t len) {
+        if (type == WS_EVT_CONNECT) {
+            // when a client connects, we transmit it's id and the current payload
+            transmitId(client);
+            transmitData(client, WEB_SOCKET_ORIGIN);
+        }
+    }
+
+  private:
+    JsonStateReader<T> _stateReader;
+
+    void transmitId(AsyncWebSocketClient * client) {
+        DynamicJsonDocument jsonDocument     = DynamicJsonDocument(WEB_SOCKET_CLIENT_ID_MSG_SIZE);
+        JsonObject          root             = jsonDocument.to<JsonObject>();
+        root["type"]                         = "id";
+        root["id"]                           = WebSocketConnector<T>::clientId(client);
+        size_t                        len    = measureJson(jsonDocument);
+        AsyncWebSocketMessageBuffer * buffer = WebSocketConnector<T>::_webSocket.makeBuffer(len);
+        if (buffer) {
+            serializeJson(jsonDocument, (char *)buffer->get(), len + 1);
+            client->text(buffer);
+        }
+    }
+
+    /**
    * Broadcasts the payload to the destination, if provided. Otherwise broadcasts to all clients except the origin, if
    * specified.
    *
    * Original implementation sent clients their own IDs so they could ignore updates they initiated. This approach
    * simplifies the client and the server implementation but may not be sufficent for all use-cases.
    */
-  void transmitData(AsyncWebSocketClient* client, const String& originId) {
-    DynamicJsonDocument jsonDocument = DynamicJsonDocument(WebSocketConnector<T>::_bufferSize);
-    JsonObject root = jsonDocument.to<JsonObject>();
-    root["type"] = "payload";
-    root["origin_id"] = originId;
-    JsonObject payload = root.createNestedObject("payload");
-    WebSocketConnector<T>::_statefulService->read(payload, _stateReader);
+    void transmitData(AsyncWebSocketClient * client, const String & originId) {
+        DynamicJsonDocument jsonDocument = DynamicJsonDocument(WebSocketConnector<T>::_bufferSize);
+        JsonObject          root         = jsonDocument.to<JsonObject>();
+        root["type"]                     = "payload";
+        root["origin_id"]                = originId;
+        JsonObject payload               = root.createNestedObject("payload");
+        WebSocketConnector<T>::_statefulService->read(payload, _stateReader);
 
-    size_t len = measureJson(jsonDocument);
-    AsyncWebSocketMessageBuffer* buffer = WebSocketConnector<T>::_webSocket.makeBuffer(len);
-    if (buffer) {
-      serializeJson(jsonDocument, (char*)buffer->get(), len + 1);
-      if (client) {
-        client->text(buffer);
-      } else {
-        WebSocketConnector<T>::_webSocket.textAll(buffer);
-      }
+        size_t                        len    = measureJson(jsonDocument);
+        AsyncWebSocketMessageBuffer * buffer = WebSocketConnector<T>::_webSocket.makeBuffer(len);
+        if (buffer) {
+            serializeJson(jsonDocument, (char *)buffer->get(), len + 1);
+            if (client) {
+                client->text(buffer);
+            } else {
+                WebSocketConnector<T>::_webSocket.textAll(buffer);
+            }
+        }
     }
-  }
 };
 
 template <class T>
 class WebSocketRx : virtual public WebSocketConnector<T> {
- public:
-  WebSocketRx(JsonStateUpdater<T> stateUpdater,
-              StatefulService<T>* statefulService,
-              AsyncWebServer* server,
-              char const* webSocketPath,
-              SecurityManager* securityManager,
-              AuthenticationPredicate authenticationPredicate = AuthenticationPredicates::IS_ADMIN,
-              size_t bufferSize = DEFAULT_BUFFER_SIZE) :
-      WebSocketConnector<T>(statefulService,
-                            server,
-                            webSocketPath,
-                            securityManager,
-                            authenticationPredicate,
-                            bufferSize),
-      _stateUpdater(stateUpdater) {
-  }
-
-  WebSocketRx(JsonStateUpdater<T> stateUpdater,
-              StatefulService<T>* statefulService,
-              AsyncWebServer* server,
-              char const* webSocketPath,
-              size_t bufferSize = DEFAULT_BUFFER_SIZE) :
-      WebSocketConnector<T>(statefulService, server, webSocketPath, bufferSize), _stateUpdater(stateUpdater) {
-  }
-
- protected:
-  virtual void onWSEvent(AsyncWebSocket* server,
-                         AsyncWebSocketClient* client,
-                         AwsEventType type,
-                         void* arg,
-                         uint8_t* data,
-                         size_t len) {
-    if (type == WS_EVT_DATA) {
-      AwsFrameInfo* info = (AwsFrameInfo*)arg;
-      if (info->final && info->index == 0 && info->len == len) {
-        if (info->opcode == WS_TEXT) {
-          DynamicJsonDocument jsonDocument = DynamicJsonDocument(WebSocketConnector<T>::_bufferSize);
-          DeserializationError error = deserializeJson(jsonDocument, (char*)data);
-          if (!error && jsonDocument.is<JsonObject>()) {
-            JsonObject jsonObject = jsonDocument.as<JsonObject>();
-            WebSocketConnector<T>::_statefulService->update(
-                jsonObject, _stateUpdater, WebSocketConnector<T>::clientId(client));
-          }
-        }
-      }
+  public:
+    WebSocketRx(JsonStateUpdater<T>     stateUpdater,
+                StatefulService<T> *    statefulService,
+                AsyncWebServer *        server,
+                const char *            webSocketPath,
+                SecurityManager *       securityManager,
+                AuthenticationPredicate authenticationPredicate = AuthenticationPredicates::IS_ADMIN,
+                size_t                  bufferSize              = DEFAULT_BUFFER_SIZE)
+        : WebSocketConnector<T>(statefulService, server, webSocketPath, securityManager, authenticationPredicate, bufferSize)
+        , _stateUpdater(stateUpdater) {
     }
-  }
 
- private:
-  JsonStateUpdater<T> _stateUpdater;
+    WebSocketRx(JsonStateUpdater<T>  stateUpdater,
+                StatefulService<T> * statefulService,
+                AsyncWebServer *     server,
+                const char *         webSocketPath,
+                size_t               bufferSize = DEFAULT_BUFFER_SIZE)
+        : WebSocketConnector<T>(statefulService, server, webSocketPath, bufferSize)
+        , _stateUpdater(stateUpdater) {
+    }
+
+  protected:
+    virtual void onWSEvent(AsyncWebSocket * server, AsyncWebSocketClient * client, AwsEventType type, void * arg, uint8_t * data, size_t len) {
+        if (type == WS_EVT_DATA) {
+            AwsFrameInfo * info = (AwsFrameInfo *)arg;
+            if (info->final && info->index == 0 && info->len == len) {
+                if (info->opcode == WS_TEXT) {
+                    DynamicJsonDocument  jsonDocument = DynamicJsonDocument(WebSocketConnector<T>::_bufferSize);
+                    DeserializationError error        = deserializeJson(jsonDocument, (char *)data);
+                    if (!error && jsonDocument.is<JsonObject>()) {
+                        JsonObject jsonObject = jsonDocument.as<JsonObject>();
+                        WebSocketConnector<T>::_statefulService->update(jsonObject, _stateUpdater, WebSocketConnector<T>::clientId(client));
+                    }
+                }
+            }
+        }
+    }
+
+  private:
+    JsonStateUpdater<T> _stateUpdater;
 };
 
 template <class T>
 class WebSocketTxRx : public WebSocketTx<T>, public WebSocketRx<T> {
- public:
-  WebSocketTxRx(JsonStateReader<T> stateReader,
-                JsonStateUpdater<T> stateUpdater,
-                StatefulService<T>* statefulService,
-                AsyncWebServer* server,
-                char const* webSocketPath,
-                SecurityManager* securityManager,
-                AuthenticationPredicate authenticationPredicate = AuthenticationPredicates::IS_ADMIN,
-                size_t bufferSize = DEFAULT_BUFFER_SIZE) :
-      WebSocketConnector<T>(statefulService,
-                            server,
-                            webSocketPath,
-                            securityManager,
-                            authenticationPredicate,
-                            bufferSize),
-      WebSocketTx<T>(stateReader,
-                     statefulService,
-                     server,
-                     webSocketPath,
-                     securityManager,
-                     authenticationPredicate,
-                     bufferSize),
-      WebSocketRx<T>(stateUpdater,
-                     statefulService,
-                     server,
-                     webSocketPath,
-                     securityManager,
-                     authenticationPredicate,
-                     bufferSize) {
-  }
+  public:
+    WebSocketTxRx(JsonStateReader<T>      stateReader,
+                  JsonStateUpdater<T>     stateUpdater,
+                  StatefulService<T> *    statefulService,
+                  AsyncWebServer *        server,
+                  const char *            webSocketPath,
+                  SecurityManager *       securityManager,
+                  AuthenticationPredicate authenticationPredicate = AuthenticationPredicates::IS_ADMIN,
+                  size_t                  bufferSize              = DEFAULT_BUFFER_SIZE)
+        : WebSocketConnector<T>(statefulService, server, webSocketPath, securityManager, authenticationPredicate, bufferSize)
+        , WebSocketTx<T>(stateReader, statefulService, server, webSocketPath, securityManager, authenticationPredicate, bufferSize)
+        , WebSocketRx<T>(stateUpdater, statefulService, server, webSocketPath, securityManager, authenticationPredicate, bufferSize) {
+    }
 
-  WebSocketTxRx(JsonStateReader<T> stateReader,
-                JsonStateUpdater<T> stateUpdater,
-                StatefulService<T>* statefulService,
-                AsyncWebServer* server,
-                char const* webSocketPath,
-                size_t bufferSize = DEFAULT_BUFFER_SIZE) :
-      WebSocketConnector<T>(statefulService, server, webSocketPath, bufferSize),
-      WebSocketTx<T>(stateReader, statefulService, server, webSocketPath, bufferSize),
-      WebSocketRx<T>(stateUpdater, statefulService, server, webSocketPath, bufferSize) {
-  }
+    WebSocketTxRx(JsonStateReader<T>   stateReader,
+                  JsonStateUpdater<T>  stateUpdater,
+                  StatefulService<T> * statefulService,
+                  AsyncWebServer *     server,
+                  const char *         webSocketPath,
+                  size_t               bufferSize = DEFAULT_BUFFER_SIZE)
+        : WebSocketConnector<T>(statefulService, server, webSocketPath, bufferSize)
+        , WebSocketTx<T>(stateReader, statefulService, server, webSocketPath, bufferSize)
+        , WebSocketRx<T>(stateUpdater, statefulService, server, webSocketPath, bufferSize) {
+    }
 
- protected:
-  void onWSEvent(AsyncWebSocket* server,
-                 AsyncWebSocketClient* client,
-                 AwsEventType type,
-                 void* arg,
-                 uint8_t* data,
-                 size_t len) {
-    WebSocketRx<T>::onWSEvent(server, client, type, arg, data, len);
-    WebSocketTx<T>::onWSEvent(server, client, type, arg, data, len);
-  }
+  protected:
+    void onWSEvent(AsyncWebSocket * server, AsyncWebSocketClient * client, AwsEventType type, void * arg, uint8_t * data, size_t len) {
+        WebSocketRx<T>::onWSEvent(server, client, type, arg, data, len);
+        WebSocketTx<T>::onWSEvent(server, client, type, arg, data, len);
+    }
 };
 
 #endif
diff --git a/lib/framework/WiFiScanner.cpp b/lib/framework/WiFiScanner.cpp
index a6f2b6550..85f532a44 100644
--- a/lib/framework/WiFiScanner.cpp
+++ b/lib/framework/WiFiScanner.cpp
@@ -1,49 +1,47 @@
 #include <WiFiScanner.h>
 
-WiFiScanner::WiFiScanner(AsyncWebServer* server, SecurityManager* securityManager) {
-  server->on(SCAN_NETWORKS_SERVICE_PATH,
-             HTTP_GET,
-             securityManager->wrapRequest(std::bind(&WiFiScanner::scanNetworks, this, std::placeholders::_1),
-                                          AuthenticationPredicates::IS_ADMIN));
-  server->on(LIST_NETWORKS_SERVICE_PATH,
-             HTTP_GET,
-             securityManager->wrapRequest(std::bind(&WiFiScanner::listNetworks, this, std::placeholders::_1),
-                                          AuthenticationPredicates::IS_ADMIN));
+WiFiScanner::WiFiScanner(AsyncWebServer * server, SecurityManager * securityManager) {
+    server->on(SCAN_NETWORKS_SERVICE_PATH,
+               HTTP_GET,
+               securityManager->wrapRequest(std::bind(&WiFiScanner::scanNetworks, this, std::placeholders::_1), AuthenticationPredicates::IS_ADMIN));
+    server->on(LIST_NETWORKS_SERVICE_PATH,
+               HTTP_GET,
+               securityManager->wrapRequest(std::bind(&WiFiScanner::listNetworks, this, std::placeholders::_1), AuthenticationPredicates::IS_ADMIN));
 };
 
-void WiFiScanner::scanNetworks(AsyncWebServerRequest* request) {
-  if (WiFi.scanComplete() != -1) {
-    WiFi.scanDelete();
-    WiFi.scanNetworks(true);
-  }
-  request->send(202);
+void WiFiScanner::scanNetworks(AsyncWebServerRequest * request) {
+    if (WiFi.scanComplete() != -1) {
+        WiFi.scanDelete();
+        WiFi.scanNetworks(true);
+    }
+    request->send(202);
 }
 
-void WiFiScanner::listNetworks(AsyncWebServerRequest* request) {
-  int numNetworks = WiFi.scanComplete();
-  if (numNetworks > -1) {
-    AsyncJsonResponse* response = new AsyncJsonResponse(false, MAX_WIFI_SCANNER_SIZE);
-    JsonObject root = response->getRoot();
-    JsonArray networks = root.createNestedArray("networks");
-    for (int i = 0; i < numNetworks; i++) {
-      JsonObject network = networks.createNestedObject();
-      network["rssi"] = WiFi.RSSI(i);
-      network["ssid"] = WiFi.SSID(i);
-      network["bssid"] = WiFi.BSSIDstr(i);
-      network["channel"] = WiFi.channel(i);
+void WiFiScanner::listNetworks(AsyncWebServerRequest * request) {
+    int numNetworks = WiFi.scanComplete();
+    if (numNetworks > -1) {
+        AsyncJsonResponse * response = new AsyncJsonResponse(false, MAX_WIFI_SCANNER_SIZE);
+        JsonObject          root     = response->getRoot();
+        JsonArray           networks = root.createNestedArray("networks");
+        for (int i = 0; i < numNetworks; i++) {
+            JsonObject network = networks.createNestedObject();
+            network["rssi"]    = WiFi.RSSI(i);
+            network["ssid"]    = WiFi.SSID(i);
+            network["bssid"]   = WiFi.BSSIDstr(i);
+            network["channel"] = WiFi.channel(i);
 #ifdef ESP32
-      network["encryption_type"] = (uint8_t)WiFi.encryptionType(i);
+            network["encryption_type"] = (uint8_t)WiFi.encryptionType(i);
 #elif defined(ESP8266)
-      network["encryption_type"] = convertEncryptionType(WiFi.encryptionType(i));
+            network["encryption_type"] = convertEncryptionType(WiFi.encryptionType(i));
 #endif
+        }
+        response->setLength();
+        request->send(response);
+    } else if (numNetworks == -1) {
+        request->send(202);
+    } else {
+        scanNetworks(request);
     }
-    response->setLength();
-    request->send(response);
-  } else if (numNetworks == -1) {
-    request->send(202);
-  } else {
-    scanNetworks(request);
-  }
 }
 
 #ifdef ESP8266
@@ -53,18 +51,18 @@ void WiFiScanner::listNetworks(AsyncWebServerRequest* request) {
  * This allows us to use a single set of mappings in the UI.
  */
 uint8_t WiFiScanner::convertEncryptionType(uint8_t encryptionType) {
-  switch (encryptionType) {
+    switch (encryptionType) {
     case ENC_TYPE_NONE:
-      return AUTH_OPEN;
+        return AUTH_OPEN;
     case ENC_TYPE_WEP:
-      return AUTH_WEP;
+        return AUTH_WEP;
     case ENC_TYPE_TKIP:
-      return AUTH_WPA_PSK;
+        return AUTH_WPA_PSK;
     case ENC_TYPE_CCMP:
-      return AUTH_WPA2_PSK;
+        return AUTH_WPA2_PSK;
     case ENC_TYPE_AUTO:
-      return AUTH_WPA_WPA2_PSK;
-  }
-  return -1;
+        return AUTH_WPA_WPA2_PSK;
+    }
+    return -1;
 }
 #endif
diff --git a/lib/framework/WiFiScanner.h b/lib/framework/WiFiScanner.h
index 6f9103028..601e998de 100644
--- a/lib/framework/WiFiScanner.h
+++ b/lib/framework/WiFiScanner.h
@@ -20,16 +20,16 @@
 #define MAX_WIFI_SCANNER_SIZE 1024
 
 class WiFiScanner {
- public:
-  WiFiScanner(AsyncWebServer* server, SecurityManager* securityManager);
+  public:
+    WiFiScanner(AsyncWebServer * server, SecurityManager * securityManager);
 
- private:
-  void scanNetworks(AsyncWebServerRequest* request);
-  void listNetworks(AsyncWebServerRequest* request);
+  private:
+    void scanNetworks(AsyncWebServerRequest * request);
+    void listNetworks(AsyncWebServerRequest * request);
 
 #ifdef ESP8266
-  uint8_t convertEncryptionType(uint8_t encryptionType);
+    uint8_t convertEncryptionType(uint8_t encryptionType);
 #endif
 };
 
-#endif  // end WiFiScanner_h
+#endif // end WiFiScanner_h
diff --git a/lib/framework/WiFiSettingsService.cpp b/lib/framework/WiFiSettingsService.cpp
index 2c9c9ad5e..54226a550 100644
--- a/lib/framework/WiFiSettingsService.cpp
+++ b/lib/framework/WiFiSettingsService.cpp
@@ -74,7 +74,7 @@ void WiFiSettingsService::manageSTA() {
             // configure for static IP
             WiFi.config(_state.localIP, _state.gatewayIP, _state.subnetMask, _state.dnsIP1, _state.dnsIP2);
         } else {
-           // configure for DHCP
+            // configure for DHCP
 #ifdef ESP32
             WiFi.config(INADDR_NONE, INADDR_NONE, INADDR_NONE);
 #elif defined(ESP8266)
diff --git a/lib/framework/WiFiSettingsService.h b/lib/framework/WiFiSettingsService.h
index 2a79075b3..eeafae4d8 100644
--- a/lib/framework/WiFiSettingsService.h
+++ b/lib/framework/WiFiSettingsService.h
@@ -23,89 +23,87 @@
 #endif
 
 class WiFiSettings {
- public:
-  // core wifi configuration
-  String ssid;
-  String password;
-  String hostname;
-  bool staticIPConfig;
+  public:
+    // core wifi configuration
+    String ssid;
+    String password;
+    String hostname;
+    bool   staticIPConfig;
 
-  // optional configuration for static IP address
-  IPAddress localIP;
-  IPAddress gatewayIP;
-  IPAddress subnetMask;
-  IPAddress dnsIP1;
-  IPAddress dnsIP2;
+    // optional configuration for static IP address
+    IPAddress localIP;
+    IPAddress gatewayIP;
+    IPAddress subnetMask;
+    IPAddress dnsIP1;
+    IPAddress dnsIP2;
 
-  static void read(WiFiSettings& settings, JsonObject& root) {
-    // connection settings
-    root["ssid"] = settings.ssid;
-    root["password"] = settings.password;
-    root["hostname"] = settings.hostname;
-    root["static_ip_config"] = settings.staticIPConfig;
+    static void read(WiFiSettings & settings, JsonObject & root) {
+        // connection settings
+        root["ssid"]             = settings.ssid;
+        root["password"]         = settings.password;
+        root["hostname"]         = settings.hostname;
+        root["static_ip_config"] = settings.staticIPConfig;
 
-    // extended settings
-    JsonUtils::writeIP(root, "local_ip", settings.localIP);
-    JsonUtils::writeIP(root, "gateway_ip", settings.gatewayIP);
-    JsonUtils::writeIP(root, "subnet_mask", settings.subnetMask);
-    JsonUtils::writeIP(root, "dns_ip_1", settings.dnsIP1);
-    JsonUtils::writeIP(root, "dns_ip_2", settings.dnsIP2);
-  }
-
-  static StateUpdateResult update(JsonObject& root, WiFiSettings& settings) {
-
-    settings.ssid = root["ssid"] | FACTORY_WIFI_SSID;
-    settings.password = root["password"] | FACTORY_WIFI_PASSWORD;
-    settings.hostname = root["hostname"] | FACTORY_WIFI_HOSTNAME;
-    settings.staticIPConfig = root["static_ip_config"] | false;
-
-    // extended settings
-    JsonUtils::readIP(root, "local_ip", settings.localIP);
-    JsonUtils::readIP(root, "gateway_ip", settings.gatewayIP);
-    JsonUtils::readIP(root, "subnet_mask", settings.subnetMask);
-    JsonUtils::readIP(root, "dns_ip_1", settings.dnsIP1);
-    JsonUtils::readIP(root, "dns_ip_2", settings.dnsIP2);
-
-    // Swap around the dns servers if 2 is populated but 1 is not
-    if (settings.dnsIP1 == INADDR_NONE && settings.dnsIP2 != INADDR_NONE) {
-      settings.dnsIP1 = settings.dnsIP2;
-      settings.dnsIP2 = INADDR_NONE;
+        // extended settings
+        JsonUtils::writeIP(root, "local_ip", settings.localIP);
+        JsonUtils::writeIP(root, "gateway_ip", settings.gatewayIP);
+        JsonUtils::writeIP(root, "subnet_mask", settings.subnetMask);
+        JsonUtils::writeIP(root, "dns_ip_1", settings.dnsIP1);
+        JsonUtils::writeIP(root, "dns_ip_2", settings.dnsIP2);
     }
 
-    // Turning off static ip config if we don't meet the minimum requirements
-    // of ipAddress, gateway and subnet. This may change to static ip only
-    // as sensible defaults can be assumed for gateway and subnet
-    if (settings.staticIPConfig &&
-        (settings.localIP == INADDR_NONE || settings.gatewayIP == INADDR_NONE || settings.subnetMask == INADDR_NONE)) {
-      settings.staticIPConfig = false;
+    static StateUpdateResult update(JsonObject & root, WiFiSettings & settings) {
+        settings.ssid           = root["ssid"] | FACTORY_WIFI_SSID;
+        settings.password       = root["password"] | FACTORY_WIFI_PASSWORD;
+        settings.hostname       = root["hostname"] | FACTORY_WIFI_HOSTNAME;
+        settings.staticIPConfig = root["static_ip_config"] | false;
+
+        // extended settings
+        JsonUtils::readIP(root, "local_ip", settings.localIP);
+        JsonUtils::readIP(root, "gateway_ip", settings.gatewayIP);
+        JsonUtils::readIP(root, "subnet_mask", settings.subnetMask);
+        JsonUtils::readIP(root, "dns_ip_1", settings.dnsIP1);
+        JsonUtils::readIP(root, "dns_ip_2", settings.dnsIP2);
+
+        // Swap around the dns servers if 2 is populated but 1 is not
+        if (settings.dnsIP1 == INADDR_NONE && settings.dnsIP2 != INADDR_NONE) {
+            settings.dnsIP1 = settings.dnsIP2;
+            settings.dnsIP2 = INADDR_NONE;
+        }
+
+        // Turning off static ip config if we don't meet the minimum requirements
+        // of ipAddress, gateway and subnet. This may change to static ip only
+        // as sensible defaults can be assumed for gateway and subnet
+        if (settings.staticIPConfig && (settings.localIP == INADDR_NONE || settings.gatewayIP == INADDR_NONE || settings.subnetMask == INADDR_NONE)) {
+            settings.staticIPConfig = false;
+        }
+        return StateUpdateResult::CHANGED;
     }
-    return StateUpdateResult::CHANGED;
-  }
 };
 
 class WiFiSettingsService : public StatefulService<WiFiSettings> {
- public:
-  WiFiSettingsService(AsyncWebServer* server, FS* fs, SecurityManager* securityManager);
+  public:
+    WiFiSettingsService(AsyncWebServer * server, FS * fs, SecurityManager * securityManager);
 
-  void begin();
-  void loop();
+    void begin();
+    void loop();
 
- private:
-  HttpEndpoint<WiFiSettings> _httpEndpoint;
-  FSPersistence<WiFiSettings> _fsPersistence;
-  unsigned long _lastConnectionAttempt;
+  private:
+    HttpEndpoint<WiFiSettings>  _httpEndpoint;
+    FSPersistence<WiFiSettings> _fsPersistence;
+    unsigned long               _lastConnectionAttempt;
 
 #ifdef ESP32
-  bool _stopping;
-  void onStationModeDisconnected(WiFiEvent_t event, WiFiEventInfo_t info);
-  void onStationModeStop(WiFiEvent_t event, WiFiEventInfo_t info);
+    bool _stopping;
+    void onStationModeDisconnected(WiFiEvent_t event, WiFiEventInfo_t info);
+    void onStationModeStop(WiFiEvent_t event, WiFiEventInfo_t info);
 #elif defined(ESP8266)
-  WiFiEventHandler _onStationModeDisconnectedHandler;
-  void onStationModeDisconnected(const WiFiEventStationModeDisconnected& event);
+    WiFiEventHandler _onStationModeDisconnectedHandler;
+    void             onStationModeDisconnected(const WiFiEventStationModeDisconnected & event);
 #endif
 
-  void reconfigureWiFiConnection();
-  void manageSTA();
+    void reconfigureWiFiConnection();
+    void manageSTA();
 };
 
-#endif  // end WiFiSettingsService_h
+#endif // end WiFiSettingsService_h
diff --git a/lib/framework/WiFiStatus.cpp b/lib/framework/WiFiStatus.cpp
index 159197e83..84e6a1c84 100644
--- a/lib/framework/WiFiStatus.cpp
+++ b/lib/framework/WiFiStatus.cpp
@@ -1,73 +1,72 @@
 #include <WiFiStatus.h>
 
-WiFiStatus::WiFiStatus(AsyncWebServer* server, SecurityManager* securityManager) {
-  server->on(WIFI_STATUS_SERVICE_PATH,
-             HTTP_GET,
-             securityManager->wrapRequest(std::bind(&WiFiStatus::wifiStatus, this, std::placeholders::_1),
-                                          AuthenticationPredicates::IS_AUTHENTICATED));
+WiFiStatus::WiFiStatus(AsyncWebServer * server, SecurityManager * securityManager) {
+    server->on(WIFI_STATUS_SERVICE_PATH,
+               HTTP_GET,
+               securityManager->wrapRequest(std::bind(&WiFiStatus::wifiStatus, this, std::placeholders::_1), AuthenticationPredicates::IS_AUTHENTICATED));
 #ifdef ESP32
-  WiFi.onEvent(onStationModeConnected, WiFiEvent_t::SYSTEM_EVENT_STA_CONNECTED);
-  WiFi.onEvent(onStationModeDisconnected, WiFiEvent_t::SYSTEM_EVENT_STA_DISCONNECTED);
-  WiFi.onEvent(onStationModeGotIP, WiFiEvent_t::SYSTEM_EVENT_STA_GOT_IP);
+    WiFi.onEvent(onStationModeConnected, WiFiEvent_t::SYSTEM_EVENT_STA_CONNECTED);
+    WiFi.onEvent(onStationModeDisconnected, WiFiEvent_t::SYSTEM_EVENT_STA_DISCONNECTED);
+    WiFi.onEvent(onStationModeGotIP, WiFiEvent_t::SYSTEM_EVENT_STA_GOT_IP);
 #elif defined(ESP8266)
-  _onStationModeConnectedHandler = WiFi.onStationModeConnected(onStationModeConnected);
-  _onStationModeDisconnectedHandler = WiFi.onStationModeDisconnected(onStationModeDisconnected);
-  _onStationModeGotIPHandler = WiFi.onStationModeGotIP(onStationModeGotIP);
+    _onStationModeConnectedHandler    = WiFi.onStationModeConnected(onStationModeConnected);
+    _onStationModeDisconnectedHandler = WiFi.onStationModeDisconnected(onStationModeDisconnected);
+    _onStationModeGotIPHandler        = WiFi.onStationModeGotIP(onStationModeGotIP);
 #endif
 }
 
 #ifdef ESP32
 void WiFiStatus::onStationModeConnected(WiFiEvent_t event, WiFiEventInfo_t info) {
-  // Serial.println(F("WiFi Connected."));
+    // Serial.println(F("WiFi Connected."));
 }
 
 void WiFiStatus::onStationModeDisconnected(WiFiEvent_t event, WiFiEventInfo_t info) {
-  // Serial.print(F("WiFi Disconnected. Reason code="));
-  // Serial.println(info.disconnected.reason);
+    // Serial.print(F("WiFi Disconnected. Reason code="));
+    // Serial.println(info.disconnected.reason);
 }
 
 void WiFiStatus::onStationModeGotIP(WiFiEvent_t event, WiFiEventInfo_t info) {
-  // Serial.printf_P(PSTR("WiFi Got IP. localIP=%s, hostName=%s\r\n"), WiFi.localIP().toString().c_str(), WiFi.getHostname());
+    // Serial.printf_P(PSTR("WiFi Got IP. localIP=%s, hostName=%s\r\n"), WiFi.localIP().toString().c_str(), WiFi.getHostname());
 }
 #elif defined(ESP8266)
-void WiFiStatus::onStationModeConnected(const WiFiEventStationModeConnected& event) {
-  // Serial.print(F("WiFi Connected. SSID="));
-  // Serial.println(event.ssid);
+void WiFiStatus::onStationModeConnected(const WiFiEventStationModeConnected & event) {
+    // Serial.print(F("WiFi Connected. SSID="));
+    // Serial.println(event.ssid);
 }
 
-void WiFiStatus::onStationModeDisconnected(const WiFiEventStationModeDisconnected& event) {
-  // Serial.print(F("WiFi Disconnected. Reason code="));
-  // Serial.println(event.reason);
+void WiFiStatus::onStationModeDisconnected(const WiFiEventStationModeDisconnected & event) {
+    // Serial.print(F("WiFi Disconnected. Reason code="));
+    // Serial.println(event.reason);
 }
 
-void WiFiStatus::onStationModeGotIP(const WiFiEventStationModeGotIP& event) {
-  // Serial.printf_P(PSTR("WiFi Got IP. localIP=%s, hostName=%s\r\n"), event.ip.toString().c_str(), WiFi.hostname().c_str());
+void WiFiStatus::onStationModeGotIP(const WiFiEventStationModeGotIP & event) {
+    // Serial.printf_P(PSTR("WiFi Got IP. localIP=%s, hostName=%s\r\n"), event.ip.toString().c_str(), WiFi.hostname().c_str());
 }
 #endif
 
-void WiFiStatus::wifiStatus(AsyncWebServerRequest* request) {
-  AsyncJsonResponse* response = new AsyncJsonResponse(false, MAX_WIFI_STATUS_SIZE);
-  JsonObject root = response->getRoot();
-  wl_status_t status = WiFi.status();
-  root["status"] = (uint8_t)status;
-  if (status == WL_CONNECTED) {
-    root["local_ip"] = WiFi.localIP().toString();
-    root["mac_address"] = WiFi.macAddress();
-    root["rssi"] = WiFi.RSSI();
-    root["ssid"] = WiFi.SSID();
-    root["bssid"] = WiFi.BSSIDstr();
-    root["channel"] = WiFi.channel();
-    root["subnet_mask"] = WiFi.subnetMask().toString();
-    root["gateway_ip"] = WiFi.gatewayIP().toString();
-    IPAddress dnsIP1 = WiFi.dnsIP(0);
-    IPAddress dnsIP2 = WiFi.dnsIP(1);
-    if (dnsIP1 != INADDR_NONE) {
-      root["dns_ip_1"] = dnsIP1.toString();
+void WiFiStatus::wifiStatus(AsyncWebServerRequest * request) {
+    AsyncJsonResponse * response = new AsyncJsonResponse(false, MAX_WIFI_STATUS_SIZE);
+    JsonObject          root     = response->getRoot();
+    wl_status_t         status   = WiFi.status();
+    root["status"]               = (uint8_t)status;
+    if (status == WL_CONNECTED) {
+        root["local_ip"]    = WiFi.localIP().toString();
+        root["mac_address"] = WiFi.macAddress();
+        root["rssi"]        = WiFi.RSSI();
+        root["ssid"]        = WiFi.SSID();
+        root["bssid"]       = WiFi.BSSIDstr();
+        root["channel"]     = WiFi.channel();
+        root["subnet_mask"] = WiFi.subnetMask().toString();
+        root["gateway_ip"]  = WiFi.gatewayIP().toString();
+        IPAddress dnsIP1    = WiFi.dnsIP(0);
+        IPAddress dnsIP2    = WiFi.dnsIP(1);
+        if (dnsIP1 != INADDR_NONE) {
+            root["dns_ip_1"] = dnsIP1.toString();
+        }
+        if (dnsIP2 != INADDR_NONE) {
+            root["dns_ip_2"] = dnsIP2.toString();
+        }
     }
-    if (dnsIP2 != INADDR_NONE) {
-      root["dns_ip_2"] = dnsIP2.toString();
-    }
-  }
-  response->setLength();
-  request->send(response);
+    response->setLength();
+    request->send(response);
 }
diff --git a/lib/framework/WiFiStatus.h b/lib/framework/WiFiStatus.h
index 197bd6412..a8ceacf0c 100644
--- a/lib/framework/WiFiStatus.h
+++ b/lib/framework/WiFiStatus.h
@@ -19,27 +19,27 @@
 #define WIFI_STATUS_SERVICE_PATH "/rest/wifiStatus"
 
 class WiFiStatus {
- public:
-  WiFiStatus(AsyncWebServer* server, SecurityManager* securityManager);
+  public:
+    WiFiStatus(AsyncWebServer * server, SecurityManager * securityManager);
 
- private:
+  private:
 #ifdef ESP32
-  // static functions for logging WiFi events to the UART
-  static void onStationModeConnected(WiFiEvent_t event, WiFiEventInfo_t info);
-  static void onStationModeDisconnected(WiFiEvent_t event, WiFiEventInfo_t info);
-  static void onStationModeGotIP(WiFiEvent_t event, WiFiEventInfo_t info);
+    // static functions for logging WiFi events to the UART
+    static void onStationModeConnected(WiFiEvent_t event, WiFiEventInfo_t info);
+    static void onStationModeDisconnected(WiFiEvent_t event, WiFiEventInfo_t info);
+    static void onStationModeGotIP(WiFiEvent_t event, WiFiEventInfo_t info);
 #elif defined(ESP8266)
-  // handler refrences for logging important WiFi events over serial
-  WiFiEventHandler _onStationModeConnectedHandler;
-  WiFiEventHandler _onStationModeDisconnectedHandler;
-  WiFiEventHandler _onStationModeGotIPHandler;
-  // static functions for logging WiFi events to the UART
-  static void onStationModeConnected(const WiFiEventStationModeConnected& event);
-  static void onStationModeDisconnected(const WiFiEventStationModeDisconnected& event);
-  static void onStationModeGotIP(const WiFiEventStationModeGotIP& event);
+    // handler refrences for logging important WiFi events over serial
+    WiFiEventHandler _onStationModeConnectedHandler;
+    WiFiEventHandler _onStationModeDisconnectedHandler;
+    WiFiEventHandler _onStationModeGotIPHandler;
+    // static functions for logging WiFi events to the UART
+    static void onStationModeConnected(const WiFiEventStationModeConnected & event);
+    static void onStationModeDisconnected(const WiFiEventStationModeDisconnected & event);
+    static void onStationModeGotIP(const WiFiEventStationModeGotIP & event);
 #endif
 
-  void wifiStatus(AsyncWebServerRequest* request);
+    void wifiStatus(AsyncWebServerRequest * request);
 };
 
-#endif  // end WiFiStatus_h
+#endif // end WiFiStatus_h
diff --git a/lib_standalone/FSPersistence.h b/lib_standalone/FSPersistence.h
index e6c43a69f..eb7eaf8f6 100644
--- a/lib_standalone/FSPersistence.h
+++ b/lib_standalone/FSPersistence.h
@@ -11,7 +11,7 @@ class FSPersistence {
                   JsonStateUpdater<T>  stateUpdater,
                   StatefulService<T> * statefulService,
                   FS *                 fs,
-                  char const *         filePath,
+                  const char *         filePath,
                   size_t               bufferSize = DEFAULT_BUFFER_SIZE)
         : _stateReader(stateReader)
         , _stateUpdater(stateUpdater)
@@ -52,7 +52,7 @@ class FSPersistence {
     JsonStateUpdater<T>  _stateUpdater;
     StatefulService<T> * _statefulService;
     FS *                 _fs;
-    char const *         _filePath;
+    const char *         _filePath;
     size_t               _bufferSize;
     update_handler_id_t  _updateHandlerId;