drogon/orm_lib/tests/Users.cc

/**
 *
 *  Users.cc
 *  DO NOT EDIT. This file is generated by drogon_ctl
 *
 */

#include "Users.h"
#include <drogon/utils/Utilities.h>
#include <string>
#include <trantor/utils/config.h>

using namespace drogon_model::postgres;

const std::string Users::Cols::user_id = "user_id";
const std::string Users::Cols::user_name = "user_name";
const std::string Users::Cols::password = "password";
const std::string Users::Cols::org_name = "org_name";
const std::string Users::Cols::signature = "signature";
const std::string Users::Cols::avatar_id = "avatar_id";
const std::string Users::Cols::id = "id";
const std::string Users::Cols::salt = "salt";
const std::string Users::Cols::admin = "admin";
const std::string Users::primaryKeyName = "id";
const bool Users::hasPrimaryKey = true;
const std::string Users::tableName = "users";

const std::vector<typename Users::MetaData> Users::_metaData = {
    {"user_id", "std::string", "character varying", 32, 0, 0, 0},
    {"user_name", "std::string", "character varying", 64, 0, 0, 0},
    {"password", "std::string", "character varying", 64, 0, 0, 0},
    {"org_name", "std::string", "character varying", 20, 0, 0, 0},
    {"signature", "std::string", "character varying", 50, 0, 0, 0},
    {"avatar_id", "std::string", "character varying", 32, 0, 0, 0},
    {"id", "int32_t", "integer", 4, 1, 1, 1},
    {"salt", "std::string", "character varying", 20, 0, 0, 0},
    {"admin", "bool", "boolean", 1, 0, 0, 0}};
const std::string &Users::getColumnName(size_t index) noexcept(false)
{
    assert(index < _metaData.size());
    return _metaData[index]._colName;
}
Users::Users(const Row &r) noexcept
{
    if (!r["user_id"].isNull())
    {
        _userId = std::make_shared<std::string>(r["user_id"].as<std::string>());
    }
    if (!r["user_name"].isNull())
    {
        _userName =
            std::make_shared<std::string>(r["user_name"].as<std::string>());
    }
    if (!r["password"].isNull())
    {
        _password =
            std::make_shared<std::string>(r["password"].as<std::string>());
    }
    if (!r["org_name"].isNull())
    {
        _orgName =
            std::make_shared<std::string>(r["org_name"].as<std::string>());
    }
    if (!r["signature"].isNull())
    {
        _signature =
            std::make_shared<std::string>(r["signature"].as<std::string>());
    }
    if (!r["avatar_id"].isNull())
    {
        _avatarId =
            std::make_shared<std::string>(r["avatar_id"].as<std::string>());
    }
    if (!r["id"].isNull())
    {
        _id = std::make_shared<int32_t>(r["id"].as<int32_t>());
    }
    if (!r["salt"].isNull())
    {
        _salt = std::make_shared<std::string>(r["salt"].as<std::string>());
    }
    if (!r["admin"].isNull())
    {
        _admin = std::make_shared<bool>(r["admin"].as<bool>());
    }
}
const std::string &Users::getValueOfUserId(
    const std::string &defaultValue) const noexcept
{
    if (_userId)
        return *_userId;
    return defaultValue;
}
std::shared_ptr<const std::string> Users::getUserId() const noexcept
{
    return _userId;
}
void Users::setUserId(const std::string &userId) noexcept
{
    _userId = std::make_shared<std::string>(userId);
    _dirtyFlag[0] = true;
}
void Users::setUserId(std::string &&userId) noexcept
{
    _userId = std::make_shared<std::string>(std::move(userId));
    _dirtyFlag[0] = true;
}

const std::string &Users::getValueOfUserName(
    const std::string &defaultValue) const noexcept
{
    if (_userName)
        return *_userName;
    return defaultValue;
}
std::shared_ptr<const std::string> Users::getUserName() const noexcept
{
    return _userName;
}
void Users::setUserName(const std::string &userName) noexcept
{
    _userName = std::make_shared<std::string>(userName);
    _dirtyFlag[1] = true;
}
void Users::setUserName(std::string &&userName) noexcept
{
    _userName = std::make_shared<std::string>(std::move(userName));
    _dirtyFlag[1] = true;
}

const std::string &Users::getValueOfPassword(
    const std::string &defaultValue) const noexcept
{
    if (_password)
        return *_password;
    return defaultValue;
}
std::shared_ptr<const std::string> Users::getPassword() const noexcept
{
    return _password;
}
void Users::setPassword(const std::string &password) noexcept
{
    _password = std::make_shared<std::string>(password);
    _dirtyFlag[2] = true;
}
void Users::setPassword(std::string &&password) noexcept
{
    _password = std::make_shared<std::string>(std::move(password));
    _dirtyFlag[2] = true;
}

const std::string &Users::getValueOfOrgName(
    const std::string &defaultValue) const noexcept
{
    if (_orgName)
        return *_orgName;
    return defaultValue;
}
std::shared_ptr<const std::string> Users::getOrgName() const noexcept
{
    return _orgName;
}
void Users::setOrgName(const std::string &orgName) noexcept
{
    _orgName = std::make_shared<std::string>(orgName);
    _dirtyFlag[3] = true;
}
void Users::setOrgName(std::string &&orgName) noexcept
{
    _orgName = std::make_shared<std::string>(std::move(orgName));
    _dirtyFlag[3] = true;
}

const std::string &Users::getValueOfSignature(
    const std::string &defaultValue) const noexcept
{
    if (_signature)
        return *_signature;
    return defaultValue;
}
std::shared_ptr<const std::string> Users::getSignature() const noexcept
{
    return _signature;
}
void Users::setSignature(const std::string &signature) noexcept
{
    _signature = std::make_shared<std::string>(signature);
    _dirtyFlag[4] = true;
}
void Users::setSignature(std::string &&signature) noexcept
{
    _signature = std::make_shared<std::string>(std::move(signature));
    _dirtyFlag[4] = true;
}

const std::string &Users::getValueOfAvatarId(
    const std::string &defaultValue) const noexcept
{
    if (_avatarId)
        return *_avatarId;
    return defaultValue;
}
std::shared_ptr<const std::string> Users::getAvatarId() const noexcept
{
    return _avatarId;
}
void Users::setAvatarId(const std::string &avatarId) noexcept
{
    _avatarId = std::make_shared<std::string>(avatarId);
    _dirtyFlag[5] = true;
}
void Users::setAvatarId(std::string &&avatarId) noexcept
{
    _avatarId = std::make_shared<std::string>(std::move(avatarId));
    _dirtyFlag[5] = true;
}

const int32_t &Users::getValueOfId(const int32_t &defaultValue) const noexcept
{
    if (_id)
        return *_id;
    return defaultValue;
}
std::shared_ptr<const int32_t> Users::getId() const noexcept
{
    return _id;
}
const typename Users::PrimaryKeyType &Users::getPrimaryKey() const
{
    assert(_id);
    return *_id;
}

const std::string &Users::getValueOfSalt(const std::string &defaultValue) const
    noexcept
{
    if (_salt)
        return *_salt;
    return defaultValue;
}
std::shared_ptr<const std::string> Users::getSalt() const noexcept
{
    return _salt;
}
void Users::setSalt(const std::string &salt) noexcept
{
    _salt = std::make_shared<std::string>(salt);
    _dirtyFlag[7] = true;
}
void Users::setSalt(std::string &&salt) noexcept
{
    _salt = std::make_shared<std::string>(std::move(salt));
    _dirtyFlag[7] = true;
}

const bool &Users::getValueOfAdmin(const bool &defaultValue) const noexcept
{
    if (_admin)
        return *_admin;
    return defaultValue;
}
std::shared_ptr<const bool> Users::getAdmin() const noexcept
{
    return _admin;
}
void Users::setAdmin(const bool &admin) noexcept
{
    _admin = std::make_shared<bool>(admin);
    _dirtyFlag[8] = true;
}

void Users::updateId(const uint64_t id)
{
}

const std::vector<std::string> &Users::insertColumns() noexcept
{
    static const std::vector<std::string> _inCols = {"user_id",
                                                     "user_name",
                                                     "password",
                                                     "org_name",
                                                     "signature",
                                                     "avatar_id",
                                                     "salt",
                                                     "admin"};
    return _inCols;
}

void Users::outputArgs(drogon::orm::internal::SqlBinder &binder) const
{
    if (getUserId())
    {
        binder << getValueOfUserId();
    }
    else
    {
        binder << nullptr;
    }
    if (getUserName())
    {
        binder << getValueOfUserName();
    }
    else
    {
        binder << nullptr;
    }
    if (getPassword())
    {
        binder << getValueOfPassword();
    }
    else
    {
        binder << nullptr;
    }
    if (getOrgName())
    {
        binder << getValueOfOrgName();
    }
    else
    {
        binder << nullptr;
    }
    if (getSignature())
    {
        binder << getValueOfSignature();
    }
    else
    {
        binder << nullptr;
    }
    if (getAvatarId())
    {
        binder << getValueOfAvatarId();
    }
    else
    {
        binder << nullptr;
    }
    if (getSalt())
    {
        binder << getValueOfSalt();
    }
    else
    {
        binder << nullptr;
    }
    if (getAdmin())
    {
        binder << getValueOfAdmin();
    }
    else
    {
        binder << nullptr;
    }
}

const std::vector<std::string> Users::updateColumns() const
{
    std::vector<std::string> ret;
    for (size_t i = 0; i < sizeof(_dirtyFlag); i++)
    {
        if (_dirtyFlag[i])
        {
            ret.push_back(getColumnName(i));
        }
    }
    return ret;
}

void Users::updateArgs(drogon::orm::internal::SqlBinder &binder) const
{
    if (_dirtyFlag[0])
    {
        if (getUserId())
        {
            binder << getValueOfUserId();
        }
        else
        {
            binder << nullptr;
        }
    }
    if (_dirtyFlag[1])
    {
        if (getUserName())
        {
            binder << getValueOfUserName();
        }
        else
        {
            binder << nullptr;
        }
    }
    if (_dirtyFlag[2])
    {
        if (getPassword())
        {
            binder << getValueOfPassword();
        }
        else
        {
            binder << nullptr;
        }
    }
    if (_dirtyFlag[3])
    {
        if (getOrgName())
        {
            binder << getValueOfOrgName();
        }
        else
        {
            binder << nullptr;
        }
    }
    if (_dirtyFlag[4])
    {
        if (getSignature())
        {
            binder << getValueOfSignature();
        }
        else
        {
            binder << nullptr;
        }
    }
    if (_dirtyFlag[5])
    {
        if (getAvatarId())
        {
            binder << getValueOfAvatarId();
        }
        else
        {
            binder << nullptr;
        }
    }
    if (_dirtyFlag[7])
    {
        if (getSalt())
        {
            binder << getValueOfSalt();
        }
        else
        {
            binder << nullptr;
        }
    }
    if (_dirtyFlag[8])
    {
        if (getAdmin())
        {
            binder << getValueOfAdmin();
        }
        else
        {
            binder << nullptr;
        }
    }
}
Json::Value Users::toJson() const
{
    Json::Value ret;
    if (getUserId())
    {
        ret["user_id"] = getValueOfUserId();
    }
    else
    {
        ret["user_id"] = Json::Value();
    }
    if (getUserName())
    {
        ret["user_name"] = getValueOfUserName();
    }
    else
    {
        ret["user_name"] = Json::Value();
    }
    if (getPassword())
    {
        ret["password"] = getValueOfPassword();
    }
    else
    {
        ret["password"] = Json::Value();
    }
    if (getOrgName())
    {
        ret["org_name"] = getValueOfOrgName();
    }
    else
    {
        ret["org_name"] = Json::Value();
    }
    if (getSignature())
    {
        ret["signature"] = getValueOfSignature();
    }
    else
    {
        ret["signature"] = Json::Value();
    }
    if (getAvatarId())
    {
        ret["avatar_id"] = getValueOfAvatarId();
    }
    else
    {
        ret["avatar_id"] = Json::Value();
    }
    if (getId())
    {
        ret["id"] = getValueOfId();
    }
    else
    {
        ret["id"] = Json::Value();
    }
    if (getSalt())
    {
        ret["salt"] = getValueOfSalt();
    }
    else
    {
        ret["salt"] = Json::Value();
    }
    if (getAdmin())
    {
        ret["admin"] = getValueOfAdmin();
    }
    else
    {
        ret["admin"] = Json::Value();
    }
    return ret;
}