HttpRequest.h

Go to the documentation of this file.

 
#ifndef HTTPREQUEST_H
#define HTTPREQUEST_H
#pragma once
 
#include <string>
#include <map>
#include <iostream>
#include "network/Tcp.h"
#include "utility/utility.h"
#include "http/HttpResponse.h"
 
class Router; 
 
class HttpRequest
{
public:
    // ─────────────────────────────────────────────────────────────────────────────
    // Constructors
    // ─────────────────────────────────────────────────────────────────────────────
 
    HttpRequest(const char *rawHeaders, const std::string &reqMethod, const std::string &reqPath);
 
    // used by fluent builder - client side
    HttpRequest(const std::string &raw, const std::string &method, const std::string &path)
        : method(method), uri(path), path(path) {}
 
    // Server-side use — accepts Tcp* and parsed info
    HttpRequest(Tcp *connection, const std::string rawHeaders, const std::string &method, const std::string &path)
        : tcp(connection), method(method), uri(path), path(path)
    {
        parseHeaders(rawHeaders.c_str());
    }
 
    HttpRequest() = default;
    HttpRequest(const HttpRequest &) = default;
 
    // ─────────────────────────────────────────────────────────────────────────────
    // Store a CA Root Certificate
    // ─────────────────────────────────────────────────────────────────────────────
 
    HttpRequest &setRootCACertificate(const std::string &certData);
 
#if defined(PICO_HTTP_ENABLE_STORAGE)
    bool setRootCACertificateFromFile(const char *path);
#endif
 
    // ─────────────────────────────────────────────────────────────────────────────
    // Easy access methods for sending requests
    // ─────────────────────────────────────────────────────────────────────────────
 
    HttpResponse send();
 
    HttpResponse get();
    HttpResponse get(const std::string &url);
    HttpResponse post();
    HttpResponse post(const std::string &url, const std::string &body);
    HttpResponse put();
    HttpResponse put(const std::string &url, const std::string &body);
    HttpResponse del();
    HttpResponse del(const std::string &url);
 
    // ─────────────────────────────────────────────────────────────────────────────
    // Header Accessors
    // ─────────────────────────────────────────────────────────────────────────────
 
    std::string getHeader(const std::string &field) const
    {
        auto it = headers.find(toLower(field));
        return (it != headers.end()) ? it->second : "";
    }
 
    const std::map<std::string, std::string> &getHeaders() const
    {
        return headers;
    }
 
    void printHeaders() const
    {
        for (const auto &header : headers)
        {
            std::cout << header.first << ": " << header.second << std::endl;
        }
    }
 
    void setHeaderEnd(size_t end)
    {
        headerEnd = end;
    }
 
    size_t getHeaderEnd()
    {
        return headerEnd;
    }
 
    const std::string &getHost() const
    {
        return host;
    }
 
    const std::string &getProtocol() const
    {
        return protocol;
    }
 
    // ─────────────────────────────────────────────────────────────────────────────
    // Content Type / Body Type Checkers
    // ─────────────────────────────────────────────────────────────────────────────
 
    bool isFormUrlEncoded() const
    {
        auto it = headers.find("content-type");
        return it != headers.end() && it->second.find("application/x-www-form-urlencoded") != std::string::npos;
    }
 
    bool isJson() const
    {
        auto it = headers.find("content-type");
        return it != headers.end() && it->second.find("application/json") != std::string::npos;
    }
 
    const std::string getContentType() const
    {
        return getHeader("content-type");
    }
 
    const std::string getBoundary() const
    {
        auto contentType = getContentType();
        auto boundaryPos = contentType.find("boundary=");
        if (boundaryPos != std::string::npos)
        {
            return contentType.substr(boundaryPos + 9);
        }
        return "";
    }
 
    bool isMultipart() const
    {
        auto contentType = getHeader("content-type");
        return contentType.find("multipart/form-data") != std::string::npos;
    }
 
    // ─────────────────────────────────────────────────────────────────────────────
    // Body Accessors
    // ─────────────────────────────────────────────────────────────────────────────
 
    const std::string &getBody() const
    {
        return body;
    }
 
    bool isBodyTruncated() const { return bodyTruncated; }
    void markBodyTruncated() { bodyTruncated = true; }
 
    HttpRequest &setBody(const std::string &body); // Enables chaining
 
    HttpRequest& setJson(const nlohmann::json &json);
 
    HttpRequest& setJson(const std::string &json); 
 
    int getContentLength() const
    {
        std::string content_length_str = getHeader("content-length");
        int contentLength = 0;
        if (!content_length_str.empty())
        {
            contentLength = std::stoi(content_length_str);
        }
        return contentLength;
    }
 
    inline nlohmann::json json() const
    {
        return nlohmann::json::parse(getBody(), nullptr, false);
    }
 
    // ─────────────────────────────────────────────────────────────────────────────
    // Method / URL / Path Accessors
    // ─────────────────────────────────────────────────────────────────────────────
 
    HttpRequest &setMethod(const std::string &method)
    {
        this->method = method;
        return *this;
    }
 
    HttpRequest &setPath(const std::string &path)
    {
        this->path = path;
        return *this;
    }
 
    const std::string &getMethod() const
    {
        return method;
    }
 
    const std::string &getPath() const
    {
        return path;
    }
 
    const std::string &getUri() const
    {
        return uri;
    }
 
    const std::string &getQuery() const
    {
        return query;
    }
 
    // ─────────────────────────────────────────────────────────────────────────────
    // Tcp accessors
    // ─────────────────────────────────────────────────────────────────────────────
 
    Tcp *getTcp() const
    {
        return tcp;
    }
 
    // ─────────────────────────────────────────────────────────────────────────────
    // Cookie and Parameter Access
    // ─────────────────────────────────────────────────────────────────────────────
 
    const std::unordered_map<std::string, std::string> getCookies() const;
 
    const std::string getCookie(const std::string &name) const;
 
    const std::unordered_multimap<std::string, std::string> getQueryParams();
 
    const std::unordered_multimap<std::string, std::string> getFormParams();
 
    // ─────────────────────────────────────────────────────────────────────────────
    // Socket-Based Helpers (Static)
    // ─────────────────────────────────────────────────────────────────────────────
 
    static HttpRequest receive(Tcp *tcp);
 
    
    
    static std::optional<std::pair<std::string, std::string>> receiveUntilHeadersComplete(Tcp* conn);
    bool appendRemainingBody(int expectedLength);
 
 
 
 
 
    static bool getMethodAndPath(const std::string& data, std::string& method, std::string& path);
 
    // ─────────────────────────────────────────────────────────────────────────────
    // Multipart Upload Handling
    // ─────────────────────────────────────────────────────────────────────────────
 
    int handle_multipart(HttpResponse &res);
    // ─────────────────────────────────────────────────────────────────────────────
    // Fluent Builder Methods (Client Usage)
    // ─────────────────────────────────────────────────────────────────────────────
 
    static HttpRequest create(); // static builder factory
    HttpRequest &setUri(const std::string &uri);
    HttpRequest &setHost(const std::string &host);
    HttpRequest &setProtocol(const std::string &protocol);
    HttpRequest &setHeaders(const std::map<std::string, std::string> &headers);
    HttpRequest &setHeader(const std::string &key, const std::string &value);
    HttpRequest &setUserAgent(const std::string &userAgent);
    HttpRequest &setAcceptEncoding(const std::string &encoding);
 
    // ─────────────────────────────────────────────────────────────────────────────
    // toFile: Save the request body to a file
    // ─────────────────────────────────────────────────────────────────────────────
 
    HttpRequest &toFile(const std::string &path);
    std::string getOutputFilePath() const;
    bool wantsToFile() const;
 
    // ─────────────────────────────────────────────────────────────────────────────
    // Root CA Certificate Access
    // ─────────────────────────────────────────────────────────────────────────────
    const std::string &getRootCACertificate() const
    {
        return rootCACertificate;
    }
 
#if defined(PICO_HTTP_ENABLE_STORAGE)
    HttpRequest &setBodyFromFile(const std::string &path);
#endif
 
private:
    void parseHeaders(const char *raw);
    void appendToBody(const char *data, size_t len);
 
    void setQueryString(const std::string &query)
    {
        this->query = query;
    }
 
    Tcp *tcp = nullptr;
 
    std::string clientIp;
    std::string method;
    std::string uri;
    std::string path;
    std::string query;
    std::string host;
    std::string protocol;
    std::map<std::string, std::string> headers; // optional
    std::string body;
    std::string rootCACertificate;
    size_t headerEnd = 0;
    bool bodyTruncated = false;
    std::string outputFilePath;
};
 
#endif // HTTPREQUEST_H