pc-system/utils/backendapimanager.cpp

#include "backendapimanager.h"

#include <QtCore/qlogging.h>

#include <QEventLoop>
#include <QUrlQuery>

#include "logger.h"

backendAPIManager *backendAPIManager::s_instance = nullptr;

void backendAPIManager::initialize(const QString &backendUrl) {
    if (!s_instance) {
        s_instance = new backendAPIManager(backendUrl);
    }
}

void backendAPIManager::cleanup() {
    if (s_instance) {
        delete s_instance;
        s_instance = nullptr;
    }
}

void backendAPIManager::setAuthToken(const QString &token) {
    if (s_instance) {
        s_instance->authToken = token;
    }
}

backendAPIManager::backendAPIManager(const QString &backendUrl, QObject *parent)
    : QObject(parent), backendUrl(backendUrl), requestSuccess(false) {
    networkManager = new QNetworkAccessManager(this);
}

backendAPIManager::~backendAPIManager() {
    if (networkManager) {
        delete networkManager;
        networkManager = nullptr;
    }
}

void backendAPIManager::setupRequest(QNetworkRequest &request, const QString &endpoint) {
    request.setUrl(QUrl(backendUrl + endpoint));
    request.setHeader(QNetworkRequest::ContentTypeHeader, "application/json");

    if (!s_instance->authToken.isEmpty()) {
        request.setRawHeader("Authorization", s_instance->authToken.toUtf8());
    }
}

QNetworkReply *backendAPIManager::sendRequest(const QString &endpoint, const QJsonObject &data, const QString &method) {
    QNetworkRequest request;
    setupRequest(request, endpoint);

    QJsonDocument doc(data);
    QByteArray jsonData = doc.toJson();

    QNetworkReply *reply = nullptr;
    if (method == "GET") {
        if (!data.isEmpty()) {
            QUrl url = request.url();
            QUrlQuery query;
            for (const QString &key : data.keys()) {
                QJsonValue value = data.value(key);
                if (value.isString()) {
                    query.addQueryItem(key, value.toString());
                } else if (value.isDouble()) {
                    query.addQueryItem(key, QString::number(value.toDouble()));
                } else if (value.isBool()) {
                    query.addQueryItem(key, value.toBool() ? "true" : "false");
                } else if (value.isArray()) {
                    // 处理数组参数，将数组元素作为多个同名参数
                    QJsonArray array = value.toArray();
                    for (const QJsonValue &arrayValue : array) {
                        query.addQueryItem(key, arrayValue.toString());
                    }
                } else {
                    // 对于其他复杂类型，转换为JSON字符串
                    QJsonDocument doc;
                    if (value.isObject()) {
                        doc.setObject(value.toObject());
                    } else {
                        doc.setArray(value.toArray());
                    }
                    query.addQueryItem(key, doc.toJson(QJsonDocument::Compact));
                }
            }
            url.setQuery(query);
            request.setUrl(url);
            qDebug() << "GET request URL:" << url.toString();
        }
        reply = networkManager->get(request);
    } else if (method == "POST") {
        reply = networkManager->post(request, jsonData);
    } else if (method == "PUT") {
        reply = networkManager->put(request, jsonData);
    } else if (method == "DELETE") {
        reply = networkManager->deleteResource(request);
    }

    return reply;
}
QJsonObject backendAPIManager::getBlastRecords(int page, int pageSize, QJsonObject params) {
    if (!s_instance) return QJsonObject();
    s_instance->requestSuccess = false;

    params.insert("page", QString::number(page));
    params.insert("pageSize", QString::number(pageSize));

    QNetworkReply *reply = s_instance->sendRequest("blastrecord", params, "GET");

    QEventLoop loop;
    QObject::connect(reply, &QNetworkReply::finished, &loop, &QEventLoop::quit);
    loop.exec();

    QJsonObject result;
    if (reply->error() == QNetworkReply::NoError) {
        QJsonDocument response = QJsonDocument::fromJson(reply->readAll());
        result = response.object()["data"].toObject();
    }

    reply->deleteLater();
    return result;
}

// TODO: not use any more 上传爆破记录完整记录. 包含设备和雷管记录
bool backendAPIManager::uploadBlastProjectFull(const QJsonObject &projectData) {
    if (!s_instance) return false;

    s_instance->requestSuccess = false;
    QNetworkReply *reply = s_instance->sendRequest("blastrecord/pc", projectData, "POST");

    // 使用事件循环等待响应
    QEventLoop loop;
    QObject::connect(reply, &QNetworkReply::finished, &loop, &QEventLoop::quit);
    loop.exec();

    if (reply->error() == QNetworkReply::NoError) {
        QJsonDocument response = QJsonDocument::fromJson(reply->readAll());
        s_instance->handleReponseOKFinished(response, reply->url());
    } else {
        Logger::getInstance().error(QString("UploadBlastProjectFull request failed. uuid: %1 error message: %2")
                                        .arg(projectData.value("uuid").toString())
                                        .arg(reply->errorString()));
        s_instance->handleResponseError(reply->errorString());
    }

    reply->deleteLater();
    return s_instance->requestSuccess;
}

QJsonObject backendAPIManager::getHProjects(int page, int pageSize, QJsonObject extParams) {
    if (!s_instance) return QJsonObject();

    QJsonObject params{
        {"page", page},
        {"pageSize", pageSize},
        {"sort", "createdAt,desc"},
        {"blast_status", QJsonArray({"2", "1"})},
    };
    // merge additional parameters if provided
    for (const QString &key : extParams.keys()) {
        params.insert(key, extParams.value(key));
    }
    QNetworkReply *reply = s_instance->sendRequest("h-project", params, "GET");

    QEventLoop loop;
    QObject::connect(reply, &QNetworkReply::finished, &loop, &QEventLoop::quit);
    loop.exec();

    QJsonObject result;
    if (reply->error() == QNetworkReply::NoError) {
        QJsonDocument response = QJsonDocument::fromJson(reply->readAll());
        result = response.object();
    }

    reply->deleteLater();
    return result;
}

QJsonArray backendAPIManager::getSysUsers() {
    if (!s_instance) return QJsonArray();
    QJsonObject params = QJsonObject();
    params.insert("page", "1");
    params.insert("pageSize", "200");  // Assuming a reasonable page size for initial
    QNetworkReply *reply = s_instance->sendRequest("sys-user", params, "GET");

    QEventLoop loop;
    QObject::connect(reply, &QNetworkReply::finished, &loop, &QEventLoop::quit);
    loop.exec();

    QJsonArray result;
    if (reply->error() == QNetworkReply::NoError) {
        QJsonDocument response = QJsonDocument::fromJson(reply->readAll());
        result = response.object()["data"].toObject()["list"].toArray();
    }

    reply->deleteLater();
    return result;
}

QJsonArray backendAPIManager::getDailyBlastedCount(int days) {
    if (!s_instance) return QJsonArray();

    QJsonObject params;
    params.insert("days", QString::number(days));
    QNetworkReply *reply = s_instance->sendRequest("blastrecord/daily_counts", params, "GET");

    QEventLoop loop;
    QObject::connect(reply, &QNetworkReply::finished, &loop, &QEventLoop::quit);
    loop.exec();

    QJsonArray result;
    if (reply->error() == QNetworkReply::NoError) {
        QJsonDocument response = QJsonDocument::fromJson(reply->readAll());
        result = response.object()["data"].toArray();
    } else {
        Logger::getInstance().error(
            QString("GetDailyBlastedCount request failed. error message: %1").arg(reply->errorString()));
    }

    reply->deleteLater();
    return result;
}

QJsonArray backendAPIManager::getHAddresses() {
    if (!s_instance) return QJsonArray();

    QNetworkReply *reply = s_instance->sendRequest("h-address/pc", QJsonObject(), "GET");

    QEventLoop loop;
    QObject::connect(reply, &QNetworkReply::finished, &loop, &QEventLoop::quit);
    loop.exec();

    QJsonArray result;
    if (reply->error() == QNetworkReply::NoError) {
        QJsonDocument response = QJsonDocument::fromJson(reply->readAll());
        result = response.object()["data"].toArray();
    }

    reply->deleteLater();
    return result;
}

bool backendAPIManager::uploadBlastProject(const QJsonObject &projectData) {
    if (!s_instance) return false;

    s_instance->requestSuccess = false;
    QNetworkReply *reply = s_instance->sendRequest("blastrecord", projectData, "POST");

    // 使用事件循环等待响应
    QEventLoop loop;
    QObject::connect(reply, &QNetworkReply::finished, &loop, &QEventLoop::quit);
    loop.exec();

    if (reply->error() == QNetworkReply::NoError) {
        QJsonDocument response = QJsonDocument::fromJson(reply->readAll());
        s_instance->handleReponseOKFinished(response, reply->url());
    } else {
        s_instance->handleResponseError(reply->errorString());
    }

    reply->deleteLater();
    return s_instance->requestSuccess;
}

bool backendAPIManager::uploadBlastProjectDets(const QJsonObject &detsData) {
    if (!s_instance) return false;

    s_instance->requestSuccess = false;
    QNetworkReply *reply = s_instance->sendRequest("blastrecorddet/batch", detsData, "POST");

    // 使用事件循环等待响应
    QEventLoop loop;
    QObject::connect(reply, &QNetworkReply::finished, &loop, &QEventLoop::quit);
    loop.exec();

    if (reply->error() == QNetworkReply::NoError) {
        QJsonDocument response = QJsonDocument::fromJson(reply->readAll());
        s_instance->handleReponseOKFinished(response, reply->url());
    } else {
        s_instance->handleResponseError(reply->errorString());
    }

    reply->deleteLater();
    return s_instance->requestSuccess;
}

bool backendAPIManager::uploadBlastEquipments(const QJsonObject &regDetsData) {
    if (!s_instance) return false;

    s_instance->requestSuccess = false;
    QNetworkReply *reply = s_instance->sendRequest("blastrecordequipment", regDetsData, "POST");

    // 使用事件循环等待响应
    QEventLoop loop;
    QObject::connect(reply, &QNetworkReply::finished, &loop, &QEventLoop::quit);
    loop.exec();

    if (reply->error() == QNetworkReply::NoError) {
        QJsonDocument response = QJsonDocument::fromJson(reply->readAll());
        s_instance->handleReponseOKFinished(response, reply->url());
    } else {
        s_instance->handleResponseError(reply->errorString());
    }

    reply->deleteLater();
    return s_instance->requestSuccess;
}

void backendAPIManager::handleReponseOKFinished(const QJsonDocument &response, const QUrl &url) {
    // Check response status
    if (response.object().contains("code")) {
        int code = response.object()["code"].toInt();
        requestSuccess = (code == 200);
    } else {
        requestSuccess = false;
    }

    emit uploadFinished(response);
}

void backendAPIManager::handleResponseError(const QString &error) {
    requestSuccess = false;
    emit uploadError(error);
}