repoindex/alpm/packageinfolookup.cpp

#include "./packageinfolookup.h"
#include "./repository.h"

#include <cassert>

using namespace std;

namespace RepoIndex {

PackageInfoLookup::PackageInfoLookup(Manager &manager, const QJsonObject &request, QObject *parent) :
    PackageLookup(parent),
    m_what(request.value(QStringLiteral("what")).toString()),
    m_part(Manager::None)
{
    m_id = request.value(QStringLiteral("id"));
    if(m_what == QLatin1String("basicpkginfo")) {
        m_part = Manager::Basics;
    } else if(m_what == QLatin1String("pkgdetails")) {
        m_part = Manager::Details;
    } else if(m_what == QLatin1String("fullpkginfo")) {
        m_part = Manager::Basics | Manager::Details;
    } else {
        QJsonObject errorObj;
        errorObj.insert(QStringLiteral("error"), QStringLiteral("invalid_request"));
        m_results << errorObj;
        return;
    }
    m_packageSelection = request.value(QStringLiteral("sel")).toObject();
    for(auto i = m_packageSelection.constBegin(), end = m_packageSelection.constEnd(); i != end; ++i) {
        if(auto *repo = manager.repositoryByName(i.key())) {
            QStringList packagesToBeRequested;
            for(const auto &entry : i.value().toArray()) {
                const auto entryObj = entry.toObject();
                const auto pkgName = entryObj.value(QStringLiteral("name")).toString();
                if(!pkgName.isEmpty()) {
                    packagesToBeRequested << pkgName;
                }
            }
            if(!packagesToBeRequested.isEmpty()) {
                if(const auto *reply = (m_part & Manager::Details ? repo->requestFullPackageInfo(packagesToBeRequested) : repo->requestPackageInfo(packagesToBeRequested))) {
                    connect(reply, &PackageReply::resultsAvailable, this, &PackageInfoLookup::addResultsFromReply);
                    ++m_remainingReplies;
                } else {
                    // no need to request any of the packages
                    addResultsDirectly(packagesToBeRequested, repo);
                }
            }
        } else {
            // specified repository can not be found
            QJsonObject errorObj;
            errorObj.insert(QStringLiteral("repo"), i.key());
            errorObj.insert(QStringLiteral("error"), QStringLiteral("na"));
            m_results << errorObj;
        }
    }
}

void PackageInfoLookup::addResultsDirectly(const QStringList &packageNames, const Repository *repo)
{
    const auto &packages = repo->packages();
    for(const auto &packageName : packageNames) {
        QJsonObject res;
        res.insert(QStringLiteral("name"), packageName);
        res.insert(QStringLiteral("repo"), repo->name());
        // TODO: remember index
        const auto index = m_packageSelection.value(repo->name()).toObject().value(packageName).toObject().value(QStringLiteral("index"));
        if(!index.isNull() && !index.isUndefined()) {
            res.insert(QStringLiteral("index"), index);
        }
        bool avail = false;
        try {
            if(const auto &pkg = packages.at(packageName)) {
                avail = true;
                if(m_part & Manager::Basics) {
                    res.insert(QStringLiteral("basics"), pkg->basicInfo());
                }
                if(m_part & Manager::Details) {
                    res.insert(QStringLiteral("details"), pkg->detailedInfo());
                }
            }
        } catch(const out_of_range &) {
        }
        if(!avail) {
            res.insert(QStringLiteral("error"), QStringLiteral("na"));
        }
        m_results << res;
    }
}

void PackageInfoLookup::addResultsFromReply()
{
    assert(m_remainingReplies);
    auto *reply = static_cast<PackageReply *>(sender());
    reply->deleteLater();
    const auto *repo = reply->repository();
    addResultsDirectly(reply->requestedPackages(), repo);
    if(!--m_remainingReplies) {
        emit resultsAvailable(m_what, m_id, m_results);
        deleteLater();
    }
}

} // namespace RepoIndex