adding PendingTask model and controller

src/cpp/controller/PendingTask.cpp

@@ -0,0 +1,36 @@
+#include "PendingTask.h"
+
+namespace controller {
+
+	PendingTask::PendingTask(model::table::PendingTask* dbModel)
+	{
+		mDBModel = dbModel;
+	}
+
+	PendingTask::~PendingTask()
+	{
+
+	}
+
+	Poco::AutoPtr<PendingTask> PendingTask::create(int userId, std::string serializedProtoRequest, model::table::TaskType type)
+	{
+		auto db = new model::table::PendingTask(userId, serializedProtoRequest, type);
+		auto pending_task = new PendingTask(db);
+		return Poco::AutoPtr<PendingTask>(pending_task);
+	}
+
+	std::vector<Poco::AutoPtr<PendingTask>> PendingTask::load(int userId)
+	{
+		auto db = new model::table::PendingTask();
+		auto pending_task_list = db->loadFromDB<int, model::table::PendingTaskTuple>("user_id", userId, 3);
+		std::vector<Poco::AutoPtr<PendingTask>> resultVector;
+		resultVector.reserve(pending_task_list.size());
+		for (auto it = pending_task_list.begin(); it != pending_task_list.end(); it++) {
+			resultVector.push_back(new PendingTask(new model::table::PendingTask(*it)));
+		}
+		return resultVector;
+		
+
+	}
+
+}

src/cpp/controller/PendingTask.h

@@ -0,0 +1,37 @@
+#ifndef GRADIDO_LOGIN_SERVER_CONTROLLER_PENDING_TASK_INCLUDE
+#define GRADIDO_LOGIN_SERVER_CONTROLLER_PENDING_TASK_INCLUDE
+
+#include "../model/table/PendingTask.h"
+
+#include "Poco/SharedPtr.h"
+
+#include "TableControllerBase.h"
+
+namespace controller {
+
+
+	typedef Poco::Tuple<int, std::string, int, int, int, int, Poco::UInt64, Poco::UInt64, Poco::UInt64, Poco::DateTime> NodeServerFullTuple;
+
+	class PendingTask : public TableControllerBase
+	{
+	public:
+
+		~PendingTask();
+
+		static Poco::AutoPtr<PendingTask> create(int userId, std::string serializedProtoRequest, model::table::TaskType type);
+
+		static std::vector<Poco::AutoPtr<PendingTask>> load(int userId);
+		
+		inline bool deleteFromDB() { return mDBModel->deleteFromDB(); }
+
+		inline Poco::AutoPtr<model::table::PendingTask> getModel() { return _getModel<model::table::PendingTask>(); }
+
+		
+	protected:
+		PendingTask(model::table::PendingTask* dbModel);
+		
+
+	};
+}
+
+#endif //GRADIDO_LOGIN_SERVER_CONTROLLER_PENDING_TASK_INCLUDE

src/cpp/model/table/PendingTask.cpp

@@ -0,0 +1,94 @@
+#include "PendingTask.h"
+
+//#include <sstream>
+
+using namespace Poco::Data::Keywords;
+
+namespace model
+{
+	namespace table
+	{
+		PendingTask::PendingTask()
+			: mUserId(0), mTaskTypeId(TASK_TYPE_NONE)
+		{
+
+		}
+		PendingTask::PendingTask(int userId, std::string serializedProtoRequest, TaskType type)
+			: mUserId(userId), mRequest((const unsigned char*)serializedProtoRequest.data(), serializedProtoRequest.size()),
+			  mTaskTypeId(TASK_TYPE_NONE)
+		{
+			
+		}
+		PendingTask::PendingTask(const PendingTaskTuple& tuple)
+			: ModelBase(tuple.get<0>()), mUserId(tuple.get<1>()), mRequest(tuple.get<2>()), mCreated(tuple.get<3>()), mFinished(tuple.get<4>()),
+			mResultJsonString(tuple.get<5>()), mTaskTypeId(tuple.get<6>())
+		{
+
+		}
+		PendingTask::~PendingTask()
+		{
+
+		}
+
+		
+
+		std::string PendingTask::toString()
+		{
+			std::stringstream ss;
+			std::shared_lock<std::shared_mutex> _lock(mSharedMutex);
+			return ss.str();
+		}
+
+		
+		const char* PendingTask::typeToString(TaskType type)
+		{
+			switch (type) {
+			case TASK_TYPE_GROUP_CREATE: return "group create";
+			case TASK_TYPE_GROUP_ADD_MEMBER: return "group add member";
+			case TASK_TYPE_CREATION: return "creation";
+			case TASK_TYPE_TRANSFER: return "transfer";
+			case TASK_TYPE_HEDERA_TOPIC_CREATE: return "hedera topic create";
+			case TASK_TYPE_HEDERA_TOPIC_MESSAGE: return "hedera topic send message";
+			case TASK_TYPE_HEDERA_ACCOUNT_CREATE: return "hedera account create";
+			default: return "<unknown>";
+			}
+			return "<invalid>";
+		}
+	
+		Poco::Data::Statement PendingTask::_loadFromDB(Poco::Data::Session session, const std::string& fieldName)
+		{
+			Poco::Data::Statement select(session);
+
+			select << "SELECT id, user_id, request, created, finished, result_json, task_type_id FROM " << getTableName()
+				<< " where " << fieldName << " = ?"
+				, into(mID), into(mUserId), into(mRequest), into(mCreated), into(mFinished), into(mResultJsonString), into(mTaskTypeId);
+
+			return select;
+		}
+
+		Poco::Data::Statement PendingTask::_loadIdFromDB(Poco::Data::Session session)
+		{
+			Poco::Data::Statement select(session);
+			lock();
+			select << "SELECT id FROM " << getTableName()
+				<< " WHERE user_id = ? "
+				<< " AND created = ? "
+				<< " AND task_type_id = ? "
+				, into(mID), use(mUserId), use(mCreated), use(mTaskTypeId);
+			unlock();
+			return select;
+		}
+
+
+		Poco::Data::Statement PendingTask::_insertIntoDB(Poco::Data::Session session)
+		{
+			Poco::Data::Statement insert(session);
+			lock();
+			insert << "INSERT INTO " << getTableName()
+				<< " (user_id, request, created, task_type_id) VALUES(?,?,?,?)"
+				, use(mUserId), use(mRequest), use(mCreated), use(mTaskTypeId);
+			unlock();
+			return insert;
+		}
+	}
+}

src/cpp/model/table/PendingTask.h

@@ -0,0 +1,61 @@
+#ifndef GRADIDO_LOGIN_SERVER_MODEL_TABLE_PENDING_TASKS_INCLUDE
+#define GRADIDO_LOGIN_SERVER_MODEL_TABLE_PENDING_TASKS_INCLUDE
+
+#include "ModelBase.h"
+#include "Poco/Types.h"
+
+#include <shared_mutex>
+
+namespace model {
+	namespace table {
+
+		enum TaskType {
+			TASK_TYPE_NONE = 0,
+			TASK_TYPE_GROUP_CREATE = 1,
+			TASK_TYPE_GROUP_ADD_MEMBER = 2,
+			TASK_TYPE_CREATION = 10,
+			TASK_TYPE_TRANSFER = 11,
+			TASK_TYPE_HEDERA_TOPIC_CREATE = 20,
+			TASK_TYPE_HEDERA_TOPIC_MESSAGE = 21,
+			TASK_TYPE_HEDERA_ACCOUNT_CREATE = 25,
+
+		};
+
+		typedef Poco::Tuple<int, int, Poco::Data::BLOB, Poco::DateTime, Poco::DateTime, std::string, int> PendingTaskTuple;
+
+		class PendingTask : public ModelBase
+		{
+		public:
+			PendingTask();
+			PendingTask(int userId, std::string serializedProtoRequest, TaskType type);
+			PendingTask(const PendingTaskTuple& tuple);
+
+			~PendingTask();
+
+			// generic db operations
+			const char* getTableName() const { return "pending_tasks"; }
+			std::string toString();
+
+
+			static const char* typeToString(TaskType type);
+		protected:
+			Poco::Data::Statement _loadFromDB(Poco::Data::Session session, const std::string& fieldName);
+			Poco::Data::Statement _loadIdFromDB(Poco::Data::Session session);
+			Poco::Data::Statement _insertIntoDB(Poco::Data::Session session);
+
+			int mUserId;
+			Poco::Data::BLOB mRequest;
+			Poco::DateTime mCreated;
+			Poco::DateTime mFinished;
+			std::string mResultJsonString;
+			int mTaskTypeId;
+
+			std::shared_mutex mSharedMutex;
+
+		};
+
+	}
+}
+
+
+#endif //GRADIDO_LOGIN_SERVER_MODEL_TABLE_PENDING_TASKS_INCLUDE