Rework config (#134)

WebUI/src/lib/_fbs/open-shock/serialization/configuration/captive-portal-config.ts

@@ -11,18 +11,36 @@ export class CaptivePortalConfig {
   return this;
 }
 
+static getRootAsCaptivePortalConfig(bb:flatbuffers.ByteBuffer, obj?:CaptivePortalConfig):CaptivePortalConfig {
+  return (obj || new CaptivePortalConfig()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+}
+
+static getSizePrefixedRootAsCaptivePortalConfig(bb:flatbuffers.ByteBuffer, obj?:CaptivePortalConfig):CaptivePortalConfig {
+  bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
+  return (obj || new CaptivePortalConfig()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+}
+
 alwaysEnabled():boolean {
-  return !!this.bb!.readInt8(this.bb_pos);
+  const offset = this.bb!.__offset(this.bb_pos, 4);
+  return offset ? !!this.bb!.readInt8(this.bb_pos + offset) : false;
 }
 
-static sizeOf():number {
-  return 1;
+static startCaptivePortalConfig(builder:flatbuffers.Builder) {
+  builder.startObject(1);
 }
 
-static createCaptivePortalConfig(builder:flatbuffers.Builder, always_enabled: boolean):flatbuffers.Offset {
-  builder.prep(1, 1);
-  builder.writeInt8(Number(Boolean(always_enabled)));
-  return builder.offset();
+static addAlwaysEnabled(builder:flatbuffers.Builder, alwaysEnabled:boolean) {
+  builder.addFieldInt8(0, +alwaysEnabled, +false);
 }
 
+static endCaptivePortalConfig(builder:flatbuffers.Builder):flatbuffers.Offset {
+  const offset = builder.endObject();
+  return offset;
+}
+
+static createCaptivePortalConfig(builder:flatbuffers.Builder, alwaysEnabled:boolean):flatbuffers.Offset {
+  CaptivePortalConfig.startCaptivePortalConfig(builder);
+  CaptivePortalConfig.addAlwaysEnabled(builder, alwaysEnabled);
+  return CaptivePortalConfig.endCaptivePortalConfig(builder);
+}
 }

WebUI/src/lib/_fbs/open-shock/serialization/configuration/config.ts

@@ -28,7 +28,7 @@ static getSizePrefixedRootAsConfig(bb:flatbuffers.ByteBuffer, obj?:Config):Confi
 
 rf(obj?:RFConfig):RFConfig|null {
   const offset = this.bb!.__offset(this.bb_pos, 4);
-  return offset ? (obj || new RFConfig()).__init(this.bb_pos + offset, this.bb!) : null;
+  return offset ? (obj || new RFConfig()).__init(this.bb!.__indirect(this.bb_pos + offset), this.bb!) : null;
 }
 
 wifi(obj?:WiFiConfig):WiFiConfig|null {
@@ -38,7 +38,7 @@ wifi(obj?:WiFiConfig):WiFiConfig|null {
 
 captivePortal(obj?:CaptivePortalConfig):CaptivePortalConfig|null {
   const offset = this.bb!.__offset(this.bb_pos, 8);
-  return offset ? (obj || new CaptivePortalConfig()).__init(this.bb_pos + offset, this.bb!) : null;
+  return offset ? (obj || new CaptivePortalConfig()).__init(this.bb!.__indirect(this.bb_pos + offset), this.bb!) : null;
 }
 
 backend(obj?:BackendConfig):BackendConfig|null {
@@ -51,15 +51,15 @@ static startConfig(builder:flatbuffers.Builder) {
 }
 
 static addRf(builder:flatbuffers.Builder, rfOffset:flatbuffers.Offset) {
-  builder.addFieldStruct(0, rfOffset, 0);
+  builder.addFieldOffset(0, rfOffset, 0);
 }
 
 static addWifi(builder:flatbuffers.Builder, wifiOffset:flatbuffers.Offset) {
   builder.addFieldOffset(1, wifiOffset, 0);
 }
 
 static addCaptivePortal(builder:flatbuffers.Builder, captivePortalOffset:flatbuffers.Offset) {
-  builder.addFieldStruct(2, captivePortalOffset, 0);
+  builder.addFieldOffset(2, captivePortalOffset, 0);
 }
 
 static addBackend(builder:flatbuffers.Builder, backendOffset:flatbuffers.Offset) {

WebUI/src/lib/_fbs/open-shock/serialization/configuration/rfconfig.ts

@@ -11,23 +11,46 @@ export class RFConfig {
   return this;
 }
 
+static getRootAsRFConfig(bb:flatbuffers.ByteBuffer, obj?:RFConfig):RFConfig {
+  return (obj || new RFConfig()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+}
+
+static getSizePrefixedRootAsRFConfig(bb:flatbuffers.ByteBuffer, obj?:RFConfig):RFConfig {
+  bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
+  return (obj || new RFConfig()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+}
+
 txPin():number {
-  return this.bb!.readUint8(this.bb_pos);
+  const offset = this.bb!.__offset(this.bb_pos, 4);
+  return offset ? this.bb!.readUint8(this.bb_pos + offset) : 0;
 }
 
 keepaliveEnabled():boolean {
-  return !!this.bb!.readInt8(this.bb_pos + 1);
+  const offset = this.bb!.__offset(this.bb_pos, 6);
+  return offset ? !!this.bb!.readInt8(this.bb_pos + offset) : false;
 }
 
-static sizeOf():number {
-  return 2;
+static startRFConfig(builder:flatbuffers.Builder) {
+  builder.startObject(2);
 }
 
-static createRFConfig(builder:flatbuffers.Builder, tx_pin: number, keepalive_enabled: boolean):flatbuffers.Offset {
-  builder.prep(1, 2);
-  builder.writeInt8(Number(Boolean(keepalive_enabled)));
-  builder.writeInt8(tx_pin);
-  return builder.offset();
+static addTxPin(builder:flatbuffers.Builder, txPin:number) {
+  builder.addFieldInt8(0, txPin, 0);
 }
 
+static addKeepaliveEnabled(builder:flatbuffers.Builder, keepaliveEnabled:boolean) {
+  builder.addFieldInt8(1, +keepaliveEnabled, +false);
+}
+
+static endRFConfig(builder:flatbuffers.Builder):flatbuffers.Offset {
+  const offset = builder.endObject();
+  return offset;
+}
+
+static createRFConfig(builder:flatbuffers.Builder, txPin:number, keepaliveEnabled:boolean):flatbuffers.Offset {
+  RFConfig.startRFConfig(builder);
+  RFConfig.addTxPin(builder, txPin);
+  RFConfig.addKeepaliveEnabled(builder, keepaliveEnabled);
+  return RFConfig.endRFConfig(builder);
+}
 }

include/config/BackendConfig.h

@@ -0,0 +1,19 @@
+#pragma once
+
+#include "config/ConfigBase.h"
+
+#include <string>
+
+namespace OpenShock::Config {
+  struct BackendConfig : public ConfigBase<Serialization::Configuration::BackendConfig> {
+    std::string authToken;
+
+    void ToDefault() override;
+
+    bool FromFlatbuffers(const Serialization::Configuration::BackendConfig* config) override;
+    flatbuffers::Offset<Serialization::Configuration::BackendConfig> ToFlatbuffers(flatbuffers::FlatBufferBuilder& builder) const override;
+
+    bool FromJSON(const cJSON* json) override;
+    cJSON* ToJSON() const override;
+  };
+}  // namespace OpenShock::Config

include/config/CaptivePortalConfig.h

@@ -0,0 +1,20 @@
+#pragma once
+
+#include "config/ConfigBase.h"
+
+namespace OpenShock::Config {
+  struct CaptivePortalConfig : public ConfigBase<Serialization::Configuration::CaptivePortalConfig> {
+    CaptivePortalConfig();
+    CaptivePortalConfig(bool alwaysEnabled);
+
+    bool alwaysEnabled;
+
+    void ToDefault() override;
+
+    bool FromFlatbuffers(const Serialization::Configuration::CaptivePortalConfig* config) override;
+    flatbuffers::Offset<Serialization::Configuration::CaptivePortalConfig> ToFlatbuffers(flatbuffers::FlatBufferBuilder& builder) const override;
+
+    bool FromJSON(const cJSON* json) override;
+    cJSON* ToJSON() const override;
+  };
+}  // namespace OpenShock::Config

include/Config.h → include/config/Config.h

@@ -1,37 +1,24 @@
 #pragma once
 
-#include "serialization/_fbs/ConfigFile_generated.h"
+#include "config/BackendConfig.h"
+#include "config/CaptivePortalConfig.h"
+#include "config/RFConfig.h"
+#include "config/WiFiConfig.h"
+#include "config/WiFiCredentials.h"
 
 #include <functional>
 #include <string>
 #include <vector>
 
 namespace OpenShock::Config {
-  // This is a copy of the flatbuffers schema defined in schemas/ConfigFile.fbs
-  struct RFConfig {
-    std::uint8_t txPin;
-    bool keepAliveEnabled;
-  };
-  struct WiFiCredentials {
-    std::uint8_t id;
-    std::string ssid;
-    std::uint8_t bssid[6];
-    std::string password;
-  };
-  struct WiFiConfig {
-    std::string apSsid;
-    std::string hostname;
-    std::vector<WiFiCredentials> credentials;
-  };
-  struct CaptivePortalConfig {
-    bool alwaysEnabled;
-  };
-  struct BackendConfig {
-    std::string authToken;
-  };
-
   void Init();
 
+  /* Get the config file translated to JSON. */
+  std::string GetAsJSON();
+
+  /* Save the config file from JSON. */
+  bool SaveFromJSON(const std::string& json);
+
   /**
    * @brief Resets the config file to the factory default values.
    *
@@ -68,4 +55,6 @@ namespace OpenShock::Config {
   const std::string& GetBackendAuthToken();
   bool SetBackendAuthToken(const std::string& token);
   bool ClearBackendAuthToken();
+
+  bool SaveChanges();
 }  // namespace OpenShock::Config

include/config/ConfigBase.h

@@ -0,0 +1,19 @@
+#pragma once
+
+#include "serialization/_fbs/ConfigFile_generated.h"
+
+#include <cJSON.h>
+
+namespace OpenShock::Config {
+  template <typename T>
+  struct ConfigBase {
+    virtual void ToDefault() = 0;
+
+    virtual bool FromFlatbuffers(const T* config) = 0;
+    virtual flatbuffers::Offset<T> ToFlatbuffers(flatbuffers::FlatBufferBuilder& builder) const = 0;
+
+    virtual bool FromJSON(const cJSON* json) = 0;
+    virtual cJSON* ToJSON() const = 0;
+  };
+
+}  // namespace OpenShock::Config

include/config/RFConfig.h

@@ -0,0 +1,18 @@
+#pragma once
+
+#include "config/ConfigBase.h"
+
+namespace OpenShock::Config {
+  struct RFConfig : public ConfigBase<Serialization::Configuration::RFConfig> {
+    std::uint8_t txPin;
+    bool keepAliveEnabled;
+
+    void ToDefault() override;
+
+    bool FromFlatbuffers(const Serialization::Configuration::RFConfig* config) override;
+    flatbuffers::Offset<Serialization::Configuration::RFConfig> ToFlatbuffers(flatbuffers::FlatBufferBuilder& builder) const override;
+
+    bool FromJSON(const cJSON* json) override;
+    cJSON* ToJSON() const override;
+  };
+}  // namespace OpenShock::Config

include/config/RootConfig.h

@@ -0,0 +1,24 @@
+#pragma once
+
+#include "config/RFConfig.h"
+#include "config/WiFiConfig.h"
+#include "config/CaptivePortalConfig.h"
+#include "config/BackendConfig.h"
+#include "config/ConfigBase.h"
+
+namespace OpenShock::Config {
+  struct RootConfig : public ConfigBase<Serialization::Configuration::Config> {
+    OpenShock::Config::RFConfig rf;
+    OpenShock::Config::WiFiConfig wifi;
+    OpenShock::Config::CaptivePortalConfig captivePortal;
+    OpenShock::Config::BackendConfig backend;
+
+    void ToDefault() override;
+
+    bool FromFlatbuffers(const Serialization::Configuration::Config* config) override;
+    flatbuffers::Offset<Serialization::Configuration::Config> ToFlatbuffers(flatbuffers::FlatBufferBuilder& builder) const override;
+
+    bool FromJSON(const cJSON* json) override;
+    cJSON* ToJSON() const override;
+  };
+}  // namespace OpenShock::Config

include/config/WiFiConfig.h

@@ -0,0 +1,23 @@
+#pragma once
+
+#include "config/WiFiCredentials.h"
+#include "config/ConfigBase.h"
+
+#include <string>
+#include <vector>
+
+namespace OpenShock::Config {
+  struct WiFiConfig : public ConfigBase<Serialization::Configuration::WiFiConfig> {
+    std::string accessPointSSID;
+    std::string hostname;
+    std::vector<OpenShock::Config::WiFiCredentials> credentialsList;
+
+    void ToDefault() override;
+
+    bool FromFlatbuffers(const Serialization::Configuration::WiFiConfig* config) override;
+    flatbuffers::Offset<Serialization::Configuration::WiFiConfig> ToFlatbuffers(flatbuffers::FlatBufferBuilder& builder) const override;
+
+    bool FromJSON(const cJSON* json) override;
+    cJSON* ToJSON() const override;
+  };
+}  // namespace OpenShock::Config

include/config/WiFiCredentials.h

@@ -0,0 +1,25 @@
+#pragma once
+
+#include "config/ConfigBase.h"
+
+#include <string>
+
+namespace OpenShock::Config {
+  struct WiFiCredentials : public ConfigBase<Serialization::Configuration::WiFiCredentials> {
+    WiFiCredentials();
+    WiFiCredentials(std::uint8_t id, const std::string& ssid, const std::uint8_t (&bssid)[6], const std::string& password);
+
+    std::uint8_t id;
+    std::string ssid;
+    std::uint8_t bssid[6];
+    std::string password;
+
+    void ToDefault() override;
+
+    bool FromFlatbuffers(const Serialization::Configuration::WiFiCredentials* config) override;
+    flatbuffers::Offset<Serialization::Configuration::WiFiCredentials> ToFlatbuffers(flatbuffers::FlatBufferBuilder& builder) const override;
+
+    bool FromJSON(const cJSON* json) override;
+    cJSON* ToJSON() const override;
+  };
+}  // namespace OpenShock::Config

include/config/internal/utils.h

@@ -0,0 +1,27 @@
+#pragma once
+
+#include "config/ConfigBase.h"
+
+#include <cJSON.h>
+
+namespace OpenShock::Config::Internal::Utils {
+  inline void FromFbsStr(std::string& str, const flatbuffers::String* fbsStr, const char* defaultStr) {
+    if (fbsStr != nullptr) {
+      str = fbsStr->c_str();
+    } else {
+      str = defaultStr;
+    }
+  }
+  template<typename T, typename U>  // T inherits from ConfigBase<U>
+  void FromFbsVec(std::vector<T>& vec, const flatbuffers::Vector<flatbuffers::Offset<U>>* fbsVec) {
+    vec.clear();
+    if (fbsVec != nullptr) {
+      for (auto fbsItem : *fbsVec) {
+        T item;
+        if (item.FromFlatbuffers(fbsItem)) {
+          vec.push_back(std::move(item));
+        }
+      }
+    }
+  }
+}  // namespace OpenShock::Config::Internal::Utils