CscHttpClient.h

Go to the documentation of this file.

#ifndef _CscHttpClient_H
#define _CscHttpClient_H
 
#include "CscCommon.h"
#include "Util/json.h"
#include <mutex>
#include <sstream>
#include <utility>
 
using std::stringstream, std::exception, std::move;
 
using namespace conscience_utils;
using namespace conscience_utils::JSON;
using namespace conscience_utils::logging;
 
namespace fs = std::filesystem;
 
namespace conscience_core::communication::HTTP {
 
struct CscHttpClientConfiguration {
    static optional<unsigned> &defaultTimeoutSecondsGet();
    static optional<unsigned> &defaultTimeoutSecondsPost();
    static optional<unsigned> &defaultTimeoutSecondsDownload();
};
 
class HttpErrorResponseException : public CscException {
public:
    HttpErrorResponseException(const string &errorMessage, optional<unsigned> httpCode) noexcept;
    ~HttpErrorResponseException() noexcept override = default;
    optional<unsigned> getHttpCode() const;
private:
    const optional<unsigned> httpCode;
};
 
class HttpErrorTimeoutException : public CscException {
public:
    HttpErrorTimeoutException(const string &errorMessage) noexcept : CscException(errorMessage) {}
    ~HttpErrorTimeoutException() noexcept override = default;
};
 
    class HttpResponse {
    public:
        HttpResponse(const long code,
                     const string &content,
                     const map<string, string> &headers);
 
        const string &getContent() const;
        ptr<CscJsonObjectReader> getContentAsJson() const;
 
        template <class T>
        vector<T> getContentAsJsonArray() const {
            return getContentAsJson()->asArrayValue<T>();
        }
 
        const long &getCode() const;
        const map<string, string> &getHeaders();
 
        optional<string> getHeader(const string &headerName) const;
 
    private:
        const long code;
        const string content;
        const map<string, string> headers;
    };
 
    struct HttpGet {
    public:
        string protocol;
        string host;
        string path;
        map<string, string> queryStringParameters = {};
        optional<int> port = {};
        map<string, string> headers = {};
        optional<unsigned> timeoutSeconds = CscHttpClientConfiguration::defaultTimeoutSecondsGet();
 
        int getPort() const {
            return port.value_or(protocol == "https" ? 443 : 80);
        }
    };
 
    typedef variant<map<string, string>, string, const char *, ptr<CscJsonObject>> PostParameters;
 
    struct HttpPost {
    public:
        string protocol;
        string host;
        string path;
        PostParameters body;
        map<string, string> queryStringParameters = {};
        map<string, string> headers = {};
        optional<int> port = {};
        optional<unsigned> timeoutSeconds = CscHttpClientConfiguration::defaultTimeoutSecondsPost();
        std::optional<std::string> rawBinaryBody;
 
        int getPort() const {
            return port.value_or(protocol == "https" ? 443 : 80);
        }
    };
 
    struct HttpMultipartPost {
        std::string protocol;
        std::string host;
        std::string path;
        std::map<std::string, std::string> fields; // Ex. {{"key", "value"}}
        std::string fileFieldName; // Ex. "file"
        std::string fileName; // Ex. "image.jpg"
        std::string mimeType; // Ex. "image/jpeg"
        std::vector<uint8_t> fileContent; // Données de l'image en mémoire
        std::map<std::string, std::string> headers;
        int port = 80;
        int timeoutSeconds = 30;
    };
 
    inline PostParameters postBody(const map<string, string> &fromMap) {
        return fromMap;
    }
 
    class CscHttpClient {
    public:
        static CscHttpClient &Instance();
 
        ptr<HttpResponse> get(const HttpGet &parameters) const noexcept(false);
        ptr<HttpResponse> postMultipart(const HttpMultipartPost &parameters) const;
 
        ptr<HttpResponse> download(
            const HttpGet &parameters, const fs::path &outFilePath, optional<function<void(float progressRatio)>> onProgress = {}, optional<unsigned> timeoutSeconds = CscHttpClientConfiguration::defaultTimeoutSecondsDownload()) const noexcept(false);
 
        ptr<HttpResponse> upload(
            const string &protocol, const string &host, const string &path, int port, const fs::path &filePath) const noexcept(false);
 
        ptr<HttpResponse> upload(
            const string &protocol,
            const string &host,
            const string &path,
            int port,
            const std::vector<unsigned char> &dataBuffer,
            const std::string &contentType = "application/octet-stream") const;
            
        ptr<HttpResponse> post(const HttpPost &parameters) const noexcept(false);
 
    private:
        std::string generateBoundary() const;
        struct InternalRequestOptions {
        public:
            bool post = false;
            optional<fs::path> uploadedFilePath = {};
            map<string, string> headers;
            map<string, string> queryStringParameters;
            optional<PostParameters> postParameters = {};
            optional<fs::path> downloadedFilePath = {};
            optional<unsigned> timeoutSeconds = {};
            optional<function<void(float progressRatio)>> onProgress = {};
            std::optional<std::string> rawBody;
            InternalRequestOptions &setPost(bool post);
            InternalRequestOptions &setUploadedFilePath(const fs::path &uploadedFilePath);
            InternalRequestOptions &setDownloadedFilePath(const fs::path &downloadedFilePath);
            InternalRequestOptions &setHeaders(const map<string, string> &headers);
            InternalRequestOptions &setQueryStringParameters(const map<string, string> &parameters);
            InternalRequestOptions &setRawBody(const std::string &body);
            
            InternalRequestOptions &setPostParameters(PostParameters parameters);
            InternalRequestOptions &setTimeoutSeconds(const optional<unsigned> &timeoutSeconds);
            optional<string> getHeader(const string &name) const;
            InternalRequestOptions &setProgressCallback(const optional<function<void(float progressRatio)>> &onProgress);
        };
 
        InternalRequestOptions options() const;
 
        inline static std::mutex singletonMutex;
        inline static CscHttpClient *instance = nullptr;
 
        std::unique_ptr<CscLogger> logger;
 
        CscHttpClient();
 
        virtual ~CscHttpClient() = default;
 
        ptr<HttpResponse> performRequest(
            const string &protocol, const string &host, const string &path, int port, const InternalRequestOptions &options) const;
 
        void logRequest(string summary, const string &protocol, const string &host, const string &path, int port) const;
    };
 
}
 
#endif