colnod-connector/src/colnod/requestmanager.cpp

#include "requestmanager.h"

RequestManager::RequestManager()
{
    manager = new QNetworkAccessManager();
    token = "";
    loginStatus = false;  //should be false, true for testing request header
/*
    QFile configFile(QDir::current().filePath("config.json"));
       if (!configFile.open(QIODevice::ReadOnly)) {
           qCritical() << "Couldn't open config file config.json" << QDir::current().filePath("config.json");
           QCoreApplication::exit(-1);
           return;
       }
    this->config = QJsonDocument::fromJson(configFile.readAll());*/
    QObject::connect(manager, &QNetworkAccessManager::sslErrors, this, &RequestManager::onSSLError);
}

void RequestManager::login(QString host, QString username, QString password)
{

    QNetworkRequest request;
    QString hash = encryptedPassword(this->password);
    authHeader = getLoginHeader(this->user, hash);
    QJsonObject reqBody = {
                {"password", hash},
                {"username", this->user}
    };
    //this->host = host;

    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());
    QObject::connect(reply, &QNetworkReply::finished, [=]() {
        if (reply->error())
        {
            qDebug() << reply->errorString();
            loginStatus = false;
            return;
        }
        if (loginStatus)
            return;
        jsonResponse = reply->readAll();
        prepareAuthHeader();
        loginStatus = true;
        emit successLogin();
        reply->deleteLater();
        });
}

QNetworkReply* RequestManager::getRequest(QString endpoint)
{
    QNetworkRequest request;
    request.setUrl(host + endpoint);
    qDebug() << "Auth: " << authHeader;
    request.setRawHeader("Authorization", authHeader.toLocal8Bit());
    QNetworkReply* reply = manager->post(request, QByteArray());
    QObject::connect(reply, &QNetworkReply::finished, [=]() {
        if (reply->error())
        {
            qDebug() << reply->errorString();
            loginStatus = false;
            //getRequest(endpoint);
            return;
        }
        emit responseReady();
    });
    return reply;

}

QString RequestManager::getFromJson(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(QString password)
{
     return QCryptographicHash::hash(password.toLocal8Bit(), QCryptographicHash::Sha512).toHex().toUpper();
}

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

void RequestManager::prepareAuthHeader()
{
    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();
    }

}

Response* RequestManager::getSubjects()
{
    auto response = new Response;
    if (!loginStatus){
        login(host, user, password);
        connect(this, &RequestManager::successLogin, [=](){
            auto subjectReply = getRequest("/SubjectManager/getSubjects");
            response->reply = subjectReply;
            connect(subjectReply, &QNetworkReply::finished, response, &Response::finished);
            });
    }
    else
    {
        QNetworkReply* reply = getRequest("/SubjectManager/getSubjects");
        connect(reply, &QNetworkReply::finished, response, &Response::finished);
    }

    return response;
}

Response* RequestManager::getTokens()
{
    auto response = new Response;
    if (!loginStatus){
        login(host, user, password);
        connect(this, &RequestManager::successLogin, [=](){
            auto subjectReply = getRequest("/TokenManager/getTokens");
            response->reply = subjectReply;
            connect(subjectReply, &QNetworkReply::finished, response, &Response::finished);
            });
    }
    else
    {
        QNetworkReply* reply = getRequest("/TokenManager/getTokens");
        connect(reply, &QNetworkReply::finished, response, &Response::finished);
    }

    return response;
}

Response* RequestManager::getTokenSubject()
{
    auto response = new Response;
    if (!loginStatus){
        login(host, user, password);
        connect(this, &RequestManager::successLogin, [=](){
            auto subjectReply = getRequest("/OpenManager/getTokenSubject");
            response->reply = subjectReply;
            connect(subjectReply, &QNetworkReply::finished, response, &Response::finished);
            });
    }
    else
    {
        QNetworkReply* reply = getRequest("/OpenManager/getTokenSubject");
        connect(reply, &QNetworkReply::finished, response, &Response::finished);
    }

    return response;
}