version-pc-pid-upload/processthread.cpp

#include "processthread.h"
#include "api/configapi.h"
#include "appevent.h"
#include "processmodel.h"
#include "qjsonarray.h"
#include "qjsonobject.h"
#include <cwf/sqldatabasestorage.h>
#include <optional>

#include "api/processapi.h"
#include "qjsonvalue.h"
#include "qlist.h"
#include "qmessagebox.h"
#include "qnamespace.h"

#include "basemainTr.h"

CWF::SqlDatabaseStorage storage("QSQLITE", "localhost", "postgres", "postgres", "1234", 5432);

// 将 FILETIME 转换为 Unix 时间戳
static qint64 fileTimeToUnixTimestamp(FILETIME ft)
{
    // FILETIME 是自 1601 年以来的 100 毫微秒数
    ULARGE_INTEGER ull;
    ull.LowPart = ft.dwLowDateTime;
    ull.HighPart = ft.dwHighDateTime;
    // FILETIME 和 时间戳的 基础时间不一样
    // 转换为秒，并减去 1601 到 1970 年之间的秒数
    if (ull.QuadPart / 10000000LL > 11644473600LL) {
        qint64 timestamp = ull.QuadPart / 10000000LL - 11644473600LL;
        return timestamp;
    }
    return ull.QuadPart / 10000000LL;
}
QString convertSecondsToTimeFormat(int totalSeconds)
{
    int days = totalSeconds / (24 * 3600);           // 计算天数
    int hours = (totalSeconds % (24 * 3600)) / 3600; // 计算小时
    int minutes = (totalSeconds % 3600) / 60;        // 计算分钟
    int seconds = totalSeconds % 60;                 // 计算秒数

    // 返回格式化后的字符串，并使用 tr() 标记可翻译的文本
    return QString(Tr::tr("%1days%2hours%3minutes%4seconds"))
        .arg(days)
        .arg(hours)
        .arg(minutes)
        .arg(seconds);
}
///
/// \brief 转换到分钟
/// \param totalSeconds
/// \return
///
QString convertSecondsToMinutesTimeFormat(int totalSeconds)
{
    // 只计算分钟
    int minutes = totalSeconds / 60;
    return QString::number(minutes);
}
void ProcessThread::sendExitTime(qint64 updataTime)
{
    ProcessModel processModel{storage};
    // 在数据库 获取 不是这个更新日期的数据

    CWF::SqlQueryManager qry(storage);
    qry.select("*", processModel.getTableName())
        .where(QString("updataTime != '%1' OR updataTime IS NULL").arg(updataTime));
    qry.prepare();
    QJsonObject jsonObject = qry.exec();

    QJsonArray jsonArray = qry.toJson();

    QJsonArray sendJsonArray;
    if (jsonArray.size() > 0) {
        for (const auto &json : jsonArray) {
            const QJsonObject object = json.toObject();
            QJsonObject sendObject;
            sendObject.insert("pid", object["pid"]);
            sendObject.insert("pid_name", object["processName"]);
            sendObject.insert("begin_time", object["creationTime"]);
            sendObject.insert("end_time", object["exitTime"]);
            sendObject.insert("last_check_time", object["updataTime"]);
            sendObject.insert("status", 1);
            sendObject.insert("notes", "");
            sendJsonArray.append(sendObject);
        }
    }
    // 上传 后 删除
    if (sendJsonArray.size() > 0) {
        TC::ProcessApi processApi(sendJsonArray);
        bool isSendok = processApi.post();
        if (isSendok) {
            // 移除发送到服务器的本地数据
            CWF::SqlQueryManager qry(storage);
            qry.remove(processModel.getTableName(),
                       QString("updataTime != '%1' OR updataTime IS NULL").arg(updataTime));
            qry.prepare();
            QJsonObject jsonObject = qry.exec();

            QJsonArray jsonArray = qry.toJson();
        }
    }
    bool isok = false;
    QVariant timeVariant = AppEvent::instance()->configReadValue("ProcessOutTime", &isok);

    int time = 0;
    if (isok) {
        time = timeVariant.toLongLong();
    } else {
        // 服务器时间
        TC::ConfigApi configApi("swrunTime");
        std::optional<QVariant> value = configApi.get();
        if (value.has_value()) {
            time = value.value().toInt();
        }
    }

    QVariant messageBoxPointX = QVariant();
    QVariant messageBoxPointY = QVariant();
    QVariant messageText = QVariant("");
    QVariant messageTitle = QVariant(Tr::tr("Tips"));
    {
        TC::ConfigApi configApi("messageBoxPointX");
        std::optional<QVariant> value = configApi.get();
        if (value.has_value()) {
            messageBoxPointX = value.value().toInt();
        }
    }
    {
        TC::ConfigApi configApi("messageBoxPointY");
        std::optional<QVariant> value = configApi.get();
        if (value.has_value()) {
            messageBoxPointY = value.value().toInt();
        }
    }
    {
        TC::ConfigApi configApi("messageText");
        std::optional<QVariant> value = configApi.get();
        if (value.has_value()) {
            messageText = value.value().toString();
        }
    }
    {
        TC::ConfigApi configApi("messageTitle");
        std::optional<QVariant> value = configApi.get();
        if (value.has_value()) {
            messageTitle = value.value().toString();
        }
    }

    QMap<QString, QString> messageProcessName;

    TC::ProcessNameApi processNameApi;
    QJsonArray array = processNameApi.get();
    for (const auto item : array) {
        if (item.isObject()) {
            const auto object = item.toObject();

            const QString name = object["name"].toString();
            const QString zhName = object["chinese_name"].toString();
            if (object.contains("is_prompt")) {
                if (object["is_prompt"].toInt() == 2) {
                    messageProcessName[name] = zhName;
                };
            }
        }
    }
    // messageProcessName["WeChat.exe"] = "WeChat.exe";

    // 提示
    // SELECT * FROM ProcessTime  WHERE (updataTime - lastAlertTime) > 1565;
    if (time > 0) {
        CWF::SqlQueryManager qry(storage);
        qry.select("*", processModel.getTableName())
            .where(QString("(updataTime - lastAlertTime) > %1").arg(time));
        qry.prepare();
        QJsonObject jsonObject = qry.exec();
        QJsonArray jsonArray = qry.toJson();

        const QStringList keys = messageProcessName.keys();

        for (const auto &value : jsonArray) {
            // SLDWORKS.exe

            const QJsonObject object = value.toObject();
            const QString processName = object["processName"].toString();
            const qint64 runTime = object["exitTime"].toVariant().toLongLong()
                                   - object["creationTime"].toVariant().toLongLong();

            for (const QString &key : keys) {
                if (processName.compare(key, Qt::CaseSensitivity::CaseInsensitive) == 0) {
                    // QVariant messageBoxPointX = QVariant();
                    // QVariant messageBoxPointY = QVariant();
                    // QVariant messageText = QVariant("");
                    // QVariant messageTitle = QVariant(Tr::tr("Tips"));
                    // Program A has been used for 20 minutes, please exercise

                    // const QString text = QString(tr("program %1 %3 run time :%2")
                    //                                  .arg(messageProcessName[key])
                    //                                  .arg(convertSecondsToTimeFormat(runTime))
                    //                                  .arg(messageText.toString()));

                    const QString text = QString(tr("Program %1 has been used for %2 minutes%3")
                                                     .arg(messageProcessName[key])
                                                     .arg(convertSecondsToMinutesTimeFormat(runTime))
                                                     .arg(messageText.toString()));
                    emit messageBox(text, messageBoxPointX, messageBoxPointY, messageTitle);
                }
            }

            // 更新 lastAlertTime
            ProcessModel processModel{storage};
            processModel.buildFromJson(object);
            // 更新 消息时间
            processModel.setLastAlertTime(updataTime);
            processModel.save();
        }
    }
}

bool ProcessThread::upDataProcessSql()
{
    std::vector<std::shared_ptr<ProcessMonitor::ProcessInfo>> timeProcessVector
        = processMonitor.checkProcesses();

    // 退出时间默认当前时间 然后更新
    auto exitTimestamp = QDateTime::currentSecsSinceEpoch();
    auto updataTimestamp = QDateTime::currentSecsSinceEpoch();
    QStringList sqlValues;

    for (auto timeProcess : timeProcessVector) {
        qint64 timestamp = fileTimeToUnixTimestamp(timeProcess->creationTime);

        ProcessModel processModel{storage};
        CWF::SqlQueryManager qry(storage);
        qry.select("*", processModel.getTableName())
            .where(QString("pid == '%1' AND processName == '%2'")
                       .arg(timeProcess->pid)
                       .arg(timeProcess->processName.c_str()));
        qry.prepare();
        QJsonObject jsonObject = qry.exec();
        if (jsonObject["success"].toBool()) {
            // 查询或者替换 ?
            QJsonArray array = qry.toJson();
            if (array.size() > 0) {
                // 替换
                for (const QJsonValue &info : array) {
                    const QJsonObject object = info.toObject();
                    //数据还原到 结构体
                    processModel.buildFromJson(object);
                    // 更新 结束时间
                    processModel.setExitTime(exitTimestamp);
                    processModel.setUpdataTime(updataTimestamp);
                    processModel.save();
                }
            } else {
                // 插入数据
                processModel.setProcessName(timeProcess->processName.c_str());
                processModel.setPid(timeProcess->pid);
                processModel.setCreationTime(timestamp);
                processModel.setExitTime(exitTimestamp);
                processModel.setUpdataTime(updataTimestamp);
                processModel.setLastAlertTime(updataTimestamp);
                processModel.save();
            }
        }
        // qDebug().noquote().nospace() << jsonObject << qry.toJson();

        // jsonObject.insert("begin_time", object["creationTime"]);
        // jsonObject.insert("end_time", object["exitTime"]);
        // jsonObject.insert("last_check_time", object["updataTime"]);
        // jsonObject.insert("status", 1);
        // jsonObject.insert("notes", "");
        // FILETIME ft = timeProcess->creationTime;
        // FILETIME currentTime;
        // GetSystemTimeAsFileTime(&currentTime);

        // ULARGE_INTEGER creation, current;
        // creation.LowPart = ft.dwLowDateTime;
        // creation.HighPart = ft.dwHighDateTime;
        // current.LowPart = currentTime.dwLowDateTime;
        // current.HighPart = currentTime.dwHighDateTime;

        // ULONGLONG elapsedSeconds = (current.QuadPart - creation.QuadPart) / 10000000;

        // // 计算天、小时、分钟和秒
        // ULONGLONG days = elapsedSeconds / 86400;           // 1天 = 86400秒
        // ULONGLONG hours = (elapsedSeconds % 86400) / 3600; // 1小时 = 3600秒
        // ULONGLONG minutes = (elapsedSeconds % 3600) / 60;  // 1分钟 = 60秒
        // ULONGLONG seconds = elapsedSeconds % 60;           // 剩余秒数

        // // 打印进程的运行时间
        // qDebug() << QString::fromStdString(timeProcess->processName) //
        //          << days << hours << minutes << seconds << timestamp;

        /*
INSERT OR REPLACE INTO ProcessTime (pid, processName, creationTime, exitTime)
VALUES
  (123, 'process1', strftime('%s', 'now'), strftime('%s', 'now')),
  (124, 'process2', strftime('%s', 'now'), strftime('%s', 'now')),
  (125, 'process3', strftime('%s', 'now'), strftime('%s', 'now'));
*/
        // sqlValues.append(QString("(%1,'%2',%3,%4,%5)")
        //                      .arg(timeProcess->pid)                 // pid
        //                      .arg(timeProcess->processName.c_str()) // 进程名
        //                      .arg(timestamp)                        // 开始时间戳
        //                      .arg(exitTimestamp)                    // 结束时间戳
        //                      .arg(updataTimestamp));                // 数据更新时间
    }

    //     const QString query = QString(
    //                               R"(INSERT OR REPLACE INTO ProcessTime
    // (pid, processName, creationTime, exitTime, updataTime)
    // VALUES
    // %1)")
    //                               .arg(sqlValues.join(","));

    //     // 使用上述插入或者替换
    //     // 首先查找
    //     QString where;
    //     CWF::SqlQueryManager qry(storage);
    //     QJsonObject jsonObject = qry.exec(query);

    // 发送更新后的数据
    sendExitTime(updataTimestamp);

    // if (jsonObject.contains("success")) {
    //     if (jsonObject["success"].toBool()) {
    //         return true;
    //     }
    // }
    return false;
}

ProcessThread::ProcessThread(
    QObject *parent)
    : QThread{parent}
{}

void ProcessThread::run()
{
    ProcessModel processModel{storage};
    processModel.updateDB();
    {
        const QString query = QString("CREATE UNIQUE INDEX %2_%3_unique ON %1 (%2, %3);")
                                  .arg(processModel.getTableName())
                                  .arg("pid")
                                  .arg("processName");
        CWF::SqlQuery qry(storage);
        qry.exec(query);
    }
    QElapsedTimer timer; // 创建高精度计时器
    timer.start();       // 启动计时器

    upDataProcessSql();

    while (true) {
        // 校验网络
        if (timer.elapsed() >= 30 * 1000) { // 检查是否经过1分钟
            timer.restart();                // 重新启动计时器

            upDataProcessSql();
        }
        msleep(1000); // 休息1秒
    }
}