actionrest.cpp

/*
 * SPDX-FileCopyrightText: (C) 2013-2022 Daniel Nicoletti <dantti12@gmail.com>
 * SPDX-License-Identifier: BSD-3-Clause
 */
#include "actionrest_p.h"
#include "context.h"
#include "controller.h"
#include "dispatcher.h"

#include <QDebug>
#include <QUrl>

using namespace Cutelyst;
using namespace Qt::StringLiterals;

ActionREST::ActionREST(QObject *parent)
    : Action(new ActionRESTPrivate(this), parent)
{
}

bool ActionREST::doExecute(Context *c)
{
    Q_D(const ActionREST);

    if (!Action::doExecute(c)) {
        return false;
    }

    return d->dispatchRestMethod(c, c->request()->method());
}

ActionRESTPrivate::ActionRESTPrivate(ActionREST *q)
    : q_ptr(q)
{
}

bool ActionRESTPrivate::dispatchRestMethod(Context *c, const QByteArray &httpMethod) const
{
    Q_Q(const ActionREST);
    const QString restMethod = q->name() + u'_' + QString::fromLatin1(httpMethod);

    Controller *controller = q->controller();
    Action *action         = controller->actionFor(restMethod);
    if (!action) {
        // Look for non registered actions in this controller
        const ActionList actions = controller->actions();
        for (Action *controllerAction : actions) {
            if (controllerAction->name() == restMethod) {
                action = controllerAction;
                break;
            }
        }
    }

    if (action) {
        return c->execute(action);
    }

    bool ret = false;
    if (httpMethod.compare("OPTIONS") == 0) {
        ret = returnOptions(c, q->name());
    } else if (httpMethod.compare("HEAD") == 0) {
        // redispatch to GET
        ret = dispatchRestMethod(c, "GET"_ba);
    } else if (httpMethod.compare("not_implemented") != 0) {
        // try dispatching to foo_not_implemented
        ret = dispatchRestMethod(c, "not_implemented"_ba);
    } else {
        // not_implemented
        ret = returnNotImplemented(c, q->name());
    }

    return ret;
}

bool ActionRESTPrivate::returnOptions(Context *c, const QString &methodName) const
{
    Response *response = c->response();
    response->setContentType("text/plain"_ba);
    response->setStatus(Response::OK); // 200
    response->setHeader("Allow"_ba, getAllowedMethods(c->controller(), methodName));
    response->body().clear();
    return true;
}

bool ActionRESTPrivate::returnNotImplemented(Context *c, const QString &methodName) const
{
    Response *response = c->response();
    response->setStatus(Response::MethodNotAllowed); // 405
    response->setHeader("Allow"_ba, getAllowedMethods(c->controller(), methodName));

    const QByteArray body = "Method " + c->req()->method() + " not implemented for " +
                            c->request()->uri().toString(QUrl::FullyEncoded).toLatin1();
    response->setBody(body);
    return true;
}

QByteArray Cutelyst::ActionRESTPrivate::getAllowedMethods(Controller *controller,
                                                          const QString &methodName) const
{
    QStringList methods;
    const QString name       = methodName + u'_';
    const ActionList actions = controller->actions();
    for (Action *action : actions) {
        const QString method = action->name();
        if (method.startsWith(name)) {
            methods.append(method.mid(name.size()));
        }
    }

    if (methods.contains(u"GET")) {
        methods.append(QStringLiteral("HEAD"));
    }

    methods.removeDuplicates();
    methods.removeOne(u"not_implemented"_s);
    methods.sort();

    return methods.join(u", ").toLatin1();
}

#include "moc_actionrest.cpp"