IT4Change/gradido
3
0
Fork 0
mirror of https://github.com/IT4Change/gradido.git synced 2025-12-13 07:45:54 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #641 from gradido/login_fix_crash

Browse Source 
Login fix crash
This commit is contained in:
einhornimmond 2021-07-15 14:06:40 +02:00 committed by GitHub
commit 4c9713f8fe
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
16 changed files with 146 additions and 133 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

128
login_server/src/cpp/SingletonManager/PendingTasksManager.cpp
View File

@ -15,10 +15,10 @@ PendingTasksManager::~PendingTasksManager()
Poco::ScopedLock<Poco::Mutex> _lock(mWorkMutex); Poco::ScopedLock<Poco::Mutex> _lock(mWorkMutex);
mCheckForFinishedTimer.stop(); mCheckForFinishedTimer.stop();
for (auto it = mPendingTasks.begin(); it != mPendingTasks.end(); it++) { for (auto it = mPendingGradidoTransactions.begin(); it != mPendingGradidoTransactions.end(); it++) {
delete it->second; delete it->second;
} }
mPendingTasks.clear(); mPendingGradidoTransactions.clear();
} }
PendingTasksManager* PendingTasksManager::getInstance() PendingTasksManager* PendingTasksManager::getInstance()
@ -37,31 +37,32 @@ int PendingTasksManager::load()
return 0; return 0;
} }
int PendingTasksManager::addTask(Poco::AutoPtr<controller::PendingTask> task)
int PendingTasksManager::addTask(Poco::AutoPtr<model::gradido::Transaction> gradidoTransactionTask)
{ {
if (task.isNull() || !task->getModel()) { if (gradidoTransactionTask.isNull() || !gradidoTransactionTask->getModel()) {
return -1; return -1;
} }
auto model = task->getModel(); auto model = gradidoTransactionTask->getModel();
Poco::ScopedLock<Poco::Mutex> _lock(mWorkMutex); Poco::ScopedLock<Poco::Mutex> _lock(mWorkMutex);
auto pending_task_list = getTaskListForUser(model->getUserId()); auto pending_task_list = getGradidoTransactionsForUser(model->getUserId());
pending_task_list->push_back(task); pending_task_list->push_back(gradidoTransactionTask);
return 0; return 0;
} }
bool PendingTasksManager::removeTask(Poco::AutoPtr<controller::PendingTask> task)
bool PendingTasksManager::removeTask(Poco::AutoPtr<model::gradido::Transaction> gradidoTransactionTask)
{ {
if (task.isNull() || !task->getModel()) { if (gradidoTransactionTask.isNull() || !gradidoTransactionTask->getModel()) {
return false; return false;
} }
auto model = task->getModel(); auto model = gradidoTransactionTask->getModel();
Poco::ScopedLock<Poco::Mutex> _lock(mWorkMutex); Poco::ScopedLock<Poco::Mutex> _lock(mWorkMutex);
auto pending_task_list = getTaskListForUser(model->getUserId()); auto pending_task_list = getGradidoTransactionsForUser(model->getUserId());
bool removed = false; bool removed = false;
for (auto it = pending_task_list->begin(); it != pending_task_list->end(); it++) { for (auto it = pending_task_list->begin(); it != pending_task_list->end(); it++) {
if (task.get() == it->get()) { if (gradidoTransactionTask.get() == it->get()) {
pending_task_list->erase(it); pending_task_list->erase(it);
removed = true; removed = true;
break; break;
@ -71,41 +72,42 @@ bool PendingTasksManager::removeTask(Poco::AutoPtr<controller::PendingTask> task
return removed; return removed;
} }
PendingTasksManager::PendingTaskList* PendingTasksManager::getTaskListForUser(int userId)
PendingTasksManager::PendingGradidoTaskList* PendingTasksManager::getGradidoTransactionsForUser(int userId)
{ {
Poco::ScopedLock<Poco::Mutex> _lock(mWorkMutex); Poco::ScopedLock<Poco::Mutex> _lock(mWorkMutex);
auto it = mPendingTasks.find(userId); auto it = mPendingGradidoTransactions.find(userId);
if (it == mPendingTasks.end()) { if (it == mPendingGradidoTransactions.end()) {
auto pending_list = new PendingTaskList; auto pending_list = new PendingGradidoTaskList;
mPendingTasks.insert(std::pair<int, PendingTaskList*>(userId, pending_list)); mPendingGradidoTransactions.insert(std::pair<int, PendingGradidoTaskList*>(userId, pending_list));
return pending_list; return pending_list;
} }
else { else {
return it->second; return it->second;
} }
} }
const PendingTasksManager::PendingTaskList* PendingTasksManager::getTaskListForUser(int userId) const
const PendingTasksManager::PendingGradidoTaskList* PendingTasksManager::getGradidoTransactionsForUser(int userId) const
{ {
Poco::ScopedLock<Poco::Mutex> _lock(mWorkMutex); Poco::ScopedLock<Poco::Mutex> _lock(mWorkMutex);
auto it = mPendingTasks.find(userId); auto it = mPendingGradidoTransactions.find(userId);
if (it != mPendingTasks.end()) { if (it != mPendingGradidoTransactions.end()) {
return it->second; return it->second;
} }
return nullptr; return nullptr;
} }
bool PendingTasksManager::hasPendingTask(Poco::AutoPtr<controller::User> user, model::table::TaskType type) bool PendingTasksManager::hasPendingGradidoTransaction(Poco::AutoPtr<controller::User> user, model::table::TaskType type)
{ {
auto model = user->getModel(); auto model = user->getModel();
int user_id = model->getID(); int user_id = model->getID();
Poco::ScopedLock<Poco::Mutex> _lock(mWorkMutex); Poco::ScopedLock<Poco::Mutex> _lock(mWorkMutex);
auto it = mPendingTasks.find(user_id); auto it = mPendingGradidoTransactions.find(user_id);
if (it != mPendingTasks.end()) { if (it != mPendingGradidoTransactions.end()) {
auto task_list = it->second; auto task_list = it->second;
for (auto task = task_list->begin(); task != task_list->end(); it++) { for (auto taskIt = task_list->begin(); taskIt != task_list->end(); taskIt++) {
auto task_model = (*task)->getModel(); if ((*taskIt)->getModel()->getTaskType() == type) {
if (type == task_model->getTaskType()) {
return true; return true;
} }
} }
@ -114,20 +116,21 @@ bool PendingTasksManager::hasPendingTask(Poco::AutoPtr<controller::User> user, m
} }
std::vector<Poco::AutoPtr<controller::PendingTask>> PendingTasksManager::getPendingTasks(Poco::AutoPtr<controller::User> user, model::table::TaskType type)
std::vector<Poco::AutoPtr<model::gradido::Transaction>> PendingTasksManager::getPendingGradidoTransactions(Poco::AutoPtr<controller::User> user, model::table::TaskType type)
{ {
auto model = user->getModel(); auto model = user->getModel();
int user_id = model->getID(); int user_id = model->getID();
Poco::ScopedLock<Poco::Mutex> _lock(mWorkMutex); Poco::ScopedLock<Poco::Mutex> _lock(mWorkMutex);
std::vector<Poco::AutoPtr<controller::PendingTask>> results; std::vector<Poco::AutoPtr<model::gradido::Transaction>> results;
auto it = mPendingTasks.find(user_id); auto it = mPendingGradidoTransactions.find(user_id);
if (it != mPendingTasks.end()) { if (it != mPendingGradidoTransactions.end()) {
auto task_list = it->second; auto task_list = it->second;
results.reserve(task_list->size()); results.reserve(task_list->size());
for (auto taskIt = task_list->begin(); taskIt != task_list->end(); taskIt++) { for (auto taskIt = task_list->begin(); taskIt != task_list->end(); taskIt++) {
auto task_model = (*taskIt)->getModel(); auto task_model = (*taskIt)->getModel();
if (type == task_model->getTaskType()) { if (task_model->getTaskType() == type) {
results.push_back(*taskIt); results.push_back(*taskIt);
} }
} }
@ -135,48 +138,42 @@ std::vector<Poco::AutoPtr<controller::PendingTask>> PendingTasksManager::getPend
return results; return results;
} }
std::vector<Poco::AutoPtr<controller::PendingTask>> PendingTasksManager::getTransactionsUserMustSign(Poco::AutoPtr<controller::User> user) std::vector<Poco::AutoPtr<model::gradido::Transaction>> PendingTasksManager::getTransactionsUserMustSign(Poco::AutoPtr<controller::User> user)
{ {
// TODO: don't use cast here, because can lead to errors // TODO: don't use cast here, because can lead to errors
Poco::ScopedLock<Poco::Mutex> _lock(mWorkMutex); Poco::ScopedLock<Poco::Mutex> _lock(mWorkMutex);
std::vector<Poco::AutoPtr<controller::PendingTask>> transactions_to_sign; std::vector<Poco::AutoPtr<model::gradido::Transaction>> transactions_to_sign;
for (auto map_it = mPendingTasks.begin(); map_it != mPendingTasks.end(); map_it++) for (auto map_it = mPendingGradidoTransactions.begin(); map_it != mPendingGradidoTransactions.end(); map_it++)
{ {
auto list = map_it->second; auto list = map_it->second;
for (auto list_it = list->begin(); list_it != list->end(); list_it++) for (auto list_it = list->begin(); list_it != list->end(); list_it++)
{ {
if ((*list_it)->getModel()->isGradidoTransaction()) { if((*list_it)->mustSign(user)) {
auto transaction = dynamic_cast<model::gradido::Transaction*>(list_it->get()); transactions_to_sign.push_back(*list_it);
if (transaction->mustSign(user)) {
transactions_to_sign.push_back(*list_it);
}
} }
} }
} }
return transactions_to_sign; return transactions_to_sign;
} }
std::vector<Poco::AutoPtr<controller::PendingTask>> PendingTasksManager::getTransactionSomeoneMustSign(Poco::AutoPtr<controller::User> user) std::vector<Poco::AutoPtr<model::gradido::Transaction>> PendingTasksManager::getTransactionSomeoneMustSign(Poco::AutoPtr<controller::User> user)
{ {
// TODO: don't use cast here, because can lead to errors // TODO: don't use cast here, because can lead to errors
Poco::ScopedLock<Poco::Mutex> _lock(mWorkMutex); Poco::ScopedLock<Poco::Mutex> _lock(mWorkMutex);
std::vector<Poco::AutoPtr<controller::PendingTask>> transactions_to_sign; std::vector<Poco::AutoPtr<model::gradido::Transaction>> transactions_to_sign;
if (user->getModel()->getRole() != model::table::ROLE_ADMIN) { if (user->getModel()->getRole() != model::table::ROLE_ADMIN) {
return transactions_to_sign; return transactions_to_sign;
} }
for (auto map_it = mPendingTasks.begin(); map_it != mPendingTasks.end(); map_it++) for (auto map_it = mPendingGradidoTransactions.begin(); map_it != mPendingGradidoTransactions.end(); map_it++)
{ {
auto list = map_it->second; auto list = map_it->second;
for (auto list_it = list->begin(); list_it != list->end(); list_it++) for (auto list_it = list->begin(); list_it != list->end(); list_it++)
{ {
if ((*list_it)->getModel()->isGradidoTransaction()) { if ((*list_it)->needSomeoneToSign(user)) {
auto transaction = dynamic_cast<model::gradido::Transaction*>(list_it->get()); transactions_to_sign.push_back(*list_it);
if (transaction->needSomeoneToSign(user)) {
transactions_to_sign.push_back(*list_it);
}
} }
} }
} }
@ -189,27 +186,25 @@ void PendingTasksManager::checkForFinishedTasks(Poco::Timer& timer)
Poco::ScopedLock<Poco::Mutex> _lock(mWorkMutex); Poco::ScopedLock<Poco::Mutex> _lock(mWorkMutex);
try { try {
for (auto map_it = mPendingTasks.begin(); map_it != mPendingTasks.end(); map_it++) for (auto map_it = mPendingGradidoTransactions.begin(); map_it != mPendingGradidoTransactions.end(); map_it++)
{ {
auto list = map_it->second; auto list = map_it->second;
for (auto list_it = list->begin(); list_it != list->end(); list_it++) for (auto list_it = list->begin(); list_it != list->end(); list_it++)
{ {
if ((*list_it)->getModel()->isGradidoTransaction()) { auto transaction = *list_it;
auto transaction = dynamic_cast<model::gradido::Transaction*>(list_it->get()); auto json = transaction->getModel()->getResultJson();
auto json = transaction->getModel()->getResultJson(); bool removeIt = false;
bool removeIt = false; if (!json.isNull()) {
if (!json.isNull()) { auto state = json->get("state");
auto state = json->get("state"); if (!state.isEmpty() && state.toString() == "success") {
if (!state.isEmpty() && state.toString() == "success") { removeIt = true;
removeIt = true;
}
}
if (removeIt) {
transaction->deleteFromDB();
list_it = list->erase(list_it);
if (!list->size() || list_it == list->end()) break;
} }
} }
if (removeIt) {
transaction->deleteFromDB();
list_it = list->erase(list_it);
if (!list->size() || list_it == list->end()) break;
}
} }
} }
} }
@ -224,10 +219,11 @@ void PendingTasksManager::checkForFinishedTasks(Poco::Timer& timer)
} }
} }
Poco::AutoPtr<controller::PendingTask> PendingTasksManager::getPendingTask(int pendingTaskId)
Poco::AutoPtr<model::gradido::Transaction> PendingTasksManager::getPendingGradidoTransaction(int pendingTaskId)
{ {
Poco::ScopedLock<Poco::Mutex> _lock(mWorkMutex); Poco::ScopedLock<Poco::Mutex> _lock(mWorkMutex);
for (auto map_it = mPendingTasks.begin(); map_it != mPendingTasks.end(); map_it++) for (auto map_it = mPendingGradidoTransactions.begin(); map_it != mPendingGradidoTransactions.end(); map_it++)
{ {
auto list = map_it->second; auto list = map_it->second;
for (auto list_it = list->begin(); list_it != list->end(); list_it++) for (auto list_it = list->begin(); list_it != list->end(); list_it++)

27
login_server/src/cpp/SingletonManager/PendingTasksManager.h
View File

@ -13,9 +13,10 @@
#ifndef GRADIDO_LOGIN_SERVER_SINGLETON_MANAGER_PENDING_TASKS_MANAGER #ifndef GRADIDO_LOGIN_SERVER_SINGLETON_MANAGER_PENDING_TASKS_MANAGER
#define GRADIDO_LOGIN_SERVER_SINGLETON_MANAGER_PENDING_TASKS_MANAGER #define GRADIDO_LOGIN_SERVER_SINGLETON_MANAGER_PENDING_TASKS_MANAGER
#include "../controller/PendingTask.h" #include "controller/PendingTask.h"
#include "../controller/User.h" #include "model/gradido/Transaction.h"
#include "../model/gradido/Transaction.h" #include "controller/User.h"
#include "model/gradido/Transaction.h"
class UserUpdateGroupPage; class UserUpdateGroupPage;
@ -24,6 +25,7 @@ class PendingTasksManager: protected UniLib::lib::MultithreadContainer
friend UserUpdateGroupPage; friend UserUpdateGroupPage;
public: public:
typedef std::list<Poco::AutoPtr<controller::PendingTask>> PendingTaskList; typedef std::list<Poco::AutoPtr<controller::PendingTask>> PendingTaskList;
typedef std::list<Poco::AutoPtr<model::gradido::Transaction>> PendingGradidoTaskList;
~PendingTasksManager(); ~PendingTasksManager();
@ -34,8 +36,9 @@ public:
//! \return -1 task is zero //! \return -1 task is zero
//! \return 0 if added //! \return 0 if added
int addTask(Poco::AutoPtr<controller::PendingTask> task); int addTask(Poco::AutoPtr<model::gradido::Transaction> gradidoTransactionTask);
bool removeTask(Poco::AutoPtr<controller::PendingTask> task);
bool removeTask(Poco::AutoPtr<model::gradido::Transaction> gradidoTransactionTask);
//! check if tasks can be removed //! check if tasks can be removed
void checkForFinishedTasks(Poco::Timer& timer); void checkForFinishedTasks(Poco::Timer& timer);
@ -43,12 +46,12 @@ public:
//! by calling this, important is to call lock to prevent vanishing the list while working with it, //! by calling this, important is to call lock to prevent vanishing the list while working with it,
//! and unlock afterwards //! and unlock afterwards
//! \return list or nullptr if no list for user exist //! \return list or nullptr if no list for user exist
const PendingTaskList* getTaskListForUser(int userId) const; const PendingGradidoTaskList* getGradidoTransactionsForUser(int userId) const;
bool hasPendingTask(Poco::AutoPtr<controller::User> user, model::table::TaskType type); bool hasPendingGradidoTransaction(Poco::AutoPtr<controller::User> user, model::table::TaskType type);
std::vector<Poco::AutoPtr<controller::PendingTask>> getPendingTasks(Poco::AutoPtr<controller::User> user, model::table::TaskType type); std::vector<Poco::AutoPtr<model::gradido::Transaction>> getPendingGradidoTransactions(Poco::AutoPtr<controller::User> user, model::table::TaskType type);
Poco::AutoPtr<controller::PendingTask> getPendingTask(int pendingTaskId); Poco::AutoPtr<model::gradido::Transaction> getPendingGradidoTransaction(int pendingTaskId);
std::vector<Poco::AutoPtr<controller::PendingTask>> getTransactionsUserMustSign(Poco::AutoPtr<controller::User> user); std::vector<Poco::AutoPtr<model::gradido::Transaction>> getTransactionsUserMustSign(Poco::AutoPtr<controller::User> user);
std::vector<Poco::AutoPtr<controller::PendingTask>> getTransactionSomeoneMustSign(Poco::AutoPtr<controller::User> user); std::vector<Poco::AutoPtr<model::gradido::Transaction>> getTransactionSomeoneMustSign(Poco::AutoPtr<controller::User> user);
protected: protected:
@ -58,8 +61,10 @@ protected:
std::map<int, PendingTaskList*> mPendingTasks; std::map<int, PendingTaskList*> mPendingTasks;
std::map<int, PendingGradidoTaskList*> mPendingGradidoTransactions;
//! \return list for user, creating new list and map entry if not exist //! \return list for user, creating new list and map entry if not exist
PendingTaskList* getTaskListForUser(int userId); PendingTaskList* getTaskListForUser(int userId);
PendingGradidoTaskList* getGradidoTransactionsForUser(int userId);
}; };

7
login_server/src/cpp/controller/EmailVerificationCode.cpp
View File

@ -70,10 +70,13 @@ namespace controller {
Poco::AutoPtr<EmailVerificationCode> EmailVerificationCode::loadOrCreate(int user_id, model::table::EmailOptInType type) Poco::AutoPtr<EmailVerificationCode> EmailVerificationCode::loadOrCreate(int user_id, model::table::EmailOptInType type)
{ {
model::table::EmailOptIn db; auto db = new model::table::EmailOptIn();
std::vector<std::string> fields = { "user_id", "email_opt_in_type_id" }; std::vector<std::string> fields = { "user_id", "email_opt_in_type_id" };
std::vector<int> field_values = { user_id, (int)type }; std::vector<int> field_values = { user_id, (int)type };
auto results = db.loadFromDB<int, model::table::EmailOptInTuple>(fields, field_values); auto results = db->loadFromDB<int, model::table::EmailOptInTuple>(fields, field_values);
db->release();
db = nullptr;
if (results.size() > 0) { if (results.size() > 0) {
return Poco::AutoPtr<EmailVerificationCode>(new EmailVerificationCode(new model::table::EmailOptIn(results[0]))); return Poco::AutoPtr<EmailVerificationCode>(new EmailVerificationCode(new model::table::EmailOptIn(results[0])));
} }

2
login_server/src/cpp/controller/User.cpp
View File

@ -136,7 +136,7 @@ namespace controller {
{ {
auto db = new model::table::User(); auto db = new model::table::User();
if (0 == db->loadFromDB("id", user_id)) { if (0 == db->loadFromDB("id", user_id)) {
delete db; db->release();
return nullptr; return nullptr;
} }
auto user = new User(db); auto user = new User(db);

4
login_server/src/cpp/model/gradido/Transaction.cpp
View File

@ -360,8 +360,8 @@ namespace model {
//transaction_send_task->scheduleTask(transaction_send_task); //transaction_send_task->scheduleTask(transaction_send_task);
auto pt = PendingTasksManager::getInstance(); auto pt = PendingTasksManager::getInstance();
pt->removeTask(Poco::AutoPtr<Transaction>(this, true)); // pt->removeTask(Poco::AutoPtr<Transaction>(this, true));
deleteFromDB(); // deleteFromDB();
return 1 == runSendTransaction(); return 1 == runSendTransaction();
//return true; //return true;
} }

4
login_server/src/cpp/model/table/AppAccessToken.h
View File

@ -16,7 +16,7 @@ namespace model {
AppAccessToken(int user_id, const Poco::UInt64& code); AppAccessToken(int user_id, const Poco::UInt64& code);
AppAccessToken(const AppAccessCodeTuple& tuple); AppAccessToken(const AppAccessCodeTuple& tuple);
AppAccessToken(); AppAccessToken();
~AppAccessToken();
// generic db operations // generic db operations
const char* getTableName() const { return "app_access_tokens"; } const char* getTableName() const { return "app_access_tokens"; }
@ -32,6 +32,8 @@ namespace model {
size_t update(); size_t update();
protected: protected:
~AppAccessToken();
Poco::Data::Statement _loadFromDB(Poco::Data::Session session, const std::string& fieldName); Poco::Data::Statement _loadFromDB(Poco::Data::Session session, const std::string& fieldName);
Poco::Data::Statement _loadIdFromDB(Poco::Data::Session session); Poco::Data::Statement _loadIdFromDB(Poco::Data::Session session);
Poco::Data::Statement _insertIntoDB(Poco::Data::Session session); Poco::Data::Statement _insertIntoDB(Poco::Data::Session session);

3
login_server/src/cpp/model/table/ElopageBuy.h
View File

@ -31,7 +31,6 @@ namespace model {
{ {
public: public:
ElopageBuy(const Poco::Net::NameValueCollection& elopage_webhook_requestData); ElopageBuy(const Poco::Net::NameValueCollection& elopage_webhook_requestData);
~ElopageBuy();
// generic db operations // generic db operations
const char* getTableName() const { return "elopage_buys"; } const char* getTableName() const { return "elopage_buys"; }
@ -39,6 +38,8 @@ namespace model {
std::string toString(); std::string toString();
protected: protected:
~ElopageBuy();
Poco::Data::Statement _loadIdFromDB(Poco::Data::Session session); Poco::Data::Statement _loadIdFromDB(Poco::Data::Session session);
Poco::Data::Statement _loadFromDB(Poco::Data::Session session, const std::string& fieldName); Poco::Data::Statement _loadFromDB(Poco::Data::Session session, const std::string& fieldName);
Poco::Data::Statement _insertIntoDB(Poco::Data::Session session); Poco::Data::Statement _insertIntoDB(Poco::Data::Session session);

4
login_server/src/cpp/model/table/EmailOptIn.h
View File

@ -26,7 +26,7 @@ namespace model {
EmailOptIn(const Poco::UInt64& code, EmailOptInType type); EmailOptIn(const Poco::UInt64& code, EmailOptInType type);
EmailOptIn(const EmailOptInTuple& tuple); EmailOptIn(const EmailOptInTuple& tuple);
EmailOptIn(); EmailOptIn();
~EmailOptIn();
// generic db operations // generic db operations
const char* getTableName() const { return "email_opt_in"; } const char* getTableName() const { return "email_opt_in"; }
@ -46,6 +46,8 @@ namespace model {
static const char* typeToString(EmailOptInType type); static const char* typeToString(EmailOptInType type);
static EmailOptInType stringToType(const std::string& typeString); static EmailOptInType stringToType(const std::string& typeString);
protected: protected:
~EmailOptIn();
Poco::Data::Statement _loadFromDB(Poco::Data::Session session, const std::string& fieldName); Poco::Data::Statement _loadFromDB(Poco::Data::Session session, const std::string& fieldName);
Poco::Data::Statement _loadIdFromDB(Poco::Data::Session session); Poco::Data::Statement _loadIdFromDB(Poco::Data::Session session);
Poco::Data::Statement _loadMultipleFromDB(Poco::Data::Session session, const std::string& fieldName); Poco::Data::Statement _loadMultipleFromDB(Poco::Data::Session session, const std::string& fieldName);

3
login_server/src/cpp/model/table/Group.h
View File

@ -15,7 +15,6 @@ namespace model {
Group(); Group();
Group(const std::string& alias, const std::string& name, const std::string& url, const std::string& host, const std::string& home, const std::string& description); Group(const std::string& alias, const std::string& name, const std::string& url, const std::string& host, const std::string& home, const std::string& description);
Group(GroupTuple userTuple); Group(GroupTuple userTuple);
~Group();
// generic db operations // generic db operations
const char* getTableName() const { return "groups"; } const char* getTableName() const { return "groups"; }
@ -35,6 +34,8 @@ namespace model {
inline void setHome(const std::string& home) { UNIQUE_LOCK; mHome = home; } inline void setHome(const std::string& home) { UNIQUE_LOCK; mHome = home; }
protected: protected:
~Group();
Poco::Data::Statement _loadFromDB(Poco::Data::Session session, const std::string& fieldName); Poco::Data::Statement _loadFromDB(Poco::Data::Session session, const std::string& fieldName);
Poco::Data::Statement _loadAllFromDB(Poco::Data::Session session); Poco::Data::Statement _loadAllFromDB(Poco::Data::Session session);
Poco::Data::Statement _loadMultipleFromDB(Poco::Data::Session session, const std::string& fieldName); Poco::Data::Statement _loadMultipleFromDB(Poco::Data::Session session, const std::string& fieldName);

7
login_server/src/cpp/model/table/ModelBase.h
View File

@ -32,7 +32,7 @@ namespace model {
public: public:
ModelBase(int id) :mID(id), mReferenceCount(1) {} ModelBase(int id) :mID(id), mReferenceCount(1) {}
ModelBase() : mID(0), mReferenceCount(1) {} ModelBase() : mID(0), mReferenceCount(1) {}
virtual ~ModelBase();
virtual const char* getTableName() const = 0; virtual const char* getTableName() const = 0;
//! called from within of some catch to give more information for debugging, don't lock mutex! //! called from within of some catch to give more information for debugging, don't lock mutex!
@ -90,6 +90,8 @@ namespace model {
void duplicate(); void duplicate();
void release(); void release();
protected: protected:
virtual ~ModelBase();
virtual Poco::Data::Statement _loadIdFromDB(Poco::Data::Session session) = 0; virtual Poco::Data::Statement _loadIdFromDB(Poco::Data::Session session) = 0;
virtual Poco::Data::Statement _loadFromDB(Poco::Data::Session session, const std::string& fieldName) = 0; virtual Poco::Data::Statement _loadFromDB(Poco::Data::Session session, const std::string& fieldName) = 0;
virtual Poco::Data::Statement _loadFromDB(Poco::Data::Session session, const std::vector<std::string>& fieldNames, MysqlConditionType conditionType = MYSQL_CONDITION_AND); virtual Poco::Data::Statement _loadFromDB(Poco::Data::Session session, const std::vector<std::string>& fieldNames, MysqlConditionType conditionType = MYSQL_CONDITION_AND);
@ -105,6 +107,9 @@ namespace model {
mutable std::shared_mutex mSharedMutex; mutable std::shared_mutex mSharedMutex;
private:
}; };
template<class T> template<class T>

3
login_server/src/cpp/model/table/PendingTask.h
View File

@ -28,7 +28,6 @@ namespace model {
PendingTask(int userId, std::string serializedProtoRequest, TaskType type); PendingTask(int userId, std::string serializedProtoRequest, TaskType type);
PendingTask(const PendingTaskTuple& tuple); PendingTask(const PendingTaskTuple& tuple);
~PendingTask();
// generic db operations // generic db operations
const char* getTableName() const { return "pending_tasks"; } const char* getTableName() const { return "pending_tasks"; }
@ -65,6 +64,8 @@ namespace model {
static const char* typeToString(TaskType type); static const char* typeToString(TaskType type);
protected: protected:
~PendingTask();
Poco::Data::Statement _loadFromDB(Poco::Data::Session session, const std::string& fieldName); Poco::Data::Statement _loadFromDB(Poco::Data::Session session, const std::string& fieldName);
Poco::Data::Statement _loadAllFromDB(Poco::Data::Session session); Poco::Data::Statement _loadAllFromDB(Poco::Data::Session session);
Poco::Data::Statement _loadIdFromDB(Poco::Data::Session session); Poco::Data::Statement _loadIdFromDB(Poco::Data::Session session);

3
login_server/src/cpp/model/table/User.h
View File

@ -38,7 +38,7 @@ namespace model {
User(); User();
User(UserTuple tuple); User(UserTuple tuple);
User(const std::string& email, const std::string& first_name, const std::string& last_name, int group_id, Poco::UInt64 passwordHashed = 0, std::string languageKey = "de"); User(const std::string& email, const std::string& first_name, const std::string& last_name, int group_id, Poco::UInt64 passwordHashed = 0, std::string languageKey = "de");
~User();
// generic db operations // generic db operations
const char* getTableName() const { return "users"; } const char* getTableName() const { return "users"; }
@ -97,6 +97,7 @@ namespace model {
Poco::JSON::Object getJson(); Poco::JSON::Object getJson();
protected: protected:
~User();
Poco::Data::Statement _loadFromDB(Poco::Data::Session session, const std::string& fieldName); Poco::Data::Statement _loadFromDB(Poco::Data::Session session, const std::string& fieldName);
Poco::Data::Statement _loadIdFromDB(Poco::Data::Session session); Poco::Data::Statement _loadIdFromDB(Poco::Data::Session session);

2
login_server/src/cpp/model/table/UserBackup.h
View File

@ -15,7 +15,6 @@ namespace model {
UserBackup(int user_id, const std::string& passphrase, ServerConfig::Mnemonic_Types type); UserBackup(int user_id, const std::string& passphrase, ServerConfig::Mnemonic_Types type);
UserBackup(const UserBackupsTuple& tuple); UserBackup(const UserBackupsTuple& tuple);
UserBackup(); UserBackup();
~UserBackup();
// generic db operations // generic db operations
const char* getTableName() const { return "user_backups"; } const char* getTableName() const { return "user_backups"; }
@ -29,6 +28,7 @@ namespace model {
protected: protected:
~UserBackup();
//! \brief call from constructor if mMnemonicType -1 //! \brief call from constructor if mMnemonicType -1
//! //!

5
login_server/src/cpp/model/table/UserRole.h
View File

@ -23,7 +23,6 @@ namespace model {
UserRole(int user_id, RoleType type); UserRole(int user_id, RoleType type);
UserRole(const UserRolesTuple& tuple); UserRole(const UserRolesTuple& tuple);
UserRole(); UserRole();
~UserRole();
// generic db operations // generic db operations
const char* getTableName() const { return "user_roles"; } const char* getTableName() const { return "user_roles"; }
@ -35,7 +34,9 @@ namespace model {
inline void setUserId(int user_Id) { mUserId = user_Id; } inline void setUserId(int user_Id) { mUserId = user_Id; }
static const char* typeToString(RoleType type); static const char* typeToString(RoleType type);
protected: protected:
~UserRole();
Poco::Data::Statement _loadFromDB(Poco::Data::Session session, const std::string& fieldName); Poco::Data::Statement _loadFromDB(Poco::Data::Session session, const std::string& fieldName);
Poco::Data::Statement _loadIdFromDB(Poco::Data::Session session); Poco::Data::Statement _loadIdFromDB(Poco::Data::Session session);
Poco::Data::Statement _loadMultipleFromDB(Poco::Data::Session session, const std::string& fieldName); Poco::Data::Statement _loadMultipleFromDB(Poco::Data::Session session, const std::string& fieldName);

58
login_server/src/cpsp/CheckTransaction.cpsp
View File

@ -46,10 +46,7 @@ enum PageState {
PageState state = PAGE_NO_TRANSACTIONS; PageState state = PAGE_NO_TRANSACTIONS;
Poco::AutoPtr<model::gradido::Transaction> transaction;
Poco::AutoPtr<controller::PendingTask> pending_task;
model::gradido::Transaction* transaction = nullptr;
Poco::AutoPtr<model::gradido::TransactionBody> transaction_body; Poco::AutoPtr<model::gradido::TransactionBody> transaction_body;
if(!form.empty()) if(!form.empty())
@ -64,10 +61,9 @@ enum PageState {
if(DataTypeConverter::NUMBER_PARSE_OKAY == DataTypeConverter::strToInt(pending_task_id_string, pending_task_id)) if(DataTypeConverter::NUMBER_PARSE_OKAY == DataTypeConverter::strToInt(pending_task_id_string, pending_task_id))
{ {
// load transaction from pending task manager // load transaction from pending task manager
pending_task = pt->getPendingTask(pending_task_id); transaction = pt->getPendingGradidoTransaction(pending_task_id);
if(!pending_task.isNull() && pending_task->getModel()->isGradidoTransaction()) if(!transaction.isNull())
{ {
transaction = dynamic_cast<model::gradido::Transaction*>(pending_task.get());
if(transaction->hasSigned(account_user)) { if(transaction->hasSigned(account_user)) {
transaction = nullptr; transaction = nullptr;
} else { } else {
@ -78,10 +74,11 @@ enum PageState {
{ {
//mSession->finalizeTransaction(false, true); //mSession->finalizeTransaction(false, true);
// //
if(transaction && transaction->getModel()->getUserId() == user_model->getID()) if(!transaction.isNull() && transaction->getModel()->getUserId() == user_model->getID())
{ {
pt->removeTask(pending_task); if(pt->removeTask(transaction)) {
transaction->deleteFromDB(); transaction->deleteFromDB();
}
transaction = nullptr; transaction = nullptr;
} }
} }
@ -110,7 +107,7 @@ enum PageState {
} }
if(!hasErrors) { if(!hasErrors) {
//mSession->finalizeTransaction(true, false); //mSession->finalizeTransaction(true, false);
if(transaction && transaction->sign(account_user)) { if(!transaction.isNull() && transaction->sign(account_user)) {
transaction = nullptr; transaction = nullptr;
} }
} }
@ -129,15 +126,15 @@ enum PageState {
} }
auto transactions_user_must_sign = pt->getTransactionsUserMustSign(account_user); auto transactions_user_must_sign = pt->getTransactionsUserMustSign(account_user);
std::vector<Poco::AutoPtr<controller::PendingTask>> transactions_someone_must_sign; std::vector<Poco::AutoPtr<model::gradido::Transaction>> transactions_someone_must_sign;
// TODO: work with community server roles // TODO: work with community server roles
if(user_model->getRole() == model::table::ROLE_ADMIN) { if(user_model->getRole() == model::table::ROLE_ADMIN) {
transactions_someone_must_sign = pt->getTransactionSomeoneMustSign(account_user); transactions_someone_must_sign = pt->getTransactionSomeoneMustSign(account_user);
} }
std::vector<Poco::AutoPtr<controller::PendingTask>> transactions_to_sign; std::vector<Poco::AutoPtr<model::gradido::Transaction>> transactions_to_sign;
bool transaction_removeable = false; bool transaction_removeable = false;
int transaction_to_sign_index = 0; int transaction_to_sign_index = 0;
if(!transaction) if(transaction.isNull())
{ {
if(transactions_user_must_sign.size() > skip_count) { if(transactions_user_must_sign.size() > skip_count) {
transactions_to_sign = transactions_user_must_sign; transactions_to_sign = transactions_user_must_sign;
@ -149,7 +146,7 @@ enum PageState {
if(transactions_to_sign.size() > transaction_to_sign_index) if(transactions_to_sign.size() > transaction_to_sign_index)
{ {
transaction = dynamic_cast<model::gradido::Transaction*>(transactions_to_sign[transaction_to_sign_index].get()); transaction = transactions_to_sign[transaction_to_sign_index];
transaction_body = transaction->getTransactionBody(); transaction_body = transaction->getTransactionBody();
// user can only delete there own transactions // user can only delete there own transactions
// TODO: Auto timeout for community transactions // TODO: Auto timeout for community transactions
@ -181,7 +178,7 @@ enum PageState {
{ {
enableLogout = false; enableLogout = false;
} }
if(PAGE_NO_TRANSACTIONS == state && transaction && !transaction_body.isNull()) if(PAGE_NO_TRANSACTIONS == state && !transaction.isNull() && !transaction_body.isNull())
{ {
auto transactionType = transaction_body->getType(); auto transactionType = transaction_body->getType();
memo = transaction_body->getMemo(); memo = transaction_body->getMemo();
@ -203,8 +200,6 @@ enum PageState {
} }
} }
%><%@ include file="include/header_navi_chr.cpsp" %> %><%@ include file="include/header_navi_chr.cpsp" %>
<%= getErrorsHtml() %> <%= getErrorsHtml() %>
<div class="col-md-10 equel-grid mb-3"> <div class="col-md-10 equel-grid mb-3">
@ -270,18 +265,19 @@ enum PageState {
</div> </div>
</div> </div>
<% } else if(PAGE_TRANSACTION_GROUP_ADD_MEMBER == state) { <% } else if(PAGE_TRANSACTION_GROUP_ADD_MEMBER == state) {
auto groupMemberUpdateTransaction = transaction_body->getGroupMemberUpdate(); auto groupMemberUpdateTransaction = transaction_body->getGroupMemberUpdate();
auto groups = controller::Group::load(groupMemberUpdateTransaction->getTargetGroupAlias()); auto groups = controller::Group::load(groupMemberUpdateTransaction->getTargetGroupAlias());
Poco::AutoPtr<model::table::Group> group_model; Poco::AutoPtr<model::table::Group> group_model;
Poco::AutoPtr<controller::User> user; Poco::AutoPtr<controller::User> user;
if(groups.size() == 1 && !groups[0].isNull()) group_model = groups[0]->getModel(); if(groups.size() == 1 && !groups[0].isNull()) group_model = groups[0]->getModel();
auto user_id = transaction->getModel()->getUserId(); auto user_id = transaction->getModel()->getUserId();
if(user_id == user_model->getID()) { if(user_id == user_model->getID()) {
user = account_user; user = account_user;
} else { } else {
user = controller::User::sload(user_id); user = controller::User::sload(user_id);
} }
%>
%>
<p><%= gettext("Benutzer zu einer Gruppe hinzufügen") %></p> <p><%= gettext("Benutzer zu einer Gruppe hinzufügen") %></p>
<div class="content-table"> <div class="content-table">
<p><% if(!user.isNull()) { %> <p><% if(!user.isNull()) { %>
@ -326,7 +322,7 @@ enum PageState {
</div> </div>
</div> </div>
<form> <form>
<% if(transaction) { %> <% if(!transaction.isNull()) { %>
<input type="hidden" name="pending-task-id" value="<%= transaction->getModel()->getID() %>"> <input type="hidden" name="pending-task-id" value="<%= transaction->getModel()->getID() %>">
<% } %> <% } %>
<input type="hidden" name="skip-count" value="<%= skip_count %>"> <input type="hidden" name="skip-count" value="<%= skip_count %>">

7
login_server/src/cpsp/UserUpdateGroup.cpsp
View File

@ -73,15 +73,14 @@ enum PageState {
pt->lock("userUpdateGroup Page"); pt->lock("userUpdateGroup Page");
auto has_pending_group_add_member_task = pt->hasPendingTask(user, model::table::TASK_TYPE_GROUP_ADD_MEMBER); auto has_pending_group_add_member_task = pt->hasPendingGradidoTransaction(user, model::table::TASK_TYPE_GROUP_ADD_MEMBER);
auto referer_was_checkTransaction = refererString.find("checkTransactions") != std::string::npos; auto referer_was_checkTransaction = refererString.find("checkTransactions") != std::string::npos;
if(has_pending_group_add_member_task) { if(has_pending_group_add_member_task) {
state = PAGE_STATE_REQUEST_IS_RUNNING; state = PAGE_STATE_REQUEST_IS_RUNNING;
std::vector<Poco::AutoPtr<controller::PendingTask>> tasks = pt->getPendingTasks(user, model::table::TASK_TYPE_GROUP_ADD_MEMBER); auto tasks = pt->getPendingGradidoTransactions(user, model::table::TASK_TYPE_GROUP_ADD_MEMBER);
// should be only one // should be only one
Poco::AutoPtr<model::gradido::Transaction> transaction = tasks[0].cast<model::gradido::Transaction>(); auto transaction = tasks[0];
if(transaction->getSignCount() == 0) { if(transaction->getSignCount() == 0) {
pt->unlock(); pt->unlock();
response.redirect(getBaseUrl() + "/checkTransactions"); response.redirect(getBaseUrl() + "/checkTransactions");
return; return;