fix build

src/app/CMakeLists.txt

@@ -1,18 +1,18 @@
-#set(SOURCES
-#        main.cpp)
+set(SOURCES
+    main.cpp
+)
 
-#add_executable(eedb_app ${SOURCES})
+find_package(wt)
 
-#target_link_libraries(eedb_app
-#    wthttp   # or {Wt_HTTP_DEBUG_LIBRARY}
-#    wt        # or {Wt_DEBUG_LIBRARY}
-#    postgresql_connector
-#    auth
-#    eedb
-#        Boost::system
-#        Boost::filesystem
-#        Boost::thread
-#        Boost::program_options
-#        z
-#        )
+add_executable(eedb_app ${SOURCES})
+
+target_link_libraries(eedb_app
+    PRIVATE wthttp   # or {Wt_HTTP_DEBUG_LIBRARY}
+    PRIVATE wt        # or {Wt_DEBUG_LIBRARY}
+    PRIVATE postgres_connector
+    PRIVATE eedb
+    PRIVATE auth
+    PRIVATE widgets
+    z
+)
 

src/app/main.cpp

@@ -4,14 +4,14 @@
 #include <eedb/auth/PgUserAuth.hpp>
 #include <eedb/auth/Services.hpp>
 
-#include <eedb/db/config.hpp>
-#include <eedb/db/connection.hpp>
-#include <eedb/db/eedb/db/pg/PgUsers.hpp>
+#include <eedb/db/pg/config.hpp>
+#include <eedb/db/pg/connection.hpp>
+#include <eedb/db/pg/PgUsers.hpp>
 
-#include <eedb/widgets/BootstrapTheme.hpp>
-#include <eedb/widgets/DefaultAuthPage.hpp>
-#include <eedb/widgets/DefaultHomePage.hpp>
-#include <eedb/widgets/DefaultNavigationBar.hpp>
+#include <widget/BootstrapTheme.hpp>
+#include <widget/DefaultAuthPage.hpp>
+#include <widget/DefaultHomePage.hpp>
+#include <widget/DefaultNavigationBar.hpp>
 
 #include <Wt/WApplication.h>
 #include <Wt/WContainerWidget.h>
@@ -36,14 +36,15 @@ std::unique_ptr< Wt::WApplication > createApplication(const Wt::WEnvironment & e
         using std::move;
         using std::unique_ptr;
 
-        auto dbConfig = make_unique< eedb::db::PgConfig >(env);
+        auto dbConfig = make_unique< eedb::db::PgConfig >(
+          [&env](const std::string & name, std::string & prop) { return env.server()->readConfigurationProperty(name, prop); });
 
         auto dbConnection = make_unique< eedb::db::PgConnection >(move(dbConfig));
         auto session      = unique_ptr< eedb::Session >(make_unique< eedb::WebSession >(move(dbConnection), env));
 
         auto authPageFactory = [_session = session.get()]()->std::unique_ptr< eedb::AuthPage > {
             auto usersRegistry = make_unique< eedb::PgUsers >(_session->db());
-            auto userDatabase  = make_unique< eedb::auth::PgUserAuth >(move(usersRegistry), _session->enviroment());
+            auto userDatabase  = make_unique< eedb::auth::UserDatabase >(move(usersRegistry), _session->enviroment());
             auto services      = eedb::auth::Services();
             auto & login       = _session->login();
 

src/libs/auth/CMakeLists.txt

@@ -16,6 +16,7 @@ target_include_directories( ${LIB}
 )
 
 target_link_libraries( ${LIB}
+    PRIVATE nlohmann_json
     PRIVATE eedb
 )
 

src/libs/auth/include/eedb/auth/PgUserAuth.hpp

@@ -18,9 +18,9 @@ class AuthService;
 
 namespace eedb::auth {
 
-class PgUserAuth : public Wt::Auth::AbstractUserDatabase {
+class UserDatabase : public Wt::Auth::AbstractUserDatabase {
   public:
-    PgUserAuth(std::unique_ptr< eedb::Users > users, const Wt::WEnvironment & env);
+    UserDatabase(std::unique_ptr< eedb::Users > users, const Wt::WEnvironment & env);
 
     Transaction * startTransaction() override;
 

src/libs/auth/src/PgUserAuth.cpp

@@ -11,7 +11,6 @@
 #include <eedb/db/Users.hpp>
 
 #include <Wt/Auth/AuthService.h>
-#include <Wt/Auth/Dbo/AuthInfo.h>
 #include <Wt/WEnvironment.h>
 
 #include <nlohmann/json.hpp>
@@ -43,7 +42,7 @@ struct TransactionGuard : public Wt::Auth::AbstractUserDatabase::Transaction {
 static const std::string registration_id = "registration";
 namespace eedb::auth {
 
-struct PgUserAuth::UserAuthPriv {
+struct UserDatabase::UserAuthPriv {
     UserAuthPriv(std::unique_ptr< eedb::Users > users, const Wt::WEnvironment & env) : _users{std::move(users)}, _env{env} {
         this->setAuthService(eedb::auth::Services::authService());
     }
@@ -72,10 +71,10 @@ struct PgUserAuth::UserAuthPriv {
     int _in_transaction{0};
 };
 
-PgUserAuth::PgUserAuth(std::unique_ptr< eedb::Users > users, const Wt::WEnvironment & env)
- : _priv{spimpl::make_unique_impl< PgUserAuth::UserAuthPriv >(std::move(users), env)} {}
+UserDatabase::UserDatabase(std::unique_ptr< eedb::Users > users, const Wt::WEnvironment & env)
+ : _priv{spimpl::make_unique_impl< UserDatabase::UserAuthPriv >(std::move(users), env)} {}
 
-Wt::Auth::User PgUserAuth::findWithId(const std::string & id) const {
+Wt::Auth::User UserDatabase::findWithId(const std::string & id) const {
     spdlog::get("default")->debug("searching user by id: '{}'...", id);
     auto duser = _priv->_users->findWith(std::atoi(id.c_str()));
 
@@ -87,7 +86,7 @@ Wt::Auth::User PgUserAuth::findWithId(const std::string & id) const {
     return {};
 }
 
-Wt::Auth::User PgUserAuth::findWithIdentity(const std::string & provider, const Wt::WString & identity) const {
+Wt::Auth::User UserDatabase::findWithIdentity(const std::string & provider, const Wt::WString & identity) const {
     spdlog::get("default")->debug("searching user by identity/provider: '{}'/'{}'...", identity.toUTF8(), provider);
     auto _identity = identity.toUTF8();
     if(_priv->_authService && _priv->_authService->identityPolicy() == Wt::Auth::IdentityPolicy::EmailAddress) {
@@ -103,7 +102,7 @@ Wt::Auth::User PgUserAuth::findWithIdentity(const std::string & provider, const
     return {};
 }
 
-Wt::Auth::User PgUserAuth::findWithEmailToken(const std::string & hash) const {
+Wt::Auth::User UserDatabase::findWithEmailToken(const std::string & hash) const {
     spdlog::get("default")->debug("searching user by email token: '{}'...", hash);
 
     auto duser = _priv->_users->findWith(eedb::EmailToken{hash});
@@ -115,7 +114,7 @@ Wt::Auth::User PgUserAuth::findWithEmailToken(const std::string & hash) const {
     return {};
 }
 
-Wt::Auth::User PgUserAuth::findWithEmail(const std::string & address) const {
+Wt::Auth::User UserDatabase::findWithEmail(const std::string & address) const {
     spdlog::get("default")->debug("searching user by email: '{}'...", address);
 
     auto duser = _priv->_users->findWith(eedb::Email{address});
@@ -128,7 +127,7 @@ Wt::Auth::User PgUserAuth::findWithEmail(const std::string & address) const {
 }
 
 // @registration
-void PgUserAuth::addIdentity(const Wt::Auth::User & user, const std::string & provider, const Wt::WString & identity) {
+void UserDatabase::addIdentity(const Wt::Auth::User & user, const std::string & provider, const Wt::WString & identity) {
     spdlog::get("default")->debug("addind identity/provider: '{}'/'{}' for user_id'{}'...", identity.toUTF8(), provider, user.id());
 
     if(user.id() == registration_id) {
@@ -149,7 +148,7 @@ void PgUserAuth::addIdentity(const Wt::Auth::User & user, const std::string & pr
 ////    _userAuth.setIdentity({user.id()}, provider, identity.toUTF8());
 //}
 // @registration
-Wt::WString PgUserAuth::identity(const Wt::Auth::User & user, const std::string & provider) const {
+Wt::WString UserDatabase::identity(const Wt::Auth::User & user, const std::string & provider) const {
     spdlog::get("default")->trace("user{} identity: '{}'", provider);
     if(user.id() == registration_id) {
         return Wt::WString{_priv->_identity.value_or("")};
@@ -165,18 +164,18 @@ Wt::WString PgUserAuth::identity(const Wt::Auth::User & user, const std::string
     return Wt::WString::Empty;
 }
 
-void PgUserAuth::removeIdentity(const Wt::Auth::User & user, const std::string & provider) {
+void UserDatabase::removeIdentity(const Wt::Auth::User & user, const std::string & provider) {
     spdlog::get("default")->trace("user{} remove provider: '{}'", user.id(), provider);
     _priv->user(user)->authIdentities().removeProvider(provider);
 }
 
-Wt::Auth::User PgUserAuth::registerNew() {
+Wt::Auth::User UserDatabase::registerNew() {
     spdlog::get("default")->debug("registering new user");
     _priv->_registration = true;
     return Wt::Auth::User(registration_id, *this);
 }
 
-void PgUserAuth::deleteUser(const Wt::Auth::User & user) {
+void UserDatabase::deleteUser(const Wt::Auth::User & user) {
     spdlog::get("default")->debug("delete user {}", user.id());
     throw std::runtime_error("not implemented void PgUserAuth::deleteUser(const Wt::Auth::User & user)");
     //    _priv->_users->removeUser(eedb::ConstAuthIdentity);
@@ -200,7 +199,7 @@ void PgUserAuth::deleteUser(const Wt::Auth::User & user) {
 //         .where(auth_info.id == std::atoi(user.id().c_str())));
 //}
 
-void PgUserAuth::setPassword(const Wt::Auth::User & user, const PasswordHash & password) {
+void UserDatabase::setPassword(const Wt::Auth::User & user, const PasswordHash & password) {
     spdlog::get("default")->trace("user{} set password", user.id());
     if(user.id() == registration_id) {
         _priv->_password = password;
@@ -209,13 +208,13 @@ void PgUserAuth::setPassword(const Wt::Auth::User & user, const PasswordHash & p
     }
 }
 
-PasswordHash PgUserAuth::password(const Wt::Auth::User & user) const {
+PasswordHash UserDatabase::password(const Wt::Auth::User & user) const {
     spdlog::get("default")->trace("user{} get password", user.id());
     auto password = _priv->user(user)->authInfo().password();
     return {password.function(), password.salt(), password.value()};
 }
 
-bool PgUserAuth::setEmail(const Wt::Auth::User & user, const std::string & address) {
+bool UserDatabase::setEmail(const Wt::Auth::User & user, const std::string & address) {
     spdlog::get("default")->trace("user{} set email {}", user.id(), address);
     if(_priv->_users->findWith(eedb::Email{address}))
         return false; // user with given email exists
@@ -229,7 +228,7 @@ bool PgUserAuth::setEmail(const Wt::Auth::User & user, const std::string & addre
     return true;
 }
 
-std::string PgUserAuth::email(const Wt::Auth::User & user) const {
+std::string UserDatabase::email(const Wt::Auth::User & user) const {
     spdlog::get("default")->trace("user{} get email", user.id());
     if(user.id() == registration_id) {
         return _priv->_email.value_or("");
@@ -238,7 +237,7 @@ std::string PgUserAuth::email(const Wt::Auth::User & user) const {
     }
 }
 
-void PgUserAuth::setUnverifiedEmail(const Wt::Auth::User & user, const std::string & address) {
+void UserDatabase::setUnverifiedEmail(const Wt::Auth::User & user, const std::string & address) {
     spdlog::get("default")->trace("user{} set unverified email {}", user.id(), address);
     if(user.id() == registration_id) {
         _priv->_unverifiedEmail = address;
@@ -247,7 +246,7 @@ void PgUserAuth::setUnverifiedEmail(const Wt::Auth::User & user, const std::stri
     }
 }
 
-void PgUserAuth::setEmailToken(const Wt::Auth::User & user, const Token & token, EmailTokenRole role) {
+void UserDatabase::setEmailToken(const Wt::Auth::User & user, const Token & token, EmailTokenRole role) {
     using namespace std::chrono;
     spdlog::get("default")->trace("user{} set email token {}", user.id(), token.hash());
     if(user.id() == registration_id) {
@@ -260,7 +259,7 @@ void PgUserAuth::setEmailToken(const Wt::Auth::User & user, const Token & token,
     }
 }
 
-std::string PgUserAuth::unverifiedEmail(const Wt::Auth::User & user) const {
+std::string UserDatabase::unverifiedEmail(const Wt::Auth::User & user) const {
     spdlog::get("default")->trace("user{} get unverified email", user.id());
     if(user.id() == registration_id) {
         assert(_priv->_unverifiedEmail.has_value());
@@ -270,7 +269,7 @@ std::string PgUserAuth::unverifiedEmail(const Wt::Auth::User & user) const {
     }
 }
 
-Token PgUserAuth::emailToken(const Wt::Auth::User & user) const {
+Token UserDatabase::emailToken(const Wt::Auth::User & user) const {
     spdlog::get("default")->trace("user{} get email token", user.id());
     if(user.id() == registration_id) {
         assert(false);
@@ -284,7 +283,7 @@ Token PgUserAuth::emailToken(const Wt::Auth::User & user) const {
     }
 }
 
-EmailTokenRole PgUserAuth::emailTokenRole(const Wt::Auth::User & user) const {
+EmailTokenRole UserDatabase::emailTokenRole(const Wt::Auth::User & user) const {
     spdlog::get("default")->trace("user{} get email token role", user.id());
     auto & tokens = _priv->_users->findWith(std::atoi(user.id().c_str()))->authTokens();
     if(tokens.find(AuthTokenRole::EmailToken)) {
@@ -295,17 +294,17 @@ EmailTokenRole PgUserAuth::emailTokenRole(const Wt::Auth::User & user) const {
     assert(false);
 }
 
-void PgUserAuth::addAuthToken(const Wt::Auth::User & user, const Token & token) {
+void UserDatabase::addAuthToken(const Wt::Auth::User & user, const Token & token) {
     spdlog::get("default")->trace("user{} adding auth token", user.id());
     _priv->user(user)->authTokens().addToken(token.hash(), AuthTokenRole::Auth);
 }
 
-void PgUserAuth::removeAuthToken(const Wt::Auth::User & user, const std::string & hash) {
+void UserDatabase::removeAuthToken(const Wt::Auth::User & user, const std::string & hash) {
     spdlog::get("default")->trace("user{} removing auth token", user.id());
     _priv->user(user)->authTokens().removeToken(hash);
 }
 
-Wt::Auth::User PgUserAuth::findWithAuthToken(const std::string & hash) const {
+Wt::Auth::User UserDatabase::findWithAuthToken(const std::string & hash) const {
     spdlog::get("default")->debug("searching user by auth token: '{}'...", hash);
     auto u = _priv->_users->findWith(eedb::AuthTokenConst(hash));
     if(!u)
@@ -313,22 +312,22 @@ Wt::Auth::User PgUserAuth::findWithAuthToken(const std::string & hash) const {
     return {std::to_string(u->uid()), *this};
 }
 
-int PgUserAuth::updateAuthToken(const Wt::Auth::User & user, const std::string & oldhash, const std::string & newhash) {
+int UserDatabase::updateAuthToken(const Wt::Auth::User & user, const std::string & oldhash, const std::string & newhash) {
     spdlog::get("default")->trace("user{} updating auth token", user.id());
     _priv->user(user)->authTokens().find(oldhash)->update(newhash);
 }
 
-void PgUserAuth::setFailedLoginAttempts(const Wt::Auth::User & user, int count) {
+void UserDatabase::setFailedLoginAttempts(const Wt::Auth::User & user, int count) {
     //    _userAuth.setFailedLoginAttempts({user.id()}, count);
 }
 
-int PgUserAuth::failedLoginAttempts(const Wt::Auth::User & user) const {
+int UserDatabase::failedLoginAttempts(const Wt::Auth::User & user) const {
     //    return _userAuth.failedLoginAttempts({user.id()});
 }
 
-void PgUserAuth::setLastLoginAttempt(const Wt::Auth::User &, const Wt::WDateTime &) {}
+void UserDatabase::setLastLoginAttempt(const Wt::Auth::User &, const Wt::WDateTime &) {}
 
-Wt::WDateTime PgUserAuth::lastLoginAttempt(const Wt::Auth::User & user) const {
+Wt::WDateTime UserDatabase::lastLoginAttempt(const Wt::Auth::User & user) const {
     //    const auto time    = _userAuth.lastLoginAttempt({user.id()});
     //    const auto systime = std::chrono::system_clock::to_time_t(time);
     //    auto lastLogin     = Wt::WDateTime();
@@ -336,11 +335,11 @@ Wt::WDateTime PgUserAuth::lastLoginAttempt(const Wt::Auth::User & user) const {
     //    return lastLogin;
 }
 
-void PgUserAuth::logout(const Wt::Auth::User & user) {
+void UserDatabase::logout(const Wt::Auth::User & user) {
     //    _userAuth.logout({user.id()});
 }
 
-AbstractUserDatabase::Transaction * PgUserAuth::startTransaction() {
+AbstractUserDatabase::Transaction * UserDatabase::startTransaction() {
     auto commit_create_user = [priv = _priv.get()]() {
         if(priv->_registration) {
             assert(priv->_email.has_value() || priv->_unverifiedEmail.has_value());

src/libs/db/postgresql_connector/CMakeLists.txt

@@ -9,7 +9,7 @@ find_package(Sqlpp-connector-postgresql REQUIRED)
 add_library(${LIB} ${postgres_connector_SOURCE})
 
 # link all
-target_include_directories (${LIB}
+target_include_directories ( ${LIB}
     PRIVATE ${CMAKE_BINARY_DIR}/external/include SYSTEM
     PRIVATE ${PostgreSQL_INCLUDE_DIRS}
 )

src/libs/db/postgresql_connector/include/eedb/db/pg/config.hpp

@@ -4,10 +4,6 @@
 
 #include <functional>
 
-namespace Wt {
-class WEnvironment;
-} // namespace Wt
-
 namespace eedb::db {
 
 class PgConfig : public sqlpp::postgresql::connection_config {

src/libs/eedb/CMakeLists.txt

@@ -1,6 +1,6 @@
 set(LIB eedb)
 
-file(GLOB_RECURSE eedb_SOURCE src/dummy*)
+file(GLOB_RECURSE eedb_SOURCE src/*)
 
 # find packages
 find_package(nlohmann_json CONFIG REQUIRED)
@@ -16,8 +16,13 @@ target_include_directories(${LIB}
 target_link_libraries(${LIB}
     PUBLIC Boost::system
     PUBLIC Boost::filesystem
+    PUBLIC Boost::thread
+    PUBLIC Boost::program_options
     PUBLIC stdc++fs
     PUBLIC nlohmann_json
+    PRIVATE auth
+    PRIVATE postgres_connector
+    PRIVATE widgets
 )
 
 # add cotire

src/libs/eedb/include/eedb/Session.hpp

@@ -1,7 +1,7 @@
 #pragma once
 
 namespace eedb::auth {
-class PgUserAuth;
+class UserDatabase;
 }
 
 namespace eedb::db {

src/libs/eedb/include/eedb/WebSession.hpp

@@ -6,7 +6,7 @@
 #include <eedb/Session.hpp>
 
 namespace eedb::auth {
-class PgUserAuth;
+class UserDatabase;
 }
 
 namespace eedb::db {

src/libs/eedb/src/EEDB.cpp

@@ -3,10 +3,10 @@
 #include <eedb/Session.hpp>
 #include <eedb/auth/PgUserAuth.hpp>
 #include <eedb/db/pg/connection.hpp>
-#include <eedb/widgets/AuthPage.hpp>
-#include <eedb/widgets/BootstrapTheme.hpp>
-#include <eedb/widgets/HomePage.hpp>
-#include <eedb/widgets/Theme.hpp>
+#include <widget/AuthPage.hpp>
+#include <widget/BootstrapTheme.hpp>
+#include <widget/HomePage.hpp>
+#include <widget/Theme.hpp>
 
 #include <memory>
 

src/libs/widgets/CMakeLists.txt

@@ -9,7 +9,10 @@ find_package(Wt REQUIRED)
 add_library(${LIB} ${widget_SOURCE})
 
 # link all
-target_include_directories(${LIB} PUBLIC include)
+target_include_directories(${LIB}
+    PUBLIC include
+)
+
 target_link_libraries(${LIB}
     PUBLIC eedb
     PUBLIC auth