JsonSerializer.h

Go to the documentation of this file.

#pragma once

#include "ISerializer.h"
#include "ObjectFactory.h"
#include "DpaRaw.h"
#include "PrfFrc.h"
#include "PrfThermometer.h"
#include "PrfIo.h"
#include "PrfOs.h"
#include "PrfLeds.h"
#include "PlatformDep.h"
#include "rapidjson/rapidjson.h"
#include "rapidjson/document.h"
#include "rapidjson/istreamwrapper.h"
#include "rapidjson/stringbuffer.h"
#include "rapidjson/prettywriter.h"
#include <algorithm>
#include <memory>
#include <string>

class PrfCommonJson
{
protected:

  PrfCommonJson();
  PrfCommonJson(const PrfCommonJson& o);

  void parseRequestJson(const rapidjson::Value& val, DpaTask& dpaTask);

  void addResponseJsonPrio1Params(const DpaTask& dpaTask);

  void addResponseJsonPrio2Params(const DpaTask& dpaTask);

  std::string encodeResponseJsonFinal(const DpaTask& dpaTask);

public:

  int parseBinary(uint8_t* to, const std::string& from, int maxlen);

  template<typename T>
  void parseHexaNum(T& to, const std::string& from)
  {
    int val = 0;
    std::istringstream istr(from);
    if (istr >> std::hex >> val) {
      to = (T)val;
    }
    else {
      THROW_EX(std::logic_error, "Unexpected format: " << PAR(from));
    }
  }

  void encodeHexaNum(std::string& to, uint8_t from);

  void encodeHexaNum(std::string& to, uint16_t from);

  void encodeBinary(std::string& to, const uint8_t* from, int len);
  
  void encodeTimestamp(std::string& to, std::chrono::time_point<std::chrono::system_clock> from);

  bool m_has_ctype = false;
  bool m_has_type = false;
  bool m_has_nadr = false;
  bool m_has_hwpid = false;
  bool m_has_timeout = false;
  bool m_has_msgid = false;
  bool m_has_request = false;
  bool m_has_request_ts = false;
  bool m_has_response = false;
  bool m_has_response_ts = false;
  bool m_has_confirmation = false;
  bool m_has_confirmation_ts = false;
  bool m_has_cmd = false;
  bool m_has_rcode = false;
  bool m_has_rdata = false;
  bool m_has_dpaval = false;

  std::string m_ctype;
  std::string m_type;
  std::string m_nadr = "0";
  std::string m_hwpid = "0xffff";
  int m_timeoutJ = 0;
  std::string m_msgid;
  std::string m_requestJ;
  std::string m_request_ts;
  std::string m_responseJ;
  std::string m_response_ts;
  std::string m_confirmationJ;
  std::string m_confirmation_ts;
  std::string m_cmdJ;
  std::string m_statusJ;
  std::string m_rcodeJ;
  std::string m_rdataJ;
  std::string m_dpavalJ;

  rapidjson::Document m_doc;

  bool m_dotNotation = true;
};

class PrfRawJson : public DpaRaw, public PrfCommonJson
{
public:
  explicit PrfRawJson(const rapidjson::Value& val);

  explicit PrfRawJson(const DpaMessage& dpaMessage);
  virtual ~PrfRawJson() {}
  
  std::string encodeResponse(const std::string& errStr) override;
  
  std::string encodeAsyncRequest(const std::string& errStr);
private:
};

class PrfRawHdpJson : public DpaRaw, public PrfCommonJson
{
public:
  static const std::string PRF_NAME;

  explicit PrfRawHdpJson(const rapidjson::Value& val);
  virtual ~PrfRawHdpJson() {}

  std::string encodeResponse(const std::string& errStr) override;
private:
  std::string m_pnum;
  std::string m_pcmd;
  std::string m_data;

};

class PrfThermometerJson : public PrfThermometer, public PrfCommonJson
{
public:
  explicit PrfThermometerJson(const rapidjson::Value& val);
  virtual ~PrfThermometerJson() {}

  std::string encodeResponse(const std::string& errStr) override;
};

class PrfFrcJson : public PrfFrc, public PrfCommonJson
{
public:
  explicit PrfFrcJson(const rapidjson::Value& val);
  virtual ~PrfFrcJson() {}

  std::string encodeResponse(const std::string& errStr) override;
private:
  bool m_predefinedFrcCommand = false;
  std::string m_userData;
};

class PrfIoJson : public PrfIo, public PrfCommonJson
{
public:
  explicit PrfIoJson(const rapidjson::Value& val);
  virtual ~PrfIoJson() {}

  std::string encodeResponse(const std::string& errStr) override;
private:
  Port m_port;
  uint8_t m_bit;
  bool m_val;
};

class PrfOsJson : public PrfOs, public PrfCommonJson
{
public:
  explicit PrfOsJson(const rapidjson::Value& val);
  virtual ~PrfOsJson() {}

  std::string encodeResponse(const std::string& errStr) override;
};

template <typename L>
class PrfLedJson : public L, public PrfCommonJson
{
public:
  explicit PrfLedJson(const rapidjson::Value& val) {
    parseRequestJson(val, *this);
  }

  virtual ~PrfLedJson() {}


  std::string encodeResponse(const std::string& errStr) override
  {
    rapidjson::Value v;

    addResponseJsonPrio1Params(*this);
    addResponseJsonPrio2Params(*this);

    int ls = L::getLedState();
    if (ls >= 0) {
      v.SetString((ls ? "on" : "off"), m_doc.GetAllocator());
      m_doc.AddMember("led_state", v, m_doc.GetAllocator());
    }

    m_statusJ = errStr;
    return encodeResponseJsonFinal(*this);
  }

};

typedef PrfLedJson<PrfLedG> PrfLedGJson;

typedef PrfLedJson<PrfLedR> PrfLedRJson;

class JsonSerializer : public ObjectFactory<DpaTask, rapidjson::Value>, public ISerializer
{
public:
  JsonSerializer();

  JsonSerializer(const std::string& name);
  virtual ~JsonSerializer() {}

  const std::string& getName() const override { return m_name; }

  std::string parseCategory(const std::string& request) override;
  std::unique_ptr<DpaTask> parseRequest(const std::string& request) override;
  std::string parseConfig(const std::string& request) override;
  std::string encodeConfig(const std::string& request, const std::string& response) override;
  std::string getLastError() const override;
  std::string encodeAsyncAsDpaRaw(const DpaMessage& dpaMessage) const override;

private:
  void init();
  std::string m_lastError;
  std::string m_name;
};