OAIInvitation.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 "OAIInvitation.h"

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

#include "OAIHelpers.h"

namespace OpenAPI {

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

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

OAIInvitation::~OAIInvitation() {}

void OAIInvitation::initializeModel() {

    m_created_isSet = false;
    m_created_isValid = false;

    m_gams_license_isSet = false;
    m_gams_license_isValid = false;

    m_identity_provider_isSet = false;
    m_identity_provider_isValid = false;

    m_identity_provider_user_subject_isSet = false;
    m_identity_provider_user_subject_isValid = false;

    m_invitable_identity_providers_isSet = false;
    m_invitable_identity_providers_isValid = false;

    m_inviter_name_isSet = false;
    m_inviter_name_isValid = false;

    m_permissions_isSet = false;
    m_permissions_isValid = false;

    m_quota_isSet = false;
    m_quota_isValid = false;

    m_roles_isSet = false;
    m_roles_isValid = false;

    m_token_isSet = false;
    m_token_isValid = false;

    m_used_isSet = false;
    m_used_isValid = false;

    m_user_groups_isSet = false;
    m_user_groups_isValid = false;

    m_username_isSet = false;
    m_username_isValid = false;
}

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

void OAIInvitation::fromJsonObject(QJsonObject json) {

    m_created_isValid = ::OpenAPI::fromJsonValue(m_created, json[QString("created")]);
    m_created_isSet = !json[QString("created")].isNull() && m_created_isValid;

    m_gams_license_isValid = ::OpenAPI::fromJsonValue(m_gams_license, json[QString("gams_license")]);
    m_gams_license_isSet = !json[QString("gams_license")].isNull() && m_gams_license_isValid;

    m_identity_provider_isValid = ::OpenAPI::fromJsonValue(m_identity_provider, json[QString("identity_provider")]);
    m_identity_provider_isSet = !json[QString("identity_provider")].isNull() && m_identity_provider_isValid;

    m_identity_provider_user_subject_isValid = ::OpenAPI::fromJsonValue(m_identity_provider_user_subject, json[QString("identity_provider_user_subject")]);
    m_identity_provider_user_subject_isSet = !json[QString("identity_provider_user_subject")].isNull() && m_identity_provider_user_subject_isValid;

    m_invitable_identity_providers_isValid = ::OpenAPI::fromJsonValue(m_invitable_identity_providers, json[QString("invitable_identity_providers")]);
    m_invitable_identity_providers_isSet = !json[QString("invitable_identity_providers")].isNull() && m_invitable_identity_providers_isValid;

    m_inviter_name_isValid = ::OpenAPI::fromJsonValue(m_inviter_name, json[QString("inviter_name")]);
    m_inviter_name_isSet = !json[QString("inviter_name")].isNull() && m_inviter_name_isValid;

    m_permissions_isValid = ::OpenAPI::fromJsonValue(m_permissions, json[QString("permissions")]);
    m_permissions_isSet = !json[QString("permissions")].isNull() && m_permissions_isValid;

    m_quota_isValid = ::OpenAPI::fromJsonValue(m_quota, json[QString("quota")]);
    m_quota_isSet = !json[QString("quota")].isNull() && m_quota_isValid;

    m_roles_isValid = ::OpenAPI::fromJsonValue(m_roles, json[QString("roles")]);
    m_roles_isSet = !json[QString("roles")].isNull() && m_roles_isValid;

    m_token_isValid = ::OpenAPI::fromJsonValue(m_token, json[QString("token")]);
    m_token_isSet = !json[QString("token")].isNull() && m_token_isValid;

    m_used_isValid = ::OpenAPI::fromJsonValue(m_used, json[QString("used")]);
    m_used_isSet = !json[QString("used")].isNull() && m_used_isValid;

    m_user_groups_isValid = ::OpenAPI::fromJsonValue(m_user_groups, json[QString("user_groups")]);
    m_user_groups_isSet = !json[QString("user_groups")].isNull() && m_user_groups_isValid;

    m_username_isValid = ::OpenAPI::fromJsonValue(m_username, json[QString("username")]);
    m_username_isSet = !json[QString("username")].isNull() && m_username_isValid;
}

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

QJsonObject OAIInvitation::asJsonObject() const {
    QJsonObject obj;
    if (m_created_isSet) {
        obj.insert(QString("created"), ::OpenAPI::toJsonValue(m_created));
    }
    if (m_gams_license_isSet) {
        obj.insert(QString("gams_license"), ::OpenAPI::toJsonValue(m_gams_license));
    }
    if (m_identity_provider_isSet) {
        obj.insert(QString("identity_provider"), ::OpenAPI::toJsonValue(m_identity_provider));
    }
    if (m_identity_provider_user_subject_isSet) {
        obj.insert(QString("identity_provider_user_subject"), ::OpenAPI::toJsonValue(m_identity_provider_user_subject));
    }
    if (m_invitable_identity_providers.size() > 0) {
        obj.insert(QString("invitable_identity_providers"), ::OpenAPI::toJsonValue(m_invitable_identity_providers));
    }
    if (m_inviter_name_isSet) {
        obj.insert(QString("inviter_name"), ::OpenAPI::toJsonValue(m_inviter_name));
    }
    if (m_permissions.size() > 0) {
        obj.insert(QString("permissions"), ::OpenAPI::toJsonValue(m_permissions));
    }
    if (m_quota.isSet()) {
        obj.insert(QString("quota"), ::OpenAPI::toJsonValue(m_quota));
    }
    if (m_roles.size() > 0) {
        obj.insert(QString("roles"), ::OpenAPI::toJsonValue(m_roles));
    }
    if (m_token_isSet) {
        obj.insert(QString("token"), ::OpenAPI::toJsonValue(m_token));
    }
    if (m_used_isSet) {
        obj.insert(QString("used"), ::OpenAPI::toJsonValue(m_used));
    }
    if (m_user_groups.size() > 0) {
        obj.insert(QString("user_groups"), ::OpenAPI::toJsonValue(m_user_groups));
    }
    if (m_username_isSet) {
        obj.insert(QString("username"), ::OpenAPI::toJsonValue(m_username));
    }
    return obj;
}

QDateTime OAIInvitation::getCreated() const {
    return m_created;
}
void OAIInvitation::setCreated(const QDateTime &created) {
    m_created = created;
    m_created_isSet = true;
}

bool OAIInvitation::is_created_Set() const{
    return m_created_isSet;
}

bool OAIInvitation::is_created_Valid() const{
    return m_created_isValid;
}

QString OAIInvitation::getGamsLicense() const {
    return m_gams_license;
}
void OAIInvitation::setGamsLicense(const QString &gams_license) {
    m_gams_license = gams_license;
    m_gams_license_isSet = true;
}

bool OAIInvitation::is_gams_license_Set() const{
    return m_gams_license_isSet;
}

bool OAIInvitation::is_gams_license_Valid() const{
    return m_gams_license_isValid;
}

QString OAIInvitation::getIdentityProvider() const {
    return m_identity_provider;
}
void OAIInvitation::setIdentityProvider(const QString &identity_provider) {
    m_identity_provider = identity_provider;
    m_identity_provider_isSet = true;
}

bool OAIInvitation::is_identity_provider_Set() const{
    return m_identity_provider_isSet;
}

bool OAIInvitation::is_identity_provider_Valid() const{
    return m_identity_provider_isValid;
}

QString OAIInvitation::getIdentityProviderUserSubject() const {
    return m_identity_provider_user_subject;
}
void OAIInvitation::setIdentityProviderUserSubject(const QString &identity_provider_user_subject) {
    m_identity_provider_user_subject = identity_provider_user_subject;
    m_identity_provider_user_subject_isSet = true;
}

bool OAIInvitation::is_identity_provider_user_subject_Set() const{
    return m_identity_provider_user_subject_isSet;
}

bool OAIInvitation::is_identity_provider_user_subject_Valid() const{
    return m_identity_provider_user_subject_isValid;
}

QList<QString> OAIInvitation::getInvitableIdentityProviders() const {
    return m_invitable_identity_providers;
}
void OAIInvitation::setInvitableIdentityProviders(const QList<QString> &invitable_identity_providers) {
    m_invitable_identity_providers = invitable_identity_providers;
    m_invitable_identity_providers_isSet = true;
}

bool OAIInvitation::is_invitable_identity_providers_Set() const{
    return m_invitable_identity_providers_isSet;
}

bool OAIInvitation::is_invitable_identity_providers_Valid() const{
    return m_invitable_identity_providers_isValid;
}

QString OAIInvitation::getInviterName() const {
    return m_inviter_name;
}
void OAIInvitation::setInviterName(const QString &inviter_name) {
    m_inviter_name = inviter_name;
    m_inviter_name_isSet = true;
}

bool OAIInvitation::is_inviter_name_Set() const{
    return m_inviter_name_isSet;
}

bool OAIInvitation::is_inviter_name_Valid() const{
    return m_inviter_name_isValid;
}

QList<QString> OAIInvitation::getPermissions() const {
    return m_permissions;
}
void OAIInvitation::setPermissions(const QList<QString> &permissions) {
    m_permissions = permissions;
    m_permissions_isSet = true;
}

bool OAIInvitation::is_permissions_Set() const{
    return m_permissions_isSet;
}

bool OAIInvitation::is_permissions_Valid() const{
    return m_permissions_isValid;
}

OAIInvitation_quota OAIInvitation::getQuota() const {
    return m_quota;
}
void OAIInvitation::setQuota(const OAIInvitation_quota &quota) {
    m_quota = quota;
    m_quota_isSet = true;
}

bool OAIInvitation::is_quota_Set() const{
    return m_quota_isSet;
}

bool OAIInvitation::is_quota_Valid() const{
    return m_quota_isValid;
}

QList<QString> OAIInvitation::getRoles() const {
    return m_roles;
}
void OAIInvitation::setRoles(const QList<QString> &roles) {
    m_roles = roles;
    m_roles_isSet = true;
}

bool OAIInvitation::is_roles_Set() const{
    return m_roles_isSet;
}

bool OAIInvitation::is_roles_Valid() const{
    return m_roles_isValid;
}

QString OAIInvitation::getToken() const {
    return m_token;
}
void OAIInvitation::setToken(const QString &token) {
    m_token = token;
    m_token_isSet = true;
}

bool OAIInvitation::is_token_Set() const{
    return m_token_isSet;
}

bool OAIInvitation::is_token_Valid() const{
    return m_token_isValid;
}

bool OAIInvitation::isUsed() const {
    return m_used;
}
void OAIInvitation::setUsed(const bool &used) {
    m_used = used;
    m_used_isSet = true;
}

bool OAIInvitation::is_used_Set() const{
    return m_used_isSet;
}

bool OAIInvitation::is_used_Valid() const{
    return m_used_isValid;
}

QList<QString> OAIInvitation::getUserGroups() const {
    return m_user_groups;
}
void OAIInvitation::setUserGroups(const QList<QString> &user_groups) {
    m_user_groups = user_groups;
    m_user_groups_isSet = true;
}

bool OAIInvitation::is_user_groups_Set() const{
    return m_user_groups_isSet;
}

bool OAIInvitation::is_user_groups_Valid() const{
    return m_user_groups_isValid;
}

QString OAIInvitation::getUsername() const {
    return m_username;
}
void OAIInvitation::setUsername(const QString &username) {
    m_username = username;
    m_username_isSet = true;
}

bool OAIInvitation::is_username_Set() const{
    return m_username_isSet;
}

bool OAIInvitation::is_username_Valid() const{
    return m_username_isValid;
}

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

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

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

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

        if (m_invitable_identity_providers.size() > 0) {
            isObjectUpdated = true;
            break;
        }

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

        if (m_permissions.size() > 0) {
            isObjectUpdated = true;
            break;
        }

        if (m_quota.isSet()) {
            isObjectUpdated = true;
            break;
        }

        if (m_roles.size() > 0) {
            isObjectUpdated = true;
            break;
        }

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

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

        if (m_user_groups.size() > 0) {
            isObjectUpdated = true;
            break;
        }

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

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

} // namespace OpenAPI