colnod-connector/src/colnod/requestmanager.cpp

#include "requestmanager.h"

RequestManager::RequestManager()
{
    manager = std::make_unique<QNetworkAccessManager>();
    connect(manager.get(), &QNetworkAccessManager::sslErrors, this, &RequestManager::onSSLError);
}

std::shared_ptr<Response> RequestManager::login()
{
    Q_ASSERT(!loginResponse);
    loginResponse = std::make_shared<Response>();
    QNetworkRequest request;
    QString hash = encryptedPassword(this->password);
    authHeader = getLoginHeader(this->user, hash);
    QJsonObject reqBody = {
        {"password", hash},
        {"username", this->user}
    };
    request.setUrl(this->host + "/AaaManager/authSession");
    request.setRawHeader("Authorization", authHeader.toLocal8Bit());
    request.setHeader(QNetworkRequest::ContentTypeHeader, "application/json; charset=UTF-8");
    QJsonDocument jsonDocument;
    jsonDocument.setObject(reqBody);
    QNetworkReply* reply = manager->post(request, jsonDocument.toJson());
    loginResponse->setReply(reply);
    connect(reply, &QNetworkReply::finished, [=]() {
        if (reply->error())
        {
            Logger::logToDb(Logger::makeErrorMsg("Request Manager", reply->errorString()));
            loginStatus = false;
            reply->deleteLater();
            emit error();
            return;
        }
        loginStatus = true;
        emit successLogin();
        reply->deleteLater();
    });
    connect(this, &RequestManager::successLogin, loginResponse.get(), &Response::ready);
    connect(this, &RequestManager::successLogin, this, &RequestManager::prepareAuthHeader);
    return loginResponse;
}

QNetworkReply* RequestManager::postRequest(const QString& endpoint, const QByteArray& json)
{
    QNetworkRequest request;
    request.setUrl(host + endpoint);
    request.setRawHeader("Authorization", authHeader.toLocal8Bit());
    request.setHeader(QNetworkRequest::ContentTypeHeader, "application/json; charset=UTF-8");
    QNetworkReply* reply = manager->post(request, json);
    QObject::connect(reply, &QNetworkReply::finished, [=]() {
        if (reply->error())
        {
            Logger::logToDb(Logger::makeErrorMsg("Request Manager", reply->errorString()));
            loginStatus = false;
            reply->deleteLater();
            emit error();
            return;
        }
        emit responseReady();
        reply->deleteLater();
    });
    return reply;
}

// This will ensure login is called only once
std::shared_ptr<Response> RequestManager::getLoginResponse() {
    if (!loginResponse){
        loginResponse = login();
    }
    return loginResponse;
}

Response* RequestManager::postRequestReturnLogic(const QString& endpoint, const QByteArray& data)
{
    auto loginResponse = getLoginResponse();
    Q_ASSERT(loginResponse);
    auto response = new Response;

    if (!loginStatus){
        connect(this, &RequestManager::successLogin, [=](){
            response->setReply(postRequest(endpoint, data));
            connect(response->getReply(), &QNetworkReply::finished, response, &Response::ready);
        });
    }
    else
    {
        response->setReply(postRequest(endpoint, data));
        connect(response->getReply(), &QNetworkReply::finished, response, &Response::ready);
    }
    return response;
}

// get value of member in json
QString RequestManager::getFromJson(const QString& json, const QString &member)
{
    QJsonParseError err{};
    QJsonDocument document = QJsonDocument::fromJson(json.toUtf8(),&err);
    if (err.error != 0)
    {
        qDebug() << err.errorString();
    }
    return document.object().value(member).toString();
}

QString RequestManager::encryptedPassword(const QString& password)
{
    return QCryptographicHash::hash(password.toLocal8Bit(), QCryptographicHash::Sha512).toHex().toUpper();
}

QString RequestManager::getLoginHeader(const QString& username, const QString& hash)
{
    QString authValue = username + ":" + hash;
    return "Basic " + authValue.toLocal8Bit().toBase64();
}

void RequestManager::prepareAuthHeader()
{
    jsonResponse = loginResponse->getJson();
    QString token = getFromJson(jsonResponse, "id");
    QString authValue = token + ":";
    authHeader = "Basic " + authValue.toLocal8Bit().toBase64();
}

void RequestManager::onSSLError(QNetworkReply *reply, const QList<QSslError> &errors)
{
    //qDebug() << "Network SSL errors";
    for (const auto &error : errors)
    {
        if (error.error() == QSslError::SelfSignedCertificate)
            reply->ignoreSslErrors(errors);
        //qDebug() << error.errorString();
    }

}

QByteArray RequestManager::makeTimestampJson(uint64_t time)
{
    QJsonObject reqBody = {{"timestamp",QJsonValue(static_cast<qint64>(time)) }};
    QJsonDocument doc;
    doc.setObject(reqBody);
    return doc.toJson();
}

QByteArray RequestManager::makeTokensJson(const QHash<QString, std::shared_ptr<Token>> &tokens)
{
    QJsonObject items;
    QJsonArray jsonTokens;
    for (const auto& token : tokens)
    {
        jsonTokens.push_back(token->toJSON());
    }
    items.insert("items", jsonTokens);
    QJsonDocument doc;
    doc.setObject(items);
    return doc.toJson();
}

QByteArray RequestManager::makeIdsJson(const QList<QString> &ids)
{
    QJsonArray jsonIds;
    for (const auto& id : ids)
    {
        jsonIds.push_back(id);
    }
    QJsonObject items;
    items.insert("items", jsonIds);
    QJsonDocument doc;
    doc.setObject(items);
    return doc.toJson();
}

Response* RequestManager::getSubjects()
{
    return postRequestReturnLogic("/SubjectManager/getSubjects");
}

Response* RequestManager::getTokens()
{
    return postRequestReturnLogic("/TokenManager/getTokens");
}

Response* RequestManager::getTokenSubject()
{
    return postRequestReturnLogic("/OpenManager/getTokenSubject");
}

Response* RequestManager::getSubjectsUpdated(uint64_t time)
{
    return postRequestReturnLogic("/SubjectManager/getSubjectsUpdated", makeTimestampJson(time));
}

Response* RequestManager::getSubjectsDeleted(uint64_t time)
{
    return postRequestReturnLogic("/SubjectManager/getSubjectsDeleted", makeTimestampJson(time));
}

Response* RequestManager::getTokensUpdated(uint64_t time)
{
    return postRequestReturnLogic("/TokenManager/getTokensUpdated", makeTimestampJson(time));
}

Response* RequestManager::getTokensDeleted(uint64_t time)
{
    return postRequestReturnLogic("/TokenManager/getTokensDeleted", makeTimestampJson(time));
}

Response* RequestManager::getAccessGroups()
{
    return postRequestReturnLogic("/AccessManager/getAccessGroups");
}

Response* RequestManager::getAccessGroupsUpdated(uint64_t time)
{
    return postRequestReturnLogic("/AccessManager/getAccessGroupsUpdated", makeTimestampJson(time));
}

Response* RequestManager::getAccessGroupsDeleted(uint64_t time)
{
    return postRequestReturnLogic("/AccessManager/getAccessGroupsDeleted", makeTimestampJson(time));
}

Response* RequestManager::getAccessGroupMembership()
{
    return postRequestReturnLogic("/AccessManager/getAccessGroupMembership");
}

Response* RequestManager::getAccessGroupMembershipUpdated(uint64_t time)
{
    return postRequestReturnLogic("/AccessManager/getAccessGroupMembershipUpdated", makeTimestampJson(time));
}

Response* RequestManager::getAccessGroupMembershipDeleted(uint64_t time)
{
    return postRequestReturnLogic("/AccessManager/getAccessGroupMembershipDeleted", makeTimestampJson(time));
}

Response* RequestManager::setTokens(const QHash<QString, std::shared_ptr<Token>> &tokens)
{
    return postRequestReturnLogic("/TokenManager/setTokens", makeTokensJson(tokens));
}

Response* RequestManager::deleteTokens(const QList<QString> &ids)
{
    return postRequestReturnLogic("/TokenManager/deleteTokens", makeIdsJson(ids));
}