qmlrestclass.h

#ifndef QTRESTCLIENT_QMLRESTCLASS_H
#define QTRESTCLIENT_QMLRESTCLASS_H
 
#include <tuple>
#include <QtCore/QObject>
#include <QtQml/QQmlParserStatus>
#include <QtQml/QQmlListProperty>
#include <QtQml/QJSValue>
 
#include <QtRestClient/RestClass>
 
#include "qmlrestreply.h"
 
#ifdef DOXYGEN_RUN
namespace de::skycoder42::QtRestClient {
 
class RestClass
{
#else
namespace QtRestClient {
 
class QmlRestClass : public QObject, public QQmlParserStatus
{
    Q_OBJECT
    Q_INTERFACES(QQmlParserStatus)
#endif
 
    Q_PROPERTY(QtRestClient::RestClass* restClass READ restClass NOTIFY restClassChanged)
    Q_PROPERTY(QString path READ path WRITE setPath NOTIFY pathChanged)
#ifdef DOXYGEN_RUN
 
    Q_PROPERTY(QQmlListProperty<de::skycoder42::QtRestClient::RestClass> classes READ classes)
#else
    Q_PROPERTY(QQmlListProperty<QtRestClient::QmlRestClass> classes READ classes)
#endif
 
    Q_CLASSINFO("DefaultProperty", "classes")
 
public:
    explicit QmlRestClass(QObject *parent = nullptr);
 
    RestClass* restClass() const;
    QString path() const;
    QQmlListProperty<QmlRestClass> classes();
 
    void classBegin() override;
    void componentComplete() override;
 
    Q_INVOKABLE QtRestClient::QmlRestReply *call(const QString &verb,
                                                 QJSValue optPath = {},
                                                 QJSValue optBody = {},
                                                 QJSValue optParams = {},
                                                 QJSValue optAsPost = {},
                                                 QJSValue optHeaders = {});
 
    Q_INVOKABLE QtRestClient::QmlRestReply *get(QJSValue optPath = {},
                                                QJSValue optParams = {},
                                                QJSValue optHeaders = {});
    Q_INVOKABLE QtRestClient::QmlRestReply *post(QJSValue optPath = {},
                                                 QJSValue optBodyParams = {},
                                                 QJSValue optParams = {},
                                                 QJSValue optHeaders = {});
    Q_INVOKABLE QtRestClient::QmlRestReply *put(QJSValue optPathOrBody,
                                                QJSValue body = {},
                                                QJSValue optParams = {},
                                                QJSValue optHeaders = {});
    Q_INVOKABLE QtRestClient::QmlRestReply *deleteResource(QJSValue optPath = {},
                                                           QJSValue optParams = {},
                                                           QJSValue optHeaders = {});
    Q_INVOKABLE QtRestClient::QmlRestReply *patch(QJSValue optPathOrBody,
                                                  QJSValue body = {},
                                                  QJSValue optParams = {},
                                                  QJSValue optHeaders = {});
    Q_INVOKABLE QtRestClient::QmlRestReply *head(QJSValue optPath = {},
                                                 QJSValue optParams = {},
                                                 QJSValue optHeaders = {});
 
public Q_SLOTS:
    void setPath(QString path);
 
Q_SIGNALS:
    void restClassChanged(QtRestClient::RestClass *restClass);
    void pathChanged(QString path);
 
private Q_SLOTS:
    void revaluateClass();
 
private:
    RestClass *_class = nullptr;
    QString _path;
    QList<QmlRestClass*> _childClasses;
    bool _init = false;
 
    // moves first into second recursively, if last is undefined
    template <typename... TValues>
    bool shift(QJSValue &first, QJSValue &second, TValues& ...values) const;
    bool shift(QJSValue &end) const;
 
    template <typename... TValues>
    std::optional<std::variant<QString, QUrl>> getPath(QJSValue &optPath, TValues&... values) const;
    template <typename... TValues>
    std::optional<std::variant<QCborValue, QJsonValue>> getBody(QJSValue &optBody, TValues&... values) const;
    template <typename... TValues>
    std::optional<QVariantHash> getParams(QJSValue &optParams, TValues&... values) const;
    template <typename... TValues>
    bool getAsPost(bool hasBody, QJSValue &optParams, TValues&... values) const;
    std::optional<HeaderHash> getHeaders(QJSValue &optHeaders) const;
 
    QmlRestReply *makeQmlReply(RestReply *reply);
    QmlRestReply *callImpl(const QByteArray &verb,
                           const std::optional<std::variant<QString, QUrl>> &optPath,
                           const std::optional<std::variant<QCborValue, QJsonValue>> &optBody,
                           const std::optional<QVariantHash> &optParams,
                           bool optAsPost,
                           const std::optional<HeaderHash> &optHeaders);
};
 
}
 
#endif // QTRESTCLIENT_QMLRESTCLASS_H