request.hpp

#pragma once
 
#include "cookie.hpp"
#include "types.hpp"
 
#include <boost/beast/http/string_body.hpp>
 
#include <unordered_map>
 
namespace malloy::http
{

    template<typename Body = boost::beast::http::string_body>
    class request :
        public boost::beast::http::request<Body>
    {
        using msg_t = boost::beast::http::request<Body>;
 
    public:
        request() = default;

        request(http::method method_, std::string_view host, const std::uint16_t port, std::string_view target_) :
            m_port(port)
        {
            msg_t::version(11);
            msg_t::method(method_);
            msg_t::target(target_);
            msg_t::set(http::field::host, host);
        }

        explicit
        request(msg_t&& raw)
        {
            using namespace boost::beast::http;
 
            // Underlying
            msg_t::operator=(std::move(raw));
 
            // Cookies
            {
                const auto& [begin, end] = msg_t::base().equal_range(field::cookie);
                for (auto it = begin; it != end; it++) {
                    const auto &str = it->value();
 
                    const auto &sep_pos = it->value().find('=');
                    if (sep_pos == std::string::npos)
                        continue;
 
                    std::string key{str.substr(0, sep_pos)};
                    std::string value{str.substr(sep_pos + 1)};
                    m_cookies.insert_or_assign(std::move(key), std::move(value));
                }
            }
        }

        request(const request& other) = default;

        request(request&& other) noexcept = default;

        virtual
        ~request() = default;

        request&
        operator=(const request& rhs) = default;

        request&
        operator=(request&& rhs) noexcept = default;

        constexpr
        void
        use_tls(const bool enabled) noexcept
        {
            m_use_tls = enabled;
        }

        [[nodiscard]]
        constexpr
        bool
        use_tls() const noexcept
        {
            return m_use_tls;
        }

        [[nodiscard]]
        constexpr
        std::uint16_t
        port() const noexcept
        {
            return m_port;
        }

        [[nodiscard]]
        std::unordered_map<std::string, std::string>
        cookies() const noexcept
        {
            return m_cookies;
        }

        [[nodiscard]]
        bool
        has_cookie(const std::string& name) const
        {
            return m_cookies.contains(name);
        }

        [[nodiscard]]
        std::string_view
        cookie(const std::string_view& name) const
        {
            const auto& it = std::find_if(
                std::cbegin(m_cookies),
                std::cend(m_cookies),
                [&name](const auto& pair) {
                    return pair.first == name;
                }
            );
 
            if (it == std::cend(m_cookies))
                return { };
 
            return it->second;
        }
 
    private:
        bool m_use_tls = false;
        std::uint16_t m_port = 0;
        std::unordered_map<std::string, std::string> m_cookies;
    };
}
 
#include <sstream>
 
namespace malloy
{
 
    template<typename Body>
    [[nodiscard]]
    std::string
    to_string(const http::request<Body>& r)
    {
        std::ostringstream ss;
        ss << r;
 
        return ss.str();
    }
 
}