Pierre/shipheart-api
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Endpoint /mesures généralisé aux 4 domaines (capteurs, réservoirs, circuits, batteries), valeur actuelle réelle + points de bord synthétiques

Browse Source
This commit is contained in:
Pierre
2026-08-26 17:26:33 +02:00
parent 21df63ea72
commit 2deaf8ad4d
6 changed files with 1194 additions and 13 deletions
Download Patch File Download Diff File Expand all files Collapse all files
dataprovider.cpp
Executable
+106
View File
@@ -0,0 +1,106 @@
#include "dataprovider.h"
#include <QNetworkRequest>
#include <QNetworkReply>
#include <QJsonDocument>
#include <QJsonObject>
#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()
{
// Ne touche JAMAIS m_derniereConnexionReussie ici : on veut garder la
// trace du dernier succès réel, pas la remplacer par l'instant de l'échec.
if (m_connecte) {
m_connecte = false;
emit etatConnexionChange();
}
}
void DataProvider::get_familles(const QString &type)
{
QUrl url(m_baseUrl + "/elements/familles");
QUrlQuery query;
query.addQueryItem("type", type);
url.setQuery(query);
auto reply = m_manager.get(QNetworkRequest(url));
connect(reply, &QNetworkReply::finished, this, [this, reply, type]() {
reply->deleteLater();
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)
{
QUrl url(m_baseUrl + "/elements");
QUrlQuery query;
query.addQueryItem("type", type);
query.addQueryItem("famille", QString::number(famille));
url.setQuery(query);
auto reply = m_manager.get(QNetworkRequest(url));
connect(reply, &QNetworkReply::finished, this, [this, reply, type, famille]() {
reply->deleteLater();
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");
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);
});
}
dataprovider.h
Executable
+65
View File
@@ -0,0 +1,65 @@
#pragma once
#include <QObject>
#include <QNetworkAccessManager>
#include <QJsonArray>
#include <QDateTime>
// ============================================================================
// DataProvider - couche d'accès aux données du client WASM (cas 2/3).
// ----------------------------------------------------------------------------
// Remplace, pour les domaines déjà portés, les appels bdd.* directs du cas 1
// (qui reste inchangé, cf décision §21.1 de la synthèse). Toute la logique
// HTTP/JSON est encapsulée ici - le QML ne voit que des signaux avec des
// tableaux déjà prêts à l'emploi.
//
// Portée actuelle : les 4 domaines (circuit, batterie, capteur, reservoir)
// en lecture, écriture (consigne/mode auto) sur circuit uniquement.
//
// Suit également l'état de connexion (succès/échec de chaque requête) pour
// permettre à l'UI d'afficher un état "hors ligne" explicite plutôt que de
// laisser les listes silencieusement vides ou figées (cf synthèse, gestion
// du hors-ligne).
// ============================================================================
class DataProvider : public QObject
{
Q_OBJECT
Q_PROPERTY(bool connecte READ connecte NOTIFY etatConnexionChange)
Q_PROPERTY(bool aDejaEteConnecte READ aDejaEteConnecte NOTIFY etatConnexionChange)
Q_PROPERTY(QDateTime derniereConnexionReussie READ derniereConnexionReussie NOTIFY etatConnexionChange)
public:
explicit DataProvider(QObject *parent = nullptr);
// TODO : rendre l'adresse de base configurable (IP locale du CM5 en cas 2,
// domaine VPS en cas 3 - cf QR code d'accès, §"Architecture cible"/Cas 2-3
// de la synthèse) - en dur sur le relais VPS pour cette étape.
Q_INVOKABLE void get_familles(const QString &type);
Q_INVOKABLE void get_elements(const QString &type, int famille);
// Écriture rapide sur un circuit (bouton d'accueil) - PATCH /elements/circuit/<id>.
Q_INVOKABLE void set_circuit(int id, int consigne);
bool connecte() const { return m_connecte; }
bool aDejaEteConnecte() const { return m_derniereConnexionReussie.isValid(); }
QDateTime derniereConnexionReussie() const { return m_derniereConnexionReussie; }
signals:
// Le type (et, pour les éléments, la famille) sont désormais inclus dans
// chaque signal - indispensable avec plusieurs domaines actifs en
// parallèle, pour que le QML sache à quelle réponse il a affaire.
void famillesRecues(const QString &type, const QJsonArray &familles);
void elementsRecus(const QString &type, int famille, const QJsonArray &elements);
void circuitModifie(int id, bool succes);
void erreur(const QString &message);
void etatConnexionChange();
private:
void signalerSucces();
void signalerEchec();
QNetworkAccessManager m_manager;
QString m_baseUrl = QStringLiteral("https://api.ship2net.fr");
bool m_connecte = false;
QDateTime m_derniereConnexionReussie; // invalide (isValid()==false) tant qu'aucun succès n'a jamais eu lieu
};
main.cpp
+367 -13
View File
@@ -9,6 +9,8 @@
#include <QJsonArray>
#include <QJsonDocument>
#include <QUrlQuery>
#include <QDateTime>
#include <QMap>
#include <QDebug>
// ============================================================================
@@ -170,10 +172,10 @@ int main(int argc, char *argv[])
const QString type = query.queryItemValue("type");
int typeSource;
if (type == "circuit") typeSource = TYPE_SOURCE_CIRCUIT;
else if (type == "batterie") typeSource = TYPE_SOURCE_BATTERIE;
else if (type == "capteur") typeSource = TYPE_SOURCE_CAPTEUR;
else if (type == "reservoir") typeSource = TYPE_SOURCE_RESERVOIR;
if (type == "circuits") typeSource = TYPE_SOURCE_CIRCUIT;
else if (type == "batteries") typeSource = TYPE_SOURCE_BATTERIE;
else if (type == "capteurs") typeSource = TYPE_SOURCE_CAPTEUR;
else if (type == "reservoirs") typeSource = TYPE_SOURCE_RESERVOIR;
else {
QJsonObject err;
err["status"] = "erreur";
@@ -189,7 +191,7 @@ int main(int argc, char *argv[])
const QString nom = q1.value(1).toString();
int etat = 0;
if (type == "circuit") {
if (type == "circuits") {
// Alarmes (Events) liées à cette famille :
QSqlQuery q2;
q2.prepare("SELECT COUNT(*) FROM TB_Events WHERE Type_source=:type AND Validite=1 AND Alarme_source>0 "
@@ -221,7 +223,7 @@ int main(int argc, char *argv[])
etat = 1;
}
}
} else if (type == "batterie") {
} else if (type == "batteries") {
// Règle plus simple que les circuits (cf §20.4/§21.8 synthèse) :
// rouge si Etat_systeme en défaut sur une batterie de la famille,
// sinon orange si au moins une alarme (Events), sinon vert.
@@ -243,7 +245,7 @@ int main(int argc, char *argv[])
while (q3.next()) {
if (q3.value(0).toInt() != 0) etat = 2;
}
} else if (type == "capteur") {
} else if (type == "capteurs") {
// Période d'obsolescence NMEA (TB_Configuration) :
int periodeObsolescenceNmea = 0;
{
@@ -278,7 +280,7 @@ int main(int argc, char *argv[])
if (age > periodeObsolescenceNmea && etat < 1) etat = 1;
if ((etatCapteur > 0 || etatSysteme != 0) && etat < 2) etat = 2;
}
} else if (type == "reservoir") {
} else if (type == "reservoirs") {
// Alarmes (Events) liées à cette famille :
QSqlQuery q2;
q2.prepare("SELECT COUNT(*) FROM TB_Events WHERE Type_source=:type AND Validite=1 AND Alarme_source>0 "
@@ -326,7 +328,7 @@ int main(int argc, char *argv[])
const QString type = query.queryItemValue("type");
const QString familleStr = query.queryItemValue("famille");
if (type != "circuit" && type != "batterie" && type != "capteur" && type != "reservoir") {
if (type != "circuits" && type != "batteries" && type != "capteurs" && type != "reservoirs") {
QJsonObject err;
err["status"] = "erreur";
err["message"] = "type non supporté (circuit, batterie, capteur, reservoir)";
@@ -344,7 +346,7 @@ int main(int argc, char *argv[])
QJsonArray elements;
if (type == "circuit") {
if (type == "circuits") {
QSqlQuery q;
q.prepare(
"SELECT Cle_primaire, Etat_systeme, Nom, Etat_commande_carte, Mode_commande, Etat, Consigne, Old_consigne, "
@@ -383,7 +385,7 @@ int main(int argc, char *argv[])
obj["etat_events"] = q.value(16).toInt();
elements.append(obj);
}
} else if (type == "batterie") {
} else if (type == "batteries") {
// Rappel : le champ "etat" retourné ici est le NOMBRE D'ALARMES,
// pas un code d'état comme pour les circuits - fidèle au modèle
// natif existant (modele_batteries), pas une incohérence introduite ici.
@@ -411,7 +413,7 @@ int main(int argc, char *argv[])
obj["etat"] = q.value(7).toInt();
elements.append(obj);
}
} else if (type == "capteur") {
} else if (type == "capteurs") {
// Préférences d'unité du bateau (TB_Configuration) :
int uniteVolume = 0, uniteTemperature = 0, periodeObsolescenceNmea = 0;
{
@@ -524,7 +526,7 @@ int main(int argc, char *argv[])
obj["obsolete"] = (typeEntrees == TYPE_ENTREES_NMEA && age > periodeObsolescenceNmea);
elements.append(obj);
}
} else if (type == "reservoir") {
} else if (type == "reservoirs") {
QSqlQuery q;
q.prepare(
"SELECT Cle_primaire, Nom, Etat_systeme, Niveau, Capacite, Logique, "
@@ -644,6 +646,358 @@ int main(int argc, char *argv[])
return resp;
});
// ------------------------------------------------------------------
// GET /mesures?type=<capteurs|reservoirs>&id=<id>&periode=<0-3>
// Historique pour le graphique de la page de détail (0=1h, 1=24h,
// 2=7j, 3=30j) - regroupement TOUJOURS calculé côté serveur (jamais de
// donnée brute non agrégée transmise, cf §20.6/§21.6 synthèse).
// Capteurs : id_variable résolu depuis la config de l'élément lui-même.
// Réservoirs : id_variable résolu par CODE FIXE ("Res_niveau" dans
// TB_Variables) - le niveau est un concept universel, pas une config
// propre à chaque réservoir comme pour un capteur.
// Circuits/batteries (sélection de variable côté client) à venir.
// ------------------------------------------------------------------
server.route("/mesures", [](const QHttpServerRequest &request) {
QUrlQuery query(request.query());
const QString type = query.queryItemValue("type");
const QString idStr = query.queryItemValue("id");
const QString periodeStr = query.queryItemValue("periode");
if (type != "capteurs" && type != "reservoirs" && type != "circuits" && type != "batteries") {
QJsonObject err;
err["status"] = "erreur";
err["message"] = "type non supporté pour l'instant (capteurs, reservoirs, circuits, batteries)";
return withCors(QHttpServerResponse(QJsonDocument(err).toJson(), QHttpServerResponder::StatusCode::NotImplemented));
}
bool okId = false, okPeriode = false;
const int id = idStr.toInt(&okId);
const int periode = periodeStr.toInt(&okPeriode);
if (!okId || !okPeriode || periode < 0 || periode > 3) {
QJsonObject err;
err["status"] = "erreur";
err["message"] = "paramètres 'id'/'periode' manquants ou invalides (periode: 0=1h, 1=24h, 2=7j, 3=30j)";
return withCors(QHttpServerResponse(QJsonDocument(err).toJson(), QHttpServerResponder::StatusCode::BadRequest));
}
// Durée de chaque période, en secondes :
static const qint64 DUREES_PERIODE[4] = { 3600, 86400, 604800, 2592000 }; // 1h, 24h, 7j, 30j
const qint64 dureeSecondes = DUREES_PERIODE[periode];
const QDateTime dateFin = QDateTime::currentDateTime();
const QDateTime dateDebut = dateFin.addSecs(-dureeSecondes);
// Regroupement calculé pour viser un nombre de points raisonnable à
// l'affichage, quelle que soit la période demandée - valeur à ajuster
// visuellement une fois le graphique réellement affiché (pas un
// chiffre figé arbitrairement bas, cf discussion §20.6).
static const int POINTS_CIBLE = 200;
const int regroupement = qMax(1, (int)(dureeSecondes / POINTS_CIBLE));
// Résolution de l'id_variable, de la précision d'affichage, et du nom
// de table de mesures - selon le domaine :
int idVariable = 0;
int precision = 1;
QString nomTable;
QString variableCircuit; // Utilisée aussi plus loin (valeur actuelle) si type == "circuits"
if (type == "capteurs") {
nomTable = "TB_Mesures_capteurs";
QSqlQuery qc;
qc.prepare("SELECT ID_Variable, Precision_affichage_mesures FROM TB_Capteurs WHERE Cle_primaire=:id");
qc.bindValue(":id", id);
qc.exec();
if (!qc.next()) {
QJsonObject err;
err["status"] = "erreur";
err["message"] = "capteur introuvable";
return withCors(QHttpServerResponse(QJsonDocument(err).toJson(), QHttpServerResponder::StatusCode::NotFound));
}
idVariable = qc.value(0).toInt();
precision = qc.value(1).toInt();
} else if (type == "reservoirs") {
nomTable = "TB_Mesures_reservoirs";
QSqlQuery qExiste;
qExiste.prepare("SELECT Cle_primaire FROM TB_Reservoirs WHERE Cle_primaire=:id");
qExiste.bindValue(":id", id);
qExiste.exec();
if (!qExiste.next()) {
QJsonObject err;
err["status"] = "erreur";
err["message"] = "réservoir introuvable";
return withCors(QHttpServerResponse(QJsonDocument(err).toJson(), QHttpServerResponder::StatusCode::NotFound));
}
QSqlQuery qv;
qv.prepare("SELECT Cle_primaire FROM TB_Variables WHERE Code='Res_niveau'");
qv.exec();
if (!qv.next()) {
QJsonObject err;
err["status"] = "erreur";
err["message"] = "configuration serveur incomplète (variable 'Res_niveau' introuvable)";
return withCors(QHttpServerResponse(QJsonDocument(err).toJson(), QHttpServerResponder::StatusCode::InternalServerError));
}
idVariable = qv.value(0).toInt();
// Pas de colonne de précision dédiée pour les réservoirs (à la
// différence des capteurs) - un pourcentage à 1 décimale est une
// valeur par défaut raisonnable.
precision = 1;
} else if (type == "circuits") {
nomTable = "TB_Mesures_circuits";
// Circuits : le client choisit QUELLE variable tracer (contrairement
// à réservoirs/capteurs, à valeur fixe) :
variableCircuit = query.queryItemValue("variable");
if (variableCircuit != "consigne" && variableCircuit != "tension"
&& variableCircuit != "intensite" && variableCircuit != "frequence") {
QJsonObject err;
err["status"] = "erreur";
err["message"] = "paramètre 'variable' manquant ou invalide (consigne, tension, intensite, frequence)";
return withCors(QHttpServerResponse(QJsonDocument(err).toJson(), QHttpServerResponder::StatusCode::BadRequest));
}
// Résolution du type de module du circuit - nécessaire car SP4AC
// utilise "tension_secteur" au lieu de "tension", et la précision
// d'affichage diffère selon le type de carte (cf circuit.qml natif) :
QSqlQuery qMod;
qMod.prepare(
"SELECT (SELECT Type FROM TB_Modules_config WHERE Adresse_k_bus=TB_Circuits.Adresse_module) "
"FROM TB_Circuits WHERE Cle_primaire=:id"
);
qMod.bindValue(":id", id);
qMod.exec();
if (!qMod.next()) {
QJsonObject err;
err["status"] = "erreur";
err["message"] = "circuit introuvable";
return withCors(QHttpServerResponse(QJsonDocument(err).toJson(), QHttpServerResponder::StatusCode::NotFound));
}
const int typeModule = qMod.value(0).toInt();
static const int TYPE_MODULE_SP4AC = 3;
const bool estSP4AC = (typeModule == TYPE_MODULE_SP4AC);
QString codeVariable;
if (variableCircuit == "consigne") { codeVariable = "Circ_consigne"; precision = 0; }
else if (variableCircuit == "intensite") { codeVariable = "Circ_courant"; precision = estSP4AC ? 1 : 2; }
else if (variableCircuit == "frequence") { codeVariable = "Circ_frequence"; precision = 1; }
else { codeVariable = estSP4AC ? "Circ_tension_secteur" : "Circ_tension"; precision = estSP4AC ? 0 : 2; }
QSqlQuery qv2;
qv2.prepare("SELECT Cle_primaire FROM TB_Variables WHERE Code=:code");
qv2.bindValue(":code", codeVariable);
qv2.exec();
if (!qv2.next()) {
QJsonObject err;
err["status"] = "erreur";
err["message"] = "configuration serveur incomplète (variable '" + codeVariable + "' introuvable)";
return withCors(QHttpServerResponse(QJsonDocument(err).toJson(), QHttpServerResponder::StatusCode::InternalServerError));
}
idVariable = qv2.value(0).toInt();
} else { // batteries
nomTable = "TB_Mesures_batteries";
// Batteries : le client choisit QUELLE variable tracer, comme pour
// les circuits. Valeur par défaut "soc" si non précisée (le vrai
// défaut natif est le comparatif d'énergie, hors périmètre ici).
variableCircuit = query.queryItemValue("variable");
if (variableCircuit.isEmpty()) variableCircuit = "soc";
static const QMap<QString, QString> CODES_BATTERIE = {
{"soc", "Batt_soc"}, {"tension", "Batt_tension"}, {"temperature", "Batt_temperature"},
{"courant_differentiel", "Batt_courant_differentiel"}, {"courant_charge", "Batt_courant_charge"},
{"courant_decharge", "Batt_courant_decharge"}, {"soh", "Batt_soh"}, {"autonomie", "Batt_autonomie"}
};
static const QMap<QString, int> PRECISIONS_BATTERIE = {
{"soc", 1}, {"tension", 2}, {"temperature", 1}, {"courant_differentiel", 2},
{"courant_charge", 2}, {"courant_decharge", 2}, {"soh", 1}, {"autonomie", 1}
};
if (!CODES_BATTERIE.contains(variableCircuit)) {
QJsonObject err;
err["status"] = "erreur";
err["message"] = "paramètre 'variable' invalide (soc, tension, temperature, courant_differentiel, courant_charge, courant_decharge, soh, autonomie)";
return withCors(QHttpServerResponse(QJsonDocument(err).toJson(), QHttpServerResponder::StatusCode::BadRequest));
}
precision = PRECISIONS_BATTERIE.value(variableCircuit);
QSqlQuery qv3;
qv3.prepare("SELECT Cle_primaire FROM TB_Variables WHERE Code=:code");
qv3.bindValue(":code", CODES_BATTERIE.value(variableCircuit));
qv3.exec();
if (!qv3.next()) {
QJsonObject err;
err["status"] = "erreur";
err["message"] = "configuration serveur incomplète (variable '" + CODES_BATTERIE.value(variableCircuit) + "' introuvable)";
return withCors(QHttpServerResponse(QJsonDocument(err).toJson(), QHttpServerResponder::StatusCode::InternalServerError));
}
idVariable = qv3.value(0).toInt();
}
QString uniteBrute;
int typeUnite = 0;
{
QSqlQuery qv;
qv.prepare("SELECT Unite, Conversion_unite FROM TB_Variables WHERE Cle_primaire=:id");
qv.bindValue(":id", idVariable);
qv.exec();
if (qv.next()) {
uniteBrute = qv.value(0).toString();
typeUnite = qv.value(1).toInt();
}
}
int uniteVolume = 0, uniteTemperature = 0;
{
QSqlQuery q1("SELECT Valeur FROM TB_Configuration WHERE Nom='Unite_volume'");
if (q1.next()) uniteVolume = q1.value(0).toInt();
}
{
QSqlQuery q2("SELECT Valeur FROM TB_Configuration WHERE Nom='Unite_temperature'");
if (q2.next()) uniteTemperature = q2.value(0).toInt();
}
QString symboleUnite = uniteBrute;
if (typeUnite == TYPE_UNITE_VOLUME) symboleUnite = symbole_unite_volume(uniteVolume);
else if (typeUnite == TYPE_UNITE_TEMPERATURE) symboleUnite = symbole_unite_temperature(uniteTemperature);
// Fonction de conversion, réutilisée à plusieurs endroits ci-dessous :
auto convertir = [&](double brut) {
if (typeUnite == TYPE_UNITE_VOLUME) return conversion_volume(brut, uniteVolume);
if (typeUnite == TYPE_UNITE_TEMPERATURE) return conversion_temperature(brut, uniteTemperature);
return brut;
};
// Valeur actuelle RÉELLE (TB_Capteurs.Valeur ou TB_Reservoirs.Niveau,
// toujours à jour) - PAS extrapolée depuis le dernier point de
// l'historique, qui peut être absent (aucune mesure récente) ou vieux
// de plusieurs minutes (valeur moyennée par bucket) :
QSqlQuery qActuel;
if (type == "capteurs") {
qActuel.prepare("SELECT Valeur FROM TB_Capteurs WHERE Cle_primaire=:id");
} else if (type == "reservoirs") {
qActuel.prepare("SELECT Niveau FROM TB_Reservoirs WHERE Cle_primaire=:id");
} else if (type == "circuits") {
QString colonne;
if (variableCircuit == "consigne") colonne = "Consigne";
else if (variableCircuit == "intensite") colonne = "Intensite";
else if (variableCircuit == "frequence") colonne = "Frequence";
else colonne = "Tension";
qActuel.prepare(QString("SELECT %1 FROM TB_Circuits WHERE Cle_primaire=:id").arg(colonne));
} else { // batteries
static const QMap<QString, QString> COLONNES_BATTERIE = {
{"soc", "Soc"}, {"tension", "Tension"}, {"temperature", "Temperature"},
{"courant_differentiel", "Courant_differentiel"}, {"courant_charge", "Courant_charge"},
{"courant_decharge", "Courant_decharge"}, {"soh", "Soh"}, {"autonomie", "Autonomie"}
};
qActuel.prepare(QString("SELECT %1 FROM TB_Batteries WHERE Cle_primaire=:id").arg(COLONNES_BATTERIE.value(variableCircuit)));
}
qActuel.bindValue(":id", id);
qActuel.exec();
double valeurActuelle = 0;
if (qActuel.next()) valeurActuelle = convertir(qActuel.value(0).toDouble());
// Point de départ synthétique : dernière valeur connue AVANT le début
// de la période, reportée exactement à la date de début - assure que
// la courbe reflète l'état réel dès le premier instant demandé, même
// si aucune mesure n'a été enregistrée DURANT la période elle-même
// (élément en mode "enregistrement sur changement" - une valeur
// stable ne crée aucune nouvelle ligne dans la table de mesures).
// Logique identique à celle déjà présente dans tb_mesures.cpp natif.
QJsonArray points;
double minVal = 0, maxVal = 0, sommeVal = 0;
qint64 minT = 0, maxT = 0;
int nb = 0;
double derniereValeurConnue = 0;
bool auMoinsUnePoint = false;
{
QSqlQuery qAvant;
qAvant.prepare(
QString("SELECT Valeur FROM %1 WHERE ID=:id AND ID_Variable=:idVariable "
"AND Date<=:debut AND Valeur IS NOT NULL ORDER BY Date DESC LIMIT 1").arg(nomTable)
);
qAvant.bindValue(":id", id);
qAvant.bindValue(":idVariable", idVariable);
qAvant.bindValue(":debut", dateDebut.toString("yyyy-MM-dd HH:mm:ss"));
qAvant.exec();
if (qAvant.next()) {
const double v = convertir(qAvant.value(0).toDouble());
const qint64 t = dateDebut.toMSecsSinceEpoch();
QJsonObject pt; pt["t"] = t; pt["v"] = v;
points.append(pt);
minVal = maxVal = v;
minT = maxT = t;
sommeVal = v;
nb = 1;
derniereValeurConnue = v;
auMoinsUnePoint = true;
}
}
// Récupération des points RÉELS de la période, regroupés côté SQL
// (moyenne par bucket) - même principe que la branche "barres
// d'énergie" déjà validée pour les circuits (§20.6), généralisé ici
// à toute courbe de mesure :
QSqlQuery qm;
qm.prepare(
QString("SELECT Date, AVG(Valeur) FROM %1 "
"WHERE ID=:id AND ID_Variable=:idVariable AND Date>:debut AND Date<=:fin AND Valeur IS NOT NULL "
"GROUP BY (UNIX_TIMESTAMP(Date) DIV :regroupement) ORDER BY Date").arg(nomTable)
);
qm.bindValue(":id", id);
qm.bindValue(":idVariable", idVariable);
qm.bindValue(":debut", dateDebut.toString("yyyy-MM-dd HH:mm:ss"));
qm.bindValue(":fin", dateFin.toString("yyyy-MM-dd HH:mm:ss"));
qm.bindValue(":regroupement", regroupement);
qm.exec();
while (qm.next()) {
const QDateTime dt = qm.value(0).toDateTime();
const double valeurConvertie = convertir(qm.value(1).toDouble());
const qint64 t = dt.toMSecsSinceEpoch();
QJsonObject pt;
pt["t"] = t;
pt["v"] = valeurConvertie;
points.append(pt);
if (nb == 0 || valeurConvertie < minVal) { minVal = valeurConvertie; minT = t; }
if (nb == 0 || valeurConvertie > maxVal) { maxVal = valeurConvertie; maxT = t; }
sommeVal += valeurConvertie;
nb++;
derniereValeurConnue = valeurConvertie;
auMoinsUnePoint = true;
}
// Point de fin synthétique : reporte la dernière valeur connue
// jusqu'à "maintenant", pour que la courbe occupe toute la période -
// purement visuel, ne modifie pas les statistiques min/max/moyenne
// (ce n'est pas une nouvelle mesure, juste la continuité visuelle de
// la précédente) :
if (auMoinsUnePoint) {
QJsonObject ptFin;
ptFin["t"] = dateFin.toMSecsSinceEpoch();
ptFin["v"] = derniereValeurConnue;
points.append(ptFin);
}
QJsonObject reponse;
reponse["status"] = "ok";
reponse["points"] = points;
reponse["unite"] = symboleUnite;
reponse["precision"] = precision;
reponse["valeur_actuelle"] = valeurActuelle;
if (nb > 0) {
QJsonObject minObj; minObj["v"] = minVal; minObj["t"] = minT;
QJsonObject maxObj; maxObj["v"] = maxVal; maxObj["t"] = maxT;
reponse["min"] = minObj;
reponse["max"] = maxObj;
reponse["moyenne"] = sommeVal / nb;
}
return withCors(QHttpServerResponse(QJsonDocument(reponse).toJson()));
});
auto tcpServer = new QTcpServer();
if (!tcpServer->listen(QHostAddress::Any, 8080) || !server.bind(tcpServer)) {
qCritical() << "Impossible de démarrer le serveur HTTP sur le port 8080.";
main.cpp:Zone.Identifier
BIN
View File
Binary file not shown.
main_OLD.cpp
+656
View File
@@ -0,0 +1,656 @@
#include <QCoreApplication>
#include <QHttpServer>
#include <QHttpHeaders>
#include <QTcpServer>
#include <QSqlDatabase>
#include <QSqlQuery>
#include <QSqlError>
#include <QJsonObject>
#include <QJsonArray>
#include <QJsonDocument>
#include <QUrlQuery>
#include <QDebug>
// ============================================================================
// shipheart_api - Phase 4 : première tranche verticale, domaine "circuit"
// ----------------------------------------------------------------------------
// Deux endpoints réels, remplaçant le spike (/ping conservé comme sonde de vie
// générique, /test-db retiré car superflu désormais) :
// - GET /elements/familles?type=circuit
// - GET /elements?type=circuit&famille=<id>
// Logique et requêtes SQL reprises à l'identique de home.qml (init_circuits(),
// mise_a_jour_onglets_circuits(), mise_a_jour_circuits() - cf synthèse §20.4)
// et des constantes documentées dans le schéma (TB_Circuits.Etat, cf §20).
// ============================================================================
// Types de familles (cf TB_Familles.Type_source / TB_Events.Type_source) :
static const int TYPE_SOURCE_CIRCUIT = 1;
static const int TYPE_SOURCE_CAPTEUR = 2;
static const int TYPE_SOURCE_RESERVOIR = 3;
static const int TYPE_SOURCE_BATTERIE = 4;
// États circuit (cf commentaire colonne TB_Circuits.Etat dans le schéma) :
static const int ETAT_CIRCUIT_OK = 0;
static const int ETAT_CIRCUIT_LIMITATION = 1;
static const int ETAT_CIRCUIT_PROTECTION = 2;
static const int ETAT_CIRCUIT_DISJONCTE = 3;
static const int ETAT_CIRCUIT_ABSENCE_TERRE = 8;
static const int ETAT_CIRCUIT_ABSENCE_MASSE = 9;
static const int ETAT_COMMANDE_CARTE_OK = 0;
// Types d'entrées capteur (cf commentaire colonne TB_Capteurs.Type_entrees) :
static const int TYPE_ENTREES_AUX = 1;
static const int TYPE_ENTREES_NMEA = 7;
static const int TYPE_ENTREES_CALCULEE_BOOLEEN = 20;
// Types de conversion d'unité (cf commentaire colonne TB_Variables.Conversion_unite,
// confirmé identique à shipheart_type_unite_* dans main.qml) :
static const int TYPE_UNITE_VOLUME = 1;
static const int TYPE_UNITE_TEMPERATURE = 2;
static const int TYPE_UNITE_LATITUDE = 3;
static const int TYPE_UNITE_LONGITUDE = 4;
// Unités cibles (cf main.qml, shipheart_unite_volume_*/shipheart_unite_temperature_*) :
static const int UNITE_VOLUME_LITRES = 0;
static const int UNITE_VOLUME_US_GALLONS = 1;
static const int UNITE_VOLUME_IMP_GALLONS = 2;
static const int UNITE_TEMPERATURE_CELSIUS = 0;
static const int UNITE_TEMPERATURE_FAHRENHEIT = 1;
// ----------------------------------------------------------------------------
// Conversions - traduction fidèle de fonctions.js (conversion_volume(),
// conversion_temperature(), chaine_latitude(), chaine_longitude()) et de
// fonctions_localisation.js (symbole_unite_volume(), symbole_unite_temperature()).
// ----------------------------------------------------------------------------
static double conversion_volume(double val, int unite)
{
switch (unite) {
case UNITE_VOLUME_US_GALLONS: return val / 3.785411784;
case UNITE_VOLUME_IMP_GALLONS: return val / 4.546090;
case UNITE_VOLUME_LITRES:
default: return val;
}
}
static double conversion_temperature(double val, int unite)
{
switch (unite) {
case UNITE_TEMPERATURE_FAHRENHEIT: return (val * 1.8) + 32.0;
case UNITE_TEMPERATURE_CELSIUS:
default: return val;
}
}
static QString symbole_unite_volume(int unite)
{
switch (unite) {
case UNITE_VOLUME_US_GALLONS: return QStringLiteral("US Ga");
case UNITE_VOLUME_IMP_GALLONS: return QStringLiteral("Imp. Ga");
case UNITE_VOLUME_LITRES:
default: return QStringLiteral("lit.");
}
}
static QString symbole_unite_temperature(int unite)
{
return (unite == UNITE_TEMPERATURE_FAHRENHEIT) ? QStringLiteral("°F") : QStringLiteral("°C");
}
static QString chaine_latitude(double lat)
{
const int deg = static_cast<int>(lat);
const double minutes = (lat - deg) * 60.0;
const QString suffixe = (lat >= 0) ? QStringLiteral("N") : QStringLiteral("S");
return QString("%1°%2' %3").arg(deg).arg(minutes, 0, 'f', 3).arg(suffixe);
}
static QString chaine_longitude(double lon)
{
const int deg = static_cast<int>(lon);
const double minutes = (lon - deg) * 60.0;
const QString suffixe = (lon >= 0) ? QStringLiteral("E") : QStringLiteral("W");
return QString("%1°%2' %3").arg(deg).arg(minutes, 0, 'f', 3).arg(suffixe);
}
// ----------------------------------------------------------------------------
// Ajoute l'en-tête CORS à une réponse - indispensable puisque le client WASM
// (servi par nginx sur un port distinct) et cette API (port 8080) constituent
// deux origines différentes du point de vue du navigateur. Sans cet en-tête,
// les requêtes aboutissent bien côté serveur (visibles dans les logs) mais
// leur réponse est bloquée silencieusement côté client.
// TODO : restreindre à l'origine réelle du client en production plutôt que
// '*', une fois l'authentification (cf "Architecture cible") en place.
// ----------------------------------------------------------------------------
static QHttpServerResponse withCors(QHttpServerResponse &&resp)
{
QHttpHeaders headers = resp.headers();
headers.append(QHttpHeaders::WellKnownHeader::AccessControlAllowOrigin, "*");
// Empêche le navigateur de mettre en cache les réponses - sans ça, des
// requêtes identiques répétées (rafraîchissement périodique) pourraient
// recevoir une réponse mise en cache plutôt que la valeur réellement à
// jour en base.
headers.append(QHttpHeaders::WellKnownHeader::CacheControl, "no-store");
resp.setHeaders(std::move(headers));
return std::move(resp);
}
int main(int argc, char *argv[])
{
QCoreApplication app(argc, argv);
// --- Connexion MariaDB locale ---
QSqlDatabase db = QSqlDatabase::addDatabase("QMYSQL");
db.setHostName("localhost");
db.setUserName("koriolan");
db.setPassword("Mp7Hgf12bV9zm");
db.setDatabaseName("shipheart");
if (!db.open()) {
qCritical() << "Connexion MariaDB échouée :" << db.lastError().text();
return 1;
}
qInfo() << "Connexion MariaDB réussie.";
QHttpServer server;
// Sonde de vie générique, sans BDD :
server.route("/ping", []() {
QJsonObject obj;
obj["status"] = "ok";
return withCors(QHttpServerResponse(QJsonDocument(obj).toJson()));
});
// ------------------------------------------------------------------
// GET /elements/familles?type=circuit
// Liste des familles avec état d'alarme agrégé (fusionne les deux
// requêtes onglets de mise_a_jour_onglets_circuits()).
// ------------------------------------------------------------------
server.route("/elements/familles", [](const QHttpServerRequest &request) {
QUrlQuery query(request.query());
const QString type = query.queryItemValue("type");
int typeSource;
if (type == "circuits") typeSource = TYPE_SOURCE_CIRCUIT;
else if (type == "batteries") typeSource = TYPE_SOURCE_BATTERIE;
else if (type == "capteurs") typeSource = TYPE_SOURCE_CAPTEUR;
else if (type == "reservoirs") typeSource = TYPE_SOURCE_RESERVOIR;
else {
QJsonObject err;
err["status"] = "erreur";
err["message"] = "type non supporté (circuit, batterie, capteur, reservoir)";
return withCors(QHttpServerResponse(QJsonDocument(err).toJson(), QHttpServerResponder::StatusCode::NotImplemented));
}
QJsonArray familles;
QSqlQuery q1(QString("SELECT Cle_primaire, Nom FROM TB_Familles WHERE Type_source=%1 ORDER BY Priorite_affichage").arg(typeSource));
while (q1.next()) {
const int idFamille = q1.value(0).toInt();
const QString nom = q1.value(1).toString();
int etat = 0;
if (type == "circuits") {
// Alarmes (Events) liées à cette famille :
QSqlQuery q2;
q2.prepare("SELECT COUNT(*) FROM TB_Events WHERE Type_source=:type AND Validite=1 AND Alarme_source>0 "
"AND Etat_test=1 AND ID_Source IN (SELECT Cle_primaire FROM TB_Circuits WHERE ID_Famille=:famille)");
q2.bindValue(":type", typeSource);
q2.bindValue(":famille", idFamille);
q2.exec();
if (q2.next() && q2.value(0).toInt() > 0) etat = 1;
// État agrégé des circuits de la famille :
QSqlQuery q3;
q3.prepare("SELECT Etat, Etat_commande_carte, Etat_systeme FROM TB_Circuits "
"WHERE ID_Famille=:famille AND Priorite_affichage_accueil>0");
q3.bindValue(":famille", idFamille);
q3.exec();
while (q3.next()) {
const int etatCircuit = q3.value(0).toInt();
const int etatCommandeCarte = q3.value(1).toInt();
const int etatSysteme = q3.value(2).toInt();
if (etatSysteme != 0
|| etatCircuit == ETAT_CIRCUIT_LIMITATION
|| etatCircuit == ETAT_CIRCUIT_PROTECTION
|| etatCircuit == ETAT_CIRCUIT_DISJONCTE
|| etatCircuit == ETAT_CIRCUIT_ABSENCE_TERRE
|| etatCircuit == ETAT_CIRCUIT_ABSENCE_MASSE) {
etat = 2;
} else if (etat < 2 && (etatCommandeCarte != ETAT_COMMANDE_CARTE_OK || etatCircuit != ETAT_CIRCUIT_OK)) {
etat = 1;
}
}
} else if (type == "batteries") {
// Règle plus simple que les circuits (cf §20.4/§21.8 synthèse) :
// rouge si Etat_systeme en défaut sur une batterie de la famille,
// sinon orange si au moins une alarme (Events), sinon vert.
// Alarmes (Events) liées à cette famille :
QSqlQuery q2;
q2.prepare("SELECT COUNT(*) FROM TB_Events WHERE Type_source=:type AND Validite=1 AND Alarme_source>0 "
"AND Etat_test=1 AND ID_Source IN (SELECT Cle_primaire FROM TB_Batteries WHERE ID_Famille=:famille)");
q2.bindValue(":type", typeSource);
q2.bindValue(":famille", idFamille);
q2.exec();
if (q2.next() && q2.value(0).toInt() > 0) etat = 1;
// Etat_systeme des batteries de la famille :
QSqlQuery q3;
q3.prepare("SELECT Etat_systeme FROM TB_Batteries WHERE ID_Famille=:famille AND Priorite_affichage_accueil>0");
q3.bindValue(":famille", idFamille);
q3.exec();
while (q3.next()) {
if (q3.value(0).toInt() != 0) etat = 2;
}
} else if (type == "capteurs") {
// Période d'obsolescence NMEA (TB_Configuration) :
int periodeObsolescenceNmea = 0;
{
QSqlQuery qc("SELECT Valeur FROM TB_Configuration WHERE Nom='Periode_obsolescence_capteur_nmea'");
if (qc.next()) periodeObsolescenceNmea = qc.value(0).toInt();
}
// Alarmes (Events) liées à cette famille :
QSqlQuery q2;
q2.prepare("SELECT COUNT(*) FROM TB_Events WHERE Type_source=:type AND Validite=1 AND Alarme_source>0 "
"AND Etat_test=1 AND ID_Source IN (SELECT Cle_primaire FROM TB_Capteurs WHERE ID_Famille=:famille)");
q2.bindValue(":type", typeSource);
q2.bindValue(":famille", idFamille);
q2.exec();
if (q2.next() && q2.value(0).toInt() > 0) etat = 1;
QSqlQuery q3;
q3.prepare(
"SELECT Etat, Etat_systeme, "
"IF(Type_entrees=:typeNmea, (SELECT (UNIX_TIMESTAMP() - UNIX_TIMESTAMP(Date_maj)) FROM TB_Nmea2000 "
"WHERE Pgn=SUBSTRING_INDEX(Entrees, ':', 1) AND Field=SUBSTRING_INDEX(Entrees, ':', -1)), 0) AS Age "
"FROM TB_Capteurs WHERE ID_Famille=:famille AND Priorite_affichage_accueil>0"
);
q3.bindValue(":typeNmea", TYPE_ENTREES_NMEA);
q3.bindValue(":famille", idFamille);
q3.exec();
while (q3.next()) {
const int etatCapteur = q3.value(0).toInt();
const int etatSysteme = q3.value(1).toInt();
const int age = q3.value(2).toInt();
if (age > periodeObsolescenceNmea && etat < 1) etat = 1;
if ((etatCapteur > 0 || etatSysteme != 0) && etat < 2) etat = 2;
}
} else if (type == "reservoirs") {
// Alarmes (Events) liées à cette famille :
QSqlQuery q2;
q2.prepare("SELECT COUNT(*) FROM TB_Events WHERE Type_source=:type AND Validite=1 AND Alarme_source>0 "
"AND Etat_test=1 AND ID_Source IN (SELECT Cle_primaire FROM TB_Reservoirs WHERE ID_Famille=:famille)");
q2.bindValue(":type", typeSource);
q2.bindValue(":famille", idFamille);
q2.exec();
if (q2.next() && q2.value(0).toInt() > 0) etat = 1;
// Défaut ordre des sondes AUX (Etat_entrees) ou Etat_systeme en défaut :
QSqlQuery q3;
q3.prepare("SELECT Etat_entrees, Etat_systeme FROM TB_Reservoirs "
"WHERE ID_Famille=:famille AND Priorite_affichage_accueil>0");
q3.bindValue(":famille", idFamille);
q3.exec();
while (q3.next()) {
const int etatEntrees = q3.value(0).toInt();
const int etatSysteme = q3.value(1).toInt();
if ((etatEntrees > 0 || etatSysteme != 0) && etat < 2) etat = 2;
}
}
QJsonObject obj;
obj["id"] = idFamille;
obj["nom"] = nom;
obj["etat"] = etat;
familles.append(obj);
}
QJsonObject reponse;
reponse["status"] = "ok";
reponse["familles"] = familles;
return withCors(QHttpServerResponse(QJsonDocument(reponse).toJson()));
});
// ------------------------------------------------------------------
// GET /elements?type=circuit&famille=<id>
// Liste des circuits de la famille - sert chargement initial ET
// rafraîchissement périodique (même requête que init_circuits() et
// mise_a_jour_circuits(), cf §20.4 : ce n'est pas deux besoins
// différents, mais un seul, appelé deux fois).
// ------------------------------------------------------------------
server.route("/elements", [](const QHttpServerRequest &request) {
QUrlQuery query(request.query());
const QString type = query.queryItemValue("type");
const QString familleStr = query.queryItemValue("famille");
if (type != "circuits" && type != "batteries" && type != "capteurs" && type != "reservoirs") {
QJsonObject err;
err["status"] = "erreur";
err["message"] = "type non supporté (circuit, batterie, capteur, reservoir)";
return withCors(QHttpServerResponse(QJsonDocument(err).toJson(), QHttpServerResponder::StatusCode::NotImplemented));
}
bool ok = false;
const int idFamille = familleStr.toInt(&ok);
if (!ok) {
QJsonObject err;
err["status"] = "erreur";
err["message"] = "paramètre 'famille' manquant ou invalide";
return withCors(QHttpServerResponse(QJsonDocument(err).toJson(), QHttpServerResponder::StatusCode::BadRequest));
}
QJsonArray elements;
if (type == "circuits") {
QSqlQuery q;
q.prepare(
"SELECT Cle_primaire, Etat_systeme, Nom, Etat_commande_carte, Mode_commande, Etat, Consigne, Old_consigne, "
"Mode_test, Tension, Intensite, Frequence, "
"(SELECT Type FROM TB_Modules_config WHERE Adresse_k_bus=TB_Circuits.Adresse_module) AS type_circuit, "
"No_circuit, "
"(SELECT COUNT(*) FROM TB_Events WHERE Validite=1 AND Visibilite=1 AND "
"(Action_circuits LIKE CONCAT(TB_Circuits.Cle_primaire,'/%') OR Action_circuits LIKE CONCAT('%;', TB_Circuits.Cle_primaire,'/%'))) AS nb_events, "
"Validation_cdes_events, "
"(SELECT COUNT(*) FROM TB_Events WHERE Validite=1 AND Type_source=:type AND Alarme_source>0 AND Etat_test=1 "
"AND ID_Source=TB_Circuits.Cle_primaire) AS Nb_alarmes "
"FROM TB_Circuits WHERE Priorite_affichage_accueil>0 AND ID_Famille=:famille "
"ORDER BY Priorite_affichage_accueil, Cle_primaire"
);
q.bindValue(":type", TYPE_SOURCE_CIRCUIT);
q.bindValue(":famille", idFamille);
q.exec();
while (q.next()) {
QJsonObject obj;
obj["id"] = q.value(0).toInt();
obj["etat_systeme"] = q.value(1).toInt();
obj["nom"] = q.value(2).toString();
obj["etat_commande_carte"] = q.value(3).toInt();
obj["mode_commande"] = q.value(4).toInt();
obj["etat"] = q.value(5).toInt();
obj["consigne"] = q.value(6).toInt();
obj["old_consigne"] = q.value(7).toInt();
obj["mode_test"] = q.value(8).toInt();
obj["tension"] = q.value(9).toDouble();
obj["intensite"] = q.value(10).toDouble();
obj["frequence"] = q.value(11).toDouble();
obj["type_circuit"] = q.value(12).toInt();
obj["no_circuit"] = q.value(13).toInt();
obj["validation_cdes_events"] = (q.value(14).toInt() == 0) ? -1 : q.value(15).toInt();
obj["etat_events"] = q.value(16).toInt();
elements.append(obj);
}
} else if (type == "batteries") {
// Rappel : le champ "etat" retourné ici est le NOMBRE D'ALARMES,
// pas un code d'état comme pour les circuits - fidèle au modèle
// natif existant (modele_batteries), pas une incohérence introduite ici.
QSqlQuery q;
q.prepare(
"SELECT Cle_primaire, Etat_systeme, Nom, Type, Soc, Tension, Tension_nominale, "
"(SELECT COUNT(*) FROM TB_Events WHERE Validite=1 AND Type_source=:type AND Alarme_source>0 AND Etat_test=1 "
"AND ID_Source=TB_Batteries.Cle_primaire) AS Nb_alarmes "
"FROM TB_Batteries WHERE ID_Famille=:famille "
"ORDER BY Priorite_affichage_accueil"
);
q.bindValue(":type", TYPE_SOURCE_BATTERIE);
q.bindValue(":famille", idFamille);
q.exec();
while (q.next()) {
QJsonObject obj;
obj["id"] = q.value(0).toInt();
obj["etat_systeme"] = q.value(1).toInt();
obj["nom"] = q.value(2).toString();
obj["type_batterie"] = q.value(3).toInt();
obj["niveau"] = q.value(4).toDouble();
obj["tension"] = q.value(5).toDouble();
obj["tension_nominale"] = q.value(6).toDouble();
obj["etat"] = q.value(7).toInt();
elements.append(obj);
}
} else if (type == "capteurs") {
// Préférences d'unité du bateau (TB_Configuration) :
int uniteVolume = 0, uniteTemperature = 0, periodeObsolescenceNmea = 0;
{
QSqlQuery qc("SELECT Valeur FROM TB_Configuration WHERE Nom='Unite_volume'");
if (qc.next()) uniteVolume = qc.value(0).toInt();
}
{
QSqlQuery qc("SELECT Valeur FROM TB_Configuration WHERE Nom='Unite_temperature'");
if (qc.next()) uniteTemperature = qc.value(0).toInt();
}
{
QSqlQuery qc("SELECT Valeur FROM TB_Configuration WHERE Nom='Periode_obsolescence_capteur_nmea'");
if (qc.next()) periodeObsolescenceNmea = qc.value(0).toInt();
}
QSqlQuery q;
q.prepare(
"SELECT Cle_primaire, Etat_systeme, Nom, Type_entrees, Entrees, ID_Variable, Etat, "
"(SELECT COUNT(*) FROM TB_Events WHERE Validite=1 AND Type_source=:typeSource AND Alarme_source>0 AND Etat_test=1 "
"AND ID_Source=TB_Capteurs.Cle_primaire) AS Nb_alarmes, "
"Valeur, Precision_affichage_accueil, Liste_valeurs_textes, "
"IF(Type_entrees=:typeNmea, (SELECT (UNIX_TIMESTAMP() - UNIX_TIMESTAMP(Date_maj)) FROM TB_Nmea2000 "
"WHERE Pgn=SUBSTRING_INDEX(Entrees, ':', 1) AND Field=SUBSTRING_INDEX(Entrees, ':', -1)), 0) AS Age "
"FROM TB_Capteurs WHERE ID_Famille=:famille AND Priorite_affichage_accueil>0 "
"ORDER BY Priorite_affichage_accueil, Nom"
);
q.bindValue(":typeSource", TYPE_SOURCE_CAPTEUR);
q.bindValue(":typeNmea", TYPE_ENTREES_NMEA);
q.bindValue(":famille", idFamille);
q.exec();
while (q.next()) {
const int id = q.value(0).toInt();
const int etatSysteme = q.value(1).toInt();
const QString nom = q.value(2).toString();
const int typeEntrees = q.value(3).toInt();
const int idVariable = q.value(5).toInt();
const int etatCapteur = q.value(6).toInt();
const int nbAlarmes = q.value(7).toInt();
const double valeurBrute = q.value(8).toDouble();
const int precision = q.value(9).toInt();
const QString listeValeursTextes = q.value(10).toString();
const int age = q.value(11).toInt();
// Résolution de l'unité/conversion via TB_Variables :
QSqlQuery qv;
qv.prepare("SELECT Unite, Conversion_unite FROM TB_Variables WHERE Cle_primaire=:id");
qv.bindValue(":id", idVariable);
qv.exec();
QString uniteBrute;
int typeUnite = 0;
if (qv.next()) {
uniteBrute = qv.value(0).toString();
typeUnite = qv.value(1).toInt();
}
QJsonObject obj;
obj["id"] = id;
obj["etat_systeme"] = etatSysteme;
obj["nom"] = nom;
obj["etat"] = etatCapteur;
obj["etat_events"] = nbAlarmes;
if (typeUnite == TYPE_UNITE_LATITUDE) {
obj["valeur"] = chaine_latitude(valeurBrute);
obj["valeur_texte"] = true;
obj["unite"] = QString();
} else if (typeUnite == TYPE_UNITE_LONGITUDE) {
obj["valeur"] = chaine_longitude(valeurBrute);
obj["valeur_texte"] = true;
obj["unite"] = QString();
} else {
// Cas des listes de valeurs/textes (entrées AUX ou booléen calculé) :
QString texteListe;
if (typeEntrees == TYPE_ENTREES_AUX || typeEntrees == TYPE_ENTREES_CALCULEE_BOOLEEN) {
const auto paires = listeValeursTextes.split(';');
for (const auto &paire : paires) {
const auto champs = paire.split('/');
if (champs.size() == 2 && champs[0].toDouble() == valeurBrute) {
texteListe = champs[1];
break;
}
}
}
if (!texteListe.isEmpty()) {
obj["valeur"] = texteListe;
obj["valeur_texte"] = true;
obj["unite"] = QString();
} else {
double valeurConvertie = valeurBrute;
QString symboleUnite = uniteBrute;
if (typeUnite == TYPE_UNITE_VOLUME) {
valeurConvertie = conversion_volume(valeurBrute, uniteVolume);
symboleUnite = symbole_unite_volume(uniteVolume);
} else if (typeUnite == TYPE_UNITE_TEMPERATURE) {
valeurConvertie = conversion_temperature(valeurBrute, uniteTemperature);
symboleUnite = symbole_unite_temperature(uniteTemperature);
}
// Toujours une chaîne (même pour les nombres) - évite que QML
// ne fige le rôle 'valeur' en type numérique lors d'une famille
// visitée avant "Position" (latitude/longitude), qui tronquerait
// alors ces dernières à leur seul chiffre de tête.
obj["valeur"] = QString::number(valeurConvertie, 'f', precision);
obj["valeur_texte"] = false;
obj["unite"] = symboleUnite;
}
}
obj["obsolete"] = (typeEntrees == TYPE_ENTREES_NMEA && age > periodeObsolescenceNmea);
elements.append(obj);
}
} else if (type == "reservoirs") {
QSqlQuery q;
q.prepare(
"SELECT Cle_primaire, Nom, Etat_systeme, Niveau, Capacite, Logique, "
"(SELECT COUNT(*) FROM TB_Events WHERE Validite=1 AND Type_source=:type AND Alarme_source>0 AND Etat_test=1 "
"AND ID_Source=TB_Reservoirs.Cle_primaire) AS Nb_alarmes, "
"Etat_entrees "
"FROM TB_Reservoirs WHERE ID_Famille=:famille "
"ORDER BY Priorite_affichage_accueil"
);
q.bindValue(":type", TYPE_SOURCE_RESERVOIR);
q.bindValue(":famille", idFamille);
q.exec();
while (q.next()) {
const int etatSysteme = q.value(2).toInt();
const int nbAlarmes = q.value(6).toInt();
const int etatEntrees = q.value(7).toInt();
// État agrégé, même règle que le natif (mise_a_jour_reservoirs()) :
// rouge si Etat_systeme en défaut ou défaut d'ordre des sondes AUX,
// sinon orange si au moins une alarme, sinon vert.
int etat = 0;
if (etatSysteme < 0 || etatEntrees > 0) etat = 2;
else if (nbAlarmes > 0) etat = 1;
QJsonObject obj;
obj["id"] = q.value(0).toInt();
obj["nom"] = q.value(1).toString();
obj["etat_systeme"] = etatSysteme;
obj["niveau"] = q.value(3).toDouble();
obj["capacite"] = q.value(4).toDouble();
obj["logique"] = q.value(5).toInt();
obj["etat_events"] = nbAlarmes;
obj["etat_entrees"] = etatEntrees;
obj["etat"] = etat;
elements.append(obj);
}
}
QJsonObject reponse;
reponse["status"] = "ok";
reponse["elements"] = elements;
return withCors(QHttpServerResponse(QJsonDocument(reponse).toJson()));
});
// ------------------------------------------------------------------
// PATCH /elements/circuit/<id>
// Écriture rapide (bouton d'accueil) - PAS le formulaire de config
// complet (config_circuit.qml, avec orchestration esclave/maître,
// §20.7) qui reste un futur endpoint séparé. Reproduit fidèlement
// changement_consigne()/toggle_cdes_auto() (identiques dans circuit.qml
// et Shipheart_bouton_circuit.qml).
// ------------------------------------------------------------------
server.route("/elements/circuit/<arg>", QHttpServerRequest::Method::Patch,
[](int idCircuit, const QHttpServerRequest &request) {
const QJsonDocument body = QJsonDocument::fromJson(request.body());
if (!body.isObject()) {
QJsonObject err;
err["status"] = "erreur";
err["message"] = "corps de requête JSON invalide";
return withCors(QHttpServerResponse(QJsonDocument(err).toJson(), QHttpServerResponder::StatusCode::BadRequest));
}
const QJsonObject obj = body.object();
bool ecritureEffectuee = false;
// Changement de consigne :
if (obj.contains("consigne")) {
int consigne = obj["consigne"].toInt();
if (consigne < 0) consigne = 0;
if (consigne > 100) consigne = 100;
QString req = QString("UPDATE TB_Circuits SET New_consigne=%1 ").arg(consigne);
if (obj.contains("old_consigne")) {
req += QString(", Old_consigne=%1 ").arg(obj["old_consigne"].toInt());
}
req += QString("WHERE Cle_primaire='%1'").arg(idCircuit);
QSqlQuery q(req);
ecritureEffectuee = true;
}
// Bascule du mode "commandes automatiques" (Events) :
if (obj.contains("validation_cdes_events")) {
const int mode = obj["validation_cdes_events"].toInt() != 0 ? 1 : 0;
QSqlQuery q(QString("UPDATE TB_Circuits SET Validation_cdes_events=%1 WHERE Cle_primaire='%2'").arg(mode).arg(idCircuit));
ecritureEffectuee = true;
}
if (!ecritureEffectuee) {
QJsonObject err;
err["status"] = "erreur";
err["message"] = "aucun champ reconnu (attendu : consigne, validation_cdes_events)";
return withCors(QHttpServerResponse(QJsonDocument(err).toJson(), QHttpServerResponder::StatusCode::BadRequest));
}
// Signale à l'Appli qu'un changement est en attente, pour un
// traitement rapide (100ms maxi) plutôt que son cycle normal
// (cf synchro_bdd(shipheart_type_synchro_data) du natif) :
QSqlQuery("UPDATE TB_Systeme SET Valeur=1 WHERE Nom=\"Synchro\"");
QJsonObject reponse;
reponse["status"] = "ok";
return withCors(QHttpServerResponse(QJsonDocument(reponse).toJson()));
});
// Réponse au "preflight" CORS (requête OPTIONS automatique du navigateur
// avant tout PATCH avec Content-Type: application/json) - sans elle, le
// navigateur abandonne silencieusement la vraie requête PATCH avant même
// de l'envoyer.
server.route("/elements/circuit/<arg>", QHttpServerRequest::Method::Options,
[](int) {
QHttpServerResponse resp(QHttpServerResponder::StatusCode::NoContent);
QHttpHeaders headers = resp.headers();
headers.append(QHttpHeaders::WellKnownHeader::AccessControlAllowOrigin, "*");
headers.append(QHttpHeaders::WellKnownHeader::AccessControlAllowMethods, "GET, PATCH, OPTIONS");
headers.append(QHttpHeaders::WellKnownHeader::AccessControlAllowHeaders, "Content-Type");
resp.setHeaders(std::move(headers));
return resp;
});
auto tcpServer = new QTcpServer();
if (!tcpServer->listen(QHostAddress::Any, 8080) || !server.bind(tcpServer)) {
qCritical() << "Impossible de démarrer le serveur HTTP sur le port 8080.";
delete tcpServer;
return 1;
}
qInfo() << "shipheart_api en écoute sur le port" << tcpServer->serverPort();
return app.exec();
}
shipheart_api_circuits.zip
BIN
View File
Binary file not shown.