OAIIdentity_provider_ldap.cpp

/**
 * GAMS Engine
 * With GAMS Engine you can register and solve GAMS models. It has a namespace management system, so you can restrict your users to certain models.
 *
 * The version of the OpenAPI document: 26.01.08
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
 * https://openapi-generator.tech
 * Do not edit the class manually.
 */

#include "OAIIdentity_provider_ldap.h"

#include <QDebug>
#include <QJsonArray>
#include <QJsonDocument>
#include <QObject>

#include "OAIHelpers.h"

namespace OpenAPI {

OAIIdentity_provider_ldap::OAIIdentity_provider_ldap(QString json) {
    this->initializeModel();
    this->fromJson(json);
}

OAIIdentity_provider_ldap::OAIIdentity_provider_ldap() {
    this->initializeModel();
}

OAIIdentity_provider_ldap::~OAIIdentity_provider_ldap() {}

void OAIIdentity_provider_ldap::initializeModel() {

    m_active_directory_isSet = false;
    m_active_directory_isValid = false;

    m_base_isSet = false;
    m_base_isValid = false;

    m_bind_dn_isSet = false;
    m_bind_dn_isValid = false;

    m_encryption_isSet = false;
    m_encryption_isValid = false;

    m_hidden_isSet = false;
    m_hidden_isValid = false;

    m_host_isSet = false;
    m_host_isValid = false;

    m_label_isSet = false;
    m_label_isValid = false;

    m_name_isSet = false;
    m_name_isValid = false;

    m_password_isSet = false;
    m_password_isValid = false;

    m_port_isSet = false;
    m_port_isValid = false;

    m_uid_isSet = false;
    m_uid_isValid = false;

    m_user_filter_isSet = false;
    m_user_filter_isValid = false;

    m_verify_certificates_isSet = false;
    m_verify_certificates_isValid = false;
}

void OAIIdentity_provider_ldap::fromJson(QString jsonString) {
    QByteArray array(jsonString.toStdString().c_str());
    QJsonDocument doc = QJsonDocument::fromJson(array);
    QJsonObject jsonObject = doc.object();
    this->fromJsonObject(jsonObject);
}

void OAIIdentity_provider_ldap::fromJsonObject(QJsonObject json) {

    m_active_directory_isValid = ::OpenAPI::fromJsonValue(m_active_directory, json[QString("active_directory")]);
    m_active_directory_isSet = !json[QString("active_directory")].isNull() && m_active_directory_isValid;

    m_base_isValid = ::OpenAPI::fromJsonValue(m_base, json[QString("base")]);
    m_base_isSet = !json[QString("base")].isNull() && m_base_isValid;

    m_bind_dn_isValid = ::OpenAPI::fromJsonValue(m_bind_dn, json[QString("bind_dn")]);
    m_bind_dn_isSet = !json[QString("bind_dn")].isNull() && m_bind_dn_isValid;

    m_encryption_isValid = ::OpenAPI::fromJsonValue(m_encryption, json[QString("encryption")]);
    m_encryption_isSet = !json[QString("encryption")].isNull() && m_encryption_isValid;

    m_hidden_isValid = ::OpenAPI::fromJsonValue(m_hidden, json[QString("hidden")]);
    m_hidden_isSet = !json[QString("hidden")].isNull() && m_hidden_isValid;

    m_host_isValid = ::OpenAPI::fromJsonValue(m_host, json[QString("host")]);
    m_host_isSet = !json[QString("host")].isNull() && m_host_isValid;

    m_label_isValid = ::OpenAPI::fromJsonValue(m_label, json[QString("label")]);
    m_label_isSet = !json[QString("label")].isNull() && m_label_isValid;

    m_name_isValid = ::OpenAPI::fromJsonValue(m_name, json[QString("name")]);
    m_name_isSet = !json[QString("name")].isNull() && m_name_isValid;

    m_password_isValid = ::OpenAPI::fromJsonValue(m_password, json[QString("password")]);
    m_password_isSet = !json[QString("password")].isNull() && m_password_isValid;

    m_port_isValid = ::OpenAPI::fromJsonValue(m_port, json[QString("port")]);
    m_port_isSet = !json[QString("port")].isNull() && m_port_isValid;

    m_uid_isValid = ::OpenAPI::fromJsonValue(m_uid, json[QString("uid")]);
    m_uid_isSet = !json[QString("uid")].isNull() && m_uid_isValid;

    m_user_filter_isValid = ::OpenAPI::fromJsonValue(m_user_filter, json[QString("user_filter")]);
    m_user_filter_isSet = !json[QString("user_filter")].isNull() && m_user_filter_isValid;

    m_verify_certificates_isValid = ::OpenAPI::fromJsonValue(m_verify_certificates, json[QString("verify_certificates")]);
    m_verify_certificates_isSet = !json[QString("verify_certificates")].isNull() && m_verify_certificates_isValid;
}

QString OAIIdentity_provider_ldap::asJson() const {
    QJsonObject obj = this->asJsonObject();
    QJsonDocument doc(obj);
    QByteArray bytes = doc.toJson();
    return QString(bytes);
}

QJsonObject OAIIdentity_provider_ldap::asJsonObject() const {
    QJsonObject obj;
    if (m_active_directory_isSet) {
        obj.insert(QString("active_directory"), ::OpenAPI::toJsonValue(m_active_directory));
    }
    if (m_base_isSet) {
        obj.insert(QString("base"), ::OpenAPI::toJsonValue(m_base));
    }
    if (m_bind_dn_isSet) {
        obj.insert(QString("bind_dn"), ::OpenAPI::toJsonValue(m_bind_dn));
    }
    if (m_encryption_isSet) {
        obj.insert(QString("encryption"), ::OpenAPI::toJsonValue(m_encryption));
    }
    if (m_hidden_isSet) {
        obj.insert(QString("hidden"), ::OpenAPI::toJsonValue(m_hidden));
    }
    if (m_host_isSet) {
        obj.insert(QString("host"), ::OpenAPI::toJsonValue(m_host));
    }
    if (m_label_isSet) {
        obj.insert(QString("label"), ::OpenAPI::toJsonValue(m_label));
    }
    if (m_name_isSet) {
        obj.insert(QString("name"), ::OpenAPI::toJsonValue(m_name));
    }
    if (m_password_isSet) {
        obj.insert(QString("password"), ::OpenAPI::toJsonValue(m_password));
    }
    if (m_port_isSet) {
        obj.insert(QString("port"), ::OpenAPI::toJsonValue(m_port));
    }
    if (m_uid_isSet) {
        obj.insert(QString("uid"), ::OpenAPI::toJsonValue(m_uid));
    }
    if (m_user_filter_isSet) {
        obj.insert(QString("user_filter"), ::OpenAPI::toJsonValue(m_user_filter));
    }
    if (m_verify_certificates_isSet) {
        obj.insert(QString("verify_certificates"), ::OpenAPI::toJsonValue(m_verify_certificates));
    }
    return obj;
}

bool OAIIdentity_provider_ldap::isActiveDirectory() const {
    return m_active_directory;
}
void OAIIdentity_provider_ldap::setActiveDirectory(const bool &active_directory) {
    m_active_directory = active_directory;
    m_active_directory_isSet = true;
}

bool OAIIdentity_provider_ldap::is_active_directory_Set() const{
    return m_active_directory_isSet;
}

bool OAIIdentity_provider_ldap::is_active_directory_Valid() const{
    return m_active_directory_isValid;
}

QString OAIIdentity_provider_ldap::getBase() const {
    return m_base;
}
void OAIIdentity_provider_ldap::setBase(const QString &base) {
    m_base = base;
    m_base_isSet = true;
}

bool OAIIdentity_provider_ldap::is_base_Set() const{
    return m_base_isSet;
}

bool OAIIdentity_provider_ldap::is_base_Valid() const{
    return m_base_isValid;
}

QString OAIIdentity_provider_ldap::getBindDn() const {
    return m_bind_dn;
}
void OAIIdentity_provider_ldap::setBindDn(const QString &bind_dn) {
    m_bind_dn = bind_dn;
    m_bind_dn_isSet = true;
}

bool OAIIdentity_provider_ldap::is_bind_dn_Set() const{
    return m_bind_dn_isSet;
}

bool OAIIdentity_provider_ldap::is_bind_dn_Valid() const{
    return m_bind_dn_isValid;
}

QString OAIIdentity_provider_ldap::getEncryption() const {
    return m_encryption;
}
void OAIIdentity_provider_ldap::setEncryption(const QString &encryption) {
    m_encryption = encryption;
    m_encryption_isSet = true;
}

bool OAIIdentity_provider_ldap::is_encryption_Set() const{
    return m_encryption_isSet;
}

bool OAIIdentity_provider_ldap::is_encryption_Valid() const{
    return m_encryption_isValid;
}

bool OAIIdentity_provider_ldap::isHidden() const {
    return m_hidden;
}
void OAIIdentity_provider_ldap::setHidden(const bool &hidden) {
    m_hidden = hidden;
    m_hidden_isSet = true;
}

bool OAIIdentity_provider_ldap::is_hidden_Set() const{
    return m_hidden_isSet;
}

bool OAIIdentity_provider_ldap::is_hidden_Valid() const{
    return m_hidden_isValid;
}

QString OAIIdentity_provider_ldap::getHost() const {
    return m_host;
}
void OAIIdentity_provider_ldap::setHost(const QString &host) {
    m_host = host;
    m_host_isSet = true;
}

bool OAIIdentity_provider_ldap::is_host_Set() const{
    return m_host_isSet;
}

bool OAIIdentity_provider_ldap::is_host_Valid() const{
    return m_host_isValid;
}

QString OAIIdentity_provider_ldap::getLabel() const {
    return m_label;
}
void OAIIdentity_provider_ldap::setLabel(const QString &label) {
    m_label = label;
    m_label_isSet = true;
}

bool OAIIdentity_provider_ldap::is_label_Set() const{
    return m_label_isSet;
}

bool OAIIdentity_provider_ldap::is_label_Valid() const{
    return m_label_isValid;
}

QString OAIIdentity_provider_ldap::getName() const {
    return m_name;
}
void OAIIdentity_provider_ldap::setName(const QString &name) {
    m_name = name;
    m_name_isSet = true;
}

bool OAIIdentity_provider_ldap::is_name_Set() const{
    return m_name_isSet;
}

bool OAIIdentity_provider_ldap::is_name_Valid() const{
    return m_name_isValid;
}

QString OAIIdentity_provider_ldap::getPassword() const {
    return m_password;
}
void OAIIdentity_provider_ldap::setPassword(const QString &password) {
    m_password = password;
    m_password_isSet = true;
}

bool OAIIdentity_provider_ldap::is_password_Set() const{
    return m_password_isSet;
}

bool OAIIdentity_provider_ldap::is_password_Valid() const{
    return m_password_isValid;
}

qint32 OAIIdentity_provider_ldap::getPort() const {
    return m_port;
}
void OAIIdentity_provider_ldap::setPort(const qint32 &port) {
    m_port = port;
    m_port_isSet = true;
}

bool OAIIdentity_provider_ldap::is_port_Set() const{
    return m_port_isSet;
}

bool OAIIdentity_provider_ldap::is_port_Valid() const{
    return m_port_isValid;
}

QString OAIIdentity_provider_ldap::getUid() const {
    return m_uid;
}
void OAIIdentity_provider_ldap::setUid(const QString &uid) {
    m_uid = uid;
    m_uid_isSet = true;
}

bool OAIIdentity_provider_ldap::is_uid_Set() const{
    return m_uid_isSet;
}

bool OAIIdentity_provider_ldap::is_uid_Valid() const{
    return m_uid_isValid;
}

QString OAIIdentity_provider_ldap::getUserFilter() const {
    return m_user_filter;
}
void OAIIdentity_provider_ldap::setUserFilter(const QString &user_filter) {
    m_user_filter = user_filter;
    m_user_filter_isSet = true;
}

bool OAIIdentity_provider_ldap::is_user_filter_Set() const{
    return m_user_filter_isSet;
}

bool OAIIdentity_provider_ldap::is_user_filter_Valid() const{
    return m_user_filter_isValid;
}

bool OAIIdentity_provider_ldap::isVerifyCertificates() const {
    return m_verify_certificates;
}
void OAIIdentity_provider_ldap::setVerifyCertificates(const bool &verify_certificates) {
    m_verify_certificates = verify_certificates;
    m_verify_certificates_isSet = true;
}

bool OAIIdentity_provider_ldap::is_verify_certificates_Set() const{
    return m_verify_certificates_isSet;
}

bool OAIIdentity_provider_ldap::is_verify_certificates_Valid() const{
    return m_verify_certificates_isValid;
}

bool OAIIdentity_provider_ldap::isSet() const {
    bool isObjectUpdated = false;
    do {
        if (m_active_directory_isSet) {
            isObjectUpdated = true;
            break;
        }

        if (m_base_isSet) {
            isObjectUpdated = true;
            break;
        }

        if (m_bind_dn_isSet) {
            isObjectUpdated = true;
            break;
        }

        if (m_encryption_isSet) {
            isObjectUpdated = true;
            break;
        }

        if (m_hidden_isSet) {
            isObjectUpdated = true;
            break;
        }

        if (m_host_isSet) {
            isObjectUpdated = true;
            break;
        }

        if (m_label_isSet) {
            isObjectUpdated = true;
            break;
        }

        if (m_name_isSet) {
            isObjectUpdated = true;
            break;
        }

        if (m_password_isSet) {
            isObjectUpdated = true;
            break;
        }

        if (m_port_isSet) {
            isObjectUpdated = true;
            break;
        }

        if (m_uid_isSet) {
            isObjectUpdated = true;
            break;
        }

        if (m_user_filter_isSet) {
            isObjectUpdated = true;
            break;
        }

        if (m_verify_certificates_isSet) {
            isObjectUpdated = true;
            break;
        }
    } while (false);
    return isObjectUpdated;
}

bool OAIIdentity_provider_ldap::isValid() const {
    // only required properties are required for the object to be considered valid
    return true;
}

} // namespace OpenAPI