Merge pull request #58 from Serveis-Neby/task/138-manage-service-accpetion-and-refused

Task/138 manage service accpetion and refused

Author: erich-voigt

include/controllers/notification_controller.h

@@ -13,4 +13,5 @@
 class NotificationController {
 	public:
 	static void create_notification(pqxx::connection& db, const crow::request& req, crow::response& res, const std::string& service_id);
+	static void handle_notification(pqxx::connection& db, const crow::request& req, crow::response& res, const std::string& notification_id);
 };

include/db/connection_pool.h

@@ -0,0 +1,36 @@
+#pragma once
+
+#include <condition_variable>
+#include <iostream>
+#include <mutex>
+#include <pqxx/pqxx>
+#include <queue>
+
+class ConnectionPool {
+	public:
+	static ConnectionPool& getInstance(const std::string& connectionString, int poolSize) {
+		static ConnectionPool instance(connectionString, poolSize);
+		return instance;
+	}
+
+	ConnectionPool(const ConnectionPool&) = delete;
+	ConnectionPool& operator=(const ConnectionPool&) = delete;
+
+	std::shared_ptr<pqxx::connection> getConnection();
+
+	void releaseConnection(std::shared_ptr<pqxx::connection> conn);
+
+	private:
+	ConnectionPool(const std::string& connectionString, int poolSize);
+
+	~ConnectionPool() ;
+	
+	std::shared_ptr<pqxx::connection> createConnection();
+
+	private:
+	std::string connectionString_;
+	int poolSize_;
+	std::deque<std::shared_ptr<pqxx::connection>> connections_;
+	std::mutex mutex_;
+	std::condition_variable condition_;
+};

include/middlewares/verify_jwt.h

@@ -1,13 +1,18 @@
 #pragma once
 
 #include <crow.h>
+#include <db/connection_pool.h>
 #include <jwt-cpp/jwt.h>
 #include <utils/auth.h>
+#include <utils/common.h>
 #include <utils/utils.h>
+#include <memory>
 
 struct VerifyJWT : crow::ILocalMiddleware {
 	struct context {};
 
 	void before_handle(crow::request& req, crow::response& res, context& ctx);
 	void after_handle(crow::request& req, crow::response& res, context& ctx);
 };
+
+using NebyApp = crow::App<VerifyJWT>;

include/models/community_model.h

@@ -24,7 +24,7 @@ class CommunityModel {
 	std::string get_created_at() const;
 	std::string get_updated_at() const;
 
-	static std::string generate_community_code();
+	static std::string generate_community_code(const std::string& seed);
 
 	static std::unique_ptr<CommunityModel> create_community(pqxx::connection& db, const std::string& name, bool throw_when_null = false);
 

include/models/notification_model.h

@@ -27,4 +27,10 @@ class NotificationModel {
 
 	// * if the requester has already requested the service before, it returns true, otherwise false
 	static bool is_requested(pqxx::connection& db, const std::string& sender_id);
+
+	static std::unique_ptr<NotificationModel> handle_notification_status(pqxx::connection& db, const std::string& status, const std::string& notification_id, bool throw_when_null = false);
+
+	static bool refused_notifications(pqxx::connection& db, const std::string& service_id, const std::string& notification_id);
+
+	static std::unique_ptr<NotificationModel> get_notification_by_id(pqxx::connection& db, const std::string& id, bool throw_when_null = false);
 };

include/routes/auth_routes.h

@@ -5,5 +5,6 @@
 #include <middlewares/verify_jwt.h>
 #include <utils/common.h>
 #include <pqxx/pqxx>
+#include <db/connection_pool.h>
 
-void initialize_auth_routes(NebyApp& app, pqxx::connection& db);
+void initialize_auth_routes(NebyApp& app);

include/routes/notification_routes.h

@@ -2,8 +2,10 @@
 
 #include <controllers/notification_controller.h>
 #include <crow.h>
+#include <db/connection_pool.h>
 #include <middlewares/verify_jwt.h> 	
+#include <db/connection_pool.h>
 #include <utils/common.h>
 #include <pqxx/pqxx>
 
-void initialize_notifications_routes(NebyApp& app, pqxx::connection& db);
+void initialize_notifications_routes(NebyApp& app);

include/routes/service_routes.h

@@ -3,7 +3,8 @@
 #include <controllers/service_controller.h>
 #include <crow.h>
 #include <middlewares/verify_jwt.h>
+#include <db/connection_pool.h>
 #include <utils/common.h>
 #include <pqxx/pqxx>
 
-void initialize_service_routes(NebyApp& app, pqxx::connection& db);
+void initialize_service_routes(NebyApp& app);

include/routes/user_routes.h

@@ -6,4 +6,4 @@
 #include <utils/common.h>
 #include <pqxx/pqxx>
 
-void initialize_user_routes(NebyApp& app, pqxx::connection& db);
+void initialize_user_routes(NebyApp& app);

include/utils/common.h

@@ -1,13 +1,22 @@
 #pragma once
 #include <crow.h>
+#include <db/connection_pool.h>
 #include <middlewares/verify_jwt.h>
 #include <bcrypt/BCrypt.hpp>
+#include <cstdlib>
 #include <map>
 #include <string>
 
-using NebyApp = crow::App<VerifyJWT>;
 
-struct Roles {
+extern const std::string DB_NAME;
+extern const std::string DB_USER;
+extern const std::string DB_PASSWORD;
+extern const std::string DB_HOST;
+extern const int DB_PORT;
+extern const int HTTP_PORT;
+extern const std::string connection_string;
+
+struct Roles { 
 	static const std::string ADMIN;
 	static const std::string NEIGHBOR;
 };

src/controllers/notification_controller.cpp

@@ -7,6 +7,9 @@ void NotificationController::create_notification(pqxx::connection& db, const cro
 		std::string notifier_id = body["id"].s();
 		int notifier_balance = body["request_balance"].i();
 
+		std::cout << "balancation " << notifier_balance << std::endl;
+		std::cout << "id notfiier " << notifier_id << std::endl;
+
 		//? check if service exist
 		std::unique_ptr<ServiceModel> service = ServiceModel::get_service_by_id(db, service_id);
 		if (!service) {
@@ -66,3 +69,73 @@ void NotificationController::create_notification(pqxx::connection& db, const cro
 		handle_error(res, "internal server errror", 500);
 	}
 }
+
+void NotificationController::handle_notification(pqxx::connection& db, const crow::request& req, crow::response& res, const std::string& notification_id) {
+	try {
+		//? extarct query string param -> action = accepeted | refused
+		auto action = req.url_params.get("action");
+		crow::json::rvalue body = crow::json::load(req.body);
+		std::string request_id = body["id"].s();
+
+		//? check if action query param exists
+		if (!action) {
+			handle_error(res, "string query param (action) not provided", 400);
+			return;
+		}
+
+		//? check if action = accepted || refused
+		if (!(std::string(action) == NotificationStatus::ACCEPTED || std::string(action) == NotificationStatus::REFUSED)) {
+			handle_error(res, "action not valid value", 400);
+			return;
+		}
+
+		//? check if the notificaction exists
+		std::unique_ptr notification = NotificationModel::get_notification_by_id(db, notification_id);
+
+		if (!notification) {
+			handle_error(res, "notification not found", 400);
+			return;
+		}
+
+		//? check if the user making the request is the creator of the service
+		std::unique_ptr<ServiceModel> service = ServiceModel::get_service_by_id(db, notification.get()->get_service_id(), true);
+
+		if (request_id != service.get()->get_creator_id()) {
+			handle_error(res, "you are not the creator of the service", 400);
+			return;
+		}
+
+		//? if action == accepted -> accept the notification and refused others
+
+		std::unique_ptr<NotificationModel> updated_notification;
+
+		if (action == NotificationStatus::REFUSED) {
+			updated_notification = NotificationModel::handle_notification_status(db, NotificationStatus::REFUSED, notification_id, true);
+		} else {
+			updated_notification = NotificationModel::handle_notification_status(db, NotificationStatus::ACCEPTED, notification_id, true);
+
+			bool succes_refused = NotificationModel::refused_notifications(db, updated_notification.get()->get_service_id(), notification_id);
+
+			if (!succes_refused) {
+				handle_error(res, "error in refused other notifications", 400);
+				return;
+			}
+		}
+
+		//? if action == refused -> refuse the notification
+		std::cout << action << std::endl;
+		res.code = 200;
+		crow::json::wvalue data;
+		data["id"] = updated_notification.get()->get_id();
+		data["sender_id"] = updated_notification.get()->get_sender_id();
+		data["service_id"] = updated_notification.get()->get_service_id();
+		data["status"] = updated_notification.get()->get_status();
+		data["created_at"] = updated_notification.get()->get_created_at();
+		data["updated_at"] = updated_notification.get()->get_updated_at();
+		res.write(data.dump());
+
+		res.end();
+	} catch (const std::exception& e) {
+		std::cerr << e.what() << '\n';
+	}
+}

src/db/conncection_pool.cpp

@@ -0,0 +1,46 @@
+#include <db/connection_pool.h>
+
+std::shared_ptr<pqxx::connection> ConnectionPool::createConnection() {
+	auto conn = std::make_shared<pqxx::connection>(connectionString_);
+	if (!conn->is_open()) {
+		std::cerr << "Error in connection: " << connectionString_ << std::endl;
+		exit(1);
+	}
+	std::cout << "Connection established. " << std::endl;
+	return conn;
+}
+
+std::shared_ptr<pqxx::connection> ConnectionPool::getConnection() {
+	std::unique_lock<std::mutex> lock(mutex_);
+
+	while (connections_.empty()) {
+		condition_.wait(lock);
+	}
+
+	auto conn = connections_.front();
+	connections_.pop_front();
+
+	return conn;
+}
+
+void ConnectionPool::releaseConnection(std::shared_ptr<pqxx::connection> conn) {
+	std::unique_lock<std::mutex> lock(mutex_);
+
+	connections_.push_back(conn);
+
+	condition_.notify_one();
+}
+
+ConnectionPool::ConnectionPool(const std::string& connectionString, int poolSize)
+	: connectionString_(connectionString), poolSize_(poolSize) {
+	for (int i = 0; i < poolSize_; ++i) {
+		connections_.push_back(createConnection());
+	}
+}
+
+ConnectionPool::~ConnectionPool() {
+	for (auto& conn : connections_) {
+		conn->disconnect();
+	}
+}
+ 

src/main.cpp

@@ -1,4 +1,5 @@
 #include <crow.h>
+#include <db/connection_pool.h>
 #include <routes/auth_routes.h>
 #include <routes/notification_routes.h>
 #include <routes/service_routes.h>
@@ -12,32 +13,14 @@
 
 int main() {
 	try {
-		int HTTP_PORT = std::stoi(std::getenv("HTTP_PORT"));
-		std::string DB_NAME = std::string(std::getenv("DB_NAME"));
-		std::string DB_USER = std::string(std::getenv("DB_USER"));
-		std::string DB_PASSWORD = std::string(std::getenv("DB_PASSWORD"));
-		std::string DB_HOST = std::string(std::getenv("DB_HOST"));
-		std::string DB_PORT = std::string(std::getenv("DB_PORT"));
-
 		NebyApp app;
-		std::string connection_string = std::format("dbname={} user={} password={} host={} port={}", DB_NAME, DB_USER, DB_PASSWORD, DB_HOST, DB_PORT);
-		pqxx::connection conn(connection_string);
-		
-
-		if (conn.is_open()) {
-			std::cout << "Opened database successfully: " << conn.dbname() << std::endl;
-		} else {
-			std::cout << "Can't open database" << std::endl;
-			exit(1);
-		}
 
-		initialize_auth_routes(app, conn);
-		initialize_user_routes(app, conn);
-		initialize_service_routes(app, conn);
-		initialize_notifications_routes(app, conn);
+		initialize_auth_routes(app);
+		initialize_user_routes(app);
+		initialize_service_routes(app);
+		initialize_notifications_routes(app);
 
 		app.port(HTTP_PORT).multithreaded().run();
-		conn.disconnect();
 	} catch (const std::exception &e) {
 		std::cerr << e.what() << std::endl;
 		exit(1);

src/middlewares/verify_jwt.cpp

@@ -1,5 +1,8 @@
 #include <middlewares/verify_jwt.h>
+
 void VerifyJWT::before_handle(crow::request& req, crow::response& res, context& ctx) {
+	ConnectionPool& pool = ConnectionPool::getInstance(connection_string, 10);
+	auto conn = pool.getConnection();
 	std::string token = get_token_cookie(req);
 
 	if (token == "") {
@@ -14,52 +17,41 @@ void VerifyJWT::before_handle(crow::request& req, crow::response& res, context&
 
 	auto decoded = jwt::decode(token);
 
-	std::string id, type, community_id, username, email, created_at, updated_at, balance;
+	std::string id;
 
 	for (auto& e : decoded.get_payload_json()) {
-		if (e.first == "id") {
+		if (e.first == "id")
 			id = e.second.get<std::string>();
-		} else if (e.first == "type") {
-			type = e.second.get<std::string>();
-		} else if (e.first == "community_id") {
-			community_id = e.second.get<std::string>();
-		} else if (e.first == "username") {
-			username = e.second.get<std::string>();
-		} else if (e.first == "email") {
-			email = e.second.get<std::string>();
-		} else if (e.first == "created_at") {
-			created_at = e.second.get<std::string>();
-		} else if (e.first == "updated_at") {
-			updated_at = e.second.get<std::string>();
-		} else if (e.first == "balance") {
-			balance = e.second.get<std::string>();
-		}
 	}
 
+	std::unique_ptr<UserModel> user = UserModel::get_user_by_id(*conn.get(), id);
+
+	pool.releaseConnection(conn);
+
 	if (req.body == "") {
 		crow::json::wvalue body;
 
 		body["id"] = id;
-		body["isAdmin"] = (type == "admin");
-		body["request_community_id"] = community_id;
-		body["request_username"] = username;
-		body["request_email"] = email;
-		body["request_created_at"] = created_at;
-		body["request_updated_at"] = updated_at;
-		body["request_balance"] = std::stoi(balance);
+		body["isAdmin"] = (user.get()->get_type() == "admin");
+		body["request_community_id"] = user.get()->get_community_id();
+		body["request_username"] = user.get()->get_username();
+		body["request_email"] = user.get()->get_email();
+		body["request_created_at"] = user.get()->get_created_at();
+		body["request_updated_at"] = user.get()->get_updated_at();
+		body["request_balance"] = user.get()->get_balance();
 
 		req.body = body.dump();
 	} else {
 		crow::json::wvalue body = crow::json::load(req.body);
 
 		body["id"] = id;
-		body["isAdmin"] = (type == "admin");
-		body["request_community_id"] = community_id;
-		body["request_username"] = username;
-		body["request_email"] = email;
-		body["request_created_at"] = created_at;
-		body["request_updated_at"] = updated_at;
-		body["request_balance"] = std::stoi(balance);
+		body["isAdmin"] = (user.get()->get_type() == "admin");
+		body["request_community_id"] = user.get()->get_community_id();
+		body["request_username"] = user.get()->get_username();
+		body["request_email"] = user.get()->get_email();
+		body["request_created_at"] = user.get()->get_created_at();
+		body["request_updated_at"] = user.get()->get_updated_at();
+		body["request_balance"] = user.get()->get_balance();
 		req.body = body.dump();
 	}
 }