OpenCloseController.h

#pragma once
 
#include "../SinricProRequest.h"
#include "../EventLimiter.h"
#include "../SinricProStrings.h"
 
#include "../SinricProNamespace.h"
namespace SINRICPRO_NAMESPACE {
 
FSTR(OPEN_CLOSE, openPercent);          // "openPercent"
FSTR(OPEN_CLOSE, openRelativePercent);  // "openRelativePercent"
FSTR(OPEN_CLOSE, openDirection);        // "openDirection"
FSTR(OPEN_CLOSE, setOpenClose);         // "setOpenClose" 
FSTR(OPEN_CLOSE, adjustOpenClose);      // "adjustOpenClose" 
 
 
using OpenCloseCallback = std::function<bool(const String &, int &)>;
 
using AdjustOpenCloseCallback = std::function<bool(const String &, int &)>;
 
using DirectionOpenCloseCallback = std::function<bool(const String &, const String &, int &)>;
 
using AdjustDirectionOpenCloseCallback = std::function<bool(const String &, const String &, int &)>;
 
template <typename T>
class OpenCloseController {
  public:
    OpenCloseController();
 
    void onOpenClose(OpenCloseCallback cb);
 
    void onDirectionOpenClose(DirectionOpenCloseCallback cb);
 
    void onAdjustOpenClose(AdjustOpenCloseCallback cb);
 
    void onAdjustDirectionOpenClose(AdjustDirectionOpenCloseCallback cb);
 
    bool sendOpenCloseEvent(int openPercent, String cause = FSTR_SINRICPRO_PHYSICAL_INTERACTION);
 
    bool sendOpenCloseEvent(String openDirection, int openPercent, String cause = FSTR_SINRICPRO_PHYSICAL_INTERACTION);
 
  protected:
    bool handleOpenCloseController(SinricProRequest &request);
 
  private:
    EventLimiter event_limiter;
    DirectionOpenCloseCallback directionOpenCloseCallback;
    OpenCloseCallback openCloseCallback;
    AdjustOpenCloseCallback adjustOpenCloseCallback; 
    AdjustDirectionOpenCloseCallback adjustDirectionOpenCloseCallback;
};
 
template <typename T>
OpenCloseController<T>::OpenCloseController()
:event_limiter(EVENT_LIMIT_STATE) { 
  T* device = static_cast<T*>(this);
  device->registerRequestHandler(std::bind(&OpenCloseController<T>::handleOpenCloseController, this, std::placeholders::_1)); 
}
 
template <typename T>
void OpenCloseController<T>::onOpenClose(OpenCloseCallback cb) { openCloseCallback = cb; }
 
template <typename T>
void OpenCloseController<T>::onDirectionOpenClose(DirectionOpenCloseCallback cb) { directionOpenCloseCallback = cb; }
 
template <typename T>
void OpenCloseController<T>::onAdjustOpenClose(AdjustOpenCloseCallback cb) { adjustOpenCloseCallback = cb; }
 
template <typename T>
void OpenCloseController<T>::onAdjustDirectionOpenClose(AdjustDirectionOpenCloseCallback cb) { adjustDirectionOpenCloseCallback = cb; }
 
template <typename T>
bool OpenCloseController<T>::sendOpenCloseEvent(String openDirection, int openPercent, String cause) {
  if (event_limiter) return false;
  T* device = static_cast<T*>(this);
 
  JsonDocument eventMessage = device->prepareEvent(FSTR_OPEN_CLOSE_setOpenClose, cause.c_str());
  JsonObject event_value = eventMessage[FSTR_SINRICPRO_payload][FSTR_SINRICPRO_value];
  event_value[FSTR_OPEN_CLOSE_openDirection] = openDirection;
  event_value[FSTR_OPEN_CLOSE_openPercent] = openPercent;
 
  return device->sendEvent(eventMessage);
}
 
template <typename T>
bool OpenCloseController<T>::sendOpenCloseEvent(int openPercent, String cause) {
  if (event_limiter) return false;
  T* device = static_cast<T*>(this);
 
  JsonDocument eventMessage = device->prepareEvent(FSTR_OPEN_CLOSE_setOpenClose, cause.c_str());
  JsonObject event_value = eventMessage[FSTR_SINRICPRO_payload][FSTR_SINRICPRO_value];
  event_value[FSTR_OPEN_CLOSE_openPercent] = openPercent;
 
  return device->sendEvent(eventMessage);
}
 
template <typename T>
bool OpenCloseController<T>::handleOpenCloseController(SinricProRequest &request) {
  T* device = static_cast<T*>(this);
 
  bool success = false;
 
  if (request.action == FSTR_OPEN_CLOSE_setOpenClose) {
    bool hasOpenDirection = !request.request_value[FSTR_OPEN_CLOSE_openDirection].isNull();
    int openPercent = request.request_value[FSTR_OPEN_CLOSE_openPercent];
 
    if (hasOpenDirection && directionOpenCloseCallback) {
      String openDirection = request.request_value[FSTR_OPEN_CLOSE_openDirection];
      success = directionOpenCloseCallback(device->deviceId, openDirection, openPercent);
      request.response_value[FSTR_OPEN_CLOSE_openDirection] = openDirection;
      request.response_value[FSTR_OPEN_CLOSE_openPercent] = openPercent;
    } else if (!hasOpenDirection && openCloseCallback) {
      success = openCloseCallback(device->deviceId, openPercent);
      request.response_value[FSTR_OPEN_CLOSE_openPercent] = openPercent;
    }
 
    return success;
  }
 
  if (request.action == FSTR_OPEN_CLOSE_adjustOpenClose) {
    bool hasOpenDirection = !request.request_value[FSTR_OPEN_CLOSE_openDirection].isNull();
    int openRelativePercent = request.request_value[FSTR_OPEN_CLOSE_openRelativePercent];
 
    if (hasOpenDirection && adjustDirectionOpenCloseCallback) {
      String openDirection = request.request_value[FSTR_OPEN_CLOSE_openDirection];
      success = adjustDirectionOpenCloseCallback(device->deviceId, openDirection, openRelativePercent);
      request.response_value[FSTR_OPEN_CLOSE_openDirection] = openDirection;
      request.response_value[FSTR_OPEN_CLOSE_openPercent] = openRelativePercent;
    } else if (!hasOpenDirection && adjustOpenCloseCallback) {
      success = adjustOpenCloseCallback(device->deviceId, openRelativePercent);
      request.response_value[FSTR_OPEN_CLOSE_openPercent] = openRelativePercent;
    }
 
    return success;
  }
 
  return false;
}
 
} // SINRICPRO_NAMESPACE
 
template <typename T>
using OpenCloseController = SINRICPRO_NAMESPACE::OpenCloseController<T>;