HTTPRequest.h

#pragma once
 
#include "Import/WebFrameworkCore.h"
 
#include "BaseTCPServer.h"
#include "HTTPParser.h"
#include "MultiLocalizationManager.h"
#include "Log.h"
 
#include "Managers/SessionsManager.h"
#include "SQLite3/SQLiteManager.h"
#include "Interfaces/IStaticFile.h"
#include "Interfaces/IDynamicFile.h"
#include "Utility/ChunkGenerator.h"
#include "Utility/WebFrameworkConcepts.h"
 
namespace framework
{
    class WEB_FRAMEWORK_API HTTPRequest
    {
    private:
        SessionsManager& session;
        const web::BaseTCPServer& serverReference;
        streams::IOSocketStream& stream;
        sqlite::SQLiteManager& database;
        std::unordered_map<std::string, std::variant<std::string, int64_t, double>> routeParameters;
        sockaddr clientAddr;
        web::HTTPParser parser;
        interfaces::IStaticFile& staticResources;
        interfaces::IDynamicFile& dynamicResources;
 
    private:
        static bool isWebFrameworkDynamicPages(const std::string& filePath);
 
    public:
        static web::HTTPParser sendRequestToAnotherServer(std::string_view ip, std::string_view port, std::string_view request, DWORD timeout = 30'000, bool useHTTPS = false);
 
    public:
        HTTPRequest(SessionsManager& session, const web::BaseTCPServer& serverReference, interfaces::IStaticFile& staticResources, interfaces::IDynamicFile& dynamicResources, sqlite::SQLiteManager& database, sockaddr clientAddr, streams::IOSocketStream& stream);
 
        HTTPRequest(HTTPRequest&&) noexcept = default;
 
        HTTPRequest(const HTTPRequest&) = default;
 
        HTTPRequest& operator =(HTTPRequest&&) noexcept = default;
 
        HTTPRequest& operator =(const HTTPRequest&) = default;
 
        const std::string& getRawParameters() const;
 
        const std::string& getMethod() const;
 
        const std::unordered_map<std::string, std::string>& getKeyValueParameters() const;
 
        std::string getHTTPVersion() const;
 
        const web::HeadersMap& getHeaders() const;
 
        const std::string& getBody() const;
 
        void setAttribute(const std::string& name, const std::string& value);
 
        std::string getAttribute(const std::string& name);
 
        void deleteSession();
 
        void deleteAttribute(const std::string& name);
 
        web::HeadersMap getCookies() const;
 
        void sendAssetFile(const std::string& filePath, HTTPResponse& response, const std::unordered_map<std::string, std::string>& variables = {}, bool isBinary = true, const std::string& fileName = "");
 
        void sendStaticFile(const std::string& filePath, HTTPResponse& response, bool isBinary = true, const std::string& fileName = "");
 
        void sendDynamicFile(const std::string& filePath, HTTPResponse& response, const std::unordered_map<std::string, std::string>& variables, bool isBinary = false, const std::string& fileName = "");
 
        void streamFile(std::string_view filePath, HTTPResponse& response, std::string_view fileName, size_t chunkSize = defaultChunkSize);
 
        void registerDynamicFunction(const std::string& functionName, std::function<std::string(const std::vector<std::string>&)>&& function);
 
        void unregisterDynamicFunction(const std::string& functionName);
 
        bool isDynamicFunctionRegistered(const std::string& functionName);
 
        const json::JSONParser& getJSON() const;
 
        const std::vector<std::string>& getChunks() const;
 
        const web::HTTPParser& getParser() const;
 
        std::string getClientIpV4() const;
 
        std::string getServerIpV4() const;
 
        uint16_t getClientPort() const;
 
        uint16_t getServerPort() const;
 
        template<utility::concepts::RouteParameterType T>
        const T& getRouteParameter(const std::string& routeParameterName);
 
        template<std::derived_from<sqlite::SQLiteDatabaseModel> T, typename... Args>
        std::shared_ptr<T> createModel(Args&&... args);
 
        template<std::derived_from<sqlite::SQLiteDatabaseModel> T>
        std::shared_ptr<T> getModel() const;
 
        template<std::derived_from<utility::ChunkGenerator> T, typename... Args>
        void sendChunks(HTTPResponse& response, Args&&... args);
 
        template<std::derived_from<utility::ChunkGenerator> T, typename... Args>
        void sendFileChunks(HTTPResponse& response, std::string_view fileName, Args&&... args);
 
        friend streams::IOSocketStream& operator >> (streams::IOSocketStream& stream, HTTPRequest& request);
 
        friend std::ostream& operator << (std::ostream& stream, const HTTPRequest& request);
 
        friend class ExecutorsManager;
 
        ~HTTPRequest() = default;
    };
 
    template<std::derived_from<sqlite::SQLiteDatabaseModel> T, typename... Args>
    std::shared_ptr<T> HTTPRequest::createModel(Args&&... args)
    {
        return database.add<T>(std::forward<Args>(args)...);
    }
 
    template<std::derived_from<sqlite::SQLiteDatabaseModel> T>
    std::shared_ptr<T> HTTPRequest::getModel() const
    {
        std::shared_ptr<T> result = database.get<T>();
 
        if constexpr (std::is_default_constructible_v<T>)
        {
            if (!result)
            {
                result = database.add<T>();
            }
        }
        else if (!result)
        {
            if (Log::isValid())
            {
                Log::error("Can't get or create model in HTTPRequest::getModel<T> function where T is {}", "LogWebFrameworkModels", typeid(T).name());
            }
        }
 
        return result;
    }
 
    template<std::derived_from<utility::ChunkGenerator> T, typename... Args>
    void HTTPRequest::sendChunks(HTTPResponse& response, Args&&... args)
    {
        this->sendFileChunks<T>(response, "", std::forward<Args>(args)...);
    }
 
    template<std::derived_from<utility::ChunkGenerator> T, typename... Args>
    void HTTPRequest::sendFileChunks(HTTPResponse& response, std::string_view fileName, Args&&... args)
    {
        T generator(std::forward<Args>(args)...);
 
        web::HTTPBuilder builder = web::HTTPBuilder().chunk(generator.generate()).partialChunks().responseCode(web::responseCodes::ok).headers
        (
            "Date", HTTPResponse::getFullDate(),
            "Server", "WebFramework-Server",
            "Connection", "keep-alive"
        );
 
        if (fileName.size())
        {
            builder.headers
            (
                "Content-Disposition", std::format(R"(attachment; filename="{}")", fileName)
            );
        }
 
        stream << builder.build();
 
        response.setIsValid(false);
 
        while (true)
        {
            std::string data = generator.generate();
 
            stream << web::HTTPBuilder::getChunk(data);
 
            if (stream.eof() || data.empty())
            {
                break;
            }
        }
    }
}