validator.cpp

/*
 * SPDX-FileCopyrightText: (C) 2017-2025 Matthias Fehring <mf@huessenbergnetz.de>
 * SPDX-License-Identifier: BSD-3-Clause
 */

#include "validator_p.h"

#include <Cutelyst/application.h>
#include <Cutelyst/context.h>
#include <Cutelyst/request.h>

#include <QLoggingCategory>

using namespace Cutelyst;
using namespace Qt::Literals::StringLiterals;

Q_LOGGING_CATEGORY(C_VALIDATOR, "cutelyst.utils.validator", QtWarningMsg)

Validator::Validator(const char *translationContext)
    : d_ptr(new ValidatorPrivate(translationContext))
{
}

Validator::Validator(std::initializer_list<ValidatorRule *> validators,
                     const char *translationContext)
    : d_ptr(new ValidatorPrivate(validators, translationContext))
{
}

Validator::~Validator() = default;

void Validator::clear()
{
    Q_D(Validator);
    if (!d->validators.empty()) {
        qDeleteAll(d->validators.begin(), d->validators.end());
        d->validators.clear();
    }
}

Cutelyst::ValidatorResult Validator::validate(Context *c, ValidatorFlags flags) const
{
    ValidatorResult result;

    Q_ASSERT(c);

    ParamsMultiMap params;
    if (flags.testFlag(BodyParamsOnly)) {
        params = c->req()->bodyParameters();
    } else if (flags.testFlag(QueryParamsOnly)) {
        params = c->req()->queryParameters();
    } else {
        params = c->req()->queryParameters();
        params.unite(c->req()->bodyParameters());
    }

    result = validate(c, params, flags);

    return result;
}

ValidatorResult
    Validator::validate(Context *c, const ParamsMultiMap &params, ValidatorFlags flags) const
{
    ValidatorResult result;

    Q_ASSERT(c);
    Q_D(const Validator);

    if (d->validators.empty()) {
        qCWarning(C_VALIDATOR) << "Validation started with empty validator list.";
        return result;
    }

    if (params.empty()) {
        qCWarning(C_VALIDATOR) << "Validation started with empty parameters.";
    }

    const bool stopOnFirstError = flags.testFlag(StopOnFirstError);
    const bool noTrimming       = flags.testFlag(NoTrimming);

    for (ValidatorRule *v : d->validators) {

        if (noTrimming) {
            v->setTrimBefore(false);
        }

        const ValidatorReturnType singleResult = v->validate(c, params);

        if (singleResult.extra.isValid()) {
            result.addExtra(v->field(), singleResult.extra);
        }

        if (singleResult) {
            result.addValue(v->field(), singleResult.value);
        } else {
            result.addError(v->field(), singleResult.errorMessage);
            if (stopOnFirstError) {
                break;
            }
        }
    }

    return result;
}

AwaitedValidatorResult Validator::coValidate(Context *c, ValidatorFlags flags) const
{
    AwaitedValidatorResult avr{c};
    auto cb = avr.callback;

    Q_D(const Validator);

    ParamsMultiMap params;
    if (flags.testFlag(BodyParamsOnly)) {
        params = c->req()->bodyParameters();
    } else if (flags.testFlag(QueryParamsOnly)) {
        params = c->req()->queryParameters();
    } else {
        params = c->req()->queryParameters();
        params.unite(c->req()->bodyParameters());
    }

    auto async = new AsyncValidator{c};
    QObject::connect(async,
                     &AsyncValidator::finished,
                     [cb](const Cutelyst::ValidatorResult &result) { cb(result); });
    async->start(d->validators, flags, params);

    return avr;
}

AwaitedValidatorResult
    Validator::coValidate(Context *c, const ParamsMultiMap &params, ValidatorFlags flags) const
{
    AwaitedValidatorResult avr{c};
    auto cb = avr.callback;

    Q_D(const Validator);

    auto async = new AsyncValidator{c};
    QObject::connect(async,
                     &AsyncValidator::finished,
                     [cb](const Cutelyst::ValidatorResult &result) { cb(result); });
    async->start(d->validators, flags, params);

    return avr;
}

void Validator::addValidator(ValidatorRule *v)
{
    Q_D(Validator);
    v->setTranslationContext(d->translationContext);
    d->validators.push_back(v);
}

void Validator::loadTranslations(Application *app)
{
    app->loadTranslations(u"plugin_utils_validator"_s);
}

void AsyncValidator::start(const std::vector<ValidatorRule *> &validators,
                           Validator::ValidatorFlags flags,
                           const ParamsMultiMap &params)
{
    if (validators.empty()) {
        qCWarning(C_VALIDATOR) << "Validation started with empty validator list.";
        Q_EMIT finished(m_result);
        return;
    }

    if (params.empty()) {
        qCWarning(C_VALIDATOR) << "Validation started with empty parameters.";
    }

    m_params = params;

    for (auto validator : validators) {
        m_validators.enqueue(validator);
    }

    m_stopOnFirstError = flags.testFlag(Validator::StopOnFirstError);
    m_noTrimming       = flags.testFlag(Validator::NoTrimming);

    QMetaObject::invokeMethod(this, "doValidation", Qt::DirectConnection);
}

void AsyncValidator::doValidation()
{
    if (m_validators.empty() || m_cancelValidation) {
        Q_EMIT finished(m_result);
        return;
    }

    auto v = m_validators.dequeue();

    if (m_context.isNull()) {
        qCCritical(C_VALIDATOR)
            << "Cutelyst context object was destroyed while performing validation";
        m_result.addError(v->field(),
                          u"Cutelyst context object was destroyed while performing validation."_s);
        Q_EMIT finished(m_result);
        return;
    }

    v->validateCb(m_context.get(), m_params, [this, v](ValidatorReturnType &&singleResult) {
        if (singleResult.extra.isValid()) {
            m_result.addExtra(v->field(), singleResult.extra);
        }

        if (singleResult) {
            m_result.addValue(v->field(), singleResult.value);
        } else {
            m_result.addError(v->field(), singleResult.errorMessage);
            if (m_stopOnFirstError) {
                m_cancelValidation = true;
            }
        }
        doValidation();
    });
}