request.h

/*
 * SPDX-FileCopyrightText: (C) 2013-2022 Daniel Nicoletti <dantti12@gmail.com>
 * SPDX-License-Identifier: BSD-3-Clause
 */
#ifndef CUTELYST_REQUEST_H
#define CUTELYST_REQUEST_H
 
#include <Cutelyst/cutelyst_export.h>
#include <Cutelyst/headers.h>
#include <Cutelyst/paramsmultimap.h>
 
#include <QtCore/qobject.h>
#include <QtCore/qstringlist.h>
 
class QIODevice;
class QHostAddress;
class QNetworkCookie;
 
namespace Cutelyst {
 
class Engine;
class Upload;
class Context;

typedef QVector<Upload *> Uploads;
 
class EngineRequest;
class RequestPrivate;
class CUTELYST_EXPORT Request final : public QObject
{
    Q_OBJECT
    Q_PROPERTY(QString hostname READ hostname CONSTANT)
    Q_PROPERTY(quint16 port READ port CONSTANT)
    Q_PROPERTY(QUrl uri READ uri CONSTANT)
    Q_PROPERTY(QString base READ base CONSTANT)
    Q_PROPERTY(QString path READ path CONSTANT)
    Q_PROPERTY(QString match READ match CONSTANT)
    Q_PROPERTY(QStringList arguments READ arguments CONSTANT)
    Q_PROPERTY(QStringList args READ arguments CONSTANT)
    Q_PROPERTY(bool secure READ secure CONSTANT)
    Q_PROPERTY(QVariant bodyData READ bodyData CONSTANT)
    Q_PROPERTY(Cutelyst::ParamsMultiMap bodyParams READ bodyParameters CONSTANT)
    Q_PROPERTY(Cutelyst::ParamsMultiMap queryParams READ queryParameters CONSTANT)
    Q_PROPERTY(QByteArray contentEncoding READ contentEncoding CONSTANT)
    Q_PROPERTY(QByteArray contentType READ contentType CONSTANT)
    Q_PROPERTY(QByteArray method READ method CONSTANT)
    Q_PROPERTY(QByteArray protocol READ protocol CONSTANT)
    Q_PROPERTY(QByteArray userAgent READ userAgent CONSTANT)
    Q_PROPERTY(QByteArray referer READ referer CONSTANT)
    Q_PROPERTY(QString remoteUser READ remoteUser CONSTANT)
public:
    virtual ~Request();

    [[nodiscard]] QHostAddress address() const noexcept;

    [[nodiscard]] QString addressString() const;

    [[nodiscard]] QString hostname() const;

    [[nodiscard]] quint16 port() const noexcept;

    [[nodiscard]] QUrl uri() const;

    [[nodiscard]] QString base() const;

    [[nodiscard]] QString path() const noexcept;

    [[nodiscard]] QString match() const noexcept;

    void setMatch(const QString &match);

    [[nodiscard]] QStringList arguments() const noexcept;

    void setArguments(const QStringList &arguments);

    [[nodiscard]] inline QStringList args() const noexcept;

    [[nodiscard]] QStringList captures() const noexcept;

    void setCaptures(const QStringList &captures);

    [[nodiscard]] bool secure() const noexcept;

    [[nodiscard]] QIODevice *body() const noexcept;

    [[nodiscard]] QVariant bodyData() const;

    [[nodiscard]] QCborValue bodyCbor() const;

    [[nodiscard]] QJsonDocument bodyJsonDocument() const;

    [[nodiscard]] QJsonObject bodyJsonObject() const;

    [[nodiscard]] QJsonArray bodyJsonArray() const;

    [[nodiscard]] QVariantMap bodyParametersVariant() const;

    [[nodiscard]] ParamsMultiMap bodyParameters() const;

    [[nodiscard]] inline QString bodyParameter(const QString &key,
                                               const QString &defaultValue = {}) const;

    [[nodiscard]] QStringList bodyParameters(const QString &key) const;

    [[nodiscard]] inline ParamsMultiMap bodyParams() const;

    [[nodiscard]] inline QString bodyParam(const QString &key,
                                           const QString &defaultValue = {}) const;

    [[nodiscard]] inline QStringList bodyParams(const QString &key) const;

    [[nodiscard]] QString queryKeywords() const;

    [[nodiscard]] QVariantMap queryParametersVariant() const;

    [[nodiscard]] ParamsMultiMap queryParameters() const;

    [[nodiscard]] inline QString queryParameter(const QString &key,
                                                const QString &defaultValue = {}) const;

    [[nodiscard]] QStringList queryParameters(const QString &key) const;

    [[nodiscard]] inline ParamsMultiMap queryParams() const;

    [[nodiscard]] inline QString queryParam(const QString &key,
                                            const QString &defaultValue = {}) const;

    [[nodiscard]] inline QStringList queryParams(const QString &key) const;

    [[nodiscard]] inline QByteArray contentEncoding() const noexcept;

    [[nodiscard]] inline QByteArray contentType() const;
 
    struct Cookie {
        QByteArray name;
        QByteArray value;
    };

    [[nodiscard]] QByteArray cookie(QAnyStringView name) const;

    [[nodiscard]] QByteArrayList cookies(QAnyStringView name) const;

    [[nodiscard]] QMultiMap<QAnyStringView, Cookie> cookies() const;

    [[nodiscard]] inline QByteArray header(QAnyStringView key) const noexcept;

    [[nodiscard]] Headers headers() const noexcept;

    [[nodiscard]] QByteArray method() const noexcept;

    [[nodiscard]] bool isPost() const noexcept;

    [[nodiscard]] bool isGet() const noexcept;

    [[nodiscard]] bool isHead() const noexcept;

    [[nodiscard]] bool isPut() const noexcept;

    [[nodiscard]] bool isPatch() const noexcept;

    [[nodiscard]] bool isDelete() const noexcept;

    [[nodiscard]] QByteArray protocol() const noexcept;

    [[nodiscard]] bool xhr() const noexcept;

    [[nodiscard]] inline QByteArray userAgent() const noexcept;

    [[nodiscard]] inline QByteArray referer() const noexcept;

    [[nodiscard]] QString remoteUser() const noexcept;

    [[nodiscard]] QVector<Upload *> uploads() const;

    [[nodiscard]] QMultiMap<QAnyStringView, Upload *> uploadsMap() const;

    [[nodiscard]] Uploads uploads(QAnyStringView name) const;

    [[nodiscard]] inline Upload *upload(QAnyStringView name) const;

    [[nodiscard]] ParamsMultiMap mangleParams(const ParamsMultiMap &args,
                                              bool append = false) const;

    [[nodiscard]] QUrl uriWith(const ParamsMultiMap &args, bool append = false) const;

    [[nodiscard]] Engine *engine() const noexcept;

    explicit Request(EngineRequest *engineRequest);
 
Q_SIGNALS:
    void webSocketTextFrame(const QString &message, bool isLastFrame, Cutelyst::Context *c);

    void webSocketTextMessage(const QString &message, Cutelyst::Context *c);

    void webSocketBinaryFrame(const QByteArray &message, bool isLastFrame, Cutelyst::Context *c);

    void webSocketBinaryMessage(const QByteArray &message, Cutelyst::Context *c);

    void webSocketPong(const QByteArray &payload, Cutelyst::Context *c);

    void webSocketClosed(quint16 closeCode, const QString &reason);
 
protected:
    RequestPrivate *d_ptr;
 
private:
    friend class Application;
    friend class Dispatcher;
    friend class DispatchType;
    friend class Context;
    Q_DECLARE_PRIVATE(Request)
};
 
inline QStringList Request::args() const noexcept
{
    return arguments();
}
 
inline QString Request::bodyParameter(const QString &key, const QString &defaultValue) const
{
    return bodyParameters().value(key, defaultValue);
}
 
inline ParamsMultiMap Request::bodyParams() const
{
    return bodyParameters();
}
 
inline QString Request::bodyParam(const QString &key, const QString &defaultValue) const
{
    return bodyParameters().value(key, defaultValue);
}
 
inline QStringList Request::bodyParams(const QString &key) const
{
    return bodyParameters(key);
}
 
inline QString Request::queryParameter(const QString &key, const QString &defaultValue) const
{
    return queryParameters().value(key, defaultValue);
}
 
inline ParamsMultiMap Request::queryParams() const
{
    return queryParameters();
}
 
inline QString Request::queryParam(const QString &key, const QString &defaultValue) const
{
    return queryParameters().value(key, defaultValue);
}
 
inline QStringList Request::queryParams(const QString &key) const
{
    return queryParameters(key);
}
 
inline QByteArray Request::contentEncoding() const noexcept
{
    return headers().contentEncoding();
}
 
inline QByteArray Request::contentType() const
{
    return headers().contentType();
}
 
inline QByteArray Request::header(QAnyStringView key) const noexcept
{
    return headers().header(key);
}
 
inline QByteArray Request::userAgent() const noexcept
{
    return headers().userAgent();
}
 
inline QByteArray Request::referer() const noexcept
{
    return headers().referer();
}
 
inline Upload *Request::upload(QAnyStringView name) const
{
    return uploadsMap().value(name);
}
 
} // namespace Cutelyst
 
#endif // CUTELYST_REQUEST_H