domjudgeapimanager.cpp

#include "domjudgeapimanager.h"

#include <QUrlQuery>
#include <QJsonParseError>
#include <functional>

namespace DJ
{
namespace Shared
{

void DomjudgeApiManager::setConnectionInfo(QString protocol, QString url, QString username, QString password) {
    this->protocol = protocol;
    this->url = url;
    this->username = username;
    this->password = password;
}

void DomjudgeApiManager::loadUserData() {
    DomjudgeApiRequest request("user");
    this->userRequests.append(request);

    this->accessManager->get(request);
}

void DomjudgeApiManager::loadContestsData(){
    DomjudgeApiRequest request("contests");
    this->contestsRequests.append(request);

    this->accessManager->get(request);
}

void DomjudgeApiManager::loadGroupsData(QString cid) {
    DomjudgeApiRequest request("contests/" + cid + "/groups");
    this->groupsRequests.append(request);

    this->accessManager->get(request);
}

void DomjudgeApiManager::loadTeamData(QString cid) {
    DomjudgeApiRequest request("contests/" + cid + "/teams");
    this->teamsRequests.append(request);

    this->accessManager->get(request);
}

void DomjudgeApiManager::loadProblemData(QString cid) {
    DomjudgeApiRequest request("contests/" + cid + "/problems");
    this->problemRequests.append(request);

    this->accessManager->get(request);
}

void DomjudgeApiManager::loadSubmissions(QString cid) {

    DomjudgeApiRequest request("contests/" + cid + "/submissions");
    this->submissionRequests.append(request);

    this->accessManager->get(request);
}

void DomjudgeApiManager::loadJudgings(QString cid) {
    DomjudgeApiRequest request("contests/" + cid + "/judgements");
    this->judgingRequests.append(request);

    this->accessManager->get(request);
}

DomjudgeApiManager::DomjudgeApiRequest::DomjudgeApiRequest(QString method, QList<QPair<QString, QString>> arguments) {
    DomjudgeApiManager *apiManager = DomjudgeApiManager::sharedApiManager();
    QUrl url(apiManager->protocol + apiManager->url + "/api/" + method);

    QUrlQuery urlQuery;
    foreach (auto argument, arguments) {
        urlQuery.addQueryItem(argument.first, argument.second);
    }
    url.setQuery(urlQuery);

    this->setUrl(url);

    if (!apiManager->username.isEmpty()) {
        QString concatenated = apiManager->username + ":" + apiManager->password;
        QByteArray data = concatenated.toLocal8Bit().toBase64();
        QString headerData = "Basic " + data;
        this->setRawHeader("Authorization", headerData.toLocal8Bit());
    }
}

DomjudgeApiManager::DomjudgeApiManager() {
    this->accessManager = new QNetworkAccessManager(this);
    connect(this->accessManager, SIGNAL(finished(QNetworkReply*)), this, SLOT(replyFinished(QNetworkReply*)));
}

void DomjudgeApiManager::replyFinished(QNetworkReply *reply) {
    DomjudgeApiManager *apiManager = DomjudgeApiManager::sharedApiManager();

    // Process all types of replies
    if (this->processReply(reply, &apiManager->userRequests,
                           &DomjudgeApiManager::userDataFailedLoading,
                           &DomjudgeApiManager::userLoaded)) {
        return;
    }
    if (this->processReply(reply, &apiManager->contestsRequests,
                           &DomjudgeApiManager::contestsDataFailedLoading,
                           &DomjudgeApiManager::contestsDataLoaded)) {
        return;
    }
    if (this->processReply(reply, &apiManager->groupsRequests,
                           &DomjudgeApiManager::groupsDataFailedLoading,
                           &DomjudgeApiManager::groupsDataLoaded)) {
        return;
    }
    if (this->processReply(reply, &apiManager->teamsRequests,
                           &DomjudgeApiManager::teamsDataFailedLoading,
                           &DomjudgeApiManager::teamsDataLoaded)) {
        return;
    }
    if (this->processReply(reply, &apiManager->problemRequests,
                           &DomjudgeApiManager::problemsDataFailedLoading,
                           &DomjudgeApiManager::problemsDataLoaded)) {
        return;
    }
    if (this->processReply(reply, &apiManager->submissionRequests,
                           &DomjudgeApiManager::submissionsDataFailedLoading,
                           &DomjudgeApiManager::submissionsDataLoaded)) {
        return;
    }
    if (this->processReply(reply, &apiManager->judgingRequests,
                           &DomjudgeApiManager::judgingsDataFailedLoading,
                           &DomjudgeApiManager::judgingsDataLoaded)) {
        return;
    }
}

template<typename... ArgsError, typename... ArgsSuccess>
bool DomjudgeApiManager::processReply(QNetworkReply *reply,
                                      QList<QNetworkRequest> *requests,
                                      void(DomjudgeApiManager::*errorFunc)(ArgsError...args),
                                      void(DomjudgeApiManager::*successFunc)(ArgsSuccess...args)) {
    foreach (QNetworkRequest r, *requests) {
        if (r.url() != reply->url()) continue;
        DomjudgeApiManager *apiManager = DomjudgeApiManager::sharedApiManager();

        // See if we must do a redirect and if so, do one
        auto possibleRedirectURL = reply->attribute(QNetworkRequest::RedirectionTargetAttribute).toUrl();
        if (!possibleRedirectURL.isEmpty()) {
            auto newRequest = QNetworkRequest(possibleRedirectURL);
            if (requests->contains(reply->request())) {
                requests->append(newRequest);
                requests->removeOne(reply->request());
            }
            apiManager->accessManager->get(newRequest);
            return true;
        }

        int status_code = reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt();

        QString error = "General error";
        if (status_code == 401) {
            error = "Authentication required. Please enter correct username and password";
        } else if (status_code == 0) {
            error = "Can not find server. Please enter correct URL";
        } else if (status_code == 404) {
            error = "Can not find this URL; please enter the correct one";
        }

        if (status_code != 200) {
            std::function<void(DomjudgeApiManager *, ArgsError...)> func = errorFunc;
            emit func(this, error);
        } else {
            QJsonParseError error;
            QJsonDocument document = QJsonDocument::fromJson(reply->readAll(), &error);
            if (error.error != QJsonParseError::NoError) {
                std::function<void(DomjudgeApiManager *, ArgsError...)> func = errorFunc;
                emit func(this, "Error parsing JSON");
            } else {
                std::function<void(DomjudgeApiManager *, ArgsSuccess...)> func = successFunc;
                emit func(this, document);
            }
        }

        requests->removeOne(reply->request());

        return true;
    }

    return false;
}

}
}