update

src/FluApp.cpp

@@ -30,7 +30,6 @@ FluApp::~FluApp(){
 
 void FluApp::init(QQuickWindow *window){
     this->appWindow = window;
-    FluContentDialogType::ButtonFlag::NegativeButton;
 }
 
 void FluApp::run(){

src/FluApp.h

@@ -9,6 +9,7 @@
 #include <QJsonObject>
 #include <QQmlEngine>
 #include "FluRegister.h"
+#include "FluHttpInterceptor.h"
 #include "stdafx.h"
 
 /**
@@ -27,6 +28,11 @@ class FluApp : public QObject
      */
     Q_PROPERTY_AUTO(QJsonObject,routes);
 
+    /**
+     * @brief http拦截器
+     */
+    Q_PROPERTY_AUTO(FluHttpInterceptor*,httpInterceptor);
+
     QML_NAMED_ELEMENT(FluApp)
     QML_SINGLETON
 private:

src/FluHttp.cpp

@@ -0,0 +1,137 @@
+#include "FluHttp.h"
+
+#include <QThreadPool>
+#include "HttpClient.h"
+#include "FluApp.h"
+
+using namespace  AeaQt;
+
+FluHttp::FluHttp(QObject *parent)
+    : QObject{parent}
+{
+    enabledBreakpointDownload(false);
+}
+
+Q_INVOKABLE void FluHttp::postString(QString params,QVariantMap headers){
+    QVariantMap request = invokeIntercept(params,headers,"postString").toMap();
+    QThreadPool::globalInstance()->start([=](){
+        HttpClient client;
+        Q_EMIT start();
+        client.post(_url)
+            .bodyWithRaw(request[params].toString().toUtf8())
+            .headers(request["headers"].toMap())
+            .onSuccess([=](QString result) {
+                Q_EMIT success(result);
+                Q_EMIT finish();
+            })
+            .onFailed([=](QNetworkReply* reply) {
+                Q_EMIT error(reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt(),reply->errorString());
+                Q_EMIT finish();
+            })
+            .block()
+            .exec();
+    });
+}
+
+void FluHttp::post(QVariantMap params,QVariantMap headers){
+    QVariantMap request = invokeIntercept(params,headers,"post").toMap();
+    QThreadPool::globalInstance()->start([=](){
+        HttpClient client;
+        Q_EMIT start();
+        client.post(_url)
+            .headers(headers)
+            .bodyWithFormData(request["params"].toMap())
+            .headers(request["headers"].toMap())
+            .onSuccess([=](QString result) {
+                Q_EMIT success(result);
+                Q_EMIT finish();
+            })
+            .onFailed([=](QNetworkReply* reply) {
+                Q_EMIT error(reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt(),reply->errorString());
+                Q_EMIT finish();
+            })
+            .block()
+            .exec();
+    });
+}
+
+void FluHttp::postJson(QVariantMap params,QVariantMap headers){
+    QVariantMap request = invokeIntercept(params,headers,"postJson").toMap();
+    QThreadPool::globalInstance()->start([=](){
+        HttpClient client;
+        Q_EMIT start();
+        client.post(_url)
+            .headers(headers)
+            .bodyWithRaw(QJsonDocument::fromVariant(request["params"]).toJson())
+            .headers(request["headers"].toMap())
+            .onSuccess([=](QString result) {
+                Q_EMIT success(result);
+                Q_EMIT finish();
+            })
+            .onFailed([=](QNetworkReply* reply) {
+                Q_EMIT error(reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt(),reply->errorString());
+                Q_EMIT finish();
+            })
+            .block()
+            .exec();
+    });
+}
+
+void FluHttp::get(QVariantMap params,QVariantMap headers){
+    QVariantMap request = invokeIntercept(params,headers,"get").toMap();
+    QThreadPool::globalInstance()->start([=](){
+        HttpClient client;
+        Q_EMIT start();
+        client.get(_url)
+            .queryParams(request["params"].toMap())
+            .headers(request["headers"].toMap())
+            .onSuccess([=](QString result) {
+                Q_EMIT success(result);
+                Q_EMIT finish();
+            })
+            .onFailed([=](QNetworkReply* reply) {
+                Q_EMIT error(reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt(),reply->errorString());
+                Q_EMIT finish();
+            })
+            .block()
+            .exec();
+    });
+}
+
+Q_INVOKABLE void FluHttp::download(QString path,QVariantMap params,QVariantMap headers){
+    QVariantMap request = invokeIntercept(params,headers,"download").toMap();
+    qDebug()<<request["headers"].toMap();
+    QThreadPool::globalInstance()->start([=](){
+        HttpClient client;
+        Q_EMIT start();
+        client.get(_url)
+            .download(path)
+            .enabledBreakpointDownload(_enabledBreakpointDownload)
+            .queryParams(request["params"].toMap())
+            .headers(request["headers"].toMap())
+            .onDownloadProgress([=](qint64 recv, qint64 total) {
+                Q_EMIT downloadFileProgress(recv,total);
+            })
+            .onDownloadFileSuccess([=](QString result) {
+                Q_EMIT success(result);
+                Q_EMIT finish();
+            })
+            .onDownloadFileFailed([=](QString errorString) {
+                Q_EMIT error(-1,errorString);
+                Q_EMIT finish();
+            })
+            .block()
+            .exec();
+    });
+}
+
+QVariant FluHttp::invokeIntercept(const QVariant& params,const QVariant& headers,const QString& method){
+    QVariantMap requet = {
+        {"params",params},
+        {"headers",headers},
+        {"method",method}
+    };
+    QVariant target;
+    QMetaObject::invokeMethod(FluApp::getInstance()->httpInterceptor(), "onIntercept",Q_RETURN_ARG(QVariant,target),Q_ARG(QVariant, requet));
+    return target;
+}

src/FluHttp.h

@@ -0,0 +1,32 @@
+#ifndef FLUHTTP_H
+#define FLUHTTP_H
+
+#include <QObject>
+#include <QtQml/qqml.h>
+#include <QNetworkAccessManager>
+#include "stdafx.h"
+
+class FluHttp : public QObject
+{
+    Q_OBJECT
+    Q_PROPERTY_AUTO(QString,url);
+    Q_PROPERTY_AUTO(bool,enabledBreakpointDownload)
+    QML_NAMED_ELEMENT(FluHttp)
+private:
+    QVariant invokeIntercept(const QVariant& params,const QVariant& headers,const QString& method);
+public:
+    explicit FluHttp(QObject *parent = nullptr);
+    Q_SIGNAL void start();
+    Q_SIGNAL void finish();
+    Q_SIGNAL void error(int status,QString errorString);
+    Q_SIGNAL void success(QString result);
+    Q_SIGNAL void downloadFileProgress(qint64 recv, qint64 total);
+    Q_INVOKABLE void get(QVariantMap params = {},QVariantMap headers = {});
+    Q_INVOKABLE void post(QVariantMap params = {},QVariantMap headers = {});
+    Q_INVOKABLE void postJson(QVariantMap params = {},QVariantMap headers = {});
+    Q_INVOKABLE void postString(QString params = "",QVariantMap headers = {});
+
+    Q_INVOKABLE void download(QString path,QVariantMap params = {},QVariantMap headers = {});
+};
+
+#endif // FLUHTTP_H

src/FluHttpInterceptor.cpp

@@ -0,0 +1,7 @@
+#include "FluHttpInterceptor.h"
+
+FluHttpInterceptor::FluHttpInterceptor(QObject *parent)
+    : QObject{parent}
+{
+
+}

src/FluHttpInterceptor.h

@@ -0,0 +1,18 @@
+#ifndef FLUHTTPINTERCEPTOR_H
+#define FLUHTTPINTERCEPTOR_H
+
+#include <QObject>
+#include <QtQml/qqml.h>
+
+class FluHttpInterceptor : public QObject
+{
+    Q_OBJECT
+    QML_NAMED_ELEMENT(FluHttpInterceptor)
+public:
+    explicit FluHttpInterceptor(QObject *parent = nullptr);
+
+signals:
+
+};
+
+#endif // FLUHTTPINTERCEPTOR_H