shipheart-wasm/dataprovider.cpp

#include "dataprovider.h"
#include <QNetworkRequest>
#include <QNetworkReply>
#include <QJsonDocument>
#include <QUrl>
#include <QUrlQuery>

DataProvider::DataProvider(QObject *parent) : QObject(parent)
{
}

void DataProvider::signalerSucces()
{
    m_connecte = true;
    m_derniereConnexionReussie = QDateTime::currentDateTime();
    emit etatConnexionChange();
}

void DataProvider::signalerEchec()
{
    if (m_connecte) {
        m_connecte = false;
        emit etatConnexionChange();
    }
}

void DataProvider::get_familles(const QString &type)
{
    if (m_replyFamillesEnCours) m_replyFamillesEnCours->abort();

    QUrl url(m_baseUrl + "/elements/familles");
    QUrlQuery query;
    query.addQueryItem("type", type);
    url.setQuery(query);

    QNetworkRequest request(url);
    request.setTransferTimeout(5000);

    auto reply = m_manager.get(request);
    m_replyFamillesEnCours = reply;

    connect(reply, &QNetworkReply::finished, this, [this, reply, type]() {
        reply->deleteLater();
        if (m_replyFamillesEnCours == reply) m_replyFamillesEnCours = nullptr;
        if (reply->error() == QNetworkReply::OperationCanceledError) return;
        if (reply->error() != QNetworkReply::NoError) {
            signalerEchec();
            emit erreur(reply->errorString());
            return;
        }
        const auto doc = QJsonDocument::fromJson(reply->readAll());
        const auto obj = doc.object();
        if (obj["status"].toString() != "ok") {
            signalerEchec();
            emit erreur(obj["message"].toString());
            return;
        }
        signalerSucces();
        emit famillesRecues(type, obj["familles"].toArray());
    });
}

void DataProvider::get_elements(const QString &type, int famille)
{
    if (m_replyElementsEnCours) m_replyElementsEnCours->abort();

    QUrl url(m_baseUrl + "/elements");
    QUrlQuery query;
    query.addQueryItem("type", type);
    query.addQueryItem("famille", QString::number(famille));
    url.setQuery(query);

    QNetworkRequest request(url);
    request.setTransferTimeout(5000);

    auto reply = m_manager.get(request);
    m_replyElementsEnCours = reply;

    connect(reply, &QNetworkReply::finished, this, [this, reply, type, famille]() {
        reply->deleteLater();
        if (m_replyElementsEnCours == reply) m_replyElementsEnCours = nullptr;
        if (reply->error() == QNetworkReply::OperationCanceledError) return;
        if (reply->error() != QNetworkReply::NoError) {
            signalerEchec();
            emit erreur(reply->errorString());
            return;
        }
        const auto doc = QJsonDocument::fromJson(reply->readAll());
        const auto obj = doc.object();
        if (obj["status"].toString() != "ok") {
            signalerEchec();
            emit erreur(obj["message"].toString());
            return;
        }
        signalerSucces();
        emit elementsRecus(type, famille, obj["elements"].toArray());
    });
}

void DataProvider::set_circuit(int id, int consigne)
{
    QUrl url(m_baseUrl + "/elements/circuit/" + QString::number(id));
    QNetworkRequest request(url);
    request.setHeader(QNetworkRequest::ContentTypeHeader, "application/json");
    request.setTransferTimeout(5000);

    QJsonObject body;
    body["consigne"] = consigne;
    const QByteArray data = QJsonDocument(body).toJson();

    auto reply = m_manager.sendCustomRequest(request, "PATCH", data);
    connect(reply, &QNetworkReply::finished, this, [this, reply, id]() {
        reply->deleteLater();
        const bool succes = (reply->error() == QNetworkReply::NoError);
        if (succes) signalerSucces();
        else {
            signalerEchec();
            emit erreur(reply->errorString());
        }
        emit circuitModifie(id, succes);
    });
}

void DataProvider::get_mesures(const QString &type, int id, int periode, const QString &variable)
{
    if (m_replyMesuresEnCours) m_replyMesuresEnCours->abort();

    QUrl url(m_baseUrl + "/mesures");
    QUrlQuery query;
    query.addQueryItem("type", type);
    query.addQueryItem("id", QString::number(id));
    query.addQueryItem("periode", QString::number(periode));
    if (!variable.isEmpty()) query.addQueryItem("variable", variable);
    url.setQuery(query);

    QNetworkRequest request(url);
    request.setTransferTimeout(8000);   // Requête potentiellement plus lourde (jusqu'à 200 points) qu'un simple /elements - délai un peu plus généreux.

    auto reply = m_manager.get(request);
    m_replyMesuresEnCours = reply;

    connect(reply, &QNetworkReply::finished, this, [this, reply, type, id, periode, variable]() {
        reply->deleteLater();
        if (m_replyMesuresEnCours == reply) m_replyMesuresEnCours = nullptr;
        if (reply->error() == QNetworkReply::OperationCanceledError) return;
        if (reply->error() != QNetworkReply::NoError) {
            signalerEchec();
            emit erreur(reply->errorString());
            return;
        }
        const auto doc = QJsonDocument::fromJson(reply->readAll());
        const auto obj = doc.object();
        if (obj["status"].toString() != "ok") {
            signalerEchec();
            emit erreur(obj["message"].toString());
            return;
        }
        signalerSucces();
        emit mesuresRecues(type, id, periode, variable, obj);
    });
}

void DataProvider::get_energie(const QString &type, int id, int periode)
{
    if (m_replyEnergieEnCours) m_replyEnergieEnCours->abort();

    QUrl url(m_baseUrl + "/energie");
    QUrlQuery query;
    query.addQueryItem("type", type);
    query.addQueryItem("id", QString::number(id));
    query.addQueryItem("periode", QString::number(periode));
    url.setQuery(query);

    QNetworkRequest request(url);
    request.setTransferTimeout(8000);

    auto reply = m_manager.get(request);
    m_replyEnergieEnCours = reply;

    connect(reply, &QNetworkReply::finished, this, [this, reply, type, id, periode]() {
        reply->deleteLater();
        if (m_replyEnergieEnCours == reply) m_replyEnergieEnCours = nullptr;
        if (reply->error() == QNetworkReply::OperationCanceledError) return;
        if (reply->error() != QNetworkReply::NoError) {
            signalerEchec();
            emit erreur(reply->errorString());
            return;
        }
        const auto doc = QJsonDocument::fromJson(reply->readAll());
        const auto obj = doc.object();
        if (obj["status"].toString() != "ok") {
            signalerEchec();
            emit erreur(obj["message"].toString());
            return;
        }
        signalerSucces();
        emit energieRecue(type, id, periode, obj);
    });
}