dl_http.h

浏览该文件的文档.

#pragma once
 
#include <functional>
#include <string>
 
#include "io/dl_log.h"
#include "memory/dl_buffer.h"
#include "io/dl_json.h"
 
namespace dl
{
class Http
{
public:
    class Request
    {
    public:
        using FnCallback = std::function<void(void)>;
        enum class Type
        {
            GET,
            POST
        };
        void SetUrl(std::string_view url) { _url = url; }
        void SetType(Type type)
        {
            _type = type;
            if (_type != Type::POST
                && !_bufSend.empty())
            {
                log_err("附加数据必须是POST类型！");
                return;
            }
        }
        void SetDataSend(BufferView buf)
        {
            if (_type != Type::POST)
            {
                log_err("附加数据必须是POST类型！");
                return;
            }
            _bufSend = CreateBuffer(buf);
        }
        void SetDataSend(std::string_view str)
        {
            SetDataSend(CreateBufferView(str));
        }
        void SetDataSend(const json& j)
        {
            SetDataSend(CreateBufferView(j.dump()));
        }
        void SetHeader(const std::vector<std::string>& vec_header)
        {
            _vecHeader = vec_header;
        }
        std::vector<std::string> GetHeader() { return _vecHeader; }
        BufferView GetDataSend() { return _bufSend; }
 
        FnCallback GetCb() { return _fnCb; }
        std::string GetUrl() { return _url; }
 
        BufferView GetDataRecv() { return _bufRecv; }
        Buffer& GetDataRecvRef() { return _bufRecv; }
 
        Type GetType() { return _type; }
 
        Request() :
            _type{ Type::GET }
        {
 
        }
    private:
        Type _type;
        FnCallback _fnCb;
        std::string _url;
        std::vector<std::string> _vecHeader;
        Buffer _bufRecv;
        Buffer _bufSend;
    };
    Http();
    ~Http();
    bool SendRequest(Request& request);

    Buffer ExDownload(std::string_view url)
    {
        Request req;
        req.SetType(Request::Type::GET);
        req.SetUrl(url);
 
        if (!SendRequest(req))
            return {};
        return CreateBuffer(req.GetDataRecv());
    }
 
    void SetCACertPath(std::string_view str)
    {
        _pathCACert = str;
    }
    void SetShowResultLog(bool show) { _bShowResultLog = show; }
    // 辅助解析类
    struct RecvData
    {
        int _code;
        std::string _msg;
        json _data;
 
        RecvData(BufferView buf)
        {
            json j = dl::Json::Parse(buf);
            dl::Json::Get(j, "Code", _code);
            dl::Json::Get(j, "Msg", _msg);
            dl::Json::Get(j, "Data", _data);
        }
 
        bool Check(int code = 0)
        {
            if (_code != code)
            {
                log_warn("{}", DumpError());
                return false;
            }
            return true;
        }
 
        std::string DumpError()
        {
            std::string d;
            if (_data.is_string())
                d = _data;
            else
                d = _data.dump();
            return fmt::format("{}，{}({})", _msg, d, _code);
        }
    };
private:
    std::string _pathCACert; // 证书路径
    bool _bShowResultLog;
};
extern Http* g_http;
}