response.h

/*
 * SPDX-FileCopyrightText: (C) 2013-2023 Daniel Nicoletti <dantti12@gmail.com>
 * SPDX-License-Identifier: BSD-3-Clause
 */
#pragma once
 
#include <Cutelyst/cutelyst_global.h>
#include <Cutelyst/headers.h>
 
#include <QtCore/QIODevice>
 
class QNetworkCookie;
 
namespace Cutelyst {
 
class Context;
class Engine;
class EngineRequest;
class ResponsePrivate;
class CUTELYST_LIBRARY Response final : public QIODevice
{
    Q_OBJECT
    Q_DECLARE_PRIVATE(Response)
public:
    enum HttpStatus {
        Continue                     = 100,
        SwitchingProtocols           = 101,
        OK                           = 200,
        Created                      = 201,
        Accepted                     = 202,
        NonAuthoritativeInformation  = 203,
        NoContent                    = 204,
        ResetContent                 = 205,
        PartialContent               = 206,
        MultiStatus                  = 207,
        MultipleChoices              = 300,
        MovedPermanently             = 301,
        Found                        = 302,
        SeeOther                     = 303, // Since HTTP/1.1
        NotModified                  = 304,
        UseProxy                     = 305, // Since HTTP/1.1
        TemporaryRedirect            = 307, // Since HTTP/1.1
        PermanentRedirect            = 308, // Since HTTP/1.1
        BadRequest                   = 400,
        Unauthorized                 = 401,
        PaymentRequired              = 402,
        Forbidden                    = 403,
        NotFound                     = 404,
        MethodNotAllowed             = 405,
        NotAcceptable                = 406,
        ProxyAuthenticationRequired  = 407,
        RequestTimeout               = 408,
        Conflict                     = 409,
        Gone                         = 410,
        LengthRequired               = 411,
        PreconditionFailed           = 412,
        RequestEntityTooLarge        = 413,
        RequestURITooLong            = 414,
        UnsupportedMediaType         = 415,
        RequestedRangeNotSatisfiable = 416,
        ExpectationFailed            = 417,
        InternalServerError          = 500,
        NotImplemented               = 501,
        BadGateway                   = 502,
        ServiceUnavailable           = 503,
        GatewayTimeout               = 504,
        HTTPVersionNotSupported      = 505,
        BandwidthLimitExceeded       = 509
    };
    Q_ENUM(HttpStatus)
 
    
    enum CloseCode {
        CloseCodeNormal                = 1000,
        CloseCodeGoingAway             = 1001,
        CloseCodeProtocolError         = 1002,
        CloseCodeDatatypeNotSupported  = 1003,
        CloseCodeReserved1004          = 1004,
        CloseCodeMissingStatusCode     = 1005,
        CloseCodeAbnormalDisconnection = 1006,
        CloseCodeWrongDatatype         = 1007,
        CloseCodePolicyViolated        = 1008,
        CloseCodeTooMuchData           = 1009,
        CloseCodeMissingExtension      = 1010,
        CloseCodeBadOperation          = 1011,
        CloseCodeTlsHandshakeFailed    = 1015
    };
    Q_ENUM(CloseCode)
 
    virtual ~Response() override;
 
    quint16 status() const noexcept;
 
    void setStatus(quint16 status) noexcept;
 
    bool hasBody() const noexcept;
 
    [[nodiscard]] QByteArray &body();
 
    QIODevice *bodyDevice() const noexcept;
 
    void setBody(QIODevice *body);
 
    void setBody(const QByteArray &body);
 
    inline void setBody(const QString &body);
 
    inline void setBody(QStringView body);
 
    inline void setJsonBody(QStringView json);
 
    void setJsonBody(const QByteArray &json);
 
    void setJsonObjectBody(const QJsonObject &obj);
 
    void setJsonArrayBody(const QJsonArray &array);
 
    QByteArray contentEncoding() const noexcept;
 
    void setContentEncoding(const QByteArray &encoding);
 
    qint64 contentLength() const;
 
    void setContentLength(qint64 length);
 
    QByteArray contentType() const;
 
    void setContentType(const QByteArray &type) { headers().setContentType(type); }
 
    QByteArray contentTypeCharset() const;
 
    QVariant cookie(const QByteArray &name) const;
 
    QList<QNetworkCookie> cookies() const;
 
    void setCookie(const QNetworkCookie &cookie);
 
    void setCookies(const QList<QNetworkCookie> &cookies);
 
    int removeCookies(const QByteArray &name);
 
    void redirect(const QUrl &url, quint16 status = Found);
 
    void redirect(const QString &url, quint16 status = Found);
 
    void redirectSafe(const QUrl &url, const QUrl &fallback);
 
    QUrl location() const noexcept;
 
    QByteArray header(const QByteArray &field) const noexcept;
 
    void setHeader(const QByteArray &key, const QByteArray &value);
 
    Headers &headers() noexcept;
 
    bool isFinalizedHeaders() const noexcept;
 
    bool isSequential() const noexcept override;
 
    qint64 size() const noexcept override;
 
    bool webSocketHandshake(const QByteArray &key      = {},
                            const QByteArray &origin   = {},
                            const QByteArray &protocol = {});
 
    bool webSocketTextMessage(const QString &message);
 
    bool webSocketBinaryMessage(const QByteArray &message);
 
    bool webSocketPing(const QByteArray &payload = {});
 
    bool webSocketClose(quint16 code = Response::CloseCodeNormal, const QString &reason = {});
 
protected:
    explicit Response(const Headers &defaultHeaders, EngineRequest *conn = nullptr);
 
    virtual qint64 writeData(const char *data, qint64 len) override;
 
    virtual qint64 readData(char *data, qint64 maxlen) override;
 
    ResponsePrivate *d_ptr;
    friend class Application;
    friend class Engine;
    friend class EngineConnection;
    friend class Context;
    friend class ContextPrivate;
};
 
inline void Response::setBody(const QString &_body)
{
    setBody(_body.toUtf8());
}
 
inline void Response::setBody(QStringView _body)
{
    setBody(_body.toUtf8());
}
 
inline void Response::setJsonBody(QStringView _body)
{
    setJsonBody(_body.toUtf8());
}
 
} // namespace Cutelyst