validatorresult.cpp

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

#include "validatorresult_p.h"

#include <QJsonArray>
#include <QJsonValue>

using namespace Cutelyst;

ValidatorResult::ValidatorResult()
    : d(new ValidatorResultPrivate)
{
}

ValidatorResult::ValidatorResult(const ValidatorResult &other)
    : d(other.d)
{
}

ValidatorResult &ValidatorResult::operator=(const ValidatorResult &other)
{
    d = other.d;
    return *this;
}

ValidatorResult::~ValidatorResult()
{
}

bool ValidatorResult::isValid() const
{
    return d->errors.empty();
}

void ValidatorResult::addError(const QString &field, const QString &message)
{
    QStringList fieldErrors = d->errors.value(field);
    fieldErrors.append(message);
    d->errors.insert(field, fieldErrors);
}

QStringList ValidatorResult::errorStrings() const
{
    QStringList strings;

    auto i = d->errors.constBegin();
    while (i != d->errors.constEnd()) {
        strings.append(i.value());
        ++i;
    }

    return strings;
}

QHash<QString, QStringList> ValidatorResult::errors() const
{
    return d->errors;
}

QStringList ValidatorResult::errors(const QString &field) const
{
    return d->errors.value(field);
}

bool ValidatorResult::hasErrors(const QString &field) const
{
    return d->errors.contains(field);
}

QJsonObject ValidatorResult::errorsJsonObject() const
{
    QJsonObject json;

    if (!d->errors.empty()) {
        auto i = d->errors.constBegin();
        while (i != d->errors.constEnd()) {
            json.insert(i.key(), QJsonValue(QJsonArray::fromStringList(i.value())));
            ++i;
        }
    }

    return json;
}

QStringList ValidatorResult::failedFields() const
{
    return QStringList(d->errors.keys());
}

QVariantHash ValidatorResult::values() const
{
    return d->values;
}

QVariant ValidatorResult::value(const QString &field) const
{
    return d->values.value(field);
}

void ValidatorResult::addValue(const QString &field, const QVariant &value)
{
    d->values.insert(field, value);
}

QVariantHash ValidatorResult::extras() const
{
    return d->extras;
}

QVariant ValidatorResult::extra(const QString &field) const
{
    return d->extras.value(field);
}

void ValidatorResult::addExtra(const QString &field, const QVariant &extra)
{
    d->extras.insert(field, extra);
}