qnetworkrequestfactory.cpp

Go to the documentation of this file.

// Copyright (C) 2023 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 
#include "qnetworkrequestfactory.h"
#include "qnetworkrequestfactory_p.h"
 
#if QT_CONFIG(ssl)
#include <QtNetwork/qsslconfiguration.h>
#endif
 
#include <QtCore/qloggingcategory.h>
#include <QtCore/qmap.h>
 
QT_BEGIN_NAMESPACE
 
QT_DEFINE_QESDP_SPECIALIZATION_DTOR(QNetworkRequestFactoryPrivate)
 
using namespace Qt::StringLiterals;
 
Q_LOGGING_CATEGORY(lcQrequestfactory, "qt.network.access.request.factory")
 
 
QNetworkRequestFactory::QNetworkRequestFactory()
    : d(new QNetworkRequestFactoryPrivate)
{
}
 
QNetworkRequestFactory::QNetworkRequestFactory(const QUrl &baseUrl)
    : d(new QNetworkRequestFactoryPrivate(baseUrl))
{
}
 
QNetworkRequestFactory::~QNetworkRequestFactory()
    = default;
 
QNetworkRequestFactory::QNetworkRequestFactory(const QNetworkRequestFactory &other)
    = default;
 
QNetworkRequestFactory &QNetworkRequestFactory::operator=(const QNetworkRequestFactory &other)
    = default;
 
QUrl QNetworkRequestFactory::baseUrl() const
{
    return d->baseUrl;
}
 
void QNetworkRequestFactory::setBaseUrl(const QUrl &url)
{
    if (d->baseUrl == url)
        return;
 
    d.detach();
    d->baseUrl = url;
}
 
#if QT_CONFIG(ssl)
QSslConfiguration QNetworkRequestFactory::sslConfiguration() const
{
    return d->sslConfig;
}
 
void QNetworkRequestFactory::setSslConfiguration(const QSslConfiguration &configuration)
{
    if (d->sslConfig == configuration)
        return;
 
    d.detach();
    d->sslConfig = configuration;
}
#endif
 
QNetworkRequest QNetworkRequestFactory::createRequest() const
{
    return d->newRequest(d->requestUrl());
}
 
QNetworkRequest QNetworkRequestFactory::createRequest(const QString &path) const
{
    return d->newRequest(d->requestUrl(&path));
}
 
QNetworkRequest QNetworkRequestFactory::createRequest(const QUrlQuery &query) const
{
    return d->newRequest(d->requestUrl(nullptr, &query));
}
 
QNetworkRequest QNetworkRequestFactory::createRequest(const QString &path, const QUrlQuery &query) const
{
    return d->newRequest(d->requestUrl(&path, &query));
}
 
void QNetworkRequestFactory::setCommonHeaders(const QHttpHeaders &headers)
{
    d.detach();
    d->headers = headers;
}
 
QHttpHeaders QNetworkRequestFactory::commonHeaders() const
{
    return d->headers;
}
 
void QNetworkRequestFactory::clearCommonHeaders()
{
    if (d->headers.isEmpty())
        return;
    d.detach();
    d->headers.clear();
}
 
QByteArray QNetworkRequestFactory::bearerToken() const
{
    return d->bearerToken;
}
 
void QNetworkRequestFactory::setBearerToken(const QByteArray &token)
{
    if (d->bearerToken == token)
        return;
 
    d.detach();
    d->bearerToken = token;
}
 
void QNetworkRequestFactory::clearBearerToken()
{
    if (d->bearerToken.isEmpty())
        return;
 
    d.detach();
    d->bearerToken.clear();
}
 
QString QNetworkRequestFactory::userName() const
{
    return d->userName;
}
 
void QNetworkRequestFactory::setUserName(const QString &userName)
{
    if (d->userName == userName)
        return;
    d.detach();
    d->userName = userName;
}
 
void QNetworkRequestFactory::clearUserName()
{
    if (d->userName.isEmpty())
        return;
    d.detach();
    d->userName.clear();
}
 
QString QNetworkRequestFactory::password() const
{
    return d->password;
}
 
void QNetworkRequestFactory::setPassword(const QString &password)
{
    if (d->password == password)
        return;
    d.detach();
    d->password = password;
}
 
void QNetworkRequestFactory::clearPassword()
{
    if (d->password.isEmpty())
        return;
    d.detach();
    d->password.clear();
}
 
void QNetworkRequestFactory::setTransferTimeout(std::chrono::milliseconds timeout)
{
    if (d->transferTimeout == timeout)
        return;
 
    d.detach();
    d->transferTimeout = timeout;
}
 
std::chrono::milliseconds QNetworkRequestFactory::transferTimeout() const
{
    return d->transferTimeout;
}
 
QUrlQuery QNetworkRequestFactory::queryParameters() const
{
    return d->queryParameters;
}
 
void QNetworkRequestFactory::setQueryParameters(const QUrlQuery &query)
{
    if (d->queryParameters == query)
        return;
 
    d.detach();
    d->queryParameters = query;
}
 
void QNetworkRequestFactory::clearQueryParameters()
{
    if (d->queryParameters.isEmpty())
        return;
 
    d.detach();
    d->queryParameters.clear();
}
 
void QNetworkRequestFactory::setPriority(QNetworkRequest::Priority priority)
{
    if (d->priority == priority)
        return;
    d.detach();
    d->priority = priority;
}
 
QNetworkRequest::Priority QNetworkRequestFactory::priority() const
{
    return d->priority;
}
 
void QNetworkRequestFactory::setAttribute(QNetworkRequest::Attribute attribute,
                                          const QVariant &value)
{
    if (attribute == QNetworkRequest::HttpStatusCodeAttribute
        || attribute == QNetworkRequest::HttpReasonPhraseAttribute
        || attribute == QNetworkRequest::RedirectionTargetAttribute
        || attribute == QNetworkRequest::ConnectionEncryptedAttribute
        || attribute == QNetworkRequest::SourceIsFromCacheAttribute
        || attribute == QNetworkRequest::HttpPipeliningWasUsedAttribute
        || attribute == QNetworkRequest::Http2WasUsedAttribute
        || attribute == QNetworkRequest::OriginalContentLengthAttribute)
    {
        qCWarning(lcQrequestfactory, "%i is a reply-only attribute, ignoring.", attribute);
        return;
    }
    d.detach();
    d->attributes.insert(attribute, value);
}
 
QVariant QNetworkRequestFactory::attribute(QNetworkRequest::Attribute attribute) const
{
    return d->attributes.value(attribute);
}
 
QVariant QNetworkRequestFactory::attribute(QNetworkRequest::Attribute attribute,
                                           const QVariant &defaultValue) const
{
    return d->attributes.value(attribute, defaultValue);
}
 
void QNetworkRequestFactory::clearAttribute(QNetworkRequest::Attribute attribute)
{
    if (!d->attributes.contains(attribute))
        return;
    d.detach();
    d->attributes.remove(attribute);
}
 
void QNetworkRequestFactory::clearAttributes()
{
    if (d->attributes.isEmpty())
        return;
    d.detach();
    d->attributes.clear();
}
 
QNetworkRequestFactoryPrivate::QNetworkRequestFactoryPrivate()
    = default;
 
QNetworkRequestFactoryPrivate::QNetworkRequestFactoryPrivate(const QUrl &baseUrl)
    : baseUrl(baseUrl)
{
}
 
QNetworkRequestFactoryPrivate::~QNetworkRequestFactoryPrivate()
    = default;
 
QNetworkRequest QNetworkRequestFactoryPrivate::newRequest(const QUrl &url) const
{
    QNetworkRequest request;
    request.setUrl(url);
#if QT_CONFIG(ssl)
    if (!sslConfig.isNull())
        request.setSslConfiguration(sslConfig);
#endif
    auto h = headers;
    constexpr char Bearer[] = "Bearer ";
    if (!bearerToken.isEmpty())
        h.replaceOrAppend(QHttpHeaders::WellKnownHeader::Authorization, Bearer + bearerToken);
    request.setHeaders(std::move(h));
 
    request.setTransferTimeout(transferTimeout);
    request.setPriority(priority);
 
    for (const auto &[attribute, value] : attributes.asKeyValueRange())
        request.setAttribute(attribute, value);
 
    return request;
}
 
QUrl QNetworkRequestFactoryPrivate::requestUrl(const QString *path,
                                             const QUrlQuery *query) const
{
    const QUrl providedPath = path ? QUrl(*path) : QUrl{};
    const QUrlQuery providedQuery = query ? *query : QUrlQuery();
 
    if (!providedPath.scheme().isEmpty() || !providedPath.host().isEmpty()) {
        qCWarning(lcQrequestfactory, "The provided path %ls may only contain path and query item "
                  "components, and other parts will be ignored. Set the baseUrl instead",
                  qUtf16Printable(providedPath.toDisplayString()));
    }
 
    QUrl resultUrl = baseUrl;
    QUrlQuery resultQuery(providedQuery);
    QString basePath = baseUrl.path();
 
    resultUrl.setUserName(userName);
    resultUrl.setPassword(password);
 
    // Separate the path and query parameters components on the application-provided path
    const QString requestPath{providedPath.path()};
    const QUrlQuery pathQueryItems{providedPath};
 
    if (!pathQueryItems.isEmpty()) {
        // Add any query items provided as part of the path
        const auto items = pathQueryItems.queryItems(QUrl::ComponentFormattingOption::FullyEncoded);
        for (const auto &[key, value]: items)
            resultQuery.addQueryItem(key, value);
    }
 
    if (!queryParameters.isEmpty()) {
        // Add any query items set to this factory
        const QList<std::pair<QString,QString>> items =
                queryParameters.queryItems(QUrl::ComponentFormattingOption::FullyEncoded);
        for (const auto &item: items)
            resultQuery.addQueryItem(item.first, item.second);
    }
 
    if (!resultQuery.isEmpty())
        resultUrl.setQuery(resultQuery);
 
    if (requestPath.isEmpty())
        return resultUrl;
 
    // Ensure that the "base path" (the path that may be present
    // in the baseUrl), and the request path are joined with one '/'
    // If both have it, remove one, if neither has it, add one
    if (basePath.endsWith(u'/') && requestPath.startsWith(u'/'))
        basePath.chop(1);
    else if (!requestPath.startsWith(u'/') && !basePath.endsWith(u'/'))
        basePath.append(u'/');
 
    resultUrl.setPath(basePath.append(requestPath));
    return resultUrl;
}
 
#ifndef QT_NO_DEBUG_STREAM
QDebug operator<<(QDebug debug, const QNetworkRequestFactory &factory)
{
    const QDebugStateSaver saver(debug);
    debug.resetFormat().nospace();
 
    debug << "QNetworkRequestFactory(baseUrl = " << factory.baseUrl()
          << ", headers = " << factory.commonHeaders()
          << ", queryParameters = " << factory.queryParameters().queryItems()
          << ", bearerToken = " << (factory.bearerToken().isEmpty() ? "(empty)" : "(is set)")
          << ", transferTimeout = " << factory.transferTimeout()
          << ", userName = " << (factory.userName().isEmpty() ? "(empty)" : "(is set)")
          << ", password = " << (factory.password().isEmpty() ? "(empty)" : "(is set)")
#if QT_CONFIG(ssl)
          << ", SSL configuration"
          << (factory.sslConfiguration().isNull() ? " is not set (default)" : " is set")
#else
          << ", no SSL support"
#endif
          << ")";
    return debug;
}
#endif // QT_NO_DEBUG_STREAM
 
QT_END_NAMESPACE