HttpResponse.h

Go to the documentation of this file.

 
#ifndef HTTPRESPONSE_H
#define HTTPRESPONSE_H
 
#include <string>
#include <unordered_map>
#include <map>
#include <vector>
#include <nlohmann/json.hpp>
#include "network/Tcp.h"
#include "storage/StorageManager.h"
#include "framework/FrameworkView.h"
 
// Forward declaration of HttpRequest class
class HttpRequest;
 
class HttpResponse
{
 
public:
    HttpResponse() = default;
 
    HttpResponse(Tcp *tcp);
 
    Tcp *getTcp() const { return tcp; }
 
    // ------------------------------------------------------------------------
    // Status and Header Management
    // ------------------------------------------------------------------------
 
    HttpResponse &status(int code);
 
    HttpResponse &setStatus(int code);
 
    HttpResponse &setBody(const std::string &body);
 
    HttpResponse &setContentType(const std::string &content_type);
 
    std::string getContentType() const;
 
    HttpResponse &set(const std::string &field, const std::string &value);
 
    HttpResponse &setHeader(const std::string &key, const std::string &value);
 
    HttpResponse &setAuthorization(const std::string &jwtToken);
 
    bool isHeaderSent() const;
 
    // ------------------------------------------------------------------------
    // Cookie Support
    // ------------------------------------------------------------------------
 
    HttpResponse &setCookie(const std::string &name, const std::string &value, const std::string &options);
 
    HttpResponse &clearCookie(const std::string &name, const std::string &options);
 
    // ------------------------------------------------------------------------
    // Body and Streaming
    // ------------------------------------------------------------------------
 
    void send(const std::string &body);
 
    void send(){
        send("");  // delegate to the existing one-arg version with empty body
    }
    
    void send(std::nullptr_t) = delete; // prevent sending null
 
    void send(const FrameworkView& view) {
        send(view, {});  // delegate to the existing two-arg version with empty context
    }
 
    void send(const std::string &body, const std::string &contentType);
 
    #include "framework/FrameworkView.h"
 
    void send(const FrameworkView& view,
                        const std::map<std::string, std::string>& context);
 
    void sendHeaders();
 
    void start(int code, size_t contentLength, const std::string &contentType = "application/octet-stream",
               const std::string &contentEncoding = "");
 
    void writeChunk(const char *data, size_t length);
 
    void finish();
 
    // ------------------------------------------------------------------------
    // Common Helpers
    // ------------------------------------------------------------------------
    bool ok() const
    {
        return status_code >= 200 && status_code < 300;
    }
 
    int getSocket() const;
 
    void sendUnauthorized();
 
    void sendNotFound();
 
    void endServerError(const std::string &msg);
 
    HttpResponse &json(const std::string &jsonString);
    HttpResponse &json(const nlohmann::json &jsonObj);
    HttpResponse &jsonFormatted(const nlohmann::json &jsonObj);
 
    HttpResponse &text(const std::string &textString);
 
    HttpResponse &redirect(const std::string &url, int statusCode);
 
    bool sendFile(const std::string &path);
 
#if defined(PICO_HTTP_ENABLE_STORAGE)
    bool saveFile(const char *path) const;
#endif
 
    std::string renderTemplate(const std::string &tpl, const std::map<std::string, std::string> &context);
 
    // ───── Shared Response API (Client and Server) ─────
 
    int getStatusCode() const
    {
        return status_code;
    }
 
    std::string getHeader(const std::string &key) const
    {
        auto it = headers.find(key);
        return (it != headers.end()) ? it->second : "";
    }
 
    const std::map<std::string, std::string> &getHeaders() const
    {
        return headers;
    }
 
    const std::string &getBody() const
    {
        return body;
    }
 
    void reset();
 
    bool isBodyTruncated() const { return bodyTruncated; }
 
    void markBodyTruncated() { bodyTruncated = true; }
 
    // Convenience wrappers enabling fluent chaining
    HttpResponse& sendSuccess(const nlohmann::json& data = {}, const std::string& message = "");
    HttpResponse& sendCreated(const nlohmann::json& data = {}, const std::string& message = "");
    HttpResponse& sendMessage(const std::string& message);
    HttpResponse& sendNoContent();
    HttpResponse& sendError(int statusCode, const std::string& code, const std::string& message);
    HttpResponse& sendError(int statusCode, const std::string& message);  // simpler form
 
    //#if defined(PICO_HTTP_ENABLE_STORAGE)
    HttpResponse& toFile(const std::string& path, StorageManager* storage);
    //#endif
 
private:
    std::string getStatusMessage(int code);
 
    Tcp *tcp;                
    int status_code = 200;   
    bool headerSent = false; 
    bool bodyTruncated = false;
 
    std::map<std::string, std::string> headers; 
    std::vector<std::string> cookies;           
 
    std::string body; 
 
};
 
#endif // HTTPRESPONSE_H