myvtm/Other/libRestfulFunc/RestfulFunc.h

#ifndef _OTHER_RESFULFUNCEXPORT_HEADER_
#define _OTHER_RESFULFUNCEXPORT_HEADER_
#pragma once

#ifdef _WIN32
#ifdef RESTFULPUBLIC_EXPORTS
#ifndef RESTFULFUNC_API
#define RESTFULFUNC_API __declspec(dllexport)
#endif
#else
#ifndef RESTFULFUNC_API
#define RESTFULFUNC_API __declspec(dllimport)
#endif
#endif
#else
#if ( defined(__GNUC__) &&  __GNUC__ >= 4 )
#define RESTFULFUNC_API __attribute__((visibility("default")))
#else
#define RESTFULFUNC_API
#endif
#endif

#include <iostream>
#include <string>
#include <map>
#include <vector>

/*
* > 0 : 网站返回的错误码，比如 200，404 等
* -1：未归类，具体错误信息见 out_msg 返回的内容
* -2：超时
* -3：地址不符合规范
*/
RESTFULFUNC_API int HttpProbe(const std::string& url, std::string& out_msg, uint32_t wait_max_secs = (uint32_t)-1);

/*!
 * @brief Ping protocols
 * @param[in]
 * @param[out]
 * @return : 0: ping connect succ; 1: ping failed
 */
RESTFULFUNC_API int PingTest(const std::string& dst_ip);

RESTFULFUNC_API int SocketConnectTest(const std::string& addrIP, int nPort, std::string& out_msg);

enum HttpRequestMethod
{
    GET,
    POST,
    PUT,
    DEL,
    HEAD,
    OPTIONS,
    TRCE,
    CONNECT,
    MERGE,
    PATCH,
    UPLOAD,
    DOWNLOAD
};

enum HttpStatusCode : int
{
    Continue = 100,
    SwitchingProtocols = 101,
    OK = 200,
    Created = 201,
    Accepted = 202,
    NonAuthInfo = 203,
    NoContent = 204,
    ResetContent = 205,
    PartialContent = 206,
    MultiStatus = 207,
    AlreadyReported = 208,
    MultipleChoices = 300,
    MovedPermanently = 301,
    Found = 302,
    SeeOther = 303,
    NotModified = 304,
    UseProxy = 305,
    Forbidden = 403,
    NotFound = 404,
    ServiceUnavailable = 503
};


struct HttpClientResponseResult
{
    int statusCode;
    std::string content;

    HttpClientResponseResult() :statusCode(HttpStatusCode::NotFound), content("") {}

    /**  子类继承实现 */
    virtual bool ConsiderAsSucc() const
    {
        return (statusCode == HttpStatusCode::OK);
    }
};

struct HttpClientRequestConfig
{
    /*!
     * @brief
     * @param[in]  uri: 必须以 "http://" 或 "https://" 开头
     * @param[out] 
     * @return : 
     */
    HttpClientRequestConfig(const std::string& uri) 
        :mMethod(HttpRequestMethod::GET), mUri(uri), mToValidCert(false)
        , mBodyContent(""), mContentType(""), mHeaderAcceptType("application/json"), mTimeoutSecs(0)
    {
    }
    HttpClientRequestConfig(HttpRequestMethod method)
        : mMethod(method), mToValidCert(false), mBodyContent(""), mHeaderAcceptType("application/json")
        , mContentType(""), mTimeoutSecs(0)
    {
    }
    HttpClientRequestConfig(HttpRequestMethod method, const std::string& uri) 
        :mMethod(method), mUri(uri), mToValidCert(false), mBodyContent("")
        , mContentType(""), mHeaderAcceptType("application/json"), mTimeoutSecs(0)
    {
    }

    void SetRequestType(HttpRequestMethod method) { mMethod = method; }
    HttpRequestMethod GetRequestType() const { return mMethod; }

    // uri: 必须以 "http://" 或 "https://" 开头
    void SetUri(const std::string& uri) { mUri = uri; }
    void SetChildUri(const std::string& subUri) { mSubUri = subUri; }
    void AppendQuery(const std::string& name, const std::string& value) {
        mQueryPairs[name] = value;
    }

    std::string GetBaseUri() const { return mUri; }
    std::string GetSubUri() const { return mSubUri; }
    std::string GetRequestUri() const { return mUri + mSubUri; }

    void ResetQuery() { mQueryPairs.clear(); }
    const std::map<std::string, std::string>& GetQueryPairs() const { return mQueryPairs; }

    std::string GetAcceptType() const { return mHeaderAcceptType; }
    void SetAcceptType(const std::string& value) {
        mHeaderAcceptType = value;
    }

    bool NeedValidCert() const { return mToValidCert; }

    void SetJsonBody(const std::string& value) {
        SetBodyContent(value, "application/json");
    }

    void SetBodyContent(const std::string& value, const std::string& type) {
        mBodyContent = value;
        mContentType = type;
    }
    virtual std::string GetBodyContent() const { return mBodyContent; }
    virtual std::string GetContentType() const { return mContentType; }

    void SetTimeout(uint32_t timeoutSecs) { mTimeoutSecs = timeoutSecs; }
    uint32_t GetTimeout() const { return mTimeoutSecs; }

    virtual void PreDo() {}
    virtual void PostDo() {}

private:

    HttpRequestMethod mMethod;
    std::string mUri;
    std::string mSubUri;
    std::string mBodyContent;
    std::string mContentType;
    std::string mHeaderAcceptType;

    std::map<std::string, std::string> mQueryPairs;

    bool mToValidCert;
    uint32_t mTimeoutSecs;
};

struct HttpClientPostTypeRequest : public HttpClientRequestConfig
{
    HttpClientPostTypeRequest(const std::string& uri)
        :HttpClientRequestConfig(HttpRequestMethod::POST, uri) {}
};

struct HttpClientUploadRequest : public HttpClientRequestConfig
{
    HttpClientUploadRequest(const std::string& uri)
        :HttpClientRequestConfig(HttpRequestMethod::DOWNLOAD, uri)
    {
    }

    void ClearPararm() { mParams.clear(); }
    void AddParams(const std::string& name, const std::string& value)
    {
        mParams.push_back(std::move(std::pair<std::string, std::string>(name, value)));
    }
    void SetDefaultParam(const std::string& value)
    {
        AddParams("params", value);
    }

    void ClearFiles() { mFiles.clear(); }
    void AddFiles(const std::string& filePath)
    {
        mFiles.push_back(std::move(std::pair<std::string, std::string>("file_content", filePath)));
    }

    virtual void PreDo() 
    {
        auto p = BuildBodyContent();
        std::cout << p.second << std::endl;
        SetBodyContent(p.second, std::string("multipart/form-data; boundary=") + p.first);
    }

    std::pair<std::string, std::string> BuildBodyContent() const;

private:
    std::vector<std::pair<std::string, std::string> > mParams;
    std::vector<std::pair<std::string, std::string> > mFiles;
};

struct HttpClientDownloadRequest : public HttpClientRequestConfig
{
    HttpClientDownloadRequest(const std::string& uri) 
        :HttpClientRequestConfig(HttpRequestMethod::DOWNLOAD, uri) {
        SetAcceptType("*/*");
    }
};

class RESTFULFUNC_API RestfulClient
{

public:

    static RestfulClient& getInstance(); // Singleton
    ~RestfulClient();

    void Do(const HttpClientRequestConfig* const pRequestConfig, HttpClientResponseResult* pResponse) const;

private:
    RestfulClient();

private:

};

#endif //_OTHER_RESFULFUNCEXPORT_HEADER_