repoindex/network/userrepository.cpp

#include "userrepository.h"

#include "alpm/aurpackage.h"

#include <c++utilities/misc/memory.h>

#include <QStringBuilder>
#include <QUrlQuery>
#include <QNetworkRequest>
#include <QNetworkReply>
#include <QNetworkAccessManager>
#include <QJsonDocument>
#include <QJsonObject>
#include <QJsonArray>

using namespace std;

namespace PackageManagement {

const char *requestTypeProp = "type";
const QString rpcRequestTypeKey(QStringLiteral("type"));
const QString rpcRequestTypeSuggest(QStringLiteral("suggest"));
const QString rpcRequestTypeMultiInfo(QStringLiteral("multiinfo"));
const QString rpcArgKey(QStringLiteral("arg"));
const QString rpcArgArray(QStringLiteral("arg[]"));
const QString pkgbuildRequestType(QString("pkgbuild"));
QUrl UserRepository::m_aurRpcUrl = QUrl(QStringLiteral("https://aur.archlinux.org/rpc.php"));
QUrl UserRepository::m_aurPkgbuildUrl = QUrl(QStringLiteral("https://aur.archlinux.org/cgit/aur.git/plain/PKGBUILD"));
QUrl UserRepository::m_aurSrcInfoUrl = QUrl(QStringLiteral("https://aur.archlinux.org/cgit/aur.git/plain/.SRCINFO"));

AurPackageReply::AurPackageReply(QNetworkReply *networkReply, UserRepository *userRepo) :
    PackageReply(networkReply, userRepo->packages()),
    m_userRepo(userRepo)
{}

void AurPackageReply::processData()
{
    if(m_networkReply->error() == QNetworkReply::NoError) {
        QJsonParseError error;
        //QByteArray data = m_networkReply->readAll();
        //cerr << "AUR reply: " << data.data() << endl;
        //const QJsonDocument doc = QJsonDocument::fromJson(data, &error);
        const QJsonDocument doc = QJsonDocument::fromJson(m_networkReply->readAll(), &error);
        if(error.error == QJsonParseError::NoError) {
            for(const auto &result : doc.object().value(QStringLiteral("results")).toArray()) {
                auto package = make_unique<AurPackage>(result, m_userRepo);
                if(!package->name().isEmpty()) {
                    m_packages[package->name()] = move(package);
                }
            }
        } else {
            m_error = QStringLiteral("Error: Unable to parse JSON received from AUR: ") % error.errorString() % QStringLiteral(" at character ") % QString::number(error.offset);
        }
    } else {
        m_error = QStringLiteral("Error: Unable to request data from AUR: ") + m_networkReply->errorString();
    }
    emit resultsAvailable();
}

AurSuggestionsReply::AurSuggestionsReply(QNetworkReply *networkReply) :
    SuggestionsReply(networkReply)
{}

void AurSuggestionsReply::processData()
{
    if(m_networkReply->error() == QNetworkReply::NoError) {
        QJsonParseError error;
        //QByteArray data = m_networkReply->readAll();
        //cerr << "AUR reply: " << data.data() << endl;
        //const QJsonDocument doc = QJsonDocument::fromJson(data, &error);
        const QJsonDocument doc = QJsonDocument::fromJson(m_networkReply->readAll(), &error);
        if(error.error == QJsonParseError::NoError) {
            m_suggestions = doc.array();
        } else {
            m_error = QStringLiteral("Error: Unable to parse JSON received from AUR: ") % error.errorString() % QStringLiteral(" at character ") % QString::number(error.offset);
        }
    } else {
        m_error = QStringLiteral("Error: Unable to request data from AUR: ") + m_networkReply->errorString();
    }
    emit resultsAvailable();
}

UserRepository::UserRepository(QNetworkAccessManager &networkAccessManager, QObject *parent) :
    Repository(QStringLiteral("AUR"), parent),
    m_networkAccessManager(networkAccessManager)
{
    m_description = QStringLiteral("Arch User Repository");
}

RepositoryType UserRepository::type() const
{
    return RepositoryType::UserRepository;
}

bool UserRepository::requestsRequired() const
{
    return true;
}

AurSuggestionsReply *UserRepository::requestSuggestions(const QString &phrase) const
{
    auto url = m_aurRpcUrl;
    QUrlQuery query;
    query.addQueryItem(rpcRequestTypeKey, rpcRequestTypeSuggest);
    query.addQueryItem(rpcArgKey, phrase);
    url.setQuery(query);
    return new AurSuggestionsReply(m_networkAccessManager.get(QNetworkRequest(url)));
}

AurPackageReply *UserRepository::requestPackageInfo(const QStringList &packageNames, bool forceUpdate) const
{
    QUrlQuery query;
    for(const auto &packageName : packageNames) {
        if(forceUpdate || !m_packages.count(packageName)) {
            query.addQueryItem(rpcArgArray, packageName);
        }
    }
    if(query.isEmpty()) {
        return nullptr;
    } else {
        auto url = m_aurRpcUrl;
        query.addQueryItem(rpcRequestTypeKey, rpcRequestTypeMultiInfo);
        url.setQuery(query);
        return new AurPackageReply(m_networkAccessManager.get(QNetworkRequest(url)), const_cast<UserRepository *>(this));
    }
}

AurPackageReply *UserRepository::requestFullPackageInfo(const QString &package, bool forceUpdate) const
{
    try {
        const auto &pkg = m_packages.at(package);
        if(pkg->hasGeneralInfo() && !forceUpdate) {
            return nullptr;
        }
    } catch(const out_of_range &) {
    }
    auto url = m_aurPkgbuildUrl;
    QUrlQuery query;
    query.addQueryItem(QStringLiteral("h"), package);
    url.setQuery(query);
    return new AurPackageReply(m_networkAccessManager.get(QNetworkRequest(url)), const_cast<UserRepository *>(this));
}

} // namespace Alpm