HTTPBuilder.h

Go to the documentation of this file.

#pragma once
 
#include <string>
#include <stdexcept>
#include <format>
#include <concepts>
 
#include "HTTPUtility.h"
#include "CheckAtCompileTime.h"
#include "JSONBuilder.h"
 
namespace web
{
    class HTTP_API HTTPBuilder
    {
    private:
        std::string method;
        std::string _parameters;
        std::string _responseCode;
        std::string _headers;
        std::string _HTTPVersion;
        std::vector<std::string> _chunks;
        bool _partialChunks;
 
    public:
        static std::string getChunks(const std::vector<std::string>& chunks, bool partialChunks, bool preCalculateSize = false);
 
        static std::string getChunk(std::string_view chunk);
 
    public:
        HTTPBuilder(std::string_view fullHTTPVersion = "HTTP/1.1");
 
        HTTPBuilder(const HTTPBuilder& other) = default;
 
        HTTPBuilder(HTTPBuilder&& other) noexcept = default;
 
        HTTPBuilder& operator = (const HTTPBuilder& other) = default;
 
        HTTPBuilder& operator = (HTTPBuilder&& other) noexcept = default;
 
        HTTPBuilder& getRequest();
 
        HTTPBuilder& postRequest();
 
        HTTPBuilder& putRequest();
 
        HTTPBuilder& headRequest();
 
        HTTPBuilder& optionsRequest();
 
        HTTPBuilder& deleteRequest();
 
        HTTPBuilder& connectRequest();
 
        HTTPBuilder& traceRequest();
 
        HTTPBuilder& patchRequest();
 
        template<typename StringT, typename T, typename... Args>
        HTTPBuilder& queryParameters(StringT&& name, T&& value, Args&&... args);
 
        template<typename... Args>
        HTTPBuilder& parametersWithRoute(std::string_view route, Args&&... args);
 
        HTTPBuilder& parameters(std::string_view parameters);
 
        HTTPBuilder& responseCode(ResponseCodes code);
 
        HTTPBuilder& responseCode(int code, std::string_view responseMessage);
 
        HTTPBuilder& HTTPVersion(std::string_view httpVersion);
 
        template<typename StringT, typename T, typename... Args>
        HTTPBuilder& headers(StringT&& name, T&& value, Args&&... args);
 
        HTTPBuilder& chunks(const std::vector<std::string>& chunks);
 
        HTTPBuilder& chunks(std::vector<std::string>&& chunks);
 
        HTTPBuilder& chunk(std::string_view chunk);
 
        std::string build(std::string_view data = "", const std::unordered_map<std::string, std::string>& additionalHeaders = {}) const;
 
        std::string build(const json::JSONBuilder& builder, std::unordered_map<std::string, std::string> additionalHeaders = {}) const;
 
        std::string build(const std::unordered_map<std::string, std::string>& urlEncoded, std::unordered_map<std::string, std::string> additionalHeaders = {}) const;
 
        HTTPBuilder& clear();
 
        HTTPBuilder& partialChunks();
 
        friend HTTP_API std::ostream& operator << (std::ostream& outputStream, const HTTPBuilder& builder);
 
        ~HTTPBuilder() = default;
    };
 
    template<typename StringT, typename T, typename... Args>
    HTTPBuilder& HTTPBuilder::queryParameters(StringT&& name, T&& value, Args&&... args)
    {
        static_assert(std::is_convertible_v<decltype(name), std::string_view>, "Wrong StringT type");
 
        if (_parameters.empty())
        {
            _parameters = "/?";
        }
 
        if constexpr (std::is_arithmetic_v<T>)
        {
            _parameters += std::format("{}={}&", web::encodeUrl(static_cast<std::string_view>(name)), std::to_string(value));
        }
        else if constexpr (std::is_convertible_v<decltype(value), std::string_view>)
        {
            _parameters += std::format("{}={}&", web::encodeUrl(static_cast<std::string_view>(name)), web::encodeUrl(static_cast<std::string_view>(value)));
        }
        else if constexpr (std::is_convertible_v<decltype(value), std::string>)
        {
            _parameters += std::format("{}={}&", web::encodeUrl(static_cast<std::string_view>(name)), web::encodeUrl(static_cast<std::string>(value)));
        }
        else
        {
            throw std::logic_error("Bad type of T, it must be converted to string or arithmetic type");
        }
 
        if constexpr (requires { std::invocable<decltype(&HTTPBuilder::queryParameters<Args...>), decltype(this), Args...>; })
        {
            return this->queryParameters(std::forward<Args>(args)...);
        }
 
        _parameters.pop_back(); // remove '&'
 
        return *this;
    }
 
    template<typename... Args>
    HTTPBuilder& HTTPBuilder::parametersWithRoute(std::string_view route, Args&&... args)
    {
        if (route.starts_with('/'))
        {
            _parameters = route;
        }
        else
        {
            _parameters = "/";
 
            _parameters += route;
        }
 
        if (!route.ends_with('?'))
        {
            _parameters += '?';
        }
 
        return this->queryParameters(std::forward<Args>(args)...);
    }
 
    template<typename StringT, typename T, typename... Args>
    HTTPBuilder& HTTPBuilder::headers(StringT&& name, T&& value, Args&&... args)
    {
        if constexpr (::utility::StringConversion<StringT>::value)
        {
            if constexpr (sizeof...(args))
            {
                if (static_cast<std::string>(name) == "Content-Length" || static_cast<std::string>(name) == "content-length")
                {
                    return headers(std::forward<Args>(args)...);
                }
            }
 
            if constexpr (std::is_arithmetic_v<std::remove_reference_t<T>>)
            {
                _headers += static_cast<std::string>(name) + std::string(": ") + std::to_string(value) + std::string("\r\n");
            }
            else if constexpr (::utility::StringConversion<std::remove_reference_t<T>>::value)
            {
                _headers += static_cast<std::string>(name) + std::string(": ") + static_cast<std::string>(value) + std::string("\r\n");
            }
            else if constexpr (::utility::checkBegin<T>::value && ::utility::checkEnd<T>::value)
            {
                _headers += static_cast<std::string>(name) + std::string(": ");
 
                auto checkValueType = *std::begin(value);
 
                if constexpr (std::is_arithmetic_v<decltype(checkValueType)>)
                {
                    for (auto&& i : value)
                    {
                        _headers += std::to_string(i) + std::string(", ");
                    }
 
                    _headers.pop_back();    // delete space
                    _headers.pop_back();    // delete ;
 
                    _headers.insert(_headers.size(), "\r\n");
                }
                else if constexpr (::utility::StringConversion<decltype(checkValueType)>::value)
                {
                    for (auto&& i : value)
                    {
                        _headers += static_cast<std::string>(i) + std::string(", ");
                    }
 
                    _headers.pop_back();    // delete space
                    _headers.pop_back();    // delete ;
 
                    _headers.insert(_headers.size(), "\r\n");
                }
                else
                {
                    throw std::logic_error("Bad type of values in class T, it must be converted to string or arithmetic type");
                }
            }
            else
            {
                throw std::logic_error("Bad type of T, it must be converted to string or arithmetic type");
            }
        }
        else
        {
            throw std::logic_error("Bad type of StringT, it must be converted to string");
        }
 
        if constexpr (sizeof...(args))
        {
            return headers(std::forward<Args>(args)...);
        }
 
        return *this;
    }
}