vl_databaselogger: WIP: create rpcs to generate report files in Json …

lib/vl_abstractloggerdb.h

@@ -37,6 +37,8 @@ public slots:
     virtual QVariant readSessionComponent(const QString &dbSessionName, const QString &entityName, const QString &componentName) = 0;
     virtual QJsonObject displaySessionsInfos(const QString &sessionName) = 0;
     virtual bool deleteTransaction(const QString &transactionName) = 0;
+    virtual QString createAllSessionsJson(QString loggerDbPath) = 0;
+    virtual QString createTransationsJson(QString session, QString loggerDbPath) = 0;
 
     virtual bool addStartTime(int t_transactionId, QDateTime t_time) = 0;
     virtual bool addStopTime(int t_transactionId,  QDateTime t_time) = 0;
@@ -45,6 +47,8 @@ public slots:
     virtual void addLoggedValue(const QString &dbSessionName, QVector<int> t_transactionIds, VeinLogger::DatabaseCommandInterface::ComponentInfo component) = 0;
 
     virtual void runBatchedExecution() = 0; // Another implementation detail which must go
+    virtual QStringList getSessionsName() = 0;
+
 };
 
 /// @b factory function alias to create database

lib/vl_databaselogger.cpp

@@ -353,6 +353,49 @@ void DatabaseLogger::terminateCurrentDb()
     m_database = nullptr;
 }
 
+bool DatabaseLogger::deleteSessionJsonFile(QString sessionName)
+{
+    bool removeOk = false;
+    QDir dir = QFileInfo(m_databaseFilePath ).dir();
+    QString filePath = dir.absolutePath() + "/" + sessionName + ".json";
+    if(QFile::exists(filePath)) {
+        if (QFile::remove(filePath))
+            removeOk = true;
+    }
+    return removeOk;
+}
+
+void DatabaseLogger::deleteTransactionFromJsonFile(QString sessionName, QString transactionName)
+{
+    QDir dir = QFileInfo(m_databaseFilePath ).dir();
+    QString filePath = dir.absolutePath() + "/" + sessionName + ".json";
+    QFile file(filePath);
+    if(!file.open(QIODevice::ReadOnly)) {
+        qDebug() << "Failed to open file for reading";
+        return;
+    }
+
+    QByteArray jsonData = file.readAll();
+    file.close();
+    QJsonDocument jsonDoc = QJsonDocument::fromJson(jsonData);
+    QJsonArray jsonArray = jsonDoc.array();
+    QJsonArray newArray;
+    for (const QJsonValue &value : jsonArray) {
+        if(value.isObject()) {
+            QJsonObject obj = value.toObject();
+            if (obj.value("transactionName").toString() != transactionName)
+                newArray.append(obj);
+        }
+    }
+    jsonDoc.setArray(newArray);
+    if (!file.open(QIODevice::WriteOnly)) {
+        qDebug() << "Failed to open file for writing";
+        return;
+    }
+    file.write(jsonDoc.toJson());
+    file.close();
+}
+
 void DatabaseLogger::closeDatabase()
 {
     if(m_databaseFilePath.isEmpty())
@@ -483,6 +526,7 @@ QVariant DatabaseLogger::RPC_deleteSession(QVariantMap parameters)
         m_dbSessionName = "";
         emit sigSendEvent(new VeinEvent::CommandEvent(VeinEvent::CommandEvent::EventSubtype::NOTIFICATION, sessionNameCData));
     }
+    retVal = retVal.toBool() && deleteSessionJsonFile(session);
     return retVal;
 }
 
@@ -503,9 +547,28 @@ QVariant DatabaseLogger::RPC_displaySessionsInfos(QVariantMap parameters)
 QVariant DatabaseLogger::RPC_deleteTransaction(QVariantMap parameters)
 {
     QString transactionName = parameters["p_transaction"].toString();
+    QString selectedSession = parameters["p_selectedSession"].toString();
+    deleteTransactionFromJsonFile(selectedSession, transactionName);
     return m_database->deleteTransaction(transactionName);
 }
 
+QVariant DatabaseLogger::RPC_CreateAllSessionsJson(QVariantMap parameters)
+{
+    QVariant retval;
+    m_database->createAllSessionsJson(m_databaseFilePath);
+    return retval;
+}
+
+QVariant DatabaseLogger::RPC_CreateTransactionsJson(QVariantMap parameters)
+{
+    QVariant retval;
+    QString session = parameters["p_session"].toString();
+    if(session == "")
+        return retval;
+    m_database->createTransationsJson(session, m_databaseFilePath);
+    return retval;
+}
+
 void DatabaseLogger::initOnce()
 {
     Q_ASSERT(m_initDone == false);
@@ -575,7 +638,25 @@ void DatabaseLogger::initOnce()
                                                 this,
                                                 this,
                                                 "RPC_deleteTransaction",
-                                                VfCpp::cVeinModuleRpc::Param({{"p_transaction", "QString"}})),
+                                                VfCpp::cVeinModuleRpc::Param({{"p_transaction", "QString"}, {"p_selectedSession", "QString"}})),
+                                            &QObject::deleteLater);
+        m_rpcList[tmpval->rpcName()]=tmpval;
+
+        tmpval= VfCpp::cVeinModuleRpc::Ptr(new VfCpp::cVeinModuleRpc(
+                                                m_entityId,
+                                                this,
+                                                this,
+                                                "RPC_CreateAllSessionsJson",
+                                                VfCpp::cVeinModuleRpc::Param({})),
+                                            &QObject::deleteLater);
+        m_rpcList[tmpval->rpcName()]=tmpval;
+
+        tmpval= VfCpp::cVeinModuleRpc::Ptr(new VfCpp::cVeinModuleRpc(
+                                                m_entityId,
+                                                this,
+                                                this,
+                                                "RPC_CreateTransactionsJson",
+                                                VfCpp::cVeinModuleRpc::Param({{"p_session", "QString"}})),
                                             &QObject::deleteLater);
         m_rpcList[tmpval->rpcName()]=tmpval;
 

lib/vl_databaselogger.h

@@ -36,6 +36,8 @@ public slots:
     QVariant RPC_deleteSession(QVariantMap parameters);
     QVariant RPC_displaySessionsInfos(QVariantMap parameters);
     QVariant RPC_deleteTransaction(QVariantMap parameters);
+    QVariant RPC_CreateAllSessionsJson(QVariantMap parameters);
+    QVariant RPC_CreateTransactionsJson(QVariantMap parameters);
 
 private slots:
     void initOnce();
@@ -62,6 +64,8 @@ private slots:
     void writeCurrentStorageToDb();
     QStringList getComponentsFilteredForDb(int entityId);
     void terminateCurrentDb();
+    bool deleteSessionJsonFile(QString sessionName);
+    void deleteTransactionFromJsonFile(QString sessionName, QString transactionName);
 
     int m_entityId;
     QLatin1String m_entityName;

lib/vl_sqlitedb.cpp

@@ -612,6 +612,63 @@ bool SQLiteDB::deleteTransaction(const QString &transactionName)
     return false;
 }
 
+QString SQLiteDB::createAllSessionsJson(QString loggerDb)
+{
+    QJsonArray jsonArray;
+    QSqlQuery sessionQuery("SELECT * FROM sessions WHERE session_name NOT LIKE '_DELETED_%';", m_dPtr->m_logDB);
+    while (sessionQuery.next()) {
+        QJsonObject sessionsJson;
+        sessionsJson["id"] = sessionQuery.value(0).toString();
+        sessionsJson["sessionName"] = sessionQuery.value(1).toString();
+        jsonArray.append(sessionsJson);
+    }
+    sessionQuery.finish();
+
+    QJsonDocument jsonDoc(jsonArray);
+    QDir dir = QFileInfo(loggerDb).dir();
+    QString LoggerPath = dir.absolutePath() + "/AllSessions.json";
+    QFile file(LoggerPath);
+    if (!file.open(QIODevice::WriteOnly)) {
+        //return error;
+    }
+    file.write(jsonDoc.toJson());
+    file.close();
+    return "";
+}
+
+QString SQLiteDB::createTransationsJson(QString session, QString loggerDb)
+{
+    QJsonArray jsonArr;
+    QSqlQuery transactionQuery(m_dPtr->m_logDB);
+    transactionQuery.prepare("SELECT transactions.transaction_name, transactions.contentset_names, transactions.start_time"
+                               " FROM sessions INNER JOIN"
+                               " transactions ON sessions.id = transactions.sessionid"
+                               " WHERE session_name= :sessionName AND transactions.transaction_name NOT LIKE '_DELETED_%';");
+    transactionQuery.bindValue(":sessionName", session);
+    transactionQuery.exec();
+    while(transactionQuery.next()){
+        QString transactionName = transactionQuery.value("transaction_name").toString();
+        QString contentset = transactionQuery.value("contentset_names").toString();
+        QString startTime = transactionQuery.value("start_time").toString();
+        QJsonObject dataJson;
+        dataJson["transactionName"] = transactionName;
+        dataJson["contentset"] = contentset;
+        dataJson["startTime"] = startTime;
+        jsonArr.append(dataJson);
+    }
+    QJsonDocument jsonDoc(jsonArr);
+
+    QDir dir = QFileInfo(loggerDb).dir();
+    QString LoggerPath = dir.absolutePath() + "/" + session + ".json";
+    QFile file(LoggerPath);
+    if (!file.open(QIODevice::WriteOnly)) {
+        //return error;
+    }
+    file.write(jsonDoc.toJson());
+    file.close();
+    return "";
+}
+
 void SQLiteDB::onOpen(const QString &dbPath)
 {
     QFileInfo fInfo(dbPath);
@@ -866,6 +923,11 @@ void SQLiteDB::runBatchedExecution()
     }
 }
 
+QStringList SQLiteDB::getSessionsName()
+{
+    return m_dPtr->m_sessionIds.keys();
+}
+
 void SQLiteDB::writeStaticData(QVector<SQLBatchData> p_batchData)
 {
     if(m_dPtr->m_logDB.isOpen()) {

lib/vl_sqlitedb.h

@@ -48,11 +48,14 @@ public slots:
     QVariant readSessionComponent(const QString &session, const QString &enity, const QString &component) override;
     QJsonObject displaySessionsInfos(const QString &sessionName) override;
     bool deleteTransaction(const QString &transactionName) override;
+    QString createAllSessionsJson(QString loggerDb) override;
+    QString createTransationsJson(QString session, QString loggerDb) override;
 
     void onOpen(const QString &dbPath) override;
     bool isDbStillWitable(const QString &dbPath);
 
     void runBatchedExecution() override;
+    QStringList getSessionsName() override;
 
 protected:
     virtual void addComponent(const QString &componentName);
@@ -66,7 +69,6 @@ public slots:
     void writeStaticData(QVector<SQLBatchData> p_batchData);
     void setValidTransactions();
 
-
     DBPrivate *m_dPtr = nullptr;
 };
 

testlib/testloggerdb.cpp

@@ -197,6 +197,16 @@ bool TestLoggerDB::deleteSession(const QString &session)
 
 }
 
+QString TestLoggerDB::createAllSessionsJson(QString loggerDb)
+{
+
+}
+
+QString TestLoggerDB::createTransationsJson(QString session, QString loggerDb)
+{
+
+}
+
 void TestLoggerDB::addLoggedValue(const QString &sessionName, QVector<int> transactionIds, VeinLogger::DatabaseCommandInterface::ComponentInfo component)
 {
     if(!transactionIds.contains(testTransactionId))
@@ -243,3 +253,8 @@ void TestLoggerDB::runBatchedExecution()
     // Surprise: This is a poor mimic of what SQLite implementation does
     addStopTime(testTransactionId, QDateTime());
 }
+
+QStringList TestLoggerDB::getSessionsName()
+{
+
+}

testlib/testloggerdb.h

@@ -32,6 +32,8 @@ class TestLoggerDB : public VeinLogger::AbstractLoggerDB
     bool deleteTransaction(const QString &transactionName) override;
     int addSession(const QString &sessionName, QList<VeinLogger::DatabaseCommandInterface::ComponentInfo> componentsStoredOncePerSession) override;
     bool deleteSession(const QString &session) override;
+    QString createAllSessionsJson(QString loggerDb) override;
+    QString createTransationsJson(QString session, QString loggerDb) override;
     void addLoggedValue(const QString &sessionName, QVector<int> transactionIds, VeinLogger::DatabaseCommandInterface::ComponentInfo component) override;
     void setNextValueWriteCount(int newValueWriteCount);
 
@@ -41,6 +43,7 @@ class TestLoggerDB : public VeinLogger::AbstractLoggerDB
     void onOpen(const QString &dbPath) override;
 
     void runBatchedExecution() override;
+    QStringList getSessionsName() override;
 
 // Test specific additions
     static TestLoggerDB* getCurrentInstance(); // no singleton!!!