Rename table models to singular

doc/.gitignore

@@ -0,0 +1 @@
+html

src/cpp/HTTPInterface/AdminCheckUserBackup.cpp

@@ -10,7 +10,7 @@
 #include "../Crypto/KeyPair.h"
 #include "../SingletonManager/ConnectionManager.h"
 
-#include "../controller/UserBackups.h"
+#include "../controller/UserBackup.h"
 
 #include "Poco/Data/Binding.h"
 using namespace Poco::Data::Keywords;
@@ -20,7 +20,7 @@ typedef Poco::Tuple<int, Poco::Nullable<Poco::Data::BLOB>, std::string> UserBack
 struct SListEntry 
 {
 	Poco::AutoPtr<controller::User> user;
-	std::vector<Poco::AutoPtr<controller::UserBackups>> backups;
+	std::vector<Poco::AutoPtr<controller::UserBackup>> backups;
 };
 
 #line 1 "F:\\Gradido\\gradido_login_server\\src\\cpsp\\header_old.cpsp"
@@ -94,7 +94,7 @@ void AdminCheckUserBackup::handleRequest(Poco::Net::HTTPServerRequest& request,
 			SListEntry entry;
 			entry.user = controller::User::create();
 			entry.user->load(user_id);
-			entry.backups = controller::UserBackups::load(user_id);
+			entry.backups = controller::UserBackup::load(user_id);
 			
 			notMatchingEntrys.push_back(entry);
 			

src/cpp/HTTPInterface/AdminUserPasswordReset.cpp

@@ -10,7 +10,7 @@
 // includes
 #include "../controller/User.h"
 #include "../controller/EmailVerificationCode.h"
-#include "../controller/UserBackups.h"
+#include "../controller/UserBackup.h"
 
 
 enum PageState
@@ -43,7 +43,7 @@ void AdminUserPasswordReset::handleRequest(Poco::Net::HTTPServerRequest& request
 	PageState state = PAGE_ASK_EMAIL;
 	Poco::AutoPtr<controller::User> user = controller::User::create();
 	Poco::AutoPtr<controller::EmailVerificationCode> code;
-	Poco::AutoPtr<controller::UserBackups> userBackup;
+	Poco::AutoPtr<controller::UserBackup> userBackup;
 	bool validUser = false;
 	std::string pageName = "Admin User Passwort Reset";
 	
@@ -69,7 +69,7 @@ void AdminUserPasswordReset::handleRequest(Poco::Net::HTTPServerRequest& request
 			}
 		}
 		
-		auto backups = controller::UserBackups::load(userId);
+		auto backups = controller::UserBackup::load(userId);
 		auto userPubkey = user->getModel()->getPublicKey();
 		for(auto it = backups.begin(); it != backups.end(); it++) {
 			auto keys = (*it)->getKeyPair();
@@ -235,7 +235,7 @@ void AdminUserPasswordReset::handleRequest(Poco::Net::HTTPServerRequest& request
 	responseStream << "Bitte schreibe sie dir auf und packe sie gut weg.\n";
 	responseStream << "\n";
 #line 105 "F:\\Gradido\\gradido_login_server\\src\\cpsp\\adminUserPasswordReset.cpsp"
-	responseStream << ( controller::UserBackups::formatPassphrase(userBackup->getPassphrase(ServerConfig::Mnemonic_Types::MNEMONIC_GRADIDO_BOOK_GERMAN_RANDOM_ORDER)) );
+	responseStream << ( controller::UserBackup::formatPassphrase(userBackup->getPassphrase(ServerConfig::Mnemonic_Types::MNEMONIC_GRADIDO_BOOK_GERMAN_RANDOM_ORDER)) );
 	responseStream << "\n";
 	responseStream << " \n";
 	responseStream << "\n";

src/cpp/HTTPInterface/RepairDefectPassphrase.cpp

@@ -13,7 +13,7 @@
 #include "../Crypto/Passphrase.h"
 #include "../Crypto/KeyPairEd25519.h"
 #include "../lib/DataTypeConverter.h"
-#include "../controller/UserBackups.h"
+#include "../controller/UserBackup.h"
 #include "../tasks/SigningTransaction.h"
 #include "../ServerConfig.h"
 
@@ -85,7 +85,7 @@ void RepairDefectPassphrase::handleRequest(Poco::Net::HTTPServerRequest& request
 			else 
 			{	
 				mSession->setPassphrase(passphrase);
-				auto newPassphraseModel = controller::UserBackups::create(
+				auto newPassphraseModel = controller::UserBackup::create(
 					user_model->getID(),
 					passphrase->getString(),
 					ServerConfig::MNEMONIC_GRADIDO_BOOK_GERMAN_RANDOM_ORDER_FIXED_CASES

src/cpp/HTTPInterface/ResetPassword.cpp

@@ -11,7 +11,7 @@
 #include "../SingletonManager/SessionManager.h"
 #include "../SingletonManager/EmailManager.h"
 #include "../controller/User.h"
-#include "../controller/UserBackups.h"
+#include "../controller/UserBackup.h"
 
 enum PageState {
 	PAGE_EMAIL_ASK,

src/cpp/controller/User.cpp

@@ -1,5 +1,5 @@
 #include "User.h"
-#include "UserBackups.h"
+#include "UserBackup.h"
 
 #include "sodium.h"
 
@@ -299,7 +299,7 @@ namespace controller {
 		auto user_model = getModel();
 		if (user_model->getID() <= 0) return -2;
 
-		auto backups = UserBackups::load(user_model->getID());
+		auto backups = UserBackup::load(user_model->getID());
 		if (backups.size() == 0) return -1;
 		for (auto it = backups.begin(); it != backups.end(); it++) {
 			auto user_backup = *it;

src/cpp/controller/UserBackup.cpp

@@ -1,14 +1,14 @@
-#include "UserBackups.h"
+#include "UserBackup.h"
 
 #include "../Crypto/Passphrase.h"
 
 namespace controller {
-	UserBackups::UserBackups(model::table::UserBackups* dbModel)
+	UserBackup::UserBackup(model::table::UserBackup* dbModel)
 	{
 		mDBModel = dbModel;
 	}
 
-	UserBackups::~UserBackups()
+	UserBackup::~UserBackup()
 	{
 
 	}
@@ -17,20 +17,20 @@ namespace controller {
 
 	//  ---------------   static members ----------------------------- 
 
-	Poco::AutoPtr<UserBackups> UserBackups::create(int user_id, const std::string& passphrase, ServerConfig::Mnemonic_Types type)
+	Poco::AutoPtr<UserBackup> UserBackup::create(int user_id, const std::string& passphrase, ServerConfig::Mnemonic_Types type)
 	{
 		
-		auto db = new model::table::UserBackups(user_id, passphrase, type);
+		auto db = new model::table::UserBackup(user_id, passphrase, type);
-		return Poco::AutoPtr<UserBackups>(new UserBackups(db));
+		return Poco::AutoPtr<UserBackup>(new UserBackup(db));
 	}
 
 
-	std::vector<Poco::AutoPtr<UserBackups>> UserBackups::load(int user_id)
+	std::vector<Poco::AutoPtr<UserBackup>> UserBackup::load(int user_id)
 	{
-		auto db = new model::table::UserBackups();
+		auto db = new model::table::UserBackup();
 		auto results = db->loadFromDB<int, model::table::UserBackupsTuple>("user_id", user_id, 1);
 
-		std::vector<Poco::AutoPtr<UserBackups>> resultObjects;
+		std::vector<Poco::AutoPtr<UserBackup>> resultObjects;
 		if (db->errorCount()) {
 			db->sendErrorsAsEmail();
 			db->release();
@@ -41,14 +41,14 @@ namespace controller {
 			return resultObjects;
 		}
 		for (auto it = results.begin(); it != results.end(); it++) {
-			resultObjects.push_back(new UserBackups(new model::table::UserBackups(*it)));
+			resultObjects.push_back(new UserBackup(new model::table::UserBackup(*it)));
 		}
 
 		return resultObjects;
 
 	}
 
-	Poco::SharedPtr<KeyPair> UserBackups::getKeyPair()
+	Poco::SharedPtr<KeyPair> UserBackup::getKeyPair()
 	{
 		if (!mKeyPair.isNull()) {
 			return mKeyPair;
@@ -61,7 +61,7 @@ namespace controller {
 		return mKeyPair;
 	}
 
-	KeyPairEd25519* UserBackups::createGradidoKeyPair()
+	KeyPairEd25519* UserBackup::createGradidoKeyPair()
 	{
 		auto model = getModel();
 		auto mnemonicType = model->getMnemonicType();
@@ -71,7 +71,7 @@ namespace controller {
 		return KeyPairEd25519::create(passphrase);
 	}
 
-	std::string UserBackups::getPassphrase(ServerConfig::Mnemonic_Types type)
+	std::string UserBackup::getPassphrase(ServerConfig::Mnemonic_Types type)
 	{
 		if ((int)type < 0 || (int)type >= ServerConfig::Mnemonic_Types::MNEMONIC_MAX) {
 			return "<invalid type>";
@@ -96,7 +96,7 @@ namespace controller {
 		
 	}
 
-	std::string UserBackups::formatPassphrase(std::string passphrase, int targetLinesCount/* = 5*/) 
+	std::string UserBackup::formatPassphrase(std::string passphrase, int targetLinesCount/* = 5*/) 
 	{
 		int count = passphrase.size();
 		int charPerLine = count / (targetLinesCount);

src/cpp/controller/UserBackup.h

@@ -1,7 +1,7 @@
 #ifndef GRADIDO_LOGIN_SERVER_CONTROLLER_USER_BACKUPS_INCLUDE
 #define GRADIDO_LOGIN_SERVER_CONTROLLER_USER_BACKUPS_INCLUDE
 
-#include "../model/table/UserBackups.h"
+#include "../model/table/UserBackup.h"
 #include "../Crypto/KeyPair.h"
 #include "../Crypto/KeyPairEd25519.h"
 
@@ -10,19 +10,19 @@
 #include "TableControllerBase.h"
 
 namespace controller {
-	class UserBackups : public TableControllerBase
+	class UserBackup : public TableControllerBase
 	{
 	public:
 
-		~UserBackups();
+		~UserBackup();
 
-		static Poco::AutoPtr<UserBackups> create(int user_id, const std::string& passphrase, ServerConfig::Mnemonic_Types type);
+		static Poco::AutoPtr<UserBackup> create(int user_id, const std::string& passphrase, ServerConfig::Mnemonic_Types type);
 
-		static std::vector<Poco::AutoPtr<UserBackups>> load(int user_id);
+		static std::vector<Poco::AutoPtr<UserBackup>> load(int user_id);
 
 		inline bool deleteFromDB() { return mDBModel->deleteFromDB(); }
 
-		inline Poco::AutoPtr<model::table::UserBackups> getModel() { return _getModel<model::table::UserBackups>(); }
+		inline Poco::AutoPtr<model::table::UserBackup> getModel() { return _getModel<model::table::UserBackup>(); }
 
 		//! depracted
 		//! \return create keyPair from passphrase if not exist, else return existing pointer
@@ -37,7 +37,7 @@ namespace controller {
 		std::string getPassphrase(ServerConfig::Mnemonic_Types type);
 
 	protected:
-		UserBackups(model::table::UserBackups* dbModel);
+		UserBackup(model::table::UserBackup* dbModel);
 		Poco::SharedPtr<KeyPair> mKeyPair;
 		
 	};

src/cpp/model/Session.cpp

@@ -24,7 +24,7 @@
 
 
 #include "../controller/User.h"
-#include "../controller/UserBackups.h"
+#include "../controller/UserBackup.h"
 #include "../controller/EmailVerificationCode.h"
 
 #include "table/ModelBase.h"
@@ -777,7 +777,7 @@ UserStates Session::loadUser(const std::string& email, const std::string& passwo
 		if (-2 == loginResult) {
 			// check if we have access to the passphrase, if so we can reencrypt the private key
 			auto user_model = mNewUser->getModel();
-			auto user_backups = controller::UserBackups::load(user_model->getID());
+			auto user_backups = controller::UserBackup::load(user_model->getID());
 			for (auto it = user_backups.begin(); it != user_backups.end(); it++) {
 				auto key = std::unique_ptr<KeyPairEd25519>((*it)->createGradidoKeyPair());
 				if (key->isTheSame(user_model->getPublicKey())) 
@@ -941,7 +941,7 @@ void Session::detectSessionState()
 	if (USER_NO_KEYS == userState) {
 		
 		auto user_id = mSessionUser->getDBId();
-		auto userBackups = controller::UserBackups::load(user_id);
+		auto userBackups = controller::UserBackup::load(user_id);
 
 		// check passphrase, only possible while passphrase isn't crypted in db
 		bool correctPassphraseFound = false;
@@ -1157,7 +1157,7 @@ bool Session::generateKeys(bool savePrivkey, bool savePassphrase)
 	}
 
 	if (savePassphrase) {
-		auto user_backup = controller::UserBackups::create(user_model->getID(), passphrase->getString(), mnemonic_type);
+		auto user_backup = controller::UserBackup::create(user_model->getID(), passphrase->getString(), mnemonic_type);
 		// sync version
 		//user_backup->getModel()->insertIntoDB(false);	
 

src/cpp/model/User.cpp

@@ -12,7 +12,7 @@
 #include "../SingletonManager/LanguageManager.h"
 #include "../SingletonManager/SingletonTaskObserver.h"
 
-#include "../controller/UserBackups.h"
+#include "../controller/UserBackup.h"
 
 
 #include "Poco/Data/Binding.h"
@@ -1090,7 +1090,7 @@ MemoryBin* User::sign(const unsigned char* message, size_t messageSize)
 		//addError(new Error("User::sign", "decrypt privkey failed"));
 		
 
-		auto userBackups = controller::UserBackups::load(mDBId);
+		auto userBackups = controller::UserBackup::load(mDBId);
 
 		// get privkey, only possible while passphrase isn't crypted in db
 		bool correctPassphraseFound = false;

src/cpp/model/table/CryptoKey.cpp

@@ -1,20 +1,20 @@
-#include "CryptoKeys.h"
+#include "CryptoKey.h"
 #include "../../lib/DataTypeConverter.h"
 using namespace Poco::Data::Keywords;
 
 namespace model {
 	namespace table {
-		CryptoKeys::CryptoKeys()
+		CryptoKey::CryptoKey()
 		{
 
 		}
 
-		CryptoKeys::~CryptoKeys()
+		CryptoKey::~CryptoKey()
 		{
 
 		}
 
-		std::string CryptoKeys::toString()
+		std::string CryptoKey::toString()
 		{
 			assert(mKeyType < KEY_TYPE_COUNT && mKeyType >= 0);
 			std::stringstream ss;
@@ -24,7 +24,7 @@ namespace model {
 		}
 
 
-		const char* CryptoKeys::typeToString(KeyType type)
+		const char* CryptoKey::typeToString(KeyType type)
 		{
 			switch (type) {
 			case KEY_TYPE_ED25519_REF10: return "ed25519 ref10";
@@ -33,7 +33,7 @@ namespace model {
 			return "<unknown type>";
 		}
 
-		Poco::Data::Statement CryptoKeys::_loadFromDB(Poco::Data::Session session, const std::string& fieldName)
+		Poco::Data::Statement CryptoKey::_loadFromDB(Poco::Data::Session session, const std::string& fieldName)
 		{
 			Poco::Data::Statement select(session);
 
@@ -44,7 +44,7 @@ namespace model {
 			return select;
 		}
 
-		Poco::Data::Statement CryptoKeys::_loadIdFromDB(Poco::Data::Session session)
+		Poco::Data::Statement CryptoKey::_loadIdFromDB(Poco::Data::Session session)
 		{
 			Poco::Data::Statement select(session);
 			lock();
@@ -56,7 +56,7 @@ namespace model {
 		}
 	
 		
-		Poco::Data::Statement CryptoKeys::_insertIntoDB(Poco::Data::Session session)
+		Poco::Data::Statement CryptoKey::_insertIntoDB(Poco::Data::Session session)
 		{
 			Poco::Data::Statement insert(session);
 			lock();

src/cpp/model/table/CryptoKey.h

@@ -13,11 +13,11 @@ namespace model {
 			KEY_TYPE_COUNT
 		};
 
-		class CryptoKeys : public ModelBase
+		class CryptoKey : public ModelBase
 		{
 		public:
-			CryptoKeys();
+			CryptoKey();
-			~CryptoKeys();
+			~CryptoKey();
 
 			// generic db operations
 			const char* getTableName() const { return "crypto_keys"; }

src/cpp/model/table/Group.cpp

@@ -1,19 +1,19 @@
-#include "Groups.h"
+#include "Group.h"
 
 using namespace Poco::Data::Keywords;
 
 namespace model {
 	namespace table {
-		Groups::Groups()
+		Group::Group()
 		{ 
 		}
 
-		Groups::~Groups() 
+		Group::~Group() 
 		{
 
 		}
 
-		std::string Groups::toString()
+		std::string Group::toString()
 		{
 			std::stringstream ss;
 			ss << "Alias: " << mAlias << std::endl;
@@ -22,7 +22,7 @@ namespace model {
 			return ss.str();
 		}
 
-		Poco::Data::Statement Groups::_loadFromDB(Poco::Data::Session session, const std::string& fieldName)
+		Poco::Data::Statement Group::_loadFromDB(Poco::Data::Session session, const std::string& fieldName)
 		{
 			Poco::Data::Statement select(session);
 
@@ -32,7 +32,7 @@ namespace model {
 
 			return select;
 		}
-		Poco::Data::Statement Groups::_loadIdFromDB(Poco::Data::Session session)
+		Poco::Data::Statement Group::_loadIdFromDB(Poco::Data::Session session)
 		{
 			Poco::Data::Statement select(session);
 			lock();
@@ -43,7 +43,7 @@ namespace model {
 			return select;
 
 		}
-		Poco::Data::Statement Groups::_insertIntoDB(Poco::Data::Session session)
+		Poco::Data::Statement Group::_insertIntoDB(Poco::Data::Session session)
 		{
 			Poco::Data::Statement insert(session);
 			lock();

src/cpp/model/table/Group.h

@@ -6,11 +6,11 @@
 namespace model {
 	namespace table {
 
-		class Groups : public ModelBase
+		class Group : public ModelBase
 		{
 		public:
-			Groups();
+			Group();
-			~Groups();
+			~Group();
 
 			// generic db operations
 			const char* getTableName() const { return "groups"; }

src/cpp/model/table/HederaAccount.cpp

@@ -1,21 +1,21 @@
-#include "HederaAccounts.h"
+#include "HederaAccount.h"
 
 using namespace Poco::Data::Keywords;
 
 namespace model {
 	namespace table {
 
-		HederaAccounts::HederaAccounts()
+		HederaAccount::HederaAccount()
 		{
 
 		}
 
-		HederaAccounts::~HederaAccounts()
+		HederaAccount::~HederaAccount()
 		{
 
 		}
 
-		std::string HederaAccounts::toString()
+		std::string HederaAccount::toString()
 		{
 			std::stringstream ss;
 			ss << "user id: " << std::to_string(mUserId) << std::endl;
@@ -28,7 +28,7 @@ namespace model {
 			return ss.str();
 		}
 
-		Poco::Data::Statement HederaAccounts::_loadFromDB(Poco::Data::Session session, const std::string& fieldName)
+		Poco::Data::Statement HederaAccount::_loadFromDB(Poco::Data::Session session, const std::string& fieldName)
 		{
 			Poco::Data::Statement select(session);
 
@@ -39,7 +39,16 @@ namespace model {
 			return select;
 
 		}
-		Poco::Data::Statement HederaAccounts::_loadIdFromDB(Poco::Data::Session session)
+
+		Poco::Data::Statement HederaAccount::_loadMultipleFromDB(Poco::Data::Session session, const std::string& fieldName)
+		{
+			Poco::Data::Statement select(session);
+			select << "SELECT id, user_id, account_hedera_id, account_key_id, balance, updated FROM " << getTableName()
+				<< " where " << fieldName << " LIKE ?";
+
+			return select;
+		}
+		Poco::Data::Statement HederaAccount::_loadIdFromDB(Poco::Data::Session session)
 		{
 			Poco::Data::Statement select(session);
 			lock();
@@ -49,7 +58,7 @@ namespace model {
 			unlock();
 			return select;
 		}
-		Poco::Data::Statement HederaAccounts::_insertIntoDB(Poco::Data::Session session)
+		Poco::Data::Statement HederaAccount::_insertIntoDB(Poco::Data::Session session)
 		{
 			Poco::Data::Statement insert(session);
 			lock();
@@ -59,5 +68,7 @@ namespace model {
 			unlock();
 			return insert;
 		}
+
+		
 	}
 }

src/cpp/model/table/HederaAccount.h

@@ -2,15 +2,18 @@
 #define GRADIDO_LOGIN_SERVER_MODEL_TABLE_HEDERA_ACCOUNTS_INCLUDE
 
 #include "ModelBase.h"
+#include "Poco/Tuple.h"
 
 namespace model {
 	namespace table {
 
-		class HederaAccounts : public ModelBase
+		typedef Poco::Tuple<int, int, int, Poco::UInt64, Poco::DateTime> HederaAccountsTuple;
+
+		class HederaAccount : public ModelBase
 		{
 		public:
-			HederaAccounts();
+			HederaAccount();
-			~HederaAccounts();
+			~HederaAccount();
 
 			// generic db operations
 			const char* getTableName() const { return "hedera_accounts"; }
@@ -19,6 +22,7 @@ namespace model {
 
 		protected:
 			Poco::Data::Statement _loadFromDB(Poco::Data::Session session, const std::string& fieldName);
+			Poco::Data::Statement _loadMultipleFromDB(Poco::Data::Session session, const std::string& fieldName);
 			Poco::Data::Statement _loadIdFromDB(Poco::Data::Session session);
 			Poco::Data::Statement _insertIntoDB(Poco::Data::Session session);
 

src/cpp/model/table/HederaId.cpp

@@ -1,20 +1,20 @@
-#include "HederaIds.h"
+#include "HederaId.h"
 
 using namespace Poco::Data::Keywords;
 
 namespace model {
 	namespace table {
-		HederaIds::HederaIds()
+		HederaId::HederaId()
 		{
 
 		}
 
-		HederaIds::~HederaIds()
+		HederaId::~HederaId()
 		{
 
 		}
 
-		std::string HederaIds::toString()
+		std::string HederaId::toString()
 		{
 			std::stringstream ss;
 			ss << "Shard Num: " << std::to_string(mShardNum) << std::endl;
@@ -23,7 +23,7 @@ namespace model {
 			return ss.str();
 		}
 
-		Poco::Data::Statement HederaIds::_loadFromDB(Poco::Data::Session session, const std::string& fieldName)
+		Poco::Data::Statement HederaId::_loadFromDB(Poco::Data::Session session, const std::string& fieldName)
 		{
 
 			Poco::Data::Statement select(session);
@@ -34,7 +34,7 @@ namespace model {
 
 			return select;
 		}
-		Poco::Data::Statement HederaIds::_loadIdFromDB(Poco::Data::Session session)
+		Poco::Data::Statement HederaId::_loadIdFromDB(Poco::Data::Session session)
 		{
 			Poco::Data::Statement select(session);
 			lock();
@@ -44,7 +44,7 @@ namespace model {
 			unlock();
 			return select;
 		}
-		Poco::Data::Statement HederaIds::_insertIntoDB(Poco::Data::Session session)
+		Poco::Data::Statement HederaId::_insertIntoDB(Poco::Data::Session session)
 		{
 			Poco::Data::Statement insert(session);
 			lock();

src/cpp/model/table/HederaId.h

@@ -7,11 +7,11 @@
 namespace model {
 	namespace table {
 
-		class HederaIds : public ModelBase
+		class HederaId : public ModelBase
 		{
 		public:
-			HederaIds();
+			HederaId();
-			~HederaIds();
+			~HederaId();
 
 			// generic db operations
 			const char* getTableName() const { return "hedera_ids"; }

src/cpp/model/table/HederaTopic.cpp

@@ -1,20 +1,20 @@
-#include "HederaTopics.h"
+#include "HederaTopic.h"
 
 using namespace Poco::Data::Keywords;
 
 namespace model {
 	namespace table {
-		HederaTopics::HederaTopics()
+		HederaTopic::HederaTopic()
 		{
 
 		}
 
-		HederaTopics::~HederaTopics()
+		HederaTopic::~HederaTopic()
 		{
 
 		}
 
-		std::string HederaTopics::toString()
+		std::string HederaTopic::toString()
 		{
 			std::stringstream ss;
 			ss << "Topic Hedera id: " << std::to_string(mTopicHederaId) << std::endl;
@@ -29,7 +29,7 @@ namespace model {
 			return ss.str();
 		}
 
-		Poco::Data::Statement HederaTopics::_loadFromDB(Poco::Data::Session session, const std::string& fieldName)
+		Poco::Data::Statement HederaTopic::_loadFromDB(Poco::Data::Session session, const std::string& fieldName)
 		{
 			Poco::Data::Statement select(session);
 
@@ -42,7 +42,7 @@ namespace model {
 			return select;
 
 		}
-		Poco::Data::Statement HederaTopics::_loadIdFromDB(Poco::Data::Session session)
+		Poco::Data::Statement HederaTopic::_loadIdFromDB(Poco::Data::Session session)
 		{
 			Poco::Data::Statement select(session);
 			lock();
@@ -52,7 +52,7 @@ namespace model {
 			unlock();
 			return select;
 		}
-		Poco::Data::Statement HederaTopics::_insertIntoDB(Poco::Data::Session session)
+		Poco::Data::Statement HederaTopic::_insertIntoDB(Poco::Data::Session session)
 		{
 			Poco::Data::Statement insert(session);
 			lock();

src/cpp/model/table/HederaTopic.h

@@ -6,11 +6,11 @@
 namespace model {
 	namespace table {
 
-		class HederaTopics : public ModelBase
+		class HederaTopic : public ModelBase
 		{
 		public:
-			HederaTopics();
+			HederaTopic();
-			~HederaTopics();
+			~HederaTopic();
 
 			// generic db operations
 			const char* getTableName() const { return "hedera_topics"; }

src/cpp/model/table/User.cpp

@@ -315,7 +315,7 @@ namespace model {
 			ss << "created: " << Poco::DateTimeFormatter::format(mCreated, "%f.%m.%Y %H:%M:%S") << "<br>";
 			ss << "email checked: " << mEmailChecked << "<br>";
 			ss << "language key: " << mLanguageKey << "<br>";
-			ss << "role: " << UserRoles::typeToString(getRole()) << "<br>";
+			ss << "role: " << UserRole::typeToString(getRole()) << "<br>";
 			ss << "disabled: " << mDisabled << "<br>";
 
 			mm->releaseMemory(pubkeyHex);
@@ -357,7 +357,7 @@ namespace model {
 			userObj.set("ident_hash", DRMakeStringHash(mEmail.data(), mEmail.size()));
 			userObj.set("disabled", mDisabled);
 			try {
-				userObj.set("role", UserRoles::typeToString(getRole()));
+				userObj.set("role", UserRole::typeToString(getRole()));
 			}
 			catch (Poco::Exception ex) {
 				addError(new ParamError("User::getJson", "exception by getting role", ex.displayText().data()));

src/cpp/model/table/User.h

@@ -11,7 +11,7 @@
 
 #include <shared_mutex>
 
-#include "UserRoles.h"
+#include "UserRole.h"
 
 namespace model {
 	namespace table {

src/cpp/model/table/UserBackup.cpp

@@ -1,4 +1,4 @@
-#include "UserBackups.h"
+#include "UserBackup.h"
 #include "../../controller/User.h"
 
 using namespace Poco::Data::Keywords;
@@ -6,31 +6,31 @@ using namespace Poco::Data::Keywords;
 namespace model {
 	namespace table {
 
-		UserBackups::UserBackups()
+		UserBackup::UserBackup()
 			: mUserId(0), mMnemonicType(0)
 		{
 			detectMnemonic();
 		}
 
-		UserBackups::UserBackups(int user_id, const std::string& passphrase, ServerConfig::Mnemonic_Types type)
+		UserBackup::UserBackup(int user_id, const std::string& passphrase, ServerConfig::Mnemonic_Types type)
 			: mUserId(user_id), mPassphrase(passphrase), mMnemonicType(type)
 		{
 			detectMnemonic();
 		}
 
 
-		UserBackups::UserBackups(const UserBackupsTuple& tuple)
+		UserBackup::UserBackup(const UserBackupsTuple& tuple)
 			: ModelBase(tuple.get<0>()), mUserId(tuple.get<1>()), mPassphrase(tuple.get<2>()), mMnemonicType(tuple.get<3>())
 		{
 			detectMnemonic();
 		}
 
-		UserBackups::~UserBackups()
+		UserBackup::~UserBackup()
 		{
 
 		}
 
-		Poco::Data::Statement UserBackups::_insertIntoDB(Poco::Data::Session session)
+		Poco::Data::Statement UserBackup::_insertIntoDB(Poco::Data::Session session)
 		{
 			Poco::Data::Statement insert(session);
 
@@ -43,7 +43,7 @@ namespace model {
 		}
 
 
-		Poco::Data::Statement UserBackups::_loadFromDB(Poco::Data::Session session, const std::string& fieldName)
+		Poco::Data::Statement UserBackup::_loadFromDB(Poco::Data::Session session, const std::string& fieldName)
 		{
 			Poco::Data::Statement select(session);
 
@@ -55,7 +55,7 @@ namespace model {
 			return select;
 		}
 
-		Poco::Data::Statement UserBackups::_loadIdFromDB(Poco::Data::Session session)
+		Poco::Data::Statement UserBackup::_loadIdFromDB(Poco::Data::Session session)
 		{
 			Poco::Data::Statement select(session);
 
@@ -66,7 +66,7 @@ namespace model {
 			return select;
 		}
 
-		Poco::Data::Statement UserBackups::_loadMultipleFromDB(Poco::Data::Session session, const std::string& fieldName)
+		Poco::Data::Statement UserBackup::_loadMultipleFromDB(Poco::Data::Session session, const std::string& fieldName)
 		{
 			Poco::Data::Statement select(session);
 
@@ -77,7 +77,7 @@ namespace model {
 			return select;
 		}
 
-		Poco::Data::Statement UserBackups::_loadFromDB(Poco::Data::Session session, const std::vector<std::string>& fieldNames, MysqlConditionType conditionType/* = MYSQL_CONDITION_AND*/)
+		Poco::Data::Statement UserBackup::_loadFromDB(Poco::Data::Session session, const std::vector<std::string>& fieldNames, MysqlConditionType conditionType/* = MYSQL_CONDITION_AND*/)
 		{
 			Poco::Data::Statement select(session);
 			if (fieldNames.size() <= 1) {
@@ -107,7 +107,7 @@ namespace model {
 		}
 
 		// generic db operations
-		std::string UserBackups::toString()
+		std::string UserBackup::toString()
 		{
 			std::stringstream ss;
 			ss << "user_id: " << mUserId << std::endl;
@@ -116,7 +116,7 @@ namespace model {
 			return ss.str();
 		}
 
-		void UserBackups::detectMnemonic()
+		void UserBackup::detectMnemonic()
 		{
 			if (mMnemonicType == -1) {
 				const static char* function_name = "UserBackups::detectMnemonic";

src/cpp/model/table/UserBackup.h

@@ -9,13 +9,13 @@ namespace model {
 
 		typedef Poco::Tuple<int, int, std::string, int> UserBackupsTuple;
 
-		class UserBackups : public ModelBase
+		class UserBackup : public ModelBase
 		{
 		public:
-			UserBackups(int user_id, const std::string& passphrase, ServerConfig::Mnemonic_Types type);
+			UserBackup(int user_id, const std::string& passphrase, ServerConfig::Mnemonic_Types type);
-			UserBackups(const UserBackupsTuple& tuple);
+			UserBackup(const UserBackupsTuple& tuple);
-			UserBackups();
+			UserBackup();
-			~UserBackups();
+			~UserBackup();
 
 			// generic db operations
 			const char* getTableName() const { return "user_backups"; }

src/cpp/model/table/UserRole.cpp

@@ -1,4 +1,4 @@
-#include "UserRoles.h"
+#include "UserRole.h"
 
 using namespace Poco::Data::Keywords;
 
@@ -6,28 +6,28 @@ namespace model {
 	namespace table {
 
 
-		UserRoles::UserRoles(int user_id, RoleType type)
+		UserRole::UserRole(int user_id, RoleType type)
 			: mUserId(user_id), mType(type)
 		{
 
 		}
 
-		UserRoles::UserRoles(const UserRolesTuple& tuple)
+		UserRole::UserRole(const UserRolesTuple& tuple)
 			: ModelBase(tuple.get<0>()), mUserId(tuple.get<1>()), mType(tuple.get<2>())
 		{
 
 		}
-		UserRoles::UserRoles()
+		UserRole::UserRole()
 		{
 
 		}
 
-		UserRoles::~UserRoles()
+		UserRole::~UserRole()
 		{
 
 		}
 
-		Poco::Data::Statement UserRoles::_insertIntoDB(Poco::Data::Session session)
+		Poco::Data::Statement UserRole::_insertIntoDB(Poco::Data::Session session)
 		{
 			Poco::Data::Statement insert(session);
 
@@ -40,7 +40,7 @@ namespace model {
 		}
 
 
-		Poco::Data::Statement UserRoles::_loadFromDB(Poco::Data::Session session, const std::string& fieldName)
+		Poco::Data::Statement UserRole::_loadFromDB(Poco::Data::Session session, const std::string& fieldName)
 		{
 			Poco::Data::Statement select(session);
 
@@ -52,7 +52,7 @@ namespace model {
 			return select;
 		}
 
-		Poco::Data::Statement UserRoles::_loadIdFromDB(Poco::Data::Session session)
+		Poco::Data::Statement UserRole::_loadIdFromDB(Poco::Data::Session session)
 		{
 			Poco::Data::Statement select(session);
 
@@ -63,7 +63,7 @@ namespace model {
 			return select;
 		}
 
-		Poco::Data::Statement UserRoles::_loadMultipleFromDB(Poco::Data::Session session, const std::string& fieldName)
+		Poco::Data::Statement UserRole::_loadMultipleFromDB(Poco::Data::Session session, const std::string& fieldName)
 		{
 			Poco::Data::Statement select(session);
 
@@ -74,7 +74,7 @@ namespace model {
 			return select;
 		}
 
-		Poco::Data::Statement UserRoles::_loadFromDB(Poco::Data::Session session, const std::vector<std::string>& fieldNames, MysqlConditionType conditionType/* = MYSQL_CONDITION_AND*/)
+		Poco::Data::Statement UserRole::_loadFromDB(Poco::Data::Session session, const std::vector<std::string>& fieldNames, MysqlConditionType conditionType/* = MYSQL_CONDITION_AND*/)
 		{
 			Poco::Data::Statement select(session);
 			if (fieldNames.size() <= 1) {
@@ -104,7 +104,7 @@ namespace model {
 		}
 
 		// generic db operations
-		std::string UserRoles::toString()
+		std::string UserRole::toString()
 		{
 			std::stringstream ss;
 			ss << "user_id: " << mUserId << std::endl;
@@ -112,7 +112,7 @@ namespace model {
 			return ss.str();
 		}
 
-		const char* UserRoles::typeToString(RoleType type)
+		const char* UserRole::typeToString(RoleType type)
 		{
 			switch (type) {
 			case ROLE_NOT_LOADED: return "not loaded";

src/cpp/model/table/UserRole.h

@@ -17,13 +17,13 @@ namespace model {
 
 		typedef Poco::Tuple<int, int, int> UserRolesTuple;
 
-		class UserRoles : public ModelBase
+		class UserRole : public ModelBase
 		{
 		public:
-			UserRoles(int user_id, RoleType type);
+			UserRole(int user_id, RoleType type);
-			UserRoles(const UserRolesTuple& tuple);
+			UserRole(const UserRolesTuple& tuple);
-			UserRoles();
+			UserRole();
-			~UserRoles();
+			~UserRole();
 
 			// generic db operations
 			const char* getTableName() const { return "user_roles"; }

src/cpsp/adminCheckUserBackup.cpsp

@@ -18,7 +18,7 @@ typedef Poco::Tuple<int, Poco::Nullable<Poco::Data::BLOB>, std::string> UserBack
 struct SListEntry 
 {
 	Poco::AutoPtr<controller::User> user;
-	std::vector<Poco::AutoPtr<controller::UserBackups>> backups;
+	std::vector<Poco::AutoPtr<controller::UserBackup>> backups;
 };
 
 %>
@@ -73,7 +73,7 @@ struct SListEntry
 			SListEntry entry;
 			entry.user = controller::User::create();
 			entry.user->load(user_id);
-			entry.backups = controller::UserBackups::load(user_id);
+			entry.backups = controller::UserBackup::load(user_id);
 			
 			notMatchingEntrys.push_back(entry);
 			

src/cpsp/adminUserPasswordReset.cpsp

@@ -21,7 +21,7 @@ enum PageState
 	PageState state = PAGE_ASK_EMAIL;
 	Poco::AutoPtr<controller::User> user = controller::User::create();
 	Poco::AutoPtr<controller::EmailVerificationCode> code;
-	Poco::AutoPtr<controller::UserBackups> userBackup;
+	Poco::AutoPtr<controller::UserBackup> userBackup;
 	bool validUser = false;
 	std::string pageName = "Admin User Passwort Reset";
 	

src/cpsp/repairDefectPassphrase.cpsp

@@ -64,7 +64,7 @@ enum PageState
 			else 
 			{	
 				mSession->setPassphrase(passphrase);
-				auto newPassphraseModel = controller::UserBackups::create(
+				auto newPassphraseModel = controller::UserBackup::create(
 					user_model->getID(),
 					passphrase->getString(),
 					ServerConfig::MNEMONIC_GRADIDO_BOOK_GERMAN_RANDOM_ORDER_FIXED_CASES