url.cpp

// SPDX-FileCopyrightText: Copyright (C) 2015 swift Project Community / Contributors
// SPDX-License-Identifier: GPL-3.0-or-later OR LicenseRef-swift-pilot-client-1
 
#include "misc/network/url.h"
 
#include <QJsonValue>
#include <QPair>
#include <QtGlobal>
 
#include "misc/network/networkutils.h"
#include "misc/propertyindexref.h"
 
SWIFT_DEFINE_VALUEOBJECT_MIXINS(swift::misc::network, CUrl)
 
namespace swift::misc::network
{
    CUrl::CUrl(const QString &fullUrl)
    {
        if (!fullUrl.isEmpty()) { setFullUrl(fullUrl); }
    }
 
    CUrl::CUrl(const char *url) : CUrl(QString(url)) {}
 
    CUrl::CUrl(const QUrl &url) { this->setQUrl(url); }
 
    CUrl::CUrl(const QString &address, int port) : CUrl("", address, port, "") {}
 
    CUrl::CUrl(const QString &scheme, const QString &address, int port, const QString &path)
        : m_host(address.trimmed()), m_port(port), m_path(path.trimmed())
    {
        this->setScheme(scheme);
    }
 
    void CUrl::setScheme(const QString &protocol) { m_scheme = protocol.trimmed().toLower().replace("://", ""); }
 
    void CUrl::setPath(const QString &path) { m_path = path.simplified(); }
 
    QString CUrl::appendPath(const QString &pathToAppend)
    {
        if (pathToAppend.isEmpty()) { return m_path; }
        const QString p = CFileUtils::appendFilePaths(this->getPath(), pathToAppend);
        this->setPath(p);
        return m_path;
    }
 
    int CUrl::getPort() const
    {
        if (m_port > 0) { return m_port; }
        return protocolToDefaultPort(this->getScheme());
    }
 
    bool CUrl::hasPort() const { return m_port >= 0; }
 
    bool CUrl::isEmpty() const { return m_host.isEmpty(); }
 
    bool CUrl::hasDefaultPort() const { return isDefaultPort(m_scheme, m_port); }
 
    void CUrl::setQuery(const QString &query)
    {
        const QString q(stripQueryString(query));
        m_query = q;
    }
 
    bool CUrl::hasQuery() const { return !m_query.isEmpty(); }
 
    void CUrl::appendQuery(const QString &queryToAppend)
    {
        if (queryToAppend.isEmpty()) { return; }
        const QString q(stripQueryString(queryToAppend));
        if (q.isEmpty()) { return; }
        m_query += hasQuery() ? "&" + q : q;
    }
 
    void CUrl::appendQuery(const QString &key, const QString &value)
    {
        if (key.isEmpty()) { return; }
        this->appendQuery(key + "=" + value);
    }
 
    bool CUrl::hasFragment() const { return !m_fragment.isEmpty(); }
 
    void CUrl::setFragment(const QString &fragment) { m_fragment = fragment; }
 
    QString CUrl::getFullUrl(bool withQuery) const
    {
        if (m_host.isEmpty()) { return {}; }
 
        QString qn(m_host);
        if (!hasDefaultPort() && hasPort()) { qn = qn.append(":").append(QString::number(m_port)); }
        if (hasPath()) { qn = qn.append("/").append(m_path).replace("//", "/"); }
        if (hasFragment()) { qn = qn.append("#").append(m_fragment).replace("//", "/"); }
        if (hasQuery() && withQuery) { qn = qn.append("?").append(m_query); }
        if (hasScheme()) { qn = QString(this->getScheme()).append("://").append(qn); }
        return qn;
    }
 
    void CUrl::setFullUrl(const QString &fullUrl) { setQUrl(QUrl(fullUrl)); }
 
    QString CUrl::getFileName() const { return toQUrl().fileName(); }
 
    QUrl CUrl::toQUrl() const { return QUrl(getFullUrl()); }
 
    void CUrl::setQUrl(const QUrl &url)
    {
        this->setPort(url.port());
        this->setHost(url.host());
        this->setScheme(url.scheme());
        this->setPath(url.path());
        this->setQuery(url.query());
        this->setFragment(url.fragment());
    }
 
    QNetworkRequest CUrl::toNetworkRequest() const { return CNetworkUtils::getSwiftNetworkRequest(*this); }
 
    CUrl CUrl::withAppendedPath(const QString &path) const
    {
        if (path.isEmpty()) { return *this; }
        CUrl url(*this);
        url.appendPath(path);
        return url;
    }
 
    CUrl CUrl::withSwitchedScheme(const QString &scheme, int port) const
    {
        if (getPort() == port && getScheme() == scheme) { return *this; }
        QUrl qurl(this->toQUrl());
        qurl.setPort(port);
        qurl.setScheme(scheme);
        const CUrl url(qurl);
        return url;
    }
 
    bool CUrl::pathEndsWith(const QString &ending, Qt::CaseSensitivity cs) const { return m_path.endsWith(ending, cs); }
 
    bool CUrl::isFile() const
    {
        const QString f(this->getFileName());
        return !f.isEmpty();
    }
 
    bool CUrl::isFileWithSuffix(const QString &suffix) const
    {
        const QString f(this->getFileName());
        if (suffix.isEmpty()) { return f.contains('.'); }
        return f.endsWith(suffix, Qt::CaseInsensitive);
    }
 
    bool CUrl::isExecutableFile() const { return CFileUtils::isExecutableFile(this->getFileName()); }
 
    bool CUrl::isSwiftInstaller() const { return CFileUtils::isSwiftInstaller(this->getFileName()); }
 
    QString CUrl::getFileSuffix() const
    {
        const QString f(this->getFileName());
        const int i = f.lastIndexOf('.');
        if (i < 0) return {};
        if (f.length() <= i + 1) return {}; // ends with "."
        return f.mid(i + 1); // suffix without dot
    }
 
    QString CUrl::getFileSuffixPlusDot() const
    {
        const QString f(this->getFileName());
        const int i = f.lastIndexOf('.');
        if (i < 0) return {};
        if (f.length() <= i + 1) return {}; // ends with "."
        return f.mid(i); // suffix with dot
    }
 
    bool CUrl::isHavingHtmlSuffix() const
    {
        static const QString h1(".html");
        static const QString h2(".htm");
        return this->isFileWithSuffix(h1) || this->isFileWithSuffix(h2);
    }
 
    CUrl CUrl::withAppendedQuery(const QString &query) const
    {
        if (query.isEmpty()) { return *this; }
        CUrl url(*this);
        url.appendQuery(query);
        return url;
    }
 
    QString CUrl::convertToQString(bool i18n) const
    {
        Q_UNUSED(i18n);
        return getFullUrl();
    }
 
    QJsonObject CUrl::toJson() const
    {
        const QPair<QString, QJsonValue> v("url", getFullUrl());
        const QJsonObject json({ v });
        return json;
    }
 
    void CUrl::convertFromJson(const QJsonObject &json)
    {
        const QJsonValue value = json.value("url");
        if (value.isUndefined()) { throw CJsonException("Missing 'url'"); }
        this->setFullUrl(value.toString());
    }
 
    int CUrl::protocolToDefaultPort(const QString &protocol)
    {
        const QString p(protocol.trimmed().toLower());
        if (p == "ftp") return 20;
        if (p == "https") return 443;
        if (p == "http") return 80;
        return -1;
    }
 
    bool CUrl::isDefaultPort(const QString &protocol, int port)
    {
        const int p = protocolToDefaultPort(protocol);
        if (p < 0) { return false; }
        return port == p;
    }
 
    CUrl CUrl::fromLocalFile(const QString &localFile) { return QUrl::fromLocalFile(localFile); }
 
    QString CUrl::stripQueryString(const QString &query)
    {
        QString q(query.trimmed());
        if (q.startsWith("?") || q.startsWith("&")) { q = q.mid(1); }
        if (q.endsWith("?") || q.endsWith("&")) { q = q.left(q.size() - 1); }
        return q;
    }
 
    QVariant CUrl::propertyByIndex(CPropertyIndexRef index) const
    {
        if (index.isMyself()) { return QVariant::fromValue(*this); }
        const ColumnIndex i = index.frontCasted<ColumnIndex>();
        switch (i)
        {
        case IndexHost: return QVariant::fromValue(m_host);
        case IndexPort: return QVariant::fromValue(m_port);
        case IndexScheme: return QVariant::fromValue(m_scheme);
        case IndexPath: return QVariant::fromValue(m_path);
        default: return CValueObject::propertyByIndex(index);
        }
    }
 
    void CUrl::setPropertyByIndex(CPropertyIndexRef index, const QVariant &variant)
    {
        if (index.isMyself())
        {
            (*this) = variant.value<CUrl>();
            return;
        }
        const ColumnIndex i = index.frontCasted<ColumnIndex>();
        switch (i)
        {
        case IndexHost: this->setHost(variant.value<QString>()); break;
        case IndexPort: this->setPort(variant.value<qint32>()); break;
        case IndexPath: this->setPath(variant.value<QString>()); break;
        case IndexScheme: this->setScheme(variant.value<QString>()); break;
        default: CValueObject::setPropertyByIndex(index, variant); break;
        }
    }
} // namespace swift::misc::network