From 4dcbf009da48c8c063777ae64ee46394687ff5a9 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Sascha=20K=C3=BChl?= Date: Wed, 25 Jun 2025 15:57:02 +0200 Subject: [PATCH] added a bigger real-life demo --- demo/work.cpp | 53 +++++++++++++++++ demo/work/admin/CollectionCenter.hpp | 47 +++++++++++++++ demo/work/admin/InternalUserDirectory.hpp | 18 ++++++ demo/work/admin/LdapGroupSchemaSettings.hpp | 25 ++++++++ demo/work/admin/LdapImportSettings.hpp | 27 +++++++++ demo/work/admin/LdapUserDirectory.hpp | 28 +++++++++ demo/work/admin/LdapUserSchemaSettings.hpp | 29 ++++++++++ demo/work/admin/LockType.hpp | 21 +++++++ demo/work/admin/LoginHistory.hpp | 63 +++++++++++++++++++++ demo/work/admin/Scenario.hpp | 61 ++++++++++++++++++++ demo/work/admin/User.hpp | 45 +++++++++++++++ demo/work/admin/UserDirectory.hpp | 21 +++++++ demo/work/admin/UserSession.hpp | 34 +++++++++++ demo/work/core/Model.hpp | 19 +++++++ demo/work/core/Types.hpp | 9 +++ 15 files changed, 500 insertions(+) create mode 100644 demo/work.cpp create mode 100644 demo/work/admin/CollectionCenter.hpp create mode 100644 demo/work/admin/InternalUserDirectory.hpp create mode 100644 demo/work/admin/LdapGroupSchemaSettings.hpp create mode 100644 demo/work/admin/LdapImportSettings.hpp create mode 100644 demo/work/admin/LdapUserDirectory.hpp create mode 100644 demo/work/admin/LdapUserSchemaSettings.hpp create mode 100644 demo/work/admin/LockType.hpp create mode 100644 demo/work/admin/LoginHistory.hpp create mode 100644 demo/work/admin/Scenario.hpp create mode 100644 demo/work/admin/User.hpp create mode 100644 demo/work/admin/UserDirectory.hpp create mode 100644 demo/work/admin/UserSession.hpp create mode 100644 demo/work/core/Model.hpp create mode 100644 demo/work/core/Types.hpp diff --git a/demo/work.cpp b/demo/work.cpp new file mode 100644 index 0000000..857758b --- /dev/null +++ b/demo/work.cpp @@ -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("collection_center") + .and_then([&schema] { return schema.attach("internal_user_directory"); }) + .and_then([&schema] { return schema.attach("ldap_group_schema_settings"); }) + .and_then([&schema] { return schema.attach("ldap_import_settings"); }) + .and_then([&schema] { return schema.attach("ldap_user_directory"); } ) + .and_then([&schema] { return schema.attach("ldap_user_schema_settings"); }) + .and_then([&schema] { return schema.attach("login_history"); }) + .and_then([&schema] { return schema.attach("scenario"); }) + .and_then([&schema] { return schema.attach("user"); }) + .and_then([&schema] { return schema.attach("user_directory"); }) + .and_then([&schema] { return schema.attach("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; +} diff --git a/demo/work/admin/CollectionCenter.hpp b/demo/work/admin/CollectionCenter.hpp new file mode 100644 index 0000000..f2d6522 --- /dev/null +++ b/demo/work/admin/CollectionCenter.hpp @@ -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 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 users; + + template + void process( Operator& op ) { + namespace field = matador::access; + field::process( op, *matador::base_class( 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 diff --git a/demo/work/admin/InternalUserDirectory.hpp b/demo/work/admin/InternalUserDirectory.hpp new file mode 100644 index 0000000..8bf3f75 --- /dev/null +++ b/demo/work/admin/InternalUserDirectory.hpp @@ -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 + void process( Operator& op ) { + namespace field = matador::access; + field::process( op, *matador::base_class( this ) ); + } +}; +} + +#endif //INTERNALUSERDIRECTORY_HPP diff --git a/demo/work/admin/LdapGroupSchemaSettings.hpp b/demo/work/admin/LdapGroupSchemaSettings.hpp new file mode 100644 index 0000000..69be7ce --- /dev/null +++ b/demo/work/admin/LdapGroupSchemaSettings.hpp @@ -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 + void process( Operator& op ) { + namespace field = matador::access; + field::process( op, *matador::base_class( 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 diff --git a/demo/work/admin/LdapImportSettings.hpp b/demo/work/admin/LdapImportSettings.hpp new file mode 100644 index 0000000..27ce4dc --- /dev/null +++ b/demo/work/admin/LdapImportSettings.hpp @@ -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 + void process( Operator& op ) { + namespace field = matador::access; + field::process( op, *matador::base_class( 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 diff --git a/demo/work/admin/LdapUserDirectory.hpp b/demo/work/admin/LdapUserDirectory.hpp new file mode 100644 index 0000000..7f42fc7 --- /dev/null +++ b/demo/work/admin/LdapUserDirectory.hpp @@ -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 users; + matador::object::collection groups; + + + template + void process( Operator& op ) { + namespace field = matador::access; + field::process( op, *matador::base_class( this ) ); + } +}; +} + +#endif //LDAP_USER_DIRECTORY_HPP diff --git a/demo/work/admin/LdapUserSchemaSettings.hpp b/demo/work/admin/LdapUserSchemaSettings.hpp new file mode 100644 index 0000000..79b141a --- /dev/null +++ b/demo/work/admin/LdapUserSchemaSettings.hpp @@ -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 + void process( Operator& op ) { + namespace field = matador::access; + field::process( op, *matador::base_class( 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 diff --git a/demo/work/admin/LockType.hpp b/demo/work/admin/LockType.hpp new file mode 100644 index 0000000..acb4930 --- /dev/null +++ b/demo/work/admin/LockType.hpp @@ -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 LockTypeEnum({ + {LockType::NoLock, "NoLock"}, + {LockType::AdminLock, "AdminLock"}, + {LockType::SystemLock, "SystemLock"} +}); + +} + +#endif //LOCKTYPE_HPP diff --git a/demo/work/admin/LoginHistory.hpp b/demo/work/admin/LoginHistory.hpp new file mode 100644 index 0000000..86e27eb --- /dev/null +++ b/demo/work/admin/LoginHistory.hpp @@ -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 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; + matador::object::object_ptr scenario; + matador::object::object_ptr collection_center; + std::string login_name; + FailReason fail_reason{FailReason::NoFailReason}; + core::timestamp login_time; + + template + void process( Operator& op ) { + namespace field = matador::access; + field::process( op, *matador::base_class( 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 diff --git a/demo/work/admin/Scenario.hpp b/demo/work/admin/Scenario.hpp new file mode 100644 index 0000000..8ba4a68 --- /dev/null +++ b/demo/work/admin/Scenario.hpp @@ -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 ScenarioModeEnum({ + {ScenarioMode::InvalidMode, "InvalidMode"}, + {ScenarioMode::Exercise, "Exercise"}, + {ScenarioMode::Operation, "Operation"} +}); + +enum class ScenarioState : uint8_t { + InvalidState, + Active, + Inactive +}; + +static const matador::utils::enum_mapper 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 collection_center; + + template + void process( Operator& op ) { + namespace field = matador::access; + field::process( op, *matador::base_class( 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 diff --git a/demo/work/admin/User.hpp b/demo/work/admin/User.hpp new file mode 100644 index 0000000..2e6d5a5 --- /dev/null +++ b/demo/work/admin/User.hpp @@ -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 user_directory; + + template + void process( Operator& op ) { + namespace field = matador::access; + field::process( op, *matador::base_class( 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 diff --git a/demo/work/admin/UserDirectory.hpp b/demo/work/admin/UserDirectory.hpp new file mode 100644 index 0000000..01ca905 --- /dev/null +++ b/demo/work/admin/UserDirectory.hpp @@ -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 + void process( Operator& op ) { + namespace field = matador::access; + field::process( op, *matador::base_class( this ) ); + field::attribute( op, "name", name, 511 ); + } +}; +} + +#endif //USER_DIRECTORY_HPP diff --git a/demo/work/admin/UserSession.hpp b/demo/work/admin/UserSession.hpp new file mode 100644 index 0000000..5bebf1b --- /dev/null +++ b/demo/work/admin/UserSession.hpp @@ -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; + matador::object::object_ptr scenario; + matador::object::object_ptr collection_center; + core::timestamp offline_since; + + template + void process( Operator& op ) { + namespace field = matador::access; + field::process( op, *matador::base_class( 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 diff --git a/demo/work/core/Model.hpp b/demo/work/core/Model.hpp new file mode 100644 index 0000000..f411912 --- /dev/null +++ b/demo/work/core/Model.hpp @@ -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 + void process( Operator& op ) { + namespace field = matador::access; + field::primary_key( op, "id", id ); + field::revision( op, "version", version ); + } +}; +} +#endif //MODEL_HPP diff --git a/demo/work/core/Types.hpp b/demo/work/core/Types.hpp new file mode 100644 index 0000000..b793be6 --- /dev/null +++ b/demo/work/core/Types.hpp @@ -0,0 +1,9 @@ +#ifndef TYPES_HPP +#define TYPES_HPP + +#include + +namespace work::core { +using timestamp = std::chrono::system_clock::time_point; +} +#endif //TYPES_HPP