ThingsBoardHttp.h

Go to the documentation of this file.

#ifndef ThingsBoard_Http_h
#define ThingsBoard_Http_h
 
// Local includes.
#include "Constants.h"
#include "Telemetry.h"
#include "Helper.h"
#include "IHTTP_Client.h"
#include "DefaultLogger.h"
 
 
// HTTP topics.
char constexpr HTTP_TELEMETRY_TOPIC[] = "/api/v1/%s/telemetry";
char constexpr HTTP_ATTRIBUTES_TOPIC[] = "/api/v1/%s/attributes";
char constexpr HTTP_POST_PATH[] = "application/json";
int constexpr HTTP_RESPONSE_SUCCESS_RANGE_START = 200;
int constexpr HTTP_RESPONSE_SUCCESS_RANGE_END = 299;
 
// Log messages.
char constexpr POST[] = "POST";
char constexpr GET[] = "GET";
char constexpr HTTP_FAILED[] = "(%s) failed HTTP response (%d)";
 
 
template<typename Logger = DefaultLogger>
class ThingsBoardHttpSized {
  public:
    ThingsBoardHttpSized(IHTTP_Client & client, char const * access_token, char const * host, uint16_t port = 80U, bool keep_alive = true, size_t const & max_stack_size = DEFAULT_MAX_STACK_SIZE)
      : m_client(client)
      , m_max_stack(max_stack_size)
      , m_token(access_token)
    {
        m_client.set_keep_alive(keep_alive);
        if (m_client.connect(host, port) != 0) {
            Logger::printfln(CONNECT_FAILED);
        }
    }
 
    void Set_Maximum_Stack_Size(size_t const & max_stack_size) {
        m_max_stack = max_stack_size;
    }
 
    size_t const & Get_Maximum_Stack_Size() const {
        return m_max_stack;
    }
 
    bool Send_Json(char const * topic, JsonDocument const & source) {
        // Check if allocating needed memory failed when trying to create the JsonDocument,
        // if it did the isNull() method will return true. See https://arduinojson.org/v6/api/jsonvariant/isnull/ for more information
        if (source.isNull()) {
            Logger::printfln(UNABLE_TO_ALLOCATE_JSON);
            return false;
        }
        // Check if inserting any of the internal values failed because the JsonDocument was too small,
        // if it did the overflowed() method will return true. See https://arduinojson.org/v6/api/jsondocument/overflowed/ for more information
        if (source.overflowed()) {
            Logger::printfln(JSON_SIZE_TO_SMALL);
            return false;
        }
        bool result = false;
 
        size_t const json_size = Helper::Measure_Json(source);
        if (json_size > Get_Maximum_Stack_Size()) {
            char * json = new char[json_size]();
            if (serializeJson(source, json, json_size) < json_size - 1) {
                Logger::printfln(UNABLE_TO_SERIALIZE_JSON);
            }
            else {
                result = Send_Json_String(topic, json);
            }
            delete[] json;
            json = nullptr;
        }
        else {
            char json[json_size] = {};
            if (serializeJson(source, json, json_size) < json_size - 1) {
                Logger::printfln(UNABLE_TO_SERIALIZE_JSON);
                return result;
            }
            result = Send_Json_String(topic, json);
        }
        return result;
    }
 
    bool Send_Json_String(char const * topic, char const * json) {
        if (json == nullptr || m_token == nullptr) {
            return false;
        }
 
        char path[Helper::Calculate_Print_Size(topic, m_token)] = {};
        (void)snprintf(path, sizeof(path), topic, m_token);
        return Post_Message(path, json);
    }
 
    //----------------------------------------------------------------------------
    // Telemetry API
 
    template<typename T>
    bool Send_Telemetry_Data(char const * key, T const & value) {
        return Send_Key_Value_Pair(key, value);
    }
 
#if THINGSBOARD_ENABLE_DYNAMIC
    template<typename InputIterator>
#else
    template<size_t MaxKeyValuePairAmount, typename InputIterator>
#endif // THINGSBOARD_ENABLE_DYNAMIC
    bool Send_Telemetry(InputIterator const & first, InputIterator const & last) {
#if THINGSBOARD_ENABLE_DYNAMIC
        return Send_Data_Array(first, last, true);
#else
        return Send_Data_Array<MaxKeyValuePairAmount>(first, last, true);
#endif // THINGSBOARD_ENABLE_DYNAMIC
    }
 
    bool Send_Telemetry_String(char const * json) {
        return Send_Json_String(HTTP_TELEMETRY_TOPIC, json);
    }
 
    bool Send_Telemetry_Json(JsonDocument const & source) {
        return Send_Json(HTTP_TELEMETRY_TOPIC, source);
    }
 
    //----------------------------------------------------------------------------
    // Attribute API
 
    template<typename T>
    bool Send_Attribute_Data(char const * key, T const & value) {
        return Send_Key_Value_Pair(key, value, false);
    }
 
#if THINGSBOARD_ENABLE_DYNAMIC
    template<typename InputIterator>
#else
    template<size_t MaxKeyValuePairAmount, typename InputIterator>
#endif // THINGSBOARD_ENABLE_DYNAMIC
    bool Send_Attributes(InputIterator const & first, InputIterator const & last) {
#if THINGSBOARD_ENABLE_DYNAMIC
        return Send_Data_Array(first, last, false);
#else
        return Send_Data_Array<MaxKeyValuePairAmount>(first, last, false);
#endif // THINGSBOARD_ENABLE_DYNAMIC
    }
 
    bool Send_Attribute_String(char const * json) {
        return Send_Json_String(HTTP_ATTRIBUTES_TOPIC, json);
    }
 
    bool Send_Attribute_Json(JsonDocument const & source) {
        return Send_Json(HTTP_ATTRIBUTES_TOPIC, source);
    }
 
    //----------------------------------------------------------------------------
    // Generic HTTP API
 
#if THINGSBOARD_ENABLE_STL
    bool Send_Get_Request(char const * path, std::string & response) {
#else
    bool Send_Get_Request(char const * path, String& response) {
#endif // THINGSBOARD_ENABLE_STL
        return Get_Message(path, response);
    }
 
    bool Send_Post_Request(char const * path, char const * json) {
        return Post_Message(path, json);
    }
 
  private:
    void Clear_Connection() {
        m_client.stop();
    }
 
    bool Post_Message(char const * path, char const * json) {
        bool success = m_client.post(path, HTTP_POST_PATH, json) == 0;
        int const status = m_client.get_response_status_code();
 
        if (!success || status < HTTP_RESPONSE_SUCCESS_RANGE_START || status > HTTP_RESPONSE_SUCCESS_RANGE_END) {
            Logger::printfln(HTTP_FAILED, POST, status);
            success = false;
        }
 
        Clear_Connection();
        return success;
    }
 
#if THINGSBOARD_ENABLE_STL
    bool Get_Message(char const * path, std::string& response) {
#else
    bool Get_Message(char const * path, String& response) {
#endif // THINGSBOARD_ENABLE_STL
        bool success = m_client.get(path);
        int const status = m_client.get_response_status_code();
 
        if (!success || status < HTTP_RESPONSE_SUCCESS_RANGE_START || status > HTTP_RESPONSE_SUCCESS_RANGE_END) {
            Logger::printfln(HTTP_FAILED, GET, status);
            success = false;
            goto cleanup;
        }
        response = m_client.get_response_body();
 
        cleanup:
        Clear_Connection();
        return success;
    }
 
#if THINGSBOARD_ENABLE_DYNAMIC
    template<typename InputIterator>
#else
    template<size_t MaxKeyValuePairAmount, typename InputIterator>
#endif // THINGSBOARD_ENABLE_DYNAMIC
    bool Send_Data_Array(InputIterator const & first, InputIterator const & last, bool telemetry) {
        auto const size = Helper::distance(first, last);
#if THINGSBOARD_ENABLE_DYNAMIC
        TBJsonDocument json_buffer(JSON_OBJECT_SIZE(size));
#else
        if (size > MaxKeyValuePairAmount) {
            Logger::printfln(TOO_MANY_JSON_FIELDS, size, "MaxKeyValuePairAmount", MaxKeyValuePairAmount);
            return false;
        }
        StaticJsonDocument<JSON_OBJECT_SIZE(MaxKeyValuePairAmount)> json_buffer;
#endif // THINGSBOARD_ENABLE_DYNAMIC
 
#if THINGSBOARD_ENABLE_STL
        if (std::any_of(first, last, [&json_buffer](Telemetry const & data) { return !data.SerializeKeyValue(json_buffer); })) {
            Logger::printfln(UNABLE_TO_SERIALIZE);
            return false;
        }
#else
        for (auto it = first; it != last; ++it) {
            auto const & data = *it;
            if (!data.SerializeKeyValue(json_buffer)) {
                Logger::printfln(UNABLE_TO_SERIALIZE);
                return false;
            }
        }
#endif // THINGSBOARD_ENABLE_STL
        return telemetry ? Send_Telemetry_Json(json_buffer) : Send_Attribute_Json(json_buffer);
    }
 
    template<typename T>
    bool Send_Key_Value_Pair(char const * key, T value, bool telemetry = true) {
        Telemetry const t(key, value);
        if (t.IsEmpty()) {
            // Message is ignored and not sent at all.
            return false;
        }
 
        StaticJsonDocument<JSON_OBJECT_SIZE(1)> json_buffer;
        if (!t.SerializeKeyValue(json_buffer)) {
            Logger::printfln(UNABLE_TO_SERIALIZE);
            return false;
        }
        return telemetry ? Send_Telemetry_Json(json_buffer) : Send_Attribute_Json(json_buffer);
    }
 
    IHTTP_Client& m_client = {};     // HttpClient instance
    size_t        m_max_stack = {};  // Maximum stack size we allocate at once on the stack.
    char const    *m_token = {};     // Access token used to connect with
};
 
using ThingsBoardHttp = ThingsBoardHttpSized<>;
 
#endif // ThingsBoard_Http_h