Configuration.cpp

/*
   Basecamp - ESP32 library to simplify the basics of IoT projects
   Written by Merlin Schumacher (mls@ct.de) for c't magazin für computer technik 
   (https://www.ct.de) - updated by Guido Dampf (guido@dampf.de)
   Licensed under GPLv3. See LICENSE for details.
   */
#include "Configuration.hpp"

Configuration::Configuration(String filename): _jsonFile(std::move(filename)) {}

bool Configuration::load() {
  DEBUG_PRINTLN("Loading config file ");
  DEBUG_PRINTLN(_jsonFile);
  if (!SPIFFS.begin(true)) {
    Serial.println("Could not access SPIFFS.");
    return false;
  }

  File configFile = SPIFFS.open(_jsonFile, "r");

  if (!configFile || configFile.isDirectory()) {
    Serial.println("Failed to open config file");
    return false;
  }

  DynamicJsonDocument _jsonDocument(JSON_SIZE);

  DeserializationError error = deserializeJson(_jsonDocument, configFile);
  if (error) {
    Serial.println("Failed to parse config file.");
    return false;
  }

  for (JsonPair configItem: _jsonDocument.as < JsonObject > ()) {
    const char * key = configItem.key().c_str();
    JsonVariant value = configItem.value();
    set(String(key), value);
  }

  #ifdef DEBUG
  serializeJsonPretty(_jsonDocument, Serial);
  Serial.println();
  #endif
  configFile.close();
  #if DEBUG == 2
  esp_deep_sleep_start();
  #endif
  return true;
}

bool Configuration::save() {
  DEBUG_PRINTLN("Saving config file");

  File configFile = SPIFFS.open(_jsonFile, "w");
  if (!configFile) {
    Serial.println("Failed to open config file for writing");
    return false;
  }

  if (configuration.empty()) {
    Serial.println("Configuration empty");
  }

  DynamicJsonDocument _jsonDocument(JSON_FILE_SIZE);

  for (const auto & x: configuration) {
    _jsonDocument[x.first] = String {
      x.second
    };
  }

  if (serializeJson(_jsonDocument, configFile) == 0) {
    Serial.println("Failed to write Config-File");
  }
  #ifdef DEBUG
  serializeJsonPretty(_jsonDocument, Serial);
  Serial.println();
  #endif
  configFile.close();
  _configurationTainted = false;
  return true;
}

void Configuration::set(String key, String value) {
  std::ostringstream debug;
  debug << "Settting " << key.c_str() << " to " << value.c_str() << "(was "
    << get(key).c_str() << ")";
  DEBUG_PRINTLN(debug.str().c_str());

  if (get(key) != value) {
    _configurationTainted = true;
    configuration[key] = value;
  } else {
    DEBUG_PRINTLN("Cowardly refusing to overwrite existing key with the same value");
  }
}

void Configuration::set(ConfigurationKey key, String value) {
  set(getKeyName(key), std::move(value));
}

const String & Configuration::get(String key) const {
  auto found = configuration.find(key);
  if (found != configuration.end()) {
    std::ostringstream debug;
    debug << "Config value for " << key.c_str() << ": " << found -> second.c_str();
    DEBUG_PRINTLN(debug.str().c_str());

    return found -> second;
  }

  // Default: if not set, we just return an empty String. TODO: Throw?
  return noResult_;
}

const String & Configuration::get(ConfigurationKey key) const {
  return get(getKeyName(key));
}

// return a char* instead of a Arduino String to maintain backwards compatibility
// with printed examples
[
  [deprecated("getCString() is deprecated. Use get() instead")]
] char * Configuration::getCString(String key) {
  char * newCString = (char * ) malloc(configuration[key].length() + 1);
  strcpy(newCString, get(key).c_str());
  return newCString;
}

bool Configuration::keyExists(const String & key) const {
  return (configuration.find(key) != configuration.end());
}

bool Configuration::keyExists(ConfigurationKey key) const {
  return (configuration.find(getKeyName(key)) != configuration.end());
}

bool Configuration::isKeySet(ConfigurationKey key) const {
  auto found = configuration.find(getKeyName(key));
  if (found == configuration.end()) {
    return false;
  }

  return (found -> second.length() > 0);
}

void Configuration::reset() {
  configuration.clear();
  this -> save();
  this -> load();
}

void Configuration::resetExcept(
 const std::list < ConfigurationKey > & keysToPreserve) {
  std::map < ConfigurationKey, String > preservedKeys;
  for (const auto & key: keysToPreserve) {
    if (keyExists(key)) {
      // Make a copy of the old value
      preservedKeys[key] = get(key);
    }
  }

  configuration.clear();

  for (const auto & key: preservedKeys) {
    set(key.first, key.second);
  }

  this -> save();
  this -> load();
}

void Configuration::dump() {
  #ifdef DEBUG
  for (const auto & p: configuration) {
    Serial.print("configuration[");
    Serial.print(p.first);
    Serial.print("] = ");
    Serial.println(p.second);
  }
  #endif
}