QXmppDiscoveryIq.h

// SPDX-FileCopyrightText: 2010 Jeremy Lainé <jeremy.laine@m4x.org>
// SPDX-FileCopyrightText: 2025 Linus Jahn <lnj@kaidan.im>
//
// SPDX-License-Identifier: LGPL-2.1-or-later
 
#ifndef QXMPPDISCOVERY_H
#define QXMPPDISCOVERY_H
 
#include "QXmppDataFormBase.h"
#include "QXmppGlobal.h"
#include "QXmppIq.h"
 
#include <QSharedDataPointer>
 
namespace QXmpp::Disco {
 
enum class Category {
    Account,
    Auth,
    Automation,
    Client,
    Collaboration,
    Component,
    Conference,
    Directory,
    Gateway,
    Headline,
    Hierarchy,
    Proxy,
    PubSub,
    Server,
    Store,
};
 
enum class Type {
    // client
    Bot,
    Console,
    Game,
    Handheld,
    Pc,
    Phone,
    Sms,
    Tablet,
    Web,
    // conference
    Irc,
    Mix,
    Text,
    // gateway
    // (using generic types that overlap with other categories)
    // pubsub
    Collection,
    Leaf,
    Pep,
    Service,
    // store
    File,
};
 
}  // namespace QXmpp::Disco
 
class QXmppDiscoveryIdentityPrivate;
class QXmppDiscoveryItemPrivate;
class QXmppDiscoveryIqPrivate;
 
class QXMPP_EXPORT QXmppDiscoItem
{
public:
    QXmppDiscoItem() { }
    explicit QXmppDiscoItem(const QString &jid, const QString &name = {}, const QString &node = {})
        : m_jid(jid), m_name(name), m_node(node) { }
 
    const QString &jid() const { return m_jid; }
    void setJid(const QString &newJid) { m_jid = newJid; }
 
    const QString &name() const { return m_name; }
    void setName(const QString &newName) { m_name = newName; }
 
    const QString &node() const { return m_node; }
    void setNode(const QString &newNode) { m_node = newNode; }
 
    static constexpr std::tuple XmlTag = { u"item", QXmpp::Private::ns_disco_items };
    static std::optional<QXmppDiscoItem> fromDom(const QDomElement &el);
    void toXml(QXmlStreamWriter *writer) const;
 
private:
    QString m_jid;
    QString m_name;
    QString m_node;
};
 
class QXMPP_EXPORT QXmppDiscoItems
{
public:
    QXmppDiscoItems() { }
    explicit QXmppDiscoItems(const QString &node, const QList<QXmppDiscoItem> &items = {})
        : m_node(node), m_items(items) { }
 
    const QList<QXmppDiscoItem> &items() const { return m_items; }
    void setItems(const QList<QXmppDiscoItem> &newItems) { m_items = newItems; }
 
    const QString &node() const { return m_node; }
    void setNode(const QString &newNode) { m_node = newNode; }
 
    static constexpr std::tuple XmlTag = { u"query", QXmpp::Private::ns_disco_items };
    static std::optional<QXmppDiscoItems> fromDom(const QDomElement &el);
    void toXml(QXmlStreamWriter *writer) const;
 
private:
    QList<QXmppDiscoItem> m_items;
    QString m_node;
};
 
class QXMPP_EXPORT QXmppDiscoIdentity
{
public:
    QXmppDiscoIdentity() { }
    explicit QXmppDiscoIdentity(const QString &category, const QString &type = {}, const QString &name = {}, const QString &lang = {})
        : m_category(category), m_type(type), m_name(name), m_language(lang) { }
 
    const QString &category() const { return m_category; }
    void setCategory(const QString &newCategory) { m_category = newCategory; }
 
    const QString &type() const { return m_type; }
    void setType(const QString &newType) { m_type = newType; }
 
    const QString &name() const { return m_name; }
    void setName(const QString &newName) { m_name = newName; }
 
    const QString &language() const { return m_language; }
    void setLanguage(const QString &newLanguage) { m_language = newLanguage; }
 
    static constexpr std::tuple XmlTag = { u"identity", QXmpp::Private::ns_disco_info };
    static std::optional<QXmppDiscoIdentity> fromDom(const QDomElement &el);
    void toXml(QXmlStreamWriter *writer) const;
 
private:
    QString m_category;
    QString m_type;
    QString m_name;
    QString m_language;
};
 
class QXMPP_EXPORT QXmppDiscoInfo
{
public:
    QXmppDiscoInfo() { }
    explicit QXmppDiscoInfo(const QString &node, const QList<QXmppDiscoIdentity> &identities = {}, const QList<QString> &features = {}, const QList<QXmppDataForm> &dataForms = {})
        : m_node(node), m_identities(identities), m_features(features), m_dataForms(dataForms) { }
 
    const QString &node() const { return m_node; }
    void setNode(const QString &newNode) { m_node = newNode; }
 
    const QList<QXmppDiscoIdentity> &identities() const { return m_identities; }
    void setIdentities(const QList<QXmppDiscoIdentity> &newIdentities) { m_identities = newIdentities; }
 
    const QList<QString> &features() const { return m_features; }
    void setFeatures(const QList<QString> &newFeatures) { m_features = newFeatures; }
 
    const QList<QXmppDataForm> &dataForms() const { return m_dataForms; }
    void setDataForms(const QList<QXmppDataForm> &newDataForms) { m_dataForms = newDataForms; }
    std::optional<QXmppDataForm> dataForm(QStringView formType) const;
 
    template<QXmpp::Private::DataFormConvertible FormType>
    std::optional<FormType> dataForm() const
    {
        if (auto form = dataForm(QXmpp::Private::DataFormType<FormType>)) {
            if (auto result = FormType::fromDataForm(*form)) {
                return *result;
            }
        }
        return {};
    }
 
    QByteArray calculateEntityCapabilitiesHash() const;
 
    static constexpr std::tuple XmlTag = { u"query", QXmpp::Private::ns_disco_info };
    static std::optional<QXmppDiscoInfo> fromDom(const QDomElement &el);
    void toXml(QXmlStreamWriter *writer) const;
 
private:
    QString m_node;
    QList<QXmppDiscoIdentity> m_identities;
    QList<QString> m_features;
    QList<QXmppDataForm> m_dataForms;
};
 
struct QXMPP_EXPORT QXmppDiscoService {
    QString jid;
    QXmppDiscoInfo info;
};
 
#if QXMPP_DEPRECATED_SINCE(1, 12)
class QXMPP_EXPORT QXmppDiscoveryIq : public QXmppIq
{
public:
    using Identity [[deprecated]] = QXmppDiscoIdentity;
    using Item [[deprecated]] = QXmppDiscoItem;
 
    [[deprecated("Use QXmppDiscoInfo/Items")]]
    QXmppDiscoveryIq();
    QXMPP_PRIVATE_DECLARE_RULE_OF_SIX(QXmppDiscoveryIq)
 
    enum QueryType {
        InfoQuery,
        ItemsQuery
    };
 
    QStringList features() const;
    void setFeatures(const QStringList &features);
 
    QList<QXmppDiscoIdentity> identities() const;
    void setIdentities(const QList<QXmppDiscoIdentity> &identities);
 
    QList<QXmppDiscoItem> items() const;
    void setItems(const QList<QXmppDiscoItem> &items);
 
    [[deprecated("Use dataForms() instead")]]
    QXmppDataForm form() const;
    [[deprecated("Use setDataForms() instead")]]
    void setForm(const QXmppDataForm &form);
 
    const QList<QXmppDataForm> &dataForms() const;
    void setDataForms(const QList<QXmppDataForm> &dataForms);
    std::optional<QXmppDataForm> dataForm(QStringView formType) const;
 
    template<QXmpp::Private::DataFormConvertible FormT>
    std::optional<FormT> dataForm() const
    {
        if (auto form = dataForm(QXmpp::Private::DataFormType<FormT>)) {
            if (auto result = FormT::fromDataForm(*form)) {
                return *result;
            }
        }
        return {};
    }
 
    QString queryNode() const;
    void setQueryNode(const QString &node);
 
    enum QueryType queryType() const;
    void setQueryType(enum QueryType type);
 
    QByteArray verificationString() const;
 
    [[deprecated("Use QXmpp::isIqElement()")]]
    static bool isDiscoveryIq(const QDomElement &element);
    static bool checkIqType(const QString &tagName, const QString &xmlNamespace);
 
protected:
    void parseElementFromChild(const QDomElement &element) override;
    void toXmlElementFromChild(QXmlStreamWriter *writer) const override;
 
private:
    QSharedDataPointer<QXmppDiscoveryIqPrivate> d;
};
#endif
 
#endif