exam_timer_teacher/tcontroller.cpp

#include "tcontroller.h"

#include "qglobal.h"
#include "qvariant.h"
#include "teachertr.h"
#include "tmodel.h"

#include <QDir>
#include <QJsonArray>
#include <QJsonObject>
#include <QMimeDatabase>

#include "appevent.h"
#include "qjsonwebtoken.h"

#include <cwf/filemanager.h>
#include <cwf/sqlquery.h>

#include <api/gradesapi.h>

static CWF::SqlDatabaseStorage storage("QSQLITE", "localhost", "data.db", "", "");
static const QLatin1String tokenSecret("mydirtysecret");
static QJsonObject getJwtToken(qint64 userid)
{
    QJsonWebToken token;
    const QDateTime time = QDateTime::currentDateTime();
    int expDate = 7;
    //当前时间
    token.setSecret(tokenSecret);
    token.appendClaim("iat", QString::number(time.toSecsSinceEpoch()));
    // 过期时间
    token.appendClaim("exp", QString::number(time.addDays(expDate).toSecsSinceEpoch()));
    token.appendClaim("userId", QString::number(userid));

    return QJsonObject{{"access_token", token.getToken()},
                       {"access_expire", time.addDays(expDate).toSecsSinceEpoch()},
                       {"refresh_after", time.addDays(expDate / 2).toSecsSinceEpoch()}};
}

static QStringList listFiles(const QString &path, const QString &basePath)
{
    QFileInfo info(path);
    if (info.isFile()) {
        return {path};
    }
    QDir dir(path);
    QStringList fileList;

    // 获取所有文件
    QFileInfoList files = dir.entryInfoList(QDir::Files | QDir::NoDotAndDotDot);
    foreach (QFileInfo file, files) {
        // 计算相对路径并添加到 fileList 中
        QString relativePath = dir.relativeFilePath(file.absoluteFilePath());
        fileList.append(relativePath);
    }

    // 递归获取子目录中的文件
    QFileInfoList dirs = dir.entryInfoList(QDir::Dirs | QDir::NoDotAndDotDot);
    foreach (QFileInfo subDir, dirs) {
        // 递归获取子目录的文件列表
        QStringList subDirFiles = listFiles(subDir.absoluteFilePath(), basePath);

        // 计算子目录相对于 basePath 的相对路径
        QString relativeSubDirPath = dir.relativeFilePath(subDir.absoluteFilePath());

        // 将子目录中的文件相对路径添加到 fileList 中
        foreach (QString subFile, subDirFiles) {
            fileList.append(relativeSubDirPath + "/" + subFile);
        }
    }

    return fileList;
}

void ConfigController::doGet(CWF::Request &request, CWF::Response &response) const
{
    // IP 地址是自己配置
    static QStringList filter = {"serverIP",
                                 "serverPort",
                                 "webSocketIP",
                                 "webSocketPort",
                                 "savedUsername",
                                 "savedPassword"};

    QJsonObject responseConfig;
    const QJsonObject object = AppEvent::instance()->config();
    for (auto it = object.constBegin(); it != object.constEnd(); ++it) {
        const QString key = it.key();
        if (!filter.contains(key)) {
            responseConfig.insert(key, it.value());
        }
    }
    response.write(QJsonObject{{"status", true},
                               {"message", TeacherServer::Tr::tr("ok")},
                               {"code", 200},
                               {"data", responseConfig}});
}

void LoginController::doPost(CWF::Request &request, CWF::Response &response) const
{
    // 获取服务器参数信息

    // qDebug() << request.getSession().getId();
    // qDebug() << request.getRequestURI() << request.getBody();
    QJsonParseError error;
    QJsonDocument jdc = QJsonDocument::fromJson(request.getBody(), &error);

    QJsonObject jsonObject = jdc.object();
    QJsonObject::const_iterator it = jsonObject.constBegin();
    QJsonObject::const_iterator end = jsonObject.constEnd();
    QMap<QByteArray, QByteArray> par;
    while (it != end) {
        par.insert(it.key().toUtf8(), it.value().toString().toUtf8());
        it++;
    }
    UserModel user(storage);
    request.fillQObject(&user, par, false);

    if (user.getName() == "123" && (user.getSwID() == "123" || user.getExamineeNumber() == "123")) {
        QJsonObject UserResponse{{"id", 0}, {"name", "123"}, {"JwtToken", getJwtToken(0)}};

        response.write(QJsonObject{{"status", true},
                                   {"message", TeacherServer::Tr::tr("Login succeeded")},
                                   {"code", 200},
                                   {"data", UserResponse}});
        return;
    }

    CWF::SqlQueryManager queryManager(storage);
    queryManager.select("*", user.getTableName()).where("name=?");
    queryManager.prepare();
    queryManager.addBindValue(user.getName());
    queryManager.exec();
    QJsonArray jsonArray = queryManager.toJson();
    if (jsonArray.isEmpty()) {
        response.write(QJsonObject{{"status", false},
                                   {"message", TeacherServer::Tr::tr("user does not exist")},
                                   {"code", 500},
                                   {"data", QJsonValue()}});
        return;
    }
    // QString name;
    // QString phone;
    // QString swID;
    // QString state;
    // QString examineeNumber;
    for (const QJsonValue &json : jsonArray) {
        if (json.isObject()) {
            QJsonObject obj = json.toObject();

            bool isok = false;
            if (obj.contains("swID")) {
                const QString swID = user.getSwID();
                if (obj["swID"] == user.getSwID() && !swID.isEmpty()) {
                    isok = true;
                }
            }
            if (obj.contains("examineeNumber")) {
                const QString examineeNumber = user.getExamineeNumber();
                if (obj["examineeNumber"] == examineeNumber && !examineeNumber.isEmpty()) {
                    isok = true;
                }
            }

            if (obj["state"].toInt() == 1) {
                response.write(
                    QJsonObject{{"status", false},
                                {"message",
                                 TeacherServer::Tr::tr("Login failed, The user has logged in")},
                                {"code", 500},
                                {"data", QJsonValue()}});
                return;
            }

            if (isok) {
                QJsonObject UserResponse{{"id", obj["id"]},
                                         {"name", obj["name"]},
                                         {"JwtToken", getJwtToken(obj["id"].toInt())}};

                response.write(QJsonObject{{"status", true},
                                           {"message", TeacherServer::Tr::tr("Login succeeded")},
                                           {"code", 200},
                                           {"data", UserResponse}});

                // 修改登录状态
                obj["state"] = 1;
                // 更新在线状态

                user.buildFromJson(obj);
                user.save();

                AppEvent::instance()->loginUser(obj["id"].toInt());
                return;
            }
        }
    }
    response.write(QJsonObject{{"status", false},
                               {"message", TeacherServer::Tr::tr("Login failed")},
                               {"code", 500},
                               {"data", QJsonValue()}});
}

void UserInfoController::doGet(CWF::Request &request, CWF::Response &response) const
{
    const QString authorization = request.getHttpParser().getHeaderField("Authorization");
    if (authorization.isEmpty()) {
        response.write(
            QJsonObject{{"status", false},
                        {"message", TeacherServer::Tr::tr("LoginOut failed, no find user")},
                        {"code", 500},
                        {"data", QJsonValue()}});
        return;
    }
    QJsonWebToken token = QJsonWebToken::fromTokenAndSecret(authorization.mid(7), tokenSecret);

    if (!token.isValid()) {
        response.write(QJsonObject{{"status", false},
                                   {"message", TeacherServer::Tr::tr("unauthorized")},
                                   {"code", response.SC_UNAUTHORIZED},
                                   {"data", QJsonValue()}});
        return;
    }
    QString userid = token.claim("userId");

    bool isok = false;
    qint64 id = userid.toLongLong(&isok, 10);

    if (id == 0) {
        QJsonObject userInfo;
        userInfo.insert("username", "123");
        userInfo.insert("maxTime", 0);
        userInfo.insert("checkinNumber", "--");

        response.write(QJsonObject{{"status", true},
                                   {"message", TeacherServer::Tr::tr("LoginOut succeeded")},
                                   {"code", 200},
                                   {"data", userInfo}});
        return;
    }

    UserModel user(storage);
    CWF::SqlQueryManager queryManager(storage);
    queryManager.select("*", user.getTableName()).where("id=?");
    queryManager.prepare();
    queryManager.addBindValue(id);
    queryManager.exec();
    QJsonArray jsonArray = queryManager.toJson();
    if (jsonArray.isEmpty()) {
        response.write(QJsonObject{{"status", false},
                                   {"message", TeacherServer::Tr::tr("user does not exist")},
                                   {"code", 500},
                                   {"data", QJsonValue()}});
        return;
    }

    for (const QJsonValue &json : jsonArray) {
        if (json.isObject()) {
            QJsonObject obj = json.toObject();

            int maxTime = obj.value("maxTime").toInt();
            if (maxTime == 0) { // 获取考题考试时间
                QString examContent;
                ///////////// 获取个人用户的考题
                CWF::SqlQuery query(storage);
                QJsonObject status = query.exec(QString("SELECT * FROM user WHERE id = %1").arg(id));
                if (status["success"].toBool()) {
                    const QJsonArray array = query.toJson();
                    if (!array.isEmpty()) {
                        QJsonObject object = array[0].toObject();
                        examContent = object["examTest"].toString();
                    }
                }
                qDebug() << "个人考试题目:" << examContent;
                UserModel user(storage);
                ExamsQuestionModel exams(storage);

                // 个人考试内容是空 获取默认选择的考试内容
                if (examContent.isEmpty() || examContent == "") {
                    CWF::SqlQuery query(storage);
                    QJsonObject status = query.exec(
                        QString("SELECT * FROM exams_question WHERE isSelect = 1"));
                    if (status["success"].toBool()) {
                        const QJsonArray array = query.toJson();
                        if (!array.isEmpty()) {
                            QJsonObject object = array[0].toObject();
                            examContent = object["name"].toString();
                        }
                    }
                }
                qDebug() << "使用考试题目时间:" << examContent;
                // 获取考试内容

                CWF::SqlQueryManager queryManager(storage);
                queryManager.select("*", exams.getTableName()).where("name = ?");
                queryManager.prepare();
                queryManager.addBindValue(examContent);
                queryManager.exec();
                QJsonArray jsonArray = queryManager.toJson();
                if (jsonArray.isEmpty()) {
                    response.write(
                        QJsonObject{{"status", false},
                                    {"message",
                                     TeacherServer::Tr::tr("Failed to obtain exam content")},
                                    {"code", 500},
                                    {"data", QJsonValue()}});
                    return;
                }
                qDebug() << "数据库考试题目时间:" << jsonArray;
                for (const QJsonValue &json : jsonArray) {
                    if (json.isObject()) {
                        QJsonObject obj = json.toObject();
                        maxTime = obj["maxTime"].toInt();
                    }
                }
            }

            QJsonObject userInfo;
            userInfo.insert("username", obj.value("name"));
            userInfo.insert("maxTime", maxTime);
            userInfo.insert("checkinNumber", obj.value("checkinNumber")); // 1 - name

            response.write(QJsonObject{{"status", true},
                                       {"message", TeacherServer::Tr::tr("LoginOut succeeded")},
                                       {"code", 200},
                                       {"data", userInfo}});

            return;
        }
    }
    response.write(QJsonObject{{"status", false},
                               {"message", TeacherServer::Tr::tr("Login failed")},
                               {"code", 500},
                               {"data", QJsonValue()}});
}
void LoginOutController::doPost(CWF::Request &request, CWF::Response &response) const
{
    const QString authorization = request.getHttpParser().getHeaderField("Authorization");
    if (authorization.isEmpty()) {
        response.write(
            QJsonObject{{"status", false},
                        {"message", TeacherServer::Tr::tr("LoginOut failed, no find user")},
                        {"code", 500},
                        {"data", QJsonValue()}});
        return;
    }
    QJsonWebToken token = QJsonWebToken::fromTokenAndSecret(authorization.mid(7), tokenSecret);

    if (!token.isValid()) {
        response.write(QJsonObject{{"status", false},
                                   {"message", TeacherServer::Tr::tr("unauthorized")},
                                   {"code", response.SC_UNAUTHORIZED},
                                   {"data", QJsonValue()}});
        return;
    }
    QString userid = token.claim("userId");

    bool isok = false;
    qint64 id = userid.toLongLong(&isok, 10);
    if (id == 0) {
        response.write(QJsonObject{{"status", true},
                                   {"message", TeacherServer::Tr::tr("LoginOut succeeded")},
                                   {"code", 200},
                                   {"data", QJsonValue()}});
        return;
    }

    UserModel user(storage);
    CWF::SqlQueryManager queryManager(storage);
    queryManager.select("*", user.getTableName()).where("id=?");
    queryManager.prepare();
    queryManager.addBindValue(id);
    queryManager.exec();
    QJsonArray jsonArray = queryManager.toJson();
    if (jsonArray.isEmpty()) {
        response.write(QJsonObject{{"status", false},
                                   {"message", TeacherServer::Tr::tr("user does not exist")},
                                   {"code", 500},
                                   {"data", QJsonValue()}});
        return;
    }
    for (const QJsonValue &json : jsonArray) {
        if (json.isObject()) {
            QJsonObject obj = json.toObject();
            // 修改登录状态
            obj["state"] = 0;
            // 更新在线状态
            user.buildFromJson(obj);
            user.save();
            AppEvent::instance()->loginOutUser(obj["id"].toInt());

            response.write(QJsonObject{{"status", true},
                                       {"message", TeacherServer::Tr::tr("LoginOut succeeded")},
                                       {"code", 200},
                                       {"data", QJsonValue()}});

            return;
        }
    }
    response.write(QJsonObject{{"status", false},
                               {"message", TeacherServer::Tr::tr("Login failed")},
                               {"code", 500},
                               {"data", QJsonValue()}});
}

void ExamsController::doPost(CWF::Request &request, CWF::Response &response) const
{
    const QString authorization = request.getHttpParser().getHeaderField("Authorization");

    QString examContent;
    if (!authorization.isEmpty()) {
        // response.write(
        //     QJsonObject{{"status", false},
        //                 {"message", TeacherServer::Tr::tr("exam content failed, no find user")},
        //                 {"code", 500},
        //                 {"data", QJsonValue()}});
        // return;
        QJsonWebToken token = QJsonWebToken::fromTokenAndSecret(authorization.mid(7), tokenSecret);

        if (!token.isValid()) {
            response.write(QJsonObject{{"status", false},
                                       {"message", TeacherServer::Tr::tr("unauthorized")},
                                       {"code", response.SC_UNAUTHORIZED},
                                       {"data", QJsonValue()}});
            return;
        }
        QString userid = token.claim("userId");

        bool isok = false;
        qint64 id = userid.toLongLong(&isok, 10);
        ///////////// 获取个人用户的考题
        CWF::SqlQuery query(storage);
        QJsonObject status = query.exec(QString("SELECT * FROM user WHERE id = %1").arg(id));
        if (status["success"].toBool()) {
            const QJsonArray array = query.toJson();
            if (!array.isEmpty()) {
                QJsonObject object = array[0].toObject();
                examContent = object["examTest"].toString();
            }
        }
    }
    qDebug() << "个人考试题目:" << examContent;
    UserModel user(storage);
    ExamsQuestionModel exams(storage);

    // 个人考试内容是空 获取默认选择的考试内容
    if (examContent.isEmpty() || examContent == "") {
        CWF::SqlQuery query(storage);
        QJsonObject status = query.exec(QString("SELECT * FROM exams_question WHERE isSelect = 1"));
        if (status["success"].toBool()) {
            const QJsonArray array = query.toJson();
            if (!array.isEmpty()) {
                QJsonObject object = array[0].toObject();
                examContent = object["name"].toString();
            }
        }
    }
    qDebug() << "使用考试题目:" << examContent;
    // 获取考试内容

    CWF::SqlQueryManager queryManager(storage);
    queryManager.select("*", exams.getTableName()).where("name = ?");
    queryManager.prepare();
    queryManager.addBindValue(examContent);
    queryManager.exec();
    QJsonArray jsonArray = queryManager.toJson();
    if (jsonArray.isEmpty()) {
        response.write(
            QJsonObject{{"status", false},
                        {"message", TeacherServer::Tr::tr("Failed to obtain exam content")},
                        {"code", 500},
                        {"data", QJsonValue()}});
        return;
    }
    qDebug() << "数据库考试题目:" << jsonArray;
    for (const QJsonValue &json : jsonArray) {
        if (json.isObject()) {
            QJsonObject obj = json.toObject();
            const QString dir = obj["fileDir"].toString();
            if (dir == "") {
                continue;
            }
            qDebug() << "数据库考试题目信息文件或者目录:" << dir;

            const QStringList files = listFiles(dir, dir);
            response.write(QJsonObject{{"status", true},
                                       {"message", TeacherServer::Tr::tr("ok")},
                                       {"code", 200},
                                       {"data", QJsonArray::fromStringList(files)}});
        }
    }

    response.write(QJsonObject{{"status", false},
                               {"message", TeacherServer::Tr::tr("Failed to obtain exam content")},
                               {"code", 500},
                               {"data", QJsonValue()}});
}

void ExamsFilesController::doGet(CWF::Request &request, CWF::Response &response) const
{
    const QString authorization = request.getHttpParser().getHeaderField("Authorization");

    QString examContent;
    if (!authorization.isEmpty()) {
        QJsonWebToken token = QJsonWebToken::fromTokenAndSecret(authorization.mid(7), tokenSecret);

        if (!token.isValid()) {
            response.write(QJsonObject{{"status", false},
                                       {"message", TeacherServer::Tr::tr("unauthorized")},
                                       {"code", response.SC_UNAUTHORIZED},
                                       {"data", QJsonValue()}});
            return;
        }
        QString userid = token.claim("userId");

        bool isok = false;
        qint64 id = userid.toLongLong(&isok, 10);
        ///////////// 获取个人用户的考题
        CWF::SqlQuery query(storage);
        QJsonObject status = query.exec(QString("SELECT * FROM user WHERE id = %1").arg(id));
        if (status["success"].toBool()) {
            const QJsonArray array = query.toJson();
            if (!array.isEmpty()) {
                QJsonObject object = array[0].toObject();
                examContent = object["examTest"].toString();
            }
        }
    }

    UserModel user(storage);
    ExamsQuestionModel exams(storage);

    // 个人考试内容是空 获取默认选择的考试内容
    if (examContent.isEmpty()) {
        CWF::SqlQuery query(storage);
        QJsonObject status = query.exec(QString("SELECT * FROM exams_question WHERE isSelect = 1"));
        if (status["success"].toBool()) {
            const QJsonArray array = query.toJson();
            if (!array.isEmpty()) {
                QJsonObject object = array[0].toObject();
                examContent = object["name"].toString();
            }
        }
    }

    QString fileName = request.getParameter("file");

    // 获取考试内容
    CWF::SqlQueryManager queryManager(storage);
    queryManager.select("*", exams.getTableName()).where("name = ?");
    queryManager.prepare();
    queryManager.addBindValue(examContent);
    queryManager.exec();
    QJsonArray jsonArray = queryManager.toJson();
    if (jsonArray.isEmpty()) {
        response.write(
            QJsonObject{{"status", false},
                        {"message", TeacherServer::Tr::tr("Failed to obtain exam content")},
                        {"code", 500},
                        {"data", QJsonValue()}});
        return;
    }
    QString dir;
    for (const QJsonValue &json : jsonArray) {
        if (json.isObject()) {
            QJsonObject obj = json.toObject();
            dir = obj["fileDir"].toString();
            break;
        }
    }

    // 获取扩展类型
    auto getMimeType = [](const QString &fileName) {
        QMimeDatabase mimeDatabase;
        QMimeType mimeType = mimeDatabase.mimeTypeForFile(fileName);
        return mimeType.name();
    };

    QString path = dir + "/" + fileName;
    if (!fileName.isEmpty() && QDir::isAbsolutePath(fileName)) {
        // 处理绝对路径
        path = fileName;
    }

    QFile file(path);
    if (file.open(QIODevice::ReadOnly)) {
        const QString rawFileName = QFileInfo(path).fileName();
        QString extention = CWF::FileManager::fileExtention(fileName).toLower();
        response.addHeader(CWF::HTTP::CONTENT_DISPOSITION,
                           "filename=" + QUrl::toPercentEncoding(rawFileName));
        response.addHeader(CWF::HTTP::CONTENT_TYPE, getMimeType(fileName).toUtf8());
        response.write(file.readAll());
    } else {
        response.sendJsonError(0, (file.errorString() + path).toUtf8());
    }
}

void UploadedFilesController::doPost(CWF::Request &request, CWF::Response &response) const
{
    const QString authorization = request.getHttpParser().getHeaderField("Authorization");
    if (authorization.isEmpty()) {
        response.write(
            QJsonObject{{"status", false},
                        {"message", TeacherServer::Tr::tr("LoginOut failed, no find user")},
                        {"code", 500},
                        {"data", QJsonValue()}});
        return;
    }
    QJsonWebToken token = QJsonWebToken::fromTokenAndSecret(authorization.mid(7), tokenSecret);

    if (!token.isValid()) {
        response.write(QJsonObject{{"status", false},
                                   {"message", TeacherServer::Tr::tr("unauthorized")},
                                   {"code", response.SC_UNAUTHORIZED},
                                   {"data", QJsonValue()}});
        return;
    }
    QString userid = token.claim("userId");

    bool isok = false;
    qint64 id = userid.toLongLong(&isok, 10);
    if (id == 0) {
        response.write(QJsonObject{{"status", true},
                                   {"message", TeacherServer::Tr::tr("file uploaded successfully")},
                                   {"code", 200},
                                   {"data", QJsonValue()}});
        return;
    }
    UserModel user(storage);
    CWF::SqlQueryManager queryManager(storage);
    queryManager.select("*", user.getTableName()).where("id=?");
    queryManager.prepare();
    queryManager.addBindValue(id);
    queryManager.exec();
    QJsonArray jsonArray = queryManager.toJson();
    if (jsonArray.isEmpty()) {
        response.write(QJsonObject{{"status", false},
                                   {"message", TeacherServer::Tr::tr("user does not exist")},
                                   {"code", 500},
                                   {"data", QJsonValue()}});
        return;
    }
    for (const QJsonValue &json : jsonArray) {
        if (json.isObject()) {
            QJsonObject obj = json.toObject();
            // 更新在线状态
            user.buildFromJson(obj);
            user.save();
            AppEvent::instance()->loginOutUser(obj["id"].toInt());
        }
    }
    const QMultiMap<QByteArray, QByteArray> &files = request.getUploadedFiles();
    qDebug() << files.keys();
    if (user.getId() > 0) {
        QVariant answerDir = AppEvent::instance()->configValue("answerDir");

        const QString examNumber = AppEvent::instance()->examNumber();
        const QString examRoom = AppEvent::instance()->examRoom();

        QString path = QDir(answerDir.toString()).filePath(examRoom + "_" + examNumber);
        path = QDir::cleanPath(path);

        qDebug() << path;
        QDir dir = path;

        if (!dir.exists(path)) {
            dir.mkpath(path);
        }
        for (auto it = files.begin(); it != files.end(); ++it) {
            QString fileName = user.getAnswerFileName();
            if (it.key().endsWith("zip")) {
                if (fileName.isEmpty()) {
                    fileName = QString("%1_%2.zip").arg(user.getName()).arg(user.getExamineeNumber());
                }
            } else {
                fileName = QString("%1_%2_%3")
                               .arg(user.getName())
                               .arg(user.getExamineeNumber())
                               .arg(QString(it.key()));
                continue;
            }

            const QString filePath = dir.absoluteFilePath(fileName);

            QFile file(filePath);
            if (!file.open(QIODevice::WriteOnly)) {
                qWarning() << "Failed to open file for writing:" << file.errorString() << filePath;
            }
            file.write(it.value());
            file.close();
        }
        response.write(QJsonObject{{"status", true},
                                   {"message", TeacherServer::Tr::tr("file uploaded successfully")},
                                   {"code", 200},
                                   {"data", QJsonValue()}});
        return;
    }
    response.write(QJsonObject{{"status", false},
                               {"message", TeacherServer::Tr::tr("Failed to uploaded files")},
                               {"code", 500},
                               {"data", QJsonValue()}});
}

void ExamsAnswerTimeController::doPost(CWF::Request &request, CWF::Response &response) const
{
    const QString authorization = request.getHttpParser().getHeaderField("Authorization");
    if (authorization.isEmpty()) {
        response.write(
            QJsonObject{{"status", false},
                        {"message", TeacherServer::Tr::tr("answer Time failed, no find user login")},
                        {"code", 500},
                        {"data", QJsonValue()}});
        return;
    }
    QJsonWebToken token = QJsonWebToken::fromTokenAndSecret(authorization.mid(7), tokenSecret);

    if (!token.isValid()) {
        response.write(QJsonObject{{"status", false},
                                   {"message", TeacherServer::Tr::tr("unauthorized")},
                                   {"code", response.SC_UNAUTHORIZED},
                                   {"data", QJsonValue()}});
        return;
    }
    QString userid = token.claim("userId");

    bool isok = false;
    qint64 id = userid.toLongLong(&isok, 10);
    if (id == 0) {
        response.write(
            QJsonObject{{"status", true},
                        {"message", TeacherServer::Tr::tr("Update Answer Time successfully")},
                        {"code", 200},
                        {"data", QJsonValue()}});
        return;
    }
    QJsonParseError error;
    QJsonDocument jdc = QJsonDocument::fromJson(request.getBody(), &error);

    QJsonObject jsonObject = jdc.object();

    qint64 time = 0;
    if (jsonObject.contains("answerTime")) {
        time = jsonObject["answerTime"].toVariant().toLongLong();
    }

    UserModel user(storage);
    CWF::SqlQueryManager queryManager(storage);
    queryManager.select("*", user.getTableName()).where("id=?");
    queryManager.prepare();
    queryManager.addBindValue(id);
    queryManager.exec();
    QJsonArray jsonArray = queryManager.toJson();
    if (jsonArray.isEmpty()) {
        response.write(QJsonObject{{"status", false},
                                   {"message", TeacherServer::Tr::tr("user does not exist")},
                                   {"code", 500},
                                   {"data", QJsonValue()}});
        return;
    }
    for (const QJsonValue &json : jsonArray) {
        if (json.isObject()) {
            QJsonObject obj = json.toObject();
            // 修改登录状态
            obj["answerTime"] = time;
            // 更新在线状态
            user.buildFromJson(obj);
            user.save();
            AppEvent::instance()->loginOutUser(obj["id"].toInt());

            {
                int examID = 0;
                QString examText = "";

                QString sql = QString(R"__(
SELECT eq.id, eq.name
FROM user u
JOIN exams_question eq
ON (
    (u.examTest IS NULL OR u.examTest = '') AND eq.isSelect = 1
    OR (u.examTest IS NOT NULL AND u.examTest <> '' AND eq.name = u.examTest)
)
WHERE u.id = %1;
)__")
                                  .arg(id);

                CWF::SqlQuery query(storage);
                QJsonObject status = query.exec(sql);
                if (status["success"].toBool()) {
                    const QJsonArray array = query.toJson();
                    if (!array.isEmpty()) {
                        QJsonObject object = array[0].toObject();
                        examID = object["id"].toInt();
                        examText = object["name"].toString();
                    }
                }

                const QString examNumber = AppEvent::instance()->examNumber();
                const QString examRoom = AppEvent::instance()->examRoom();

                QString fileName = user.getAnswerFileName();
                if (fileName.isEmpty()) {
                    fileName = QString("%1_%2.zip").arg(user.getName()).arg(user.getExamineeNumber());
                }

                ExamsTestModel examsTestModel(storage);
                examsTestModel.setUserId(id);
                examsTestModel.setExamsId(examID);
                examsTestModel.setEndTime(time);
                examsTestModel.setExamRoom(examRoom);
                examsTestModel.setExamSessions(examNumber);
                examsTestModel.setAnswerFileName(fileName);
                examsTestModel.save();

                // 这里通知去发送到服务器 通过指定id
                // GradesUpdate(const QString &answerFileName,
                //              const QString &checkinNumber,
                //              int endTime,
                //              const QString &examRoom,
                //              const QString &examSessions,
                //              const QString &examText,
                //              const QString &examineNumber,
                //              const QString &groupName,
                //              const QString &id,
                //              const QString &name,
                //              int onlineStatus,
                //              const QString &schoolAddress,
                //              const QString &schoolName,
                //              int sex,
                //              int startTime,
                //              int status,
                //              const QString &swId)
                if (AppEvent::instance()->isLogin()) {
                    const QString answerFileName = fileName;
                    const QString checkinNumber = user.getCheckinNumber();
                    int endTime = time;
                    // const QString examRoom = examRoom; // 考试房间
                    const QString examSessions = examNumber; //考试场次
                    // const QString examText;                  //考试内容
                    const QString examineNumber = user.getExamineeNumber(); // 考试编号
                    const QString groupName = user.getGroup();
                    const QString name = user.getName();
                    int onlineStatus = 1;
                    const QString schoolAddress = "";
                    const QString schoolName = user.getSchool();
                    int sex = 0;
                    int startTime = 0;
                    int status = 1;
                    const QString swId = user.getSwID();

                    TC::GradesUpdate gradesUpdate(answerFileName,
                                                  checkinNumber,
                                                  endTime,
                                                  examRoom,
                                                  examSessions,
                                                  examText,
                                                  examineNumber,
                                                  groupName,
                                                  name,
                                                  onlineStatus,
                                                  schoolAddress,
                                                  schoolName,
                                                  sex,
                                                  startTime,
                                                  status,
                                                  swId);
                    gradesUpdate.postAsync();
                }
                AppEvent::instance()->examsTestUpdate();
            }
            response.write(
                QJsonObject{{"status", true},
                            {"message", TeacherServer::Tr::tr("Update Answer Time successfully")},
                            {"code", 200},
                            {"data", QJsonValue()}});
            return;
        }
    }
    response.write(QJsonObject{{"status", false},
                               {"message", TeacherServer::Tr::tr("Update Answer Time Failed")},
                               {"code", 500},
                               {"data", QJsonValue()}});
}

void TableDataController::doPost(CWF::Request &request, CWF::Response &response) const
{
    QJsonParseError error;
    QJsonDocument jdc = QJsonDocument::fromJson(request.getBody(), &error);
    if (error.error != QJsonParseError::NoError) {
        response.write(QJsonObject{{"status", false},
                                   {"message", TeacherServer::Tr::tr("json param error")},
                                   {"code", 500},
                                   {"data", error.errorString()}});
        return;
    }
    QJsonObject jsonObject = jdc.object();

    int pageNum = jsonObject.value("pageNum").toInt(1);
    int pageSize = jsonObject.value("pageSize").toInt(20);
    QString examNumber = jsonObject.value("examNumber").toString("");
    QString examRoom = jsonObject.value("examRoom").toString("");

    int offset = (pageNum - 1) * pageSize;

    QStringList wheleList;

    if (!examNumber.isEmpty()) {
        wheleList += QString("e.exam_sessions='%1'").arg(examNumber);
    }
    if (!examRoom.isEmpty()) {
        wheleList += QString("e.exam_room='%1'").arg(examRoom);
    }
    QString whele;
    if (!wheleList.isEmpty()) {
        whele += "WHERE ";
        whele += wheleList.join(" AND ");
    }

    QString sql = QString(R"__(
SELECT
    s.name,
    s.swID,
    s.examineeNumber,
    s.checkinNumber,
    s.groupName,
    s.answerFileName,
    s.school,
    e.end_time AS exam_time,
    e.exam_room,
    e.exam_sessions,
    e.isUpload,
	eq.name AS examName
FROM
    user s
JOIN
    exams_test e ON s.id = e.user_id
JOIN
    exams_question eq ON e.exams_id = eq.id
%1
ORDER BY 
    e.end_time ASC
LIMIT %2, %3;
)__")
                      .arg(whele)
                      .arg(offset)
                      .arg(pageSize);

    CWF::SqlQuery query(storage);
    QJsonObject status = query.exec(sql);
    if (status["success"].toBool()) {
        const QJsonArray array = query.toJson();
        response.write(QJsonObject{{"status", true},
                                   {"message", TeacherServer::Tr::tr("Table data ")},
                                   {"code", 200},
                                   {"data", array}});
        return;
    }
    qDebug().noquote().nospace() << status << sql;
    response.write(QJsonObject{{"status", false},
                               {"message", TeacherServer::Tr::tr("Get Table Data Failed")},
                               {"code", 500},
                               {"data", QJsonValue()}});
}

void TableDataExamRoomController::doGet(CWF::Request &, CWF::Response &response) const
{
    const QString examNumber = AppEvent::instance()->examNumber();
    const QString examRoom = AppEvent::instance()->examRoom();
    QJsonObject object;
    object.insert("examNumber", examNumber);
    object.insert("examRoom", examRoom);
    response.write(QJsonObject{{"status", true},
                               {"message", "Get Table Data ok"},
                               {"code", 200},
                               {"data", object}});
}