provider.cpp

/*
    This file is part of KDE.
 
    SPDX-FileCopyrightText: 2008 Cornelius Schumacher <schumacher@kde.org>
    SPDX-FileCopyrightText: 2010 Sebastian Kügler <sebas@kde.org>
    SPDX-FileCopyrightText: 2011 Laszlo Papp <djszapi@archlinux.us>
 
    SPDX-License-Identifier: LGPL-2.1-only OR LGPL-3.0-only OR LicenseRef-KDE-Accepted-LGPL
*/
 
#include "provider.h"
 
#include "accountbalance.h"
#include "accountbalanceparser.h"
#include "achievementparser.h"
#include "activity.h"
#include "activityparser.h"
#include "buildservice.h"
#include "buildservicejob.h"
#include "buildservicejoboutput.h"
#include "buildservicejoboutputparser.h"
#include "buildservicejobparser.h"
#include "buildserviceparser.h"
#include "categoryparser.h"
#include "commentparser.h"
#include "config.h"
#include "content.h"
#include "contentparser.h"
#include "distributionparser.h"
#include "downloaditem.h"
#include "downloaditemparser.h"
#include "event.h"
#include "eventparser.h"
#include "folder.h"
#include "folderparser.h"
#include "forumparser.h"
#include "homepagetype.h"
#include "homepagetypeparser.h"
#include "knowledgebaseentry.h"
#include "knowledgebaseentryparser.h"
#include "licenseparser.h"
#include "messageparser.h"
#include "person.h"
#include "personparser.h"
#include "platformdependent_v2.h"
#include "postfiledata.h"
#include "postjob.h"
#include "privatedata.h"
#include "privatedataparser.h"
#include "project.h"
#include "projectparser.h"
#include "publisher.h"
#include "publisherfield.h"
#include "publisherfieldparser.h"
#include "publisherparser.h"
#include "remoteaccount.h"
#include "remoteaccountparser.h"
#include "topic.h"
#include "topicparser.h"
#include "version.h"
 
#include <QCoreApplication>
#include <QDebug>
#include <QFile>
#include <QNetworkAccessManager>
#include <QNetworkReply>
#include <QThreadStorage>
#include <QUrlQuery>
 
using namespace Attica;
 
class Q_DECL_HIDDEN Provider::Private : public QSharedData
{
public:
    QUrl m_baseUrl;
    QUrl m_icon;
    QString m_name;
    QString m_credentialsUserName;
    QString m_credentialsPassword;
    QString m_personVersion;
    QString m_friendVersion;
    QString m_messageVersion;
    QString m_achievementVersion;
    QString m_activityVersion;
    QString m_contentVersion;
    QString m_fanVersion;
    QString m_forumVersion;
    QString m_knowledgebaseVersion;
    QString m_eventVersion;
    QString m_commentVersion;
    QString m_registerUrl;
    PlatformDependent *m_internals;
    QString m_additionalAgentInformation;
 
    Private()
        : m_internals(nullptr)
    {
    }
 
    Private(const Private &other)
        : QSharedData(other)
        , m_baseUrl(other.m_baseUrl)
        , m_name(other.m_name)
        , m_credentialsUserName(other.m_credentialsUserName)
        , m_credentialsPassword(other.m_credentialsPassword)
        , m_personVersion(other.m_personVersion)
        , m_friendVersion(other.m_friendVersion)
        , m_messageVersion(other.m_messageVersion)
        , m_achievementVersion(other.m_achievementVersion)
        , m_activityVersion(other.m_activityVersion)
        , m_contentVersion(other.m_contentVersion)
        , m_fanVersion(other.m_fanVersion)
        , m_forumVersion(other.m_forumVersion)
        , m_knowledgebaseVersion(other.m_knowledgebaseVersion)
        , m_eventVersion(other.m_eventVersion)
        , m_commentVersion(other.m_commentVersion)
        , m_registerUrl(other.m_registerUrl)
        , m_internals(other.m_internals)
        , m_additionalAgentInformation(other.m_additionalAgentInformation)
    {
    }
 
    Private(PlatformDependent *internals,
            const QUrl &baseUrl,
            const QString &name,
            const QUrl &icon,
            const QString &person,
            const QString &friendV,
            const QString &message,
            const QString &achievement,
            const QString &activity,
            const QString &content,
            const QString &fan,
            const QString &forum,
            const QString &knowledgebase,
            const QString &event,
            const QString &comment,
            const QString &registerUrl,
            const QString &additionalAgentInformation)
        : m_baseUrl(baseUrl)
        , m_icon(icon)
        , m_name(name)
        , m_personVersion(person)
        , m_friendVersion(friendV)
        , m_messageVersion(message)
        , m_achievementVersion(achievement)
        , m_activityVersion(activity)
        , m_contentVersion(content)
        , m_fanVersion(fan)
        , m_forumVersion(forum)
        , m_knowledgebaseVersion(knowledgebase)
        , m_eventVersion(event)
        , m_commentVersion(comment)
        , m_registerUrl(registerUrl)
        , m_internals(internals)
        , m_additionalAgentInformation(additionalAgentInformation)
    {
        if (m_baseUrl.isEmpty()) {
            return;
        }
        QString user;
        QString pass;
        if (m_internals->hasCredentials(m_baseUrl) && m_internals->loadCredentials(m_baseUrl, user, pass)) {
            m_credentialsUserName = user;
            m_credentialsPassword = pass;
        }
    }
 
    ~Private()
    {
    }
};
 
Provider::Provider()
    : d(new Private)
{
}
 
Provider::Provider(const Provider &other)
    : d(other.d)
{
}
 
Provider::Provider(PlatformDependent *internals,
                   const QUrl &baseUrl,
                   const QString &name,
                   const QUrl &icon,
                   const QString &person,
                   const QString &friendV,
                   const QString &message,
                   const QString &achievement,
                   const QString &activity,
                   const QString &content,
                   const QString &fan,
                   const QString &forum,
                   const QString &knowledgebase,
                   const QString &event,
                   const QString &comment)
    : d(new Private(internals,
                    baseUrl,
                    name,
                    icon,
                    person,
                    friendV,
                    message,
                    achievement,
                    activity,
                    content,
                    fan,
                    forum,
                    knowledgebase,
                    event,
                    comment,
                    QString(),
                    QString()))
{
}
 
Provider::Provider(PlatformDependent *internals,
                   const QUrl &baseUrl,
                   const QString &name,
                   const QUrl &icon,
                   const QString &person,
                   const QString &friendV,
                   const QString &message,
                   const QString &achievement,
                   const QString &activity,
                   const QString &content,
                   const QString &fan,
                   const QString &forum,
                   const QString &knowledgebase,
                   const QString &event,
                   const QString &comment,
                   const QString &registerUrl)
    : d(new Private(internals,
                    baseUrl,
                    name,
                    icon,
                    person,
                    friendV,
                    message,
                    achievement,
                    activity,
                    content,
                    fan,
                    forum,
                    knowledgebase,
                    event,
                    comment,
                    registerUrl,
                    QString()))
{
}
 
Provider::Provider(PlatformDependent *internals,
                   const QUrl &baseUrl,
                   const QString &name,
                   const QUrl &icon,
                   const QString &person,
                   const QString &friendV,
                   const QString &message,
                   const QString &achievement,
                   const QString &activity,
                   const QString &content,
                   const QString &fan,
                   const QString &forum,
                   const QString &knowledgebase,
                   const QString &event,
                   const QString &comment,
                   const QString &registerUrl,
                   const QString &additionalAgentInformation)
    : d(new Private(internals,
                    baseUrl,
                    name,
                    icon,
                    person,
                    friendV,
                    message,
                    achievement,
                    activity,
                    content,
                    fan,
                    forum,
                    knowledgebase,
                    event,
                    comment,
                    registerUrl,
                    additionalAgentInformation))
{
}
 
Provider &Provider::operator=(const Attica::Provider &other)
{
    d = other.d;
    return *this;
}
 
Provider::~Provider()
{
}
 
QUrl Provider::baseUrl() const
{
    return d->m_baseUrl;
}
 
bool Provider::isValid() const
{
    return d->m_baseUrl.isValid();
}
 
bool Provider::isEnabled() const
{
    if (!isValid()) {
        return false;
    }
 
    return d->m_internals->isEnabled(d->m_baseUrl);
}
 
void Provider::setEnabled(bool enabled)
{
    if (!isValid()) {
        return;
    }
 
    d->m_internals->enableProvider(d->m_baseUrl, enabled);
}
 
void Provider::setAdditionalAgentInformation(const QString &additionalInformation)
{
    d->m_additionalAgentInformation = additionalInformation;
}
 
QString Provider::additionalAgentInformation() const
{
    return d->m_additionalAgentInformation;
}
 
QString Provider::name() const
{
    return d->m_name;
}
 
QUrl Attica::Provider::icon() const
{
    return d->m_icon;
}
 
bool Provider::hasCredentials()
{
    if (!isValid()) {
        return false;
    }
 
    return d->m_internals->hasCredentials(d->m_baseUrl);
}
 
bool Provider::hasCredentials() const
{
    if (!isValid()) {
        return false;
    }
 
    return d->m_internals->hasCredentials(d->m_baseUrl);
}
 
bool Provider::loadCredentials(QString &user, QString &password)
{
    if (!isValid()) {
        return false;
    }
 
    if (d->m_internals->loadCredentials(d->m_baseUrl, user, password)) {
        d->m_credentialsUserName = user;
        d->m_credentialsPassword = password;
        return true;
    }
    return false;
}
 
bool Provider::saveCredentials(const QString &user, const QString &password)
{
    if (!isValid()) {
        return false;
    }
 
    d->m_credentialsUserName = user;
    d->m_credentialsPassword = password;
    return d->m_internals->saveCredentials(d->m_baseUrl, user, password);
}
 
PostJob *Provider::checkLogin(const QString &user, const QString &password)
{
    if (!isValid()) {
        return nullptr;
    }
 
    QMap<QString, QString> postParameters;
 
    postParameters.insert(QLatin1String("login"), user);
    postParameters.insert(QLatin1String("password"), password);
 
    return new PostJob(d->m_internals, createRequest(QLatin1String("person/check")), postParameters);
}
 
ItemJob<Config> *Provider::requestConfig()
{
    if (!isValid()) {
        return nullptr;
    }
 
    QUrl url = createUrl(QLatin1String("config"));
    return doRequestConfig(url);
}
 
PostJob *Provider::registerAccount(const QString &id, const QString &password, const QString &mail, const QString &firstName, const QString &lastName)
{
    if (!isValid()) {
        return nullptr;
    }
 
    QMap<QString, QString> postParameters;
 
    postParameters.insert(QLatin1String("login"), id);
    postParameters.insert(QLatin1String("password"), password);
    postParameters.insert(QLatin1String("firstname"), firstName);
    postParameters.insert(QLatin1String("lastname"), lastName);
    postParameters.insert(QLatin1String("email"), mail);
 
    return new PostJob(d->m_internals, createRequest(QLatin1String("person/add")), postParameters);
}
 
const QString &Provider::getRegisterAccountUrl() const
{
    return d->m_registerUrl;
}
 
ItemJob<Person> *Provider::requestPerson(const QString &id)
{
    if (!isValid()) {
        return nullptr;
    }
 
    QUrl url = createUrl(QLatin1String("person/data/") + id);
    return doRequestPerson(url);
}
 
ItemJob<Person> *Provider::requestPersonSelf()
{
    if (!isValid()) {
        return nullptr;
    }
 
    QUrl url = createUrl(QLatin1String("person/self"));
    return doRequestPerson(url);
}
 
ItemJob<AccountBalance> *Provider::requestAccountBalance()
{
    if (!isValid()) {
        return nullptr;
    }
 
    QUrl url = createUrl(QLatin1String("person/balance"));
    return doRequestAccountBalance(url);
}
 
ListJob<Person> *Provider::requestPersonSearchByName(const QString &name)
{
    if (!isValid()) {
        return nullptr;
    }
 
    QUrl url = createUrl(QStringLiteral("person/data"));
    QUrlQuery q(url);
    q.addQueryItem(QStringLiteral("name"), name);
    url.setQuery(q);
    return doRequestPersonList(url);
}
 
ListJob<Person> *Provider::requestPersonSearchByLocation(qreal latitude, qreal longitude, qreal distance, int page, int pageSize)
{
    if (!isValid()) {
        return nullptr;
    }
 
    QUrl url = createUrl(QStringLiteral("person/data"));
    QUrlQuery q(url);
    q.addQueryItem(QStringLiteral("latitude"), QString::number(latitude));
    q.addQueryItem(QStringLiteral("longitude"), QString::number(longitude));
    if (distance > 0.0) {
        q.addQueryItem(QStringLiteral("distance"), QString::number(distance));
    }
    q.addQueryItem(QStringLiteral("page"), QString::number(page));
    q.addQueryItem(QStringLiteral("pagesize"), QString::number(pageSize));
    url.setQuery(q);
 
    return doRequestPersonList(url);
}
 
ListJob<Person> *Provider::requestFriends(const QString &id, int page, int pageSize)
{
    if (!isValid()) {
        return nullptr;
    }
 
    QUrl url = createUrl(QLatin1String("friend/data/") + id);
    QUrlQuery q(url);
    q.addQueryItem(QLatin1String("page"), QString::number(page));
    q.addQueryItem(QLatin1String("pagesize"), QString::number(pageSize));
    url.setQuery(q);
 
    return doRequestPersonList(url);
}
 
ListJob<Person> *Provider::requestSentInvitations(int page, int pageSize)
{
    if (!isValid()) {
        return nullptr;
    }
 
    QUrl url = createUrl(QStringLiteral("friend/sentinvitations"));
    QUrlQuery q(url);
    q.addQueryItem(QStringLiteral("page"), QString::number(page));
    q.addQueryItem(QStringLiteral("pagesize"), QString::number(pageSize));
    url.setQuery(q);
 
    return doRequestPersonList(url);
}
 
ListJob<Person> *Provider::requestReceivedInvitations(int page, int pageSize)
{
    if (!isValid()) {
        return nullptr;
    }
 
    QUrl url = createUrl(QStringLiteral("friend/receivedinvitations"));
    QUrlQuery q(url);
    q.addQueryItem(QStringLiteral("page"), QString::number(page));
    q.addQueryItem(QStringLiteral("pagesize"), QString::number(pageSize));
    url.setQuery(q);
 
    return doRequestPersonList(url);
}
 
ListJob<Achievement> *Provider::requestAchievements(const QString &contentId, const QString &achievementId, const QString &userId)
{
    if (!isValid()) {
        return nullptr;
    }
 
    QUrl url = createUrl(QLatin1String("achievements/content/") + contentId + achievementId);
    QUrlQuery q(url);
    q.addQueryItem(QStringLiteral("user_id"), userId);
    url.setQuery(q);
    return doRequestAchievementList(url);
}
 
ItemPostJob<Achievement> *Provider::addNewAchievement(const QString &contentId, const Achievement &newAchievement)
{
    if (!isValid()) {
        return nullptr;
    }
 
    StringMap postParameters;
    int i = 0;
    int j = 0;
 
    postParameters.insert(QLatin1String("name"), newAchievement.name());
    postParameters.insert(QLatin1String("description"), newAchievement.description());
    postParameters.insert(QLatin1String("explanation"), newAchievement.explanation());
    postParameters.insert(QLatin1String("points"), QString::number(newAchievement.points()));
    postParameters.insert(QLatin1String("image"), newAchievement.image().toLocalFile());
    const auto dependenciesList = newAchievement.dependencies();
    for (const QString &dependency : dependenciesList) {
        postParameters.insert(QString::fromLatin1("dependencies[%1]").arg(QString::number(i++)), dependency);
    }
 
    postParameters.insert(QLatin1String("type"), Achievement::achievementTypeToString(newAchievement.type()));
    const auto optionsList = newAchievement.options();
    for (const QString &option : optionsList) {
        postParameters.insert(QString::fromLatin1("options[%1]").arg(QString::number(j++)), option);
    }
 
    postParameters.insert(QLatin1String("steps"), QString::number(newAchievement.steps()));
    postParameters.insert(QLatin1String("visibility"), Achievement::achievementVisibilityToString(newAchievement.visibility()));
 
    return new ItemPostJob<Achievement>(d->m_internals, createRequest(QLatin1String("achievements/content/") + contentId), postParameters);
}
 
PutJob *Provider::editAchievement(const QString &contentId, const QString &achievementId, const Achievement &achievement)
{
    if (!isValid()) {
        return nullptr;
    }
 
    if (!dynamic_cast<Attica::PlatformDependentV2 *>(d->m_internals)) {
        return nullptr;
    }
 
    StringMap postParameters;
    int i = 0;
    int j = 0;
 
    postParameters.insert(QLatin1String("name"), achievement.name());
    postParameters.insert(QLatin1String("description"), achievement.description());
    postParameters.insert(QLatin1String("explanation"), achievement.explanation());
    postParameters.insert(QLatin1String("points"), QString::number(achievement.points()));
    postParameters.insert(QLatin1String("image"), achievement.image().toLocalFile());
    const auto dependenciesList = achievement.dependencies();
    for (const QString &dependency : dependenciesList) {
        postParameters.insert(QString::fromLatin1("dependencies[%1]").arg(QString::number(i++)), dependency);
    }
 
    postParameters.insert(QLatin1String("type"), Achievement::achievementTypeToString(achievement.type()));
    const auto optionsList = achievement.options();
    for (const QString &option : optionsList) {
        postParameters.insert(QString::fromLatin1("options[%1]").arg(QString::number(j++)), option);
    }
 
    postParameters.insert(QLatin1String("steps"), QString::number(achievement.steps()));
    postParameters.insert(QLatin1String("visibility"), Achievement::achievementVisibilityToString(achievement.visibility()));
 
    return new ItemPutJob<Achievement>(d->m_internals, createRequest(QLatin1String("achievement/content/") + contentId + achievementId), postParameters);
}
 
DeleteJob *Provider::deleteAchievement(const QString &contentId, const QString &achievementId)
{
    if (!isValid()) {
        return nullptr;
    }
 
    if (!dynamic_cast<Attica::PlatformDependentV2 *>(d->m_internals)) {
        return nullptr;
    }
 
    return new ItemDeleteJob<Achievement>(d->m_internals, createRequest(QLatin1String("achievements/progress/") + contentId + achievementId));
}
 
PostJob *Provider::setAchievementProgress(const QString &id, const QVariant &progress, const QDateTime &timestamp)
{
    if (!isValid()) {
        return nullptr;
    }
 
    StringMap postParameters;
 
    postParameters.insert(QLatin1String("progress"), progress.toString());
    postParameters.insert(QLatin1String("timestamp"), timestamp.toString());
 
    return new ItemPostJob<Achievement>(d->m_internals, createRequest(QLatin1String("achievements/progress/") + id), postParameters);
}
 
DeleteJob *Provider::resetAchievementProgress(const QString &id)
{
    if (!isValid()) {
        return nullptr;
    }
 
    if (!dynamic_cast<Attica::PlatformDependentV2 *>(d->m_internals)) {
        return nullptr;
    }
 
    return new ItemDeleteJob<Achievement>(d->m_internals, createRequest(QLatin1String("achievements/progress/") + id));
}
 
ListJob<Activity> *Provider::requestActivities()
{
    if (!isValid()) {
        return nullptr;
    }
 
    // qCDebug(ATTICA) << "request activity";
    QUrl url = createUrl(QLatin1String("activity"));
    return doRequestActivityList(url);
}
 
ListJob<Project> *Provider::requestProjects()
{
    if (!isValid()) {
        return nullptr;
    }
 
    // qCDebug(ATTICA) << "request projects";
    QUrl url = createUrl(QLatin1String("buildservice/project/list"));
    return new ListJob<Project>(d->m_internals, createRequest(url));
}
 
ItemJob<Project> *Provider::requestProject(const QString &id)
{
    if (!isValid()) {
        return nullptr;
    }
 
    QUrl url = createUrl(QLatin1String("buildservice/project/get/") + id);
    // qCDebug(ATTICA) << url;
    return new ItemJob<Project>(d->m_internals, createRequest(url));
}
 
QMap<QString, QString> projectPostParameters(const Project &project)
{
    QMap<QString, QString> postParameters;
 
    if (!project.name().isEmpty()) {
        postParameters.insert(QLatin1String("name"), project.name());
    }
    if (!project.summary().isEmpty()) {
        postParameters.insert(QLatin1String("summary"), project.summary());
    }
    if (!project.description().isEmpty()) {
        postParameters.insert(QLatin1String("description"), project.description());
    }
    if (!project.url().isEmpty()) {
        postParameters.insert(QLatin1String("url"), project.url());
    }
    if (!project.developers().isEmpty()) {
        postParameters.insert(QLatin1String("developers"), project.developers().join(QLatin1Char('\n')));
    }
    if (!project.version().isEmpty()) {
        postParameters.insert(QLatin1String("version"), project.version());
    }
    if (!project.license().isEmpty()) {
        postParameters.insert(QLatin1String("license"), project.license());
    }
    if (!project.requirements().isEmpty()) {
        postParameters.insert(QLatin1String("requirements"), project.requirements());
    }
    // The specfile generator expects an empty string parameter if it is supposed to regenerate the spec file
    // So we need to check for nullity here as opposed to an empty string.
    if (!project.specFile().isNull()) {
        postParameters.insert(QLatin1String("specfile"), project.specFile());
    }
    return postParameters;
}
 
PostJob *Provider::createProject(const Project &project)
{
    if (!isValid()) {
        return nullptr;
    }
 
    return new PostJob(d->m_internals, createRequest(QLatin1String("buildservice/project/create")), projectPostParameters(project));
}
 
PostJob *Provider::editProject(const Project &project)
{
    if (!isValid()) {
        return nullptr;
    }
 
    return new PostJob(d->m_internals, createRequest(QLatin1String("buildservice/project/edit/") + project.id()), projectPostParameters(project));
}
 
PostJob *Provider::deleteProject(const Project &project)
{
    if (!isValid()) {
        return nullptr;
    }
 
    return new PostJob(d->m_internals, createRequest(QLatin1String("buildservice/project/delete/") + project.id()), projectPostParameters(project));
}
 
ItemJob<BuildService> *Provider::requestBuildService(const QString &id)
{
    if (!isValid()) {
        return nullptr;
    }
 
    QUrl url = createUrl(QLatin1String("buildservice/buildservices/get/") + id);
    return new ItemJob<BuildService>(d->m_internals, createRequest(url));
}
 
ItemJob<Publisher> *Provider::requestPublisher(const QString &id)
{
    if (!isValid()) {
        return nullptr;
    }
 
    // qCDebug(ATTICA) << "request publisher" << id;
    QUrl url = createUrl(QLatin1String("buildservice/publishing/getpublisher/") + id);
    return new ItemJob<Publisher>(d->m_internals, createRequest(url));
}
 
PostJob *Provider::savePublisherField(const Project &project, const PublisherField &field)
{
    if (!isValid()) {
        return nullptr;
    }
 
    StringMap postParameters;
    postParameters.insert(QLatin1String("fields[0][name]"), field.name());
    postParameters.insert(QLatin1String("fields[0][fieldtype]"), field.type());
    postParameters.insert(QLatin1String("fields[0][data]"), field.data());
 
    QString url = QLatin1String("buildservice/publishing/savefields/") + project.id();
    // qCDebug(ATTICA) << "saving field values...";
    return new PostJob(d->m_internals, createRequest(url), postParameters);
}
 
PostJob *Provider::publishBuildJob(const BuildServiceJob &buildjob, const Publisher &publisher)
{
    if (!isValid()) {
        return nullptr;
    }
 
    StringMap postParameters;
    postParameters.insert(QLatin1String("dummyparameter"), QLatin1String("dummyvalue"));
 
    QString url = QLatin1String("buildservice/publishing/publishtargetresult/") + buildjob.id() + QLatin1Char('/') + publisher.id();
    // qCDebug(ATTICA) << "pub'ing";
    return new PostJob(d->m_internals, createRequest(url), postParameters);
}
 
// Buildservices and their jobs
ItemJob<BuildServiceJobOutput> *Provider::requestBuildServiceJobOutput(const QString &id)
{
    if (!isValid()) {
        return nullptr;
    }
 
    QUrl url = createUrl(QLatin1String("buildservice/jobs/getoutput/") + id);
    // qCDebug(ATTICA) << url;
    return new ItemJob<BuildServiceJobOutput>(d->m_internals, createRequest(url));
}
 
ItemJob<BuildServiceJob> *Provider::requestBuildServiceJob(const QString &id)
{
    if (!isValid()) {
        return nullptr;
    }
 
    QUrl url = createUrl(QLatin1String("buildservice/jobs/get/") + id);
    // qCDebug(ATTICA) << url;
    return new ItemJob<BuildServiceJob>(d->m_internals, createRequest(url));
}
 
QMap<QString, QString> buildServiceJobPostParameters(const BuildServiceJob &buildjob)
{
    QMap<QString, QString> postParameters;
 
    if (!buildjob.name().isEmpty()) {
        postParameters.insert(QLatin1String("name"), buildjob.name());
    }
    if (!buildjob.projectId().isEmpty()) {
        postParameters.insert(QLatin1String("projectid"), buildjob.projectId());
    }
    if (!buildjob.target().isEmpty()) {
        postParameters.insert(QLatin1String("target"), buildjob.target());
    }
    if (!buildjob.buildServiceId().isEmpty()) {
        postParameters.insert(QLatin1String("buildservice"), buildjob.buildServiceId());
    }
 
    return postParameters;
}
 
PostJob *Provider::cancelBuildServiceJob(const BuildServiceJob &job)
{
    if (!isValid()) {
        return nullptr;
    }
 
    StringMap postParameters;
    postParameters.insert(QLatin1String("dummyparameter"), QLatin1String("dummyvalue"));
    // qCDebug(ATTICA) << "b....................b";
    return new PostJob(d->m_internals, createRequest(QLatin1String("buildservice/jobs/cancel/") + job.id()), postParameters);
}
 
PostJob *Provider::createBuildServiceJob(const BuildServiceJob &job)
{
    if (!isValid()) {
        return nullptr;
    }
 
    StringMap postParameters;
    // A postjob won't be run without parameters.
    // so even while we don't need any in this case,
    // we add dummy data to the request
    postParameters.insert(QLatin1String("dummyparameter"), QLatin1String("dummyvalue"));
    // qCDebug(ATTICA) << "Creating new BSJ on" << job.buildServiceId();
    return new PostJob(
        d->m_internals,
        createRequest(QLatin1String("buildservice/jobs/create/") + job.projectId() + QLatin1Char('/') + job.buildServiceId() + QLatin1Char('/') + job.target()),
        postParameters);
}
 
ListJob<BuildService> *Provider::requestBuildServices()
{
    if (!isValid()) {
        return nullptr;
    }
 
    // qCDebug(ATTICA) << "request projects";
    QUrl url = createUrl(QLatin1String("buildservice/buildservices/list"));
    return new ListJob<BuildService>(d->m_internals, createRequest(url));
}
 
ListJob<Publisher> *Provider::requestPublishers()
{
    if (!isValid()) {
        return nullptr;
    }
 
    QUrl url = createUrl(QLatin1String("buildservice/publishing/getpublishingcapabilities"));
    // qCDebug(ATTICA) << "request publishers" << url;
    return new ListJob<Publisher>(d->m_internals, createRequest(url));
}
 
ListJob<BuildServiceJob> *Provider::requestBuildServiceJobs(const Project &project)
{
    if (!isValid()) {
        return nullptr;
    }
 
    // qCDebug(ATTICA) << "request projects";
    QUrl url = createUrl(QLatin1String("buildservice/jobs/list/") + project.id());
    return new ListJob<BuildServiceJob>(d->m_internals, createRequest(url));
}
 
ListJob<RemoteAccount> *Provider::requestRemoteAccounts()
{
    if (!isValid()) {
        return nullptr;
    }
 
    // qCDebug(ATTICA) << "request remoteaccounts";
    QUrl url = createUrl(QLatin1String("buildservice/remoteaccounts/list/"));
    return new ListJob<RemoteAccount>(d->m_internals, createRequest(url));
}
 
PostJob *Provider::createRemoteAccount(const RemoteAccount &account)
{
    if (!isValid()) {
        return nullptr;
    }
 
    StringMap postParameters;
    // A postjob won't be run without parameters.
    // so even while we don't need any in this case,
    // we add dummy data to the request
    postParameters.insert(QLatin1String("login"), account.login());
    postParameters.insert(QLatin1String("password"), account.password());
    postParameters.insert(QLatin1String("type"), account.type());
    postParameters.insert(QLatin1String("typeid"), account.remoteServiceId()); // FIXME: remoteserviceid?
    postParameters.insert(QLatin1String("data"), account.data());
    // qCDebug(ATTICA) << "Creating new Remoteaccount" << account.id() << account.login() << account.password();
    return new PostJob(d->m_internals, createRequest(QLatin1String("buildservice/remoteaccounts/add")), postParameters);
}
 
PostJob *Provider::editRemoteAccount(const RemoteAccount &account)
{
    if (!isValid()) {
        return nullptr;
    }
 
    StringMap postParameters;
    // A postjob won't be run without parameters.
    // so even while we don't need any in this case,
    // we add dummy data to the request
    postParameters.insert(QLatin1String("login"), account.login());
    postParameters.insert(QLatin1String("password"), account.password());
    postParameters.insert(QLatin1String("type"), account.type());
    postParameters.insert(QLatin1String("typeid"), account.remoteServiceId()); // FIXME: remoteserviceid?
    postParameters.insert(QLatin1String("data"), account.data());
    // qCDebug(ATTICA) << "Creating new Remoteaccount" << account.id() << account.login() << account.password();
    return new PostJob(d->m_internals, createRequest(QLatin1String("buildservice/remoteaccounts/edit/") + account.id()), postParameters);
}
 
ItemJob<RemoteAccount> *Provider::requestRemoteAccount(const QString &id)
{
    if (!isValid()) {
        return nullptr;
    }
 
    QUrl url = createUrl(QLatin1String("buildservice/remoteaccounts/get/") + id);
    // qCDebug(ATTICA) << url;
    return new ItemJob<RemoteAccount>(d->m_internals, createRequest(url));
}
 
PostJob *Provider::deleteRemoteAccount(const QString &id)
{
    if (!isValid()) {
        return nullptr;
    }
 
    StringMap postParameters;
    return new PostJob(d->m_internals, createRequest(QLatin1String("buildservice/remoteaccounts/remove/") + id), postParameters);
}
 
PostJob *Provider::uploadTarballToBuildService(const QString &projectId, const QString &fileName, const QByteArray &payload)
{
    if (!isValid()) {
        return nullptr;
    }
 
    QUrl url = createUrl(QLatin1String("buildservice/project/uploadsource/") + projectId);
    // qCDebug(ATTICA) << "Up'ing tarball" << url << projectId << fileName << payload;
    PostFileData postRequest(url);
    postRequest.addFile(fileName, payload, QLatin1String("application/octet-stream"), QLatin1String("source"));
    return new PostJob(d->m_internals, postRequest.request(), postRequest.data());
}
 
// Activity
 
PostJob *Provider::postActivity(const QString &message)
{
    if (!isValid()) {
        return nullptr;
    }
 
    StringMap postParameters;
    postParameters.insert(QLatin1String("message"), message);
    return new PostJob(d->m_internals, createRequest(QLatin1String("activity")), postParameters);
}
 
PostJob *Provider::inviteFriend(const QString &to, const QString &message)
{
    if (!isValid()) {
        return nullptr;
    }
 
    StringMap postParameters;
    postParameters.insert(QLatin1String("message"), message);
    return new PostJob(d->m_internals, createRequest(QLatin1String("friend/invite/") + to), postParameters);
}
 
PostJob *Provider::approveFriendship(const QString &to)
{
    if (!isValid()) {
        return nullptr;
    }
 
    return new PostJob(d->m_internals, createRequest(QLatin1String("friend/approve/") + to));
}
 
PostJob *Provider::declineFriendship(const QString &to)
{
    if (!isValid()) {
        return nullptr;
    }
 
    return new PostJob(d->m_internals, createRequest(QLatin1String("friend/decline/") + to));
}
 
PostJob *Provider::cancelFriendship(const QString &to)
{
    if (!isValid()) {
        return nullptr;
    }
 
    return new PostJob(d->m_internals, createRequest(QLatin1String("friend/cancel/") + to));
}
 
PostJob *Provider::postLocation(qreal latitude, qreal longitude, const QString &city, const QString &country)
{
    if (!isValid()) {
        return nullptr;
    }
 
    StringMap postParameters;
    postParameters.insert(QLatin1String("latitude"), QString::number(latitude));
    postParameters.insert(QLatin1String("longitude"), QString::number(longitude));
    postParameters.insert(QLatin1String("city"), city);
    postParameters.insert(QLatin1String("country"), country);
    return new PostJob(d->m_internals, createRequest(QLatin1String("person/self")), postParameters);
}
 
ListJob<Folder> *Provider::requestFolders()
{
    if (!isValid()) {
        return nullptr;
    }
 
    return doRequestFolderList(createUrl(QLatin1String("message")));
}
 
ListJob<Message> *Provider::requestMessages(const Folder &folder)
{
    if (!isValid()) {
        return nullptr;
    }
 
    return doRequestMessageList(createUrl(QLatin1String("message/") + folder.id()));
}
 
ListJob<Message> *Provider::requestMessages(const Folder &folder, Message::Status status)
{
    if (!isValid()) {
        return nullptr;
    }
 
    QUrl url = createUrl(QLatin1String("message/") + folder.id());
    QUrlQuery q(url);
    q.addQueryItem(QStringLiteral("status"), QString::number(status));
    url.setQuery(q);
    return doRequestMessageList(url);
}
 
ItemJob<Message> *Provider::requestMessage(const Folder &folder, const QString &id)
{
    if (!isValid()) {
        return nullptr;
    }
 
    return new ItemJob<Message>(d->m_internals, createRequest(QLatin1String("message/") + folder.id() + QLatin1Char('/') + id));
}
 
PostJob *Provider::postMessage(const Message &message)
{
    if (!isValid()) {
        return nullptr;
    }
 
    StringMap postParameters;
    postParameters.insert(QLatin1String("message"), message.body());
    postParameters.insert(QLatin1String("subject"), message.subject());
    postParameters.insert(QLatin1String("to"), message.to());
    return new PostJob(d->m_internals, createRequest(QLatin1String("message/2")), postParameters);
}
 
ListJob<Category> *Provider::requestCategories()
{
    if (!isValid()) {
        return nullptr;
    }
 
    const QUrl url = createUrl(QLatin1String("content/categories"));
 
    // Thread-local cache of categories requests. They are fairly slow and block startup
    static QThreadStorage<QHash<QUrl, ListJob<Category> *>> reqs;
    ListJob<Category> *job = reqs.localData().value(url);
    if (!job) {
        job = new ListJob<Category>(d->m_internals, createRequest(url));
        QObject::connect(job, &BaseJob::finished, [url] {
            reqs.localData().remove(url);
        });
        reqs.localData().insert(url, job);
    }
    return job;
}
 
ListJob<License> *Provider::requestLicenses()
{
    if (!isValid()) {
        return nullptr;
    }
 
    QUrl url = createUrl(QLatin1String("content/licenses"));
    ListJob<License> *job = new ListJob<License>(d->m_internals, createRequest(url));
    return job;
}
 
ListJob<Distribution> *Provider::requestDistributions()
{
    if (!isValid()) {
        return nullptr;
    }
 
    QUrl url = createUrl(QLatin1String("content/distributions"));
    ListJob<Distribution> *job = new ListJob<Distribution>(d->m_internals, createRequest(url));
    return job;
}
 
ListJob<HomePageType> *Provider::requestHomePageTypes()
{
    if (!isValid()) {
        return nullptr;
    }
 
    QUrl url = createUrl(QLatin1String("content/homepages"));
    ListJob<HomePageType> *job = new ListJob<HomePageType>(d->m_internals, createRequest(url));
    return job;
}
 
ListJob<Content> *Provider::searchContents(const Category::List &categories, const QString &search, SortMode sortMode, uint page, uint pageSize)
{
    return searchContents(categories, QString(), Distribution::List(), License::List(), search, sortMode, page, pageSize);
}
 
ListJob<Content> *
Provider::searchContentsByPerson(const Category::List &categories, const QString &person, const QString &search, SortMode sortMode, uint page, uint pageSize)
{
    return searchContents(categories, person, Distribution::List(), License::List(), search, sortMode, page, pageSize);
}
 
ListJob<Content> *Provider::searchContents(const Category::List &categories,
                                           const QString &person,
                                           const Distribution::List &distributions,
                                           const License::List &licenses,
                                           const QString &search,
                                           SortMode sortMode,
                                           uint page,
                                           uint pageSize)
{
    if (!isValid()) {
        return nullptr;
    }
 
    QUrl url = createUrl(QStringLiteral("content/data"));
    QUrlQuery q(url);
    QStringList categoryIds;
    categoryIds.reserve(categories.count());
    for (const Category &category : categories) {
        categoryIds.append(category.id());
    }
    q.addQueryItem(QStringLiteral("categories"), categoryIds.join(QLatin1Char('x')));
 
    QStringList distributionIds;
    for (const Distribution &distribution : distributions) {
        distributionIds.append(QString::number(distribution.id()));
    }
    q.addQueryItem(QStringLiteral("distribution"), distributionIds.join(QLatin1Char(',')));
 
    QStringList licenseIds;
    for (const License &license : licenses) {
        licenseIds.append(QString::number(license.id()));
    }
    q.addQueryItem(QStringLiteral("license"), licenseIds.join(QLatin1Char(',')));
 
    if (!person.isEmpty()) {
        q.addQueryItem(QStringLiteral("user"), person);
    }
 
    q.addQueryItem(QStringLiteral("search"), search);
    QString sortModeString;
    switch (sortMode) {
    case Newest:
        sortModeString = QLatin1String("new");
        break;
    case Alphabetical:
        sortModeString = QLatin1String("alpha");
        break;
    case Rating:
        sortModeString = QLatin1String("high");
        break;
    case Downloads:
        sortModeString = QLatin1String("down");
        break;
    }
 
    if (!sortModeString.isEmpty()) {
        q.addQueryItem(QStringLiteral("sortmode"), sortModeString);
    }
 
    q.addQueryItem(QStringLiteral("page"), QString::number(page));
    q.addQueryItem(QStringLiteral("pagesize"), QString::number(pageSize));
 
    url.setQuery(q);
    ListJob<Content> *job = new ListJob<Content>(d->m_internals, createRequest(url));
    return job;
}
 
ItemJob<Content> *Provider::requestContent(const QString &id)
{
    if (!isValid()) {
        return nullptr;
    }
 
    QUrl url = createUrl(QLatin1String("content/data/") + id);
    ItemJob<Content> *job = new ItemJob<Content>(d->m_internals, createRequest(url));
    return job;
}
 
ItemPostJob<Content> *Provider::addNewContent(const Category &category, const Content &cont)
{
    if (!isValid() || !category.isValid()) {
        return nullptr;
    }
 
    QUrl url = createUrl(QLatin1String("content/add"));
    StringMap pars(cont.attributes());
 
    pars.insert(QLatin1String("type"), category.id());
    pars.insert(QLatin1String("name"), cont.name());
 
    // qCDebug(ATTICA) << "Parameter map: " << pars;
 
    return new ItemPostJob<Content>(d->m_internals, createRequest(url), pars);
}
 
ItemPostJob<Content> *Provider::editContent(const Category &updatedCategory, const QString &contentId, const Content &updatedContent)
{
    if (!isValid()) {
        return nullptr;
    }
 
    // FIXME I get a server error message here, though the name of the item is changed
    QUrl url = createUrl(QLatin1String("content/edit/") + contentId);
    StringMap pars(updatedContent.attributes());
 
    pars.insert(QLatin1String("type"), updatedCategory.id());
    pars.insert(QLatin1String("name"), updatedContent.name());
 
    // qCDebug(ATTICA) << "Parameter map: " << pars;
 
    return new ItemPostJob<Content>(d->m_internals, createRequest(url), pars);
}
 
/*
PostJob* Provider::setDownloadFile(const QString& contentId, QIODevice* payload)
{
    QUrl url = createUrl("content/uploaddownload/" + contentId);
    PostFileData postRequest(url);
    // FIXME mime type
    //postRequest.addFile("localfile", payload, "application/octet-stream");
    postRequest.addFile("localfile", payload, "image/jpeg");
    return new PostJob(d->m_internals, postRequest.request(), postRequest.data());
}
*/
 
PostJob *Provider::deleteContent(const QString &contentId)
{
    if (!isValid()) {
        return nullptr;
    }
 
    QUrl url = createUrl(QLatin1String("content/delete/") + contentId);
    PostFileData postRequest(url);
    postRequest.addArgument(QLatin1String("contentid"), contentId);
    return new PostJob(d->m_internals, postRequest.request(), postRequest.data());
}
 
PostJob *Provider::setDownloadFile(const QString &contentId, const QString &fileName, const QByteArray &payload)
{
    if (!isValid()) {
        return nullptr;
    }
 
    QUrl url = createUrl(QLatin1String("content/uploaddownload/") + contentId);
    PostFileData postRequest(url);
    postRequest.addArgument(QLatin1String("contentid"), contentId);
    // FIXME mime type
    postRequest.addFile(fileName, payload, QLatin1String("application/octet-stream"));
    return new PostJob(d->m_internals, postRequest.request(), postRequest.data());
}
 
PostJob *Provider::deleteDownloadFile(const QString &contentId)
{
    if (!isValid()) {
        return nullptr;
    }
 
    QUrl url = createUrl(QLatin1String("content/deletedownload/") + contentId);
    PostFileData postRequest(url);
    postRequest.addArgument(QLatin1String("contentid"), contentId);
    return new PostJob(d->m_internals, postRequest.request(), postRequest.data());
}
 
PostJob *Provider::setPreviewImage(const QString &contentId, const QString &previewId, const QString &fileName, const QByteArray &image)
{
    if (!isValid()) {
        return nullptr;
    }
 
    QUrl url = createUrl(QLatin1String("content/uploadpreview/") + contentId + QLatin1Char('/') + previewId);
 
    PostFileData postRequest(url);
    postRequest.addArgument(QLatin1String("contentid"), contentId);
    postRequest.addArgument(QLatin1String("previewid"), previewId);
    // FIXME mime type
    postRequest.addFile(fileName, image, QLatin1String("application/octet-stream"));
 
    return new PostJob(d->m_internals, postRequest.request(), postRequest.data());
}
 
PostJob *Provider::deletePreviewImage(const QString &contentId, const QString &previewId)
{
    if (!isValid()) {
        return nullptr;
    }
 
    QUrl url = createUrl(QLatin1String("content/deletepreview/") + contentId + QLatin1Char('/') + previewId);
    PostFileData postRequest(url);
    postRequest.addArgument(QLatin1String("contentid"), contentId);
    postRequest.addArgument(QLatin1String("previewid"), previewId);
    return new PostJob(d->m_internals, postRequest.request(), postRequest.data());
}
 
PostJob *Provider::voteForContent(const QString &contentId, uint rating)
{
    if (!isValid()) {
        return nullptr;
    }
 
    // according to OCS API, the rating is 0..100
    if (rating > 100) {
        qWarning() << "Rating cannot be superior to 100, fallback to 100.";
        rating = 100;
    }
 
    StringMap postParameters;
    postParameters.insert(QLatin1String("vote"), QString::number(rating));
    // qCDebug(ATTICA) << "vote: " << QString::number(rating);
    return new PostJob(d->m_internals, createRequest(QLatin1String("content/vote/") + contentId), postParameters);
}
 
PostJob *Provider::becomeFan(const QString &contentId)
{
    if (!isValid()) {
        return nullptr;
    }
 
    QUrl url = createUrl(QLatin1String("fan/add/") + contentId);
    PostFileData postRequest(url);
    postRequest.addArgument(QLatin1String("contentid"), contentId);
    return new PostJob(d->m_internals, postRequest.request(), postRequest.data());
}
 
ListJob<Person> *Provider::requestFans(const QString &contentId, uint page, uint pageSize)
{
    if (!isValid()) {
        return nullptr;
    }
 
    QUrl url = createUrl(QLatin1String("fan/data/") + contentId);
    QUrlQuery q(url);
    q.addQueryItem(QStringLiteral("contentid"), contentId);
    q.addQueryItem(QStringLiteral("page"), QString::number(page));
    q.addQueryItem(QStringLiteral("pagesize"), QString::number(pageSize));
    url.setQuery(q);
    ListJob<Person> *job = new ListJob<Person>(d->m_internals, createRequest(url));
    return job;
}
 
ListJob<Forum> *Provider::requestForums(uint page, uint pageSize)
{
    if (!isValid()) {
        return nullptr;
    }
 
    QUrl url = createUrl(QStringLiteral("forum/list"));
    QUrlQuery q(url);
    q.addQueryItem(QStringLiteral("page"), QString::number(page));
    q.addQueryItem(QStringLiteral("pagesize"), QString::number(pageSize));
    url.setQuery(q);
 
    return doRequestForumList(url);
}
 
ListJob<Topic> *
Provider::requestTopics(const QString &forum, const QString &search, const QString &description, Provider::SortMode mode, int page, int pageSize)
{
    if (!isValid()) {
        return nullptr;
    }
 
    QUrl url = createUrl(QStringLiteral("forum/topics/list"));
    QUrlQuery q(url);
    q.addQueryItem(QStringLiteral("forum"), forum);
    q.addQueryItem(QStringLiteral("search"), search);
    q.addQueryItem(QStringLiteral("description"), description);
    QString sortModeString;
    switch (mode) {
    case Newest:
        sortModeString = QLatin1String("new");
        break;
    case Alphabetical:
        sortModeString = QLatin1String("alpha");
        break;
    default:
        break;
    }
    if (!sortModeString.isEmpty()) {
        q.addQueryItem(QStringLiteral("sortmode"), sortModeString);
    }
    q.addQueryItem(QStringLiteral("page"), QString::number(page));
    q.addQueryItem(QStringLiteral("pagesize"), QString::number(pageSize));
    url.setQuery(q);
 
    return doRequestTopicList(url);
}
 
PostJob *Provider::postTopic(const QString &forumId, const QString &subject, const QString &content)
{
    if (!isValid()) {
        return nullptr;
    }
 
    StringMap postParameters;
    postParameters.insert(QLatin1String("subject"), subject);
    postParameters.insert(QLatin1String("content"), content);
    postParameters.insert(QLatin1String("forum"), forumId);
    return new PostJob(d->m_internals, createRequest(QLatin1String("forum/topic/add")), postParameters);
}
 
ItemJob<DownloadItem> *Provider::downloadLink(const QString &contentId, const QString &itemId)
{
    if (!isValid()) {
        return nullptr;
    }
 
    QUrl url = createUrl(QLatin1String("content/download/") + contentId + QLatin1Char('/') + itemId);
    ItemJob<DownloadItem> *job = new ItemJob<DownloadItem>(d->m_internals, createRequest(url));
    return job;
}
 
ItemJob<KnowledgeBaseEntry> *Provider::requestKnowledgeBaseEntry(const QString &id)
{
    if (!isValid()) {
        return nullptr;
    }
 
    QUrl url = createUrl(QLatin1String("knowledgebase/data/") + id);
    ItemJob<KnowledgeBaseEntry> *job = new ItemJob<KnowledgeBaseEntry>(d->m_internals, createRequest(url));
    return job;
}
 
ListJob<KnowledgeBaseEntry> *Provider::searchKnowledgeBase(const Content &content, const QString &search, Provider::SortMode sortMode, int page, int pageSize)
{
    if (!isValid()) {
        return nullptr;
    }
 
    QUrl url = createUrl(QStringLiteral("knowledgebase/data"));
    QUrlQuery q(url);
    if (content.isValid()) {
        q.addQueryItem(QStringLiteral("content"), content.id());
    }
 
    q.addQueryItem(QStringLiteral("search"), search);
    QString sortModeString;
    switch (sortMode) {
    case Newest:
        sortModeString = QLatin1String("new");
        break;
    case Alphabetical:
        sortModeString = QLatin1String("alpha");
        break;
    case Rating:
        sortModeString = QLatin1String("high");
        break;
    // FIXME: knowledge base doesn't have downloads
    case Downloads:
        sortModeString = QLatin1String("new");
        break;
    }
    if (!sortModeString.isEmpty()) {
        q.addQueryItem(QStringLiteral("sortmode"), sortModeString);
    }
 
    q.addQueryItem(QStringLiteral("page"), QString::number(page));
    q.addQueryItem(QStringLiteral("pagesize"), QString::number(pageSize));
    url.setQuery(q);
 
    ListJob<KnowledgeBaseEntry> *job = new ListJob<KnowledgeBaseEntry>(d->m_internals, createRequest(url));
    return job;
}
 
ItemJob<Event> *Provider::requestEvent(const QString &id)
{
    if (!isValid()) {
        return nullptr;
    }
 
    ItemJob<Event> *job = new ItemJob<Event>(d->m_internals, createRequest(QLatin1String("event/data/") + id));
    return job;
}
 
ListJob<Event> *Provider::requestEvent(const QString &country, const QString &search, const QDate &startAt, Provider::SortMode mode, int page, int pageSize)
{
    if (!isValid()) {
        return nullptr;
    }
 
    QUrl url = createUrl(QStringLiteral("event/data"));
    QUrlQuery q(url);
 
    if (!search.isEmpty()) {
        q.addQueryItem(QStringLiteral("search"), search);
    }
 
    QString sortModeString;
    switch (mode) {
    case Newest:
        sortModeString = QLatin1String("new");
        break;
    case Alphabetical:
        sortModeString = QLatin1String("alpha");
        break;
    default:
        break;
    }
    if (!sortModeString.isEmpty()) {
        q.addQueryItem(QStringLiteral("sortmode"), sortModeString);
    }
 
    if (!country.isEmpty()) {
        q.addQueryItem(QStringLiteral("country"), country);
    }
 
    q.addQueryItem(QStringLiteral("startat"), startAt.toString(Qt::ISODate));
 
    q.addQueryItem(QStringLiteral("page"), QString::number(page));
    q.addQueryItem(QStringLiteral("pagesize"), QString::number(pageSize));
    url.setQuery(q);
 
    ListJob<Event> *job = new ListJob<Event>(d->m_internals, createRequest(url));
    return job;
}
 
ListJob<Comment> *Provider::requestComments(const Comment::Type commentType, const QString &id, const QString &id2, int page, int pageSize)
{
    if (!isValid()) {
        return nullptr;
    }
 
    QString commentTypeString;
    commentTypeString = Comment::commentTypeToString(commentType);
    if (commentTypeString.isEmpty()) {
        return nullptr;
    }
 
    QUrl url = createUrl(QLatin1String("comments/data/") + commentTypeString + QLatin1Char('/') + id + QLatin1Char('/') + id2);
 
    QUrlQuery q(url);
    q.addQueryItem(QStringLiteral("page"), QString::number(page));
    q.addQueryItem(QStringLiteral("pagesize"), QString::number(pageSize));
    url.setQuery(q);
 
    ListJob<Comment> *job = new ListJob<Comment>(d->m_internals, createRequest(url));
    return job;
}
 
ItemPostJob<Comment> *Provider::addNewComment(const Comment::Type commentType,
                                              const QString &id,
                                              const QString &id2,
                                              const QString &parentId,
                                              const QString &subject,
                                              const QString &message)
{
    if (!isValid()) {
        return nullptr;
    }
 
    QString commentTypeString;
    commentTypeString = Comment::commentTypeToString(commentType);
    if (commentTypeString.isEmpty()) {
        return nullptr;
    }
 
    QMap<QString, QString> postParameters;
 
    postParameters.insert(QLatin1String("type"), commentTypeString);
    postParameters.insert(QLatin1String("content"), id);
    postParameters.insert(QLatin1String("content2"), id2);
    postParameters.insert(QLatin1String("parent"), parentId);
    postParameters.insert(QLatin1String("subject"), subject);
    postParameters.insert(QLatin1String("message"), message);
 
    return new ItemPostJob<Comment>(d->m_internals, createRequest(QLatin1String("comments/add")), postParameters);
}
 
PostJob *Provider::voteForComment(const QString &id, uint rating)
{
    if (!isValid() || (rating > 100)) {
        return nullptr;
    }
 
    QMap<QString, QString> postParameters;
    postParameters.insert(QLatin1String("vote"), QString::number(rating));
 
    QUrl url = createUrl(QLatin1String("comments/vote/") + id);
    return new PostJob(d->m_internals, createRequest(url), postParameters);
}
 
PostJob *Provider::setPrivateData(const QString &app, const QString &key, const QString &value)
{
    if (!isValid()) {
        return nullptr;
    }
 
    QUrl url = createUrl(QLatin1String("privatedata/setattribute/") + app + QLatin1Char('/') + key);
    PostFileData postRequest(url);
 
    postRequest.addArgument(QLatin1String("value"), value);
 
    return new PostJob(d->m_internals, postRequest.request(), postRequest.data());
}
 
ItemJob<PrivateData> *Provider::requestPrivateData(const QString &app, const QString &key)
{
    if (!isValid()) {
        return nullptr;
    }
 
    ItemJob<PrivateData> *job =
        new ItemJob<PrivateData>(d->m_internals, createRequest(QLatin1String("privatedata/getattribute/") + app + QLatin1Char('/') + key));
    return job;
}
 
QUrl Provider::createUrl(const QString &path)
{
    QUrl url(d->m_baseUrl.toString() + path);
    return url;
}
 
QNetworkRequest Provider::createRequest(const QUrl &url)
{
    QNetworkRequest request(url);
    request.setHeader(QNetworkRequest::ContentTypeHeader, QStringLiteral("application/x-www-form-urlencoded"));
 
    QString agentHeader;
    if (QCoreApplication::instance()) {
        agentHeader = QString::fromLocal8Bit("%1/%2").arg(QCoreApplication::instance()->applicationName(), QCoreApplication::instance()->applicationVersion());
    } else {
        agentHeader = QString::fromLocal8Bit("Attica/%1").arg(QLatin1String(LIBATTICA_VERSION_STRING));
    }
    if (!d->m_additionalAgentInformation.isEmpty()) {
        agentHeader = QString::fromLocal8Bit("%1 (+%2)").arg(agentHeader, d->m_additionalAgentInformation);
    }
    request.setHeader(QNetworkRequest::UserAgentHeader, agentHeader);
 
    if (!d->m_credentialsUserName.isEmpty()) {
        request.setAttribute((QNetworkRequest::Attribute)BaseJob::UserAttribute, QVariant(d->m_credentialsUserName));
        request.setAttribute((QNetworkRequest::Attribute)BaseJob::PasswordAttribute, QVariant(d->m_credentialsPassword));
    }
    return request;
}
 
QNetworkRequest Provider::createRequest(const QString &path)
{
    return createRequest(createUrl(path));
}
 
ItemJob<Config> *Provider::doRequestConfig(const QUrl &url)
{
    return new ItemJob<Config>(d->m_internals, createRequest(url));
}
 
ItemJob<Person> *Provider::doRequestPerson(const QUrl &url)
{
    return new ItemJob<Person>(d->m_internals, createRequest(url));
}
 
ItemJob<AccountBalance> *Provider::doRequestAccountBalance(const QUrl &url)
{
    return new ItemJob<AccountBalance>(d->m_internals, createRequest(url));
}
 
ListJob<Person> *Provider::doRequestPersonList(const QUrl &url)
{
    return new ListJob<Person>(d->m_internals, createRequest(url));
}
 
ListJob<Achievement> *Provider::doRequestAchievementList(const QUrl &url)
{
    return new ListJob<Achievement>(d->m_internals, createRequest(url));
}
 
ListJob<Activity> *Provider::doRequestActivityList(const QUrl &url)
{
    return new ListJob<Activity>(d->m_internals, createRequest(url));
}
 
ListJob<Folder> *Provider::doRequestFolderList(const QUrl &url)
{
    return new ListJob<Folder>(d->m_internals, createRequest(url));
}
 
ListJob<Forum> *Provider::doRequestForumList(const QUrl &url)
{
    return new ListJob<Forum>(d->m_internals, createRequest(url));
}
 
ListJob<Topic> *Provider::doRequestTopicList(const QUrl &url)
{
    return new ListJob<Topic>(d->m_internals, createRequest(url));
}
 
ListJob<Message> *Provider::doRequestMessageList(const QUrl &url)
{
    return new ListJob<Message>(d->m_internals, createRequest(url));
}
 
QString Provider::achievementServiceVersion() const
{
    return d->m_achievementVersion;
}
 
QString Provider::activityServiceVersion() const
{
    return d->m_activityVersion;
}
QString Provider::commentServiceVersion() const
{
    return d->m_commentVersion;
}
QString Provider::contentServiceVersion() const
{
    return d->m_contentVersion;
}
QString Provider::fanServiceVersion() const
{
    return d->m_fanVersion;
}
QString Provider::forumServiceVersion() const
{
    return d->m_forumVersion;
}
QString Provider::friendServiceVersion() const
{
    return d->m_friendVersion;
}
QString Provider::knowledgebaseServiceVersion() const
{
    return d->m_knowledgebaseVersion;
}
QString Provider::messageServiceVersion() const
{
    return d->m_messageVersion;
}
QString Provider::personServiceVersion() const
{
    return d->m_personVersion;
}
 
bool Provider::hasAchievementService() const
{
    return !d->m_achievementVersion.isEmpty();
}
 
bool Provider::hasActivityService() const
{
    return !d->m_activityVersion.isEmpty();
}
bool Provider::hasCommentService() const
{
    return !d->m_commentVersion.isEmpty();
}
bool Provider::hasContentService() const
{
    return !d->m_contentVersion.isEmpty();
}
bool Provider::hasFanService() const
{
    return !d->m_fanVersion.isEmpty();
}
bool Provider::hasForumService() const
{
    return !d->m_forumVersion.isEmpty();
}
bool Provider::hasFriendService() const
{
    return !d->m_friendVersion.isEmpty();
}
bool Provider::hasKnowledgebaseService() const
{
    return !d->m_knowledgebaseVersion.isEmpty();
}
bool Provider::hasMessageService() const
{
    return !d->m_messageVersion.isEmpty();
}
bool Provider::hasPersonService() const
{
    return !d->m_personVersion.isEmpty();
}