added a bigger real-life demo

This commit is contained in:
Sascha Kühl 2025-06-25 15:57:02 +02:00
parent e72733d37e
commit 4dcbf009da
15 changed files with 500 additions and 0 deletions

53
demo/work.cpp Normal file
View File

@ -0,0 +1,53 @@
#include "work/admin/CollectionCenter.hpp"
#include "work/admin/InternalUserDirectory.hpp"
#include "work/admin/LdapGroupSchemaSettings.hpp"
#include "work/admin/LdapImportSettings.hpp"
#include "work/admin/LdapUserDirectory.hpp"
#include "work/admin/LdapUserSchemaSettings.hpp"
#include "work/admin/LoginHistory.hpp"
#include "work/admin/Scenario.hpp"
#include "work/admin/User.hpp"
#include "work/admin/UserDirectory.hpp"
#include "work/admin/UserSession.hpp"
#include "matador/object/schema.hpp"
#include "matador/sql/connection.hpp"
#include "matador/orm/session.hpp"
using namespace matador;
using namespace work::models;
int main() {
object::schema schema;
auto result = schema.attach<admin::CollectionCenter>("collection_center")
.and_then([&schema] { return schema.attach<admin::InternalUserDirectory>("internal_user_directory"); })
.and_then([&schema] { return schema.attach<admin::LdapGroupSchemaSettings>("ldap_group_schema_settings"); })
.and_then([&schema] { return schema.attach<admin::LdapImportSettings>("ldap_import_settings"); })
.and_then([&schema] { return schema.attach<admin::LdapUserDirectory>("ldap_user_directory"); } )
.and_then([&schema] { return schema.attach<admin::LdapUserSchemaSettings>("ldap_user_schema_settings"); })
.and_then([&schema] { return schema.attach<admin::LoginHistory>("login_history"); })
.and_then([&schema] { return schema.attach<admin::Scenario>("scenario"); })
.and_then([&schema] { return schema.attach<admin::User>("user"); })
.and_then([&schema] { return schema.attach<admin::UserDirectory>("user_directory"); })
.and_then([&schema] { return schema.attach<admin::UserSession>("user_session"); });
if (!result.is_ok()) {
return 0;
}
const std::string dns{"sqlite://demo.db"};
sql::connection c(dns);
result = c.open();
// orm::session s()
if (!result.is_ok()) {
return 0;
}
return 0;
}

View File

@ -0,0 +1,47 @@
#ifndef COLLECTION_CENTER_HPP
#define COLLECTION_CENTER_HPP
#include "../core/Model.hpp"
#include "matador/object/collection.hpp"
#include "matador/utils/base_class.hpp"
#include "matador/utils/enum_mapper.hpp"
#include "matador/utils/fetch_type.hpp"
#include "matador/utils/types.hpp"
namespace work::models::admin {
struct User;
enum class CollectionCenterType : uint8_t {
NoType,
Core,
Unit
};
static const matador::utils::enum_mapper<CollectionCenterType> CollectionCenterTypeEnum({
{CollectionCenterType::NoType, "NoType"},
{CollectionCenterType::Core, "Core"},
{CollectionCenterType::Unit, "Unit"}
});
struct CollectionCenter : core::Model {
std::string name;
matador::utils::blob symbol;
CollectionCenterType type{CollectionCenterType::NoType};
matador::object::collection<User> users;
template<typename Operator>
void process( Operator& op ) {
namespace field = matador::access;
field::process( op, *matador::base_class<Model>( this ) );
field::attribute( op, "name", name, 511 );
field::attribute( op, "symbol", symbol );
field::attribute( op, "type", type );
field::has_many( op, "users", users, "collection_center_id", matador::utils::fetch_type::LAZY );
}
};
}
#endif //COLLECTION_CENTER_HPP

View File

@ -0,0 +1,18 @@
#ifndef INTERNAL_USER_DIRECTORY_HPP
#define INTERNAL_USER_DIRECTORY_HPP
#include "UserDirectory.hpp"
#include "matador/utils/base_class.hpp"
namespace work::models::admin {
struct InternalUserDirectory : UserDirectory {
template<typename Operator>
void process( Operator& op ) {
namespace field = matador::access;
field::process( op, *matador::base_class<UserDirectory>( this ) );
}
};
}
#endif //INTERNALUSERDIRECTORY_HPP

View File

@ -0,0 +1,25 @@
#ifndef LDAP_GROUP_SCHEMA_SETTINGS_HPP
#define LDAP_GROUP_SCHEMA_SETTINGS_HPP
#include "../core/Model.hpp"
#include "matador/utils/base_class.hpp"
namespace work::models::admin {
struct LdapGroupSchemaSettings : core::Model {
std::string group_object_filter;
std::string user_member_attribute;
template<typename Operator>
void process( Operator& op ) {
namespace field = matador::access;
field::process( op, *matador::base_class<Model>( this ) );
field::attribute( op, "group_object_filter", group_object_filter, 511 );
field::attribute( op, "user_member_attribute", user_member_attribute, 511 );
}
};
}
#endif //LDAP_GROUP_SCHEMA_SETTINGS_HPP

View File

@ -0,0 +1,27 @@
#ifndef LDAP_IMPORT_SETTINGS_HPP
#define LDAP_IMPORT_SETTINGS_HPP
#include "../core/Model.hpp"
#include "matador/utils/base_class.hpp"
namespace work::models::admin {
struct LdapImportSettings : core::Model {
std::string default_role;
unsigned int sync_interval;
unsigned int network_timeout;
template<typename Operator>
void process( Operator& op ) {
namespace field = matador::access;
field::process( op, *matador::base_class<Model>( this ) );
field::attribute( op, "default_role", default_role, 511 );
field::attribute( op, "sync_interval", sync_interval );
field::attribute( op, "network_timeout", network_timeout );
}
};
}
#endif //LDAP_IMPORT_SETTINGS_HPP

View File

@ -0,0 +1,28 @@
#ifndef LDAP_USER_DIRECTORY_HPP
#define LDAP_USER_DIRECTORY_HPP
#include "UserDirectory.hpp"
#include "matador/object/collection.hpp"
#include "matador/object/object_ptr.hpp"
#include "matador/utils/base_class.hpp"
namespace work::models::admin {
struct LdapUserDirectory : UserDirectory {
std::string schema_base_dn;
std::string additional_user_base_dn;
std::string additional_group_base_dn;
matador::object::collection<std::string> users;
matador::object::collection<std::string> groups;
template<typename Operator>
void process( Operator& op ) {
namespace field = matador::access;
field::process( op, *matador::base_class<UserDirectory>( this ) );
}
};
}
#endif //LDAP_USER_DIRECTORY_HPP

View File

@ -0,0 +1,29 @@
#ifndef LDAP_USER_SCHEMA_SETTINGS_HPP
#define LDAP_USER_SCHEMA_SETTINGS_HPP
#include "../core/Model.hpp"
#include "matador/utils/base_class.hpp"
namespace work::models::admin {
struct LdapUserSchemaSettings : core::Model {
std::string user_object_filter;
std::string user_unique_id_attribute;
std::string user_member_of_attribute;
std::string user_name_attribute;
template<typename Operator>
void process( Operator& op ) {
namespace field = matador::access;
field::process( op, *matador::base_class<Model>( this ) );
field::attribute( op, "user_object_filter", user_object_filter, 511 );
field::attribute( op, "user_unique_id_attribute", user_unique_id_attribute, 511 );
field::attribute( op, "user_member_of_attribute", user_member_of_attribute, 511 );
field::attribute( op, "user_name_attribute", user_name_attribute, 511 );
}
};
}
#endif //LDAP_USER_SCHEMA_SETTINGS_HPP

View File

@ -0,0 +1,21 @@
#ifndef LOCKTYPE_HPP
#define LOCKTYPE_HPP
#include "matador/utils/enum_mapper.hpp"
namespace work::models::admin {
enum class LockType : uint8_t {
NoLock,
AdminLock,
SystemLock
};
static const matador::utils::enum_mapper<LockType> LockTypeEnum({
{LockType::NoLock, "NoLock"},
{LockType::AdminLock, "AdminLock"},
{LockType::SystemLock, "SystemLock"}
});
}
#endif //LOCKTYPE_HPP

View File

@ -0,0 +1,63 @@
#ifndef LOGIN_HISTORY_HPP
#define LOGIN_HISTORY_HPP
#include "CollectionCenter.hpp"
#include "Scenario.hpp"
#include "User.hpp"
#include "../core/Model.hpp"
#include "matador/object/object_ptr.hpp""
#include "matador/utils/base_class.hpp"
#include "matador/utils/enum_mapper.hpp"
namespace work::models::admin {
enum class FailReason : uint8_t {
NoFailReason,
InternalError,
NoPermissionToLogin,
NoScenarioForUser,
UnknownUserName,
UserLockedByAdmin,
UserLockedBySystem,
UserLockedByAdminAndSystem,
WrongPassword
};
static const matador::utils::enum_mapper<FailReason> FailReasonEnum({
{FailReason::NoFailReason, "NoFailReason"},
{FailReason::InternalError, "InternalError"},
{FailReason::NoPermissionToLogin, "NoPermissionToLogin"},
{FailReason::NoScenarioForUser, "NoScenarioForUser"},
{FailReason::UnknownUserName, "UnknownUserName"},
{FailReason::UserLockedByAdmin, "UserLockedByAdmin"},
{FailReason::UserLockedBySystem, "UserLockedBySystem"},
{FailReason::UserLockedByAdminAndSystem, "UserLockedByAdminAndSystem"},
{FailReason::WrongPassword, "WrongPassword"}
});
struct LoginHistory : core::Model {
matador::object::object_ptr<User> user;
matador::object::object_ptr<Scenario> scenario;
matador::object::object_ptr<CollectionCenter> collection_center;
std::string login_name;
FailReason fail_reason{FailReason::NoFailReason};
core::timestamp login_time;
template<typename Operator>
void process( Operator& op ) {
namespace field = matador::access;
field::process( op, *matador::base_class<Model>( this ) );
field::belongs_to( op, "user", user, matador::utils::default_foreign_attributes );
field::belongs_to( op, "scenario", scenario, matador::utils::default_foreign_attributes );
field::belongs_to( op, "collection_center", collection_center, matador::utils::default_foreign_attributes );
field::attribute( op, "login_name", login_name, 511 );
field::attribute( op, "fail_reason", fail_reason );
field::attribute( op, "login_time", login_time );
}
};
}
#endif //LOGIN_HISTORY_HPP

View File

@ -0,0 +1,61 @@
#ifndef SCENARIO_HPP
#define SCENARIO_HPP
#include "../core/Model.hpp"
#include "matador/object/collection.hpp"
#include "matador/object/object_ptr.hpp"
#include "matador/utils/base_class.hpp"
#include "matador/utils/enum_mapper.hpp"
namespace work::models::admin {
struct CollectionCenter;
enum class ScenarioMode : uint8_t {
InvalidMode,
Exercise,
Operation,
};
static const matador::utils::enum_mapper<ScenarioMode> ScenarioModeEnum({
{ScenarioMode::InvalidMode, "InvalidMode"},
{ScenarioMode::Exercise, "Exercise"},
{ScenarioMode::Operation, "Operation"}
});
enum class ScenarioState : uint8_t {
InvalidState,
Active,
Inactive
};
static const matador::utils::enum_mapper<ScenarioState> ScenarioStateEnum({
{ScenarioState::InvalidState, "InvalidState"},
{ScenarioState::Active, "Active"},
{ScenarioState::Inactive, "Inactive"}
});
struct Scenario : core::Model {
std::string name;
ScenarioMode mode{ScenarioMode::InvalidMode};
std::string description;
matador::utils::blob symbol;
ScenarioState state{ScenarioState::InvalidState};
matador::object::collection<CollectionCenter> collection_center;
template<typename Operator>
void process( Operator& op ) {
namespace field = matador::access;
field::process( op, *matador::base_class<Model>( this ) );
field::attribute( op, "name", name, 511 );
field::attribute( op, "mode", mode );
field::attribute( op, "description", description, 511 );
field::attribute( op, "symbol", symbol );
field::attribute( op, "state", state );
field::has_many( op, "collection_center", collection_center, "scenario_id", matador::utils::fetch_type::LAZY );
}
};
}
#endif //SCENARIO_HPP

45
demo/work/admin/User.hpp Normal file
View File

@ -0,0 +1,45 @@
#ifndef USER_HPP
#define USER_HPP
#include "LockType.hpp"
#include "../core/Model.hpp"
#include "../core/Types.hpp"
#include "matador/object/object_ptr.hpp""
#include "matador/utils/base_class.hpp"
#include "matador/utils/types.hpp"
namespace work::models::admin {
struct UserDirectory;
struct User : core::Model {
std::string name;
matador::utils::blob symbol;
std::string salt;
std::string password;
LockType lock_type{LockType::NoLock};
core::timestamp locked_at;
std::string lock_reason;
std::string role;
matador::object::object_ptr<UserDirectory> user_directory;
template<typename Operator>
void process( Operator& op ) {
namespace field = matador::access;
field::process( op, *matador::base_class<Model>( this ) );
field::attribute( op, "name", name, 511 );
field::attribute( op, "symbol", symbol );
field::attribute( op, "salt", salt, 511 );
field::attribute( op, "password", password, 511 );
field::attribute( op, "lock_type", lock_type );
field::attribute( op, "locked_at", locked_at );
field::attribute( op, "lock_reason", lock_reason, 511 );
field::attribute( op, "role", role, 63 );
field::belongs_to( op, "user_directory", user_directory, matador::utils::default_foreign_attributes );
}
};
}
#endif //USER_HPP

View File

@ -0,0 +1,21 @@
#ifndef USER_DIRECTORY_HPP
#define USER_DIRECTORY_HPP
#include "../core/Model.hpp"
#include "matador/utils/base_class.hpp"
namespace work::models::admin {
struct UserDirectory : core::Model {
std::string name;
template<typename Operator>
void process( Operator& op ) {
namespace field = matador::access;
field::process( op, *matador::base_class<Model>( this ) );
field::attribute( op, "name", name, 511 );
}
};
}
#endif //USER_DIRECTORY_HPP

View File

@ -0,0 +1,34 @@
#ifndef USER_SESSION_HPP
#define USER_SESSION_HPP
#include "CollectionCenter.hpp"
#include "Scenario.hpp"
#include "User.hpp"
#include "../core/Model.hpp"
#include "../core/Types.hpp"
#include "matador/object/object_ptr.hpp""
#include "matador/utils/base_class.hpp"
namespace work::models::admin {
struct UserSession : core::Model {
matador::object::object_ptr<User> user;
matador::object::object_ptr<Scenario> scenario;
matador::object::object_ptr<CollectionCenter> collection_center;
core::timestamp offline_since;
template<typename Operator>
void process( Operator& op ) {
namespace field = matador::access;
field::process( op, *matador::base_class<Model>( this ) );
field::belongs_to( op, "user", user, matador::utils::default_foreign_attributes );
field::belongs_to( op, "scenario", scenario, matador::utils::default_foreign_attributes );
field::belongs_to( op, "collection_center", collection_center, matador::utils::default_foreign_attributes );
field::attribute( op, "offline_since", offline_since );
}
};
}
#endif //USER_SESSION_HPP

19
demo/work/core/Model.hpp Normal file
View File

@ -0,0 +1,19 @@
#ifndef MODEL_HPP
#define MODEL_HPP
#include "matador/utils/access.hpp"
namespace work::core {
struct Model {
unsigned long long id;
unsigned long long version;
template<typename Operator>
void process( Operator& op ) {
namespace field = matador::access;
field::primary_key( op, "id", id );
field::revision( op, "version", version );
}
};
}
#endif //MODEL_HPP

9
demo/work/core/Types.hpp Normal file
View File

@ -0,0 +1,9 @@
#ifndef TYPES_HPP
#define TYPES_HPP
#include <chrono>
namespace work::core {
using timestamp = std::chrono::system_clock::time_point;
}
#endif //TYPES_HPP