Configuration.h

Go to the documentation of this file.

 
#pragma once
 
#include "..\UsedInterrupts.h"
 
#include <Arduino.h>
#include <SPIFFS.h>
#include <ViewBase.h>
#include <algorithm>
#include <stdlib.h>
#include <time.h>
 
namespace configuration {
class Configuration {
public:
  class TimeRestrictions {
    friend class Configuration;
 
  public:
    uint32_t startTime;
 
  public:
    uint32_t endTime;
 
  public:
    bool restrictUnlockTimes;
 
  public:
    bool restrictHygieneOpeningTimes;
 
  public:
    bool restrictEmergencyKeyTimes;
 
  public:
    bool restrictConfigurationServer;
 
  public:
    TimeRestrictions()
      : startTime(0)
      , endTime(86400)
      , restrictUnlockTimes(false)
      , restrictHygieneOpeningTimes(false)
      , restrictEmergencyKeyTimes(false)
      , restrictConfigurationServer(false) {}
 
  public:
    bool checkTime() const {
      // compute the number of seconds of this day
      time_t currentTime = time(NULL);
      tm tmBuf;
      localtime_r(&currentTime, &tmBuf);
      uint32_t currentSeconds = tmBuf.tm_hour * 3600 + tmBuf.tm_min * 60 + tmBuf.tm_sec;
 
      if (startTime == endTime) {
        return true;
      }
      else if (endTime > startTime) {
        return (currentSeconds >= startTime) && (currentSeconds <= endTime);
      }
      else {
        // Midnight overflow
        return (currentSeconds >= endTime) && (currentSeconds <= startTime);
      }
    }
 
  protected:
    void readFromFile(File& file) {
      String start = file.readStringUntil('\n');
      String end = file.readStringUntil('\n');
      String restrictions = file.readStringUntil('\n');
      start.trim();
      end.trim();
      restrictions.end();
      if (start.isEmpty() || end.isEmpty() || restrictions.isEmpty()) {
        startTime = 0;
        endTime = 86400;
        restrictUnlockTimes = false;
        restrictHygieneOpeningTimes = false;
        restrictEmergencyKeyTimes = false;
        restrictConfigurationServer = false;
      }
      else {
        startTime = strtoul(start.c_str(), NULL, 0);
        endTime = strtoul(end.c_str(), NULL, 0);
 
        unsigned long l = strtoul(restrictions.c_str(), NULL, 0);
        restrictUnlockTimes = l & (1 << 0);
        restrictHygieneOpeningTimes = l & (1 << 1);
        restrictEmergencyKeyTimes = l & (1 << 2);
        restrictConfigurationServer = l & (1 << 3);
      }
    }
 
  protected:
    void writeToFile(File& file) {
      file.println(startTime);
      file.println(endTime);
      file.println((restrictUnlockTimes << 0) | (restrictHygieneOpeningTimes << 1) | (restrictEmergencyKeyTimes << 2) |
                   (restrictConfigurationServer << 3));
    }
  };
 
#pragma region Singelton
protected:
  inline static Configuration** getInstance() {
    static Configuration* instance = nullptr;
    return &instance;
  }
 
public:
  inline static Configuration& getSingleton() {
    return **getInstance();
  }
 
public:
  inline static Configuration& begin() {
    if (!*getInstance()) {
      *getInstance() = new Configuration();
    }
    return **getInstance();
  }
#pragma endregion
 
#pragma region WiFi Settings
protected:
  String ssid;
 
protected:
  String pwd;
#pragma endregion
 
#pragma region Emlalock settings
protected:
  String userId;
 
protected:
  String apiKey;
 
protected:
  String emergencyKey;
 
protected:
  bool disableFailedSession;
#pragma endregion
 
#pragma region Miscellaneous Settings
protected:
  String timezone;
 
protected:
  String timezoneName;
 
protected:
  unsigned long backlightTimeOut;
 
protected:
  bool autoLockHygieneOpeningTimeout;
 
protected:
  TimeRestrictions timeRestrictions;
#pragma endregion
 
public:
  Configuration() {
    readConfiguration();
  }
 
#pragma region Getter
#pragma region WiFi Settings
public:
  const String& getSsid() const {
    return ssid;
  }
 
public:
  const String& getPwd() const {
    return pwd;
  }
#pragma endregion
 
#pragma region Emlalock settings
public:
  const String& getUserId() const {
    return userId;
  }
 
public:
  const String& getApiKey() const {
    return apiKey;
  }
 
public:
  const String& getEmergencyKey() const {
    return emergencyKey;
  }
 
public:
  const bool& getDisableFailedSession() const {
    return disableFailedSession;
  }
 
#pragma endregion
 
#pragma region Miscellaneous Settings
public:
  const String& getTimezone() const {
    return timezone;
  }
 
public:
  const String& getTimezoneName() const {
    return timezoneName;
  }
 
public:
  const unsigned long& getBacklightTimeOut() const {
    return backlightTimeOut;
  }
 
public:
  const bool& getAutoLockHygieneOpeningTimeout() const {
    return autoLockHygieneOpeningTimeout;
  }
 
public:
  const TimeRestrictions& getTimeRestrictions() const {
    return timeRestrictions;
  }
#pragma endregion
#pragma endregion
 
#pragma region Setter
public:
  void setWifiSettings(const String& ssid, const String& pwd) {
    this->ssid = ssid;
    this->pwd = pwd;
    writeConfiguration();
  }
 
  void setConfigurationSettings(const String& userId,
                                const String& apiKey,
                                const bool& disableFailedSession,
                                const String& timezoneName,
                                const String& timezone,
                                const long& backlightTimeOut,
                                const bool& autoLockHygieneOpeningTimeout,
                                const TimeRestrictions& timeRestrictions) {
    this->userId = userId;
    this->apiKey = apiKey;
    this->disableFailedSession = disableFailedSession;
 
    this->timezoneName = timezoneName;
    this->timezone = timezone;
    setenv("TZ", timezone.c_str(), 1);
    tzset();
 
    this->backlightTimeOut = backlightTimeOut;
    lcd::ViewBase::setBacklightTimeout(backlightTimeOut * 1000);
 
    this->autoLockHygieneOpeningTimeout = autoLockHygieneOpeningTimeout;
    this->timeRestrictions = timeRestrictions;
    this->timeRestrictions.startTime = std::min(this->timeRestrictions.startTime, (uint32_t)86400);
    this->timeRestrictions.endTime = std::min(this->timeRestrictions.endTime, (uint32_t)86400);
 
    writeConfiguration();
  }
 
  const String& generateNewEmergencyKey() {
    std::srand((unsigned int)micros());
    for (int i = 0; i < 6; i++) {
      emergencyKey[i] = getRandomChar();
    }
 
    writeConfiguration();
 
    return emergencyKey;
  }
#pragma endregion
 
public:
  void restoreFactoryDefaults() {
    ssid = "";
    pwd = "";
    userId = "";
    apiKey = "";
    emergencyKey = "AAAAAA";
    disableFailedSession = false;
    timezone = "CET-1CEST,M3.5.0,M10.5.0/3";
    timezoneName = "Europe/Berlin";
    backlightTimeOut = 15;
    autoLockHygieneOpeningTimeout = false;
    timeRestrictions = TimeRestrictions();
    writeConfiguration();
  }
 
protected:
  void readConfiguration() {
    // load everything from the SPIFFS
    UsedInterrupts::executeWithoutInterrupts([this]() {
      File file = SPIFFS.open("/configuration.txt", "r");
      if (!file) {
        Serial.println("Loading configuration.txt failed");
        return;
      }
 
      ssid = file.readStringUntil('\n');
      ssid.trim();
      pwd = file.readStringUntil('\n');
      pwd.trim();
      userId = file.readStringUntil('\n');
      userId.trim();
      apiKey = file.readStringUntil('\n');
      apiKey.trim();
      emergencyKey = file.readStringUntil('\n');
      emergencyKey.trim();
      if (emergencyKey.length() != 6) {
        emergencyKey = "AAAAAA";
      }
      disableFailedSession = strtol(file.readStringUntil('\n').c_str(), NULL, 0) == 1;
      timezone = file.readStringUntil('\n');
      timezone.trim();
      timezoneName = file.readStringUntil('\n');
      timezoneName.trim();
 
      backlightTimeOut = strtoul(file.readStringUntil('\n').c_str(), NULL, 0);
      autoLockHygieneOpeningTimeout = strtol(file.readStringUntil('\n').c_str(), NULL, 0) == 1;
 
      timeRestrictions.readFromFile(file);
 
      file.close();
      file = SPIFFS.open("/configuration.txt", "r");
      Serial.printf("configuration.txt: \n\"%s\"\n", file.readString().c_str());
    });
  }
 
protected:
  void writeConfiguration() {
    // load everything from the SPIFFS
    UsedInterrupts::executeWithoutInterrupts([this]() {
      File file = SPIFFS.open("/configuration.txt", "w");
      if (!file) {
        Serial.println("Loading configuration.txt failed");
        return;
      }
 
      file.println(ssid);
      file.println(pwd);
      file.println(userId);
      file.println(apiKey);
      file.println(emergencyKey);
      file.println((disableFailedSession) ? "1" : "0");
      file.println(timezone);
      file.println(timezoneName);
      file.println(backlightTimeOut);
      file.println((autoLockHygieneOpeningTimeout) ? "1" : "0");
 
      timeRestrictions.writeToFile(file);
    });
  }
 
protected:
  static char getRandomChar() {
    int x = 36;
    while (x > 35) {
      // according to example of
      // https://en.cppreference.com/w/cpp/numeric/random/rand we need this to
      // have no bias....
      x = std::rand() / ((RAND_MAX + 1u) / 35);
    }
 
    if (x < 26) {
      return (char)x + 'A';
    }
    return (char)x - 26 + '0';
  }
};
} // namespace configuration