actionrest.cpp

/*
 * SPDX-FileCopyrightText: (C) 2013-2025 Daniel Nicoletti <dantti12@gmail.com>
 * SPDX-License-Identifier: BSD-3-Clause
 */
#include "actionrest_p.h"
#include "context.h"
#include "context_p.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);

    const int &actionRefCount = c->d_ptr->actionRefCount; // cppcheck-suppress variableScope

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

    Action *action = d->getRestAction(c, c->request()->method());
    if (action) {
        if (actionRefCount) {
            // Async
            c->d_ptr->pendingAsync.enqueue(action);
            return true;
        } else {
            return c->execute(action);
        }
    }

    return true;
}

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

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

    const Controller *controller = q->controller();
    Action *action               = controller->actionFor(restMethod);
    if (!action) {
        // Look for non registered actions in this controller
        const ActionList actions = controller->actions();
        auto it = std::ranges::find_if(actions, [&restMethod](const Action *controllerAction) {
            return controllerAction->name() == restMethod;
        });
        if (it != actions.end()) {
            action = *it;
        }
    }

    if (!action) {
        if (httpMethod == "HEAD") {
            // redispatch to GET
            action = getRestAction(c, "GET"_ba);
        } else if (httpMethod == "OPTIONS") {
            returnOptions(c, q->name());
        } else if (httpMethod == "not_implemented") {
            // not_implemented
            returnNotImplemented(c, q->name());
        } else {
            // try dispatching to foo_not_implemented
            action = getRestAction(c, "not_implemented"_ba);
        }
    }

    return action;
}

void 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", getAllowedMethods(c->controller(), methodName));
    response->body().clear();
}

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

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

QByteArray Cutelyst::ActionRESTPrivate::getAllowedMethods(const Controller *controller,
                                                          const QString &methodName) const
{
    QStringList methods;
    const QString name       = methodName + u'_';
    const ActionList actions = controller->actions();
    for (const 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(u"HEAD"_s);
    }

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

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

#include "moc_actionrest.cpp"