HttpRequest.h

Go to the documentation of this file.

/****
 * Sming Framework Project - Open Source framework for high efficiency native ESP8266 development.
 * Created 2015 by Skurydin Alexey
 * http://github.com/SmingHub/Sming
 * All files of the Sming Core are provided under the LGPL v3 license.
 *
 * HttpRequest.h
 *
 * @author: 2017 - Slavey Karadzhov <slav@attachix.com>
 *
 ****/
 
#pragma once
 
#include "HttpCommon.h"
#ifdef ENABLE_HTTP_REQUEST_AUTH
#include "HttpRequestAuth.h"
#endif
#include "../TcpConnection.h"
#include "Data/Stream/DataSourceStream.h"
#include "HttpHeaders.h"
#include "HttpParams.h"
#include "Data/ObjectMap.h"
 
class HttpConnection;
 
using RequestHeadersCompletedDelegate = Delegate<int(HttpConnection& client, HttpResponse& response)>;
using RequestBodyDelegate = Delegate<int(HttpConnection& client, const char* at, size_t length)>;
using RequestCompletedDelegate = Delegate<int(HttpConnection& client, bool successful)>;
 
class HttpRequest
{
    friend class HttpClientConnection;
    friend class HttpServerConnection;
 
public:
    HttpRequest() = default;
 
    HttpRequest(const Url& uri) : uri(uri)
    {
    }
 
    HttpRequest(const HttpRequest& value)
        : uri(value.uri), method(value.method), headers(value.headers), postParams(value.postParams),
          headersCompletedDelegate(value.headersCompletedDelegate), requestBodyDelegate(value.requestBodyDelegate),
          requestCompletedDelegate(value.requestCompletedDelegate), sslInitDelegate(value.sslInitDelegate)
    {
    }
 
    HttpRequest* clone() const
    {
        return new HttpRequest(*this);
    }
 
    ~HttpRequest()
    {
        reset();
    }
 
    HttpRequest* setURL(const Url& uri)
    {
        this->uri = uri;
        return this;
    }
 
    HttpRequest* setMethod(HttpMethod method)
    {
        this->method = method;
        return this;
    }
 
    HttpRequest* setHeaders(const HttpHeaders& headers)
    {
        this->headers.setMultiple(headers);
        return this;
    }
 
    HttpRequest* setHeader(const String& name, const String& value)
    {
        headers[name] = value;
        return this;
    }
 
    HttpRequest* setPostParameter(const String& name, const String& value)
    {
        postParams[name] = value;
        return this;
    }
 
    HttpRequest* setFile(const String& formElementName, ReadWriteStream* stream)
    {
        if(stream != nullptr) {
            files[formElementName] = stream;
        }
        return this;
    }
 
#ifdef ENABLE_HTTP_REQUEST_AUTH
    // Authentication adapters set here
    HttpRequest* setAuth(AuthAdapter* adapter)
    {
        adapter->setRequest(this);
        auth = adapter;
        return this;
    }
#endif
 
    const String& getHeader(const String& name)
    {
        return static_cast<const HttpHeaders&>(headers)[name];
    }
 
    const String& getPostParameter(const String& name)
    {
        return static_cast<const HttpParams&>(postParams)[name];
    }
 
    String getQueryParameter(const String& name, const String& defaultValue = nullptr) const
    {
        return uri.getQueryParameter(name, defaultValue);
    }
 
    String getBody()
    {
        String s;
        if(bodyStream != nullptr) {
            bodyStream->moveString(s);
        }
        return s;
    }
 
    IDataSourceStream* getBodyStream()
    {
        return bodyStream;
    }
 
    HttpRequest* setBody(const String& body)
    {
        return setBody(reinterpret_cast<const uint8_t*>(body.c_str()), body.length());
    }
 
    HttpRequest* setBody(String&& body) noexcept;
 
    HttpRequest* setBody(IDataSourceStream* stream);
 
    HttpRequest* setBody(const uint8_t* rawData, size_t length);
 
    HttpRequest* setResponseStream(ReadWriteStream* stream);
 
    ReadWriteStream* getResponseStream()
    {
        return responseStream;
    }
 
    HttpRequest* onHeadersComplete(RequestHeadersCompletedDelegate delegateFunction)
    {
        headersCompletedDelegate = delegateFunction;
        return this;
    }
 
    HttpRequest* onBody(RequestBodyDelegate delegateFunction)
    {
        requestBodyDelegate = delegateFunction;
        return this;
    }
 
    HttpRequest* onRequestComplete(RequestCompletedDelegate delegateFunction)
    {
        requestCompletedDelegate = delegateFunction;
        return this;
    }
 
    void reset();
 
    using SslInitDelegate = Delegate<void(Ssl::Session& session, HttpRequest& request)>;
 
    HttpRequest* onSslInit(SslInitDelegate delegate)
    {
        sslInitDelegate = delegate;
        return this;
    }
 
    String toString() const;
 
    static String toString(const HttpRequest& req)
    {
        return req.toString();
    }
 
public:
    Url uri;                      
    HttpMethod method = HTTP_GET; 
    HttpHeaders headers;          
    HttpParams postParams;        
    HttpFiles files;              
 
    int retries = 0; 
 
    void* args = nullptr; 
 
protected:
    RequestHeadersCompletedDelegate headersCompletedDelegate;
    RequestBodyDelegate requestBodyDelegate;
    RequestCompletedDelegate requestCompletedDelegate;
    SslInitDelegate sslInitDelegate;
 
    IDataSourceStream* bodyStream = nullptr;
    ReadWriteStream* responseStream = nullptr; 
 
#ifdef ENABLE_HTTP_REQUEST_AUTH
    AuthAdapter* auth = nullptr;
#endif
 
private:
    HttpParams* queryParams = nullptr; // << @todo deprecate
};
 
inline String toString(const HttpRequest& req)
{
    return req.toString();
}