diff --git a/.env b/.env new file mode 100644 index 0000000000000000000000000000000000000000..3281990c5368da3253bc04d71467225fffdf2d2b --- /dev/null +++ b/.env @@ -0,0 +1,6 @@ +PGHOSTADDR=0.0.0.0 +PGPORT=5432 +PGDATABASE=mydb +PGUSER=postgres +PGPASSWORD=root +POOLSIZE=10 \ No newline at end of file diff --git a/.gitignore b/.gitignore index de30b5cd2b696a631c9b3f127129d5b92ba23b21..bd8d464c9721f49ff5ea38707eadddf0b7047f99 100644 --- a/.gitignore +++ b/.gitignore @@ -3,5 +3,8 @@ /build1/ .vscode .idea +server/build/ +log.txt +/server/cpp-dotenv CMakeUserPresets.json /metrics/cmake-build-debug" diff --git a/CMakeLists.txt b/CMakeLists.txt index e51f2bfe1b5440809734dbcce45c2ac87f01a54f..8760718d29a17aefd354f372724f1acf6406f27c 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -1,5 +1,9 @@ set(CMAKE_CXX_STANDARD 20) +<<<<<<< HEAD cmake_minimum_required(VERSION 3.16) +======= +cmake_minimum_required(VERSION 3.19) +>>>>>>> 0745844ad0c7971df126d33fb8539d97ecb2e910 set(PROJECT_NAME "SourcedOut") diff --git a/client/CMakeLists.txt b/client/CMakeLists.txt new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/conanfile.txt b/conanfile.txt deleted file mode 100644 index 18ee8ce4289f4e6832e3384009f500ec0562d3b4..0000000000000000000000000000000000000000 --- a/conanfile.txt +++ /dev/null @@ -1,10 +0,0 @@ -[requires] -boost/1.81.0 -antlr4-cppruntime/4.12.0 -libpqxx/7.7.5 -gtest/cci.20210126 - - -[generators] -CMakeDeps -CMakeToolchain \ No newline at end of file diff --git a/log.txt b/log.txt new file mode 100644 index 0000000000000000000000000000000000000000..d72fd2988823140d02a82d7cd5b1b30c53e0fbf3 --- /dev/null +++ b/log.txt @@ -0,0 +1,21 @@ +Opened database successfully: mydb +Opened database successfully: mydb +Opened database successfully: mydb +Opened database successfully: mydb +OK +Opened database successfully: mydb +OK +Opened database successfully: mydb +Opened database successfully: mydb +OK +Opened database successfully: mydb +OK +Opened database successfully: mydb +Opened database successfully: mydb +OK +Opened database successfully: mydb +OK +Opened database successfully: mydb +OK +Opened database successfully: mydb +OK diff --git a/server/CMakeLists.txt b/server/CMakeLists.txt index c33d848f16a26f6c7c6af85cbb8df47d1f4c2a1f..aeee19b9bb75cb9e1c7e600be85075dd809ddccf 100644 --- a/server/CMakeLists.txt +++ b/server/CMakeLists.txt @@ -1,6 +1,5 @@ set(CMAKE_PREFIX_PATH build) project(SourcedOut CXX) -# find_package(antlr4-runtime REQUIRED) find_package(Boost 1.8.1 REQUIRED) find_package(Threads REQUIRED) find_library(PQXX_LIB pqxx) @@ -18,6 +17,3 @@ add_subdirectory(cmd) message(STATUS ${Boost_LIBRARIES}) set(CMAKE_CXX_FLAGS ${CMAKE_CXX_FLAGS} "-lpthread -pthread") -#add_subdirectory(cpp-dotenv) -#add_executable(${PROJECT_NAME} text-basic-metrics/tbm_main.cpp text-basic-metrics/tbm_main.cpp) строка для запуска моей части в text-basic-metrics -# target_link_libraries(${PROJECT_NAME} ${Boost_LIBRARIES} ${antlr4-runtime_LIBRARIES} ${libpqxx_LIBRARIES} ${GTest_LIBRARIES}) \ No newline at end of file diff --git a/server/cmd/CMakeLists.txt b/server/cmd/CMakeLists.txt index 8826a8d8b2c62a6414c33e23374f15b2c4fce2c9..b262044a9831408306cb1132f81f599bf9b070dd 100644 --- a/server/cmd/CMakeLists.txt +++ b/server/cmd/CMakeLists.txt @@ -5,7 +5,8 @@ project(${PROJECT_NAME}) add_executable(Server main.cpp) message(STATUS ${libusers}) message("${SERVICE_LIB}") -target_link_libraries(${PROJECT_NAME} ${Boost_LIBRARIES} ${libpqxx_LIBRARIES} ${SERVICE_LIB}) -target_include_directories(Server PUBLIC ${SERVICE_lib_INCLUDE_DIRS}) +target_link_libraries(${PROJECT_NAME} ${Boost_LIBRARIES} ${libpqxx_LIBRARIES} ${SERVICE_LIB} ${libEntities_LIB} ${libRepository_LIB}) +target_include_directories(Server PUBLIC ${SERVICE_lib_INCLUDE_DIRS} ${libusers_INCLUDE_DIRS}) + message("Built server") diff --git a/server/cmd/main.cpp b/server/cmd/main.cpp index 685eb7a8e7c7da901df422ac25fa976ec98eb1b5..13257c62804f806676901db32b405dc1d3a8310d 100644 --- a/server/cmd/main.cpp +++ b/server/cmd/main.cpp @@ -1,23 +1,9 @@ -#include - -#include "PythonAntlr.h" - -int main(int argc, const char* argv[]) { - // ifstream ins("/home/denis/2023_1_DDT/antlr/test.py"); - std::ifstream ins( - "/home/denis/2023_1_DDT/server/pkg/antlr/testprogs/python/test.py"); - - PythonAntlr pA = PythonAntlr(ins); - - std::vector tokens = pA.getTokensArray(); - - std::cout << "Tokens:" << std::endl; - for (std::string token : tokens) { - std::cout << token << std::endl; - } - - std::cout << pA.getTreeString() << std::endl; - std::cout << "test" << std::endl; - - return 0; +#include "UserRepository.hpp" +#include "User.hpp" + +//using namespace dotenv; +int main(){ + User user{"qwerty200468@gmail.com", "123", "tolik"}; + UserRepository repo; + std::cout< +//#include "dotenv.h" +//using namespace dotenv; +class dbConnection { +public: + dbConnection(); + [[nodiscard]] std::shared_ptr connection() const; +private: + void establish_connection(); + + std::string m_dbhost = "localhost"; + int m_dbport = 5432; + std::string m_dbname = "demo"; + std::string m_dbuser = "postgres"; + std::string m_dbpass = "postgres"; + + std::shared_ptr m_connection; + +}; + + +#endif //SOURCEDOUT_DBCONNECTION_HPP diff --git a/server/internal/dbManager/include/dbManager.hpp b/server/internal/dbManager/include/dbManager.hpp new file mode 100644 index 0000000000000000000000000000000000000000..d17e9ab7ff1807c17f6f4006de27f3cc4002124f --- /dev/null +++ b/server/internal/dbManager/include/dbManager.hpp @@ -0,0 +1,34 @@ +#ifndef SOURCEDOUT_DBMANAGER_HPP +#define SOURCEDOUT_DBMANAGER_HPP + +#include +#include +#include +#include +#include +#include +#include +#include + +//#include "dotenv.h" +//using namespace dotenv; +class dbManager { +public: + dbManager(); + + std::shared_ptr connection(); + + void freeConnection(const std::shared_ptr &); + +private: + const size_t POOL_SIZE = 10; + std::condition_variable m_condition; + + void createPool(); + + std::queue> connection_pool; + std::mutex m_mutex; +}; + + +#endif //SOURCEDOUT_DBMANAGER_HPP diff --git a/server/internal/dbManager/src/dbConnection.cpp b/server/internal/dbManager/src/dbConnection.cpp new file mode 100644 index 0000000000000000000000000000000000000000..fe9c04dd92cf7d315635f09b9633cb98b6490245 --- /dev/null +++ b/server/internal/dbManager/src/dbConnection.cpp @@ -0,0 +1,20 @@ +// +// Created by qwert on 01.05.2023. +// + +#include +#include "../include/dbConnection.hpp" + +dbConnection::dbConnection() { + establish_connection(); +} + +std::shared_ptr dbConnection::connection() const { + return m_connection; +} + +void dbConnection::establish_connection() { + pqxx::connection c("dbname =mydb" "user = postgres password =root hostaddr =172.28.224.1 port = 5432"); + m_connection.reset(&c); + +} diff --git a/server/internal/dbManager/src/dbManager.cpp b/server/internal/dbManager/src/dbManager.cpp new file mode 100644 index 0000000000000000000000000000000000000000..f1ff7664582f4efce05967bd10f3d0eb811154cf --- /dev/null +++ b/server/internal/dbManager/src/dbManager.cpp @@ -0,0 +1,39 @@ + +#include "dbManager.hpp" + + +dbManager::dbManager() { + createPool(); +} + +void dbManager::createPool() { + std::lock_guard locker_(m_mutex); + + for (auto i = 0; i < POOL_SIZE; i++) { + connection_pool.emplace(std::make_shared( + "dbname =mydb user = postgres password =root hostaddr =172.28.224.1 port = 5432")); + } +} + +std::shared_ptr dbManager::connection() { + std::unique_lock lock_(m_mutex); + + while (connection_pool.empty()) { + m_condition.wait(lock_); + } + + auto conn_ = connection_pool.front(); + connection_pool.pop(); + + return conn_; +} + +void dbManager::freeConnection(const std::shared_ptr &conn_) { + std::unique_lock lock_(m_mutex); + + connection_pool.push(conn_); + + lock_.unlock(); + + m_condition.notify_one(); +} diff --git a/server/internal/entities/include/Solution.hpp b/server/internal/entities/include/Solution.hpp index 974a560ccdb3e47878e2864707778b1102d41436..a8aeaf38b9f43eefd1f3b10f01694badabb4ec63 100644 --- a/server/internal/entities/include/Solution.hpp +++ b/server/internal/entities/include/Solution.hpp @@ -8,10 +8,12 @@ class Solution { public: Solution(size_t id, std::string sendDate, size_t senderId, std::string source, - std::string tokens, std::string astTree, size_t taskId, std::string result) noexcept; + std::string tokens, std::string astTree, + size_t taskId, std::string result, size_t orig_solution) noexcept; + + Solution(std::string sendDate, size_t senderId, std::string source, std::string tokens, + std::string astTree, size_t taskId, std::string result, size_t orig_solution) noexcept; - Solution(std::string sendDate, size_t senderId, std::string source, std::string tokens, std::string astTree, - size_t taskId, std::string result) noexcept; Solution() noexcept; [[nodiscard]] size_t getId() const noexcept; @@ -45,6 +47,10 @@ public: void setResult(const std::string &result) noexcept; + [[nodiscard]] size_t getOrigSolution() const; + + void setOrigSolution(size_t origSolution); + void setId(size_t id) noexcept; bool operator==(const Solution &rhs) const noexcept; @@ -60,7 +66,7 @@ private: std::string astTree; size_t task_id; std::string result; -public: + size_t orig_solution = 0; }; diff --git a/server/internal/entities/src/Solution.cpp b/server/internal/entities/src/Solution.cpp index 0603c00cbb0eb713e7665ed5bfb4cce49dfca37c..db4914e8c32bbcc2a80b8ccc1a6420ad851e05f2 100644 --- a/server/internal/entities/src/Solution.cpp +++ b/server/internal/entities/src/Solution.cpp @@ -6,20 +6,23 @@ Solution::Solution(size_t id, std::string sendDate, unsigned long senderId, std::string source, std::string tokens, std::string astTree, unsigned long taskId, - std::string result) noexcept : id(id), send_date(std::move(sendDate)), sender_id(senderId), - source(std::move(source)), tokens(std::move(tokens)), - astTree(std::move(astTree)), - task_id(taskId), result(std::move(result)) {} + std::string result, size_t orig_solution_) noexcept: + id(id), send_date(std::move(sendDate)), sender_id(senderId), + source(std::move(source)), tokens(std::move(tokens)), + astTree(std::move(astTree)), + task_id(taskId), result(std::move(result)), orig_solution(orig_solution_) {} + Solution::Solution(std::string sendDate, unsigned long senderId, std::string source, std::string tokens, std::string astTree, unsigned long taskId, - std::string result) noexcept : id(0), send_date(std::move(sendDate)), sender_id(senderId), - source(std::move(source)), tokens(std::move(tokens)), - astTree(std::move(astTree)), - task_id(taskId), result(std::move(result)) {} + std::string result, size_t orig_solution_) noexcept: + id(0), send_date(std::move(sendDate)), sender_id(senderId), + source(std::move(source)), tokens(std::move(tokens)), + astTree(std::move(astTree)), + task_id(taskId), result(std::move(result)), orig_solution(orig_solution_) {} -Solution::Solution() noexcept : id(0), sender_id(0), task_id(0) {} +Solution::Solution() noexcept: id(0), sender_id(0), task_id(0), orig_solution(0) {} size_t Solution::getId() const noexcept { return id; @@ -93,3 +96,11 @@ bool Solution::operator!=(const Solution &rhs) const noexcept { return !(rhs == *this); } +size_t Solution::getOrigSolution() const { + return orig_solution; +} + +void Solution::setOrigSolution(size_t origSolution) { + orig_solution = origSolution; +} + diff --git a/server/internal/repository/CMakeLists.txt b/server/internal/repository/CMakeLists.txt index bee149e70d973e2da173369a75bb490c61d2ece7..78409d7db835bbca4e9b3c407781e2a2153481cd 100644 --- a/server/internal/repository/CMakeLists.txt +++ b/server/internal/repository/CMakeLists.txt @@ -5,15 +5,26 @@ set(LIB_NAME libRepository) file(GLOB_RECURSE SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/src/*.cpp) file(GLOB_RECURSE HEADERS ${CMAKE_CURRENT_SOURCE_DIR}/include/*.hpp ${CMAKE_CURRENT_SOURCE_DIR}/include/*.h ${CMAKE_CURRENT_SOURCE_DIR}/virtual/*.hpp) + message("SOURCES = ${SOURCES}") message("HEADERS = ${HEADERS}") set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -g -Wall -Wextra -O2 -pedantic -Wformat=2 -Wfloat-equal -Wconversion \ --Wlogical-op -Wshift-overflow=2 -Wduplicated-cond -Wcast-qual -Wcast-align") +-Wlogical-op -Wshift-overflow=2 -Wduplicated-cond -Wcast-qual -Wcast-align -ftest-coverage") set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -lboost_filesystem") +add_custom_target( + ${PROJECT_NAME}_COVERAGE + COMMAND gcovr ${CMAKE_CURRENT_BINARY_DIR} -r ${CMAKE_CURRENT_SOURCE_DIR} +) +add_custom_target( + ${PROJECT_NAME}_COVERAGE_FILE + COMMAND rm -r ${CMAKE_CURRENT_BINARY_DIR}/report || echo "There are no reports" + COMMAND mkdir ${CMAKE_CURRENT_BINARY_DIR}/report + COMMAND gcovr ${CMAKE_CURRENT_BINARY_DIR} -r ${CMAKE_CURRENT_SOURCE_DIR} --html-details report/report.html +) add_library(${LIB_NAME} ${SOURCES} ${HEADERS}) target_include_directories(${LIB_NAME} PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/include ${CMAKE_CURRENT_SOURCE_DIR}/virtual) @@ -30,3 +41,4 @@ message(Entities_LIB = "${libEntities_LIB}") message(dbManager = "${libDbManager_LIB}") message("libRepository_LIB = ${libRepository_LIB}") message("libRepository_INCLUDE_DIRS = ${libRepository_INCLUDE_DIRS}") + diff --git a/server/internal/repository/include/MetricRepository.hpp b/server/internal/repository/include/MetricRepository.hpp new file mode 100644 index 0000000000000000000000000000000000000000..5d9bf9632f6b63f294ef12714fd442b8da70c981 --- /dev/null +++ b/server/internal/repository/include/MetricRepository.hpp @@ -0,0 +1,31 @@ +#ifndef SOURCEDOUT_METRICREPOSITORY_HPP +#define SOURCEDOUT_METRICREPOSITORY_HPP + +#include "IMetricRepository.hpp" +#include "dbManager.hpp" +#include +#include + +using namespace pqxx; + +class MetricRepository : IMetricRepository { +public: + explicit MetricRepository(); + + std::optional getById(size_t id) override; + + size_t storeMetric(MetricStat metric) override; + + void updateMetric(MetricStat metric) override; + + void deleteMetric(MetricStat metric) override; + + void deleteMetricById(size_t id) override; + +private: + std::shared_ptr manager; + + static MetricStat makeMetric(const result::const_iterator &c); +}; + +#endif //SOURCEDOUT_METRICREPOSITORY_HPP diff --git a/server/internal/repository/include/SolutionRepository.hpp b/server/internal/repository/include/SolutionRepository.hpp new file mode 100644 index 0000000000000000000000000000000000000000..50d9552d293e3a1c186a3fbc5aeedf99ff0117d4 --- /dev/null +++ b/server/internal/repository/include/SolutionRepository.hpp @@ -0,0 +1,39 @@ +#ifndef SOURCEDOUT_SOLUTIONREPOSITORY_HPP +#define SOURCEDOUT_SOLUTIONREPOSITORY_HPP + +#include +#include +#include +#include +#include "ISolutionRepository.hpp" +#include "dbManager.hpp" +#include + + +using namespace pqxx; + +class SolutionRepository : ISolutionRepository { +public: + explicit SolutionRepository(); + std::optional getSolutionById(size_t id) override; + + std::vector getSolutionsBySenderId(size_t sender_id) override; + + std::vector getSolutionsByTaskId(size_t task_id) override; + + size_t storeSolution(Solution solution) override; + + void updateSolution(Solution solution) override; + + void deleteSolutionById(size_t id) override; + + void deleteSolution(Solution solution) override; + + std::optional getOriginalSolution(size_t id) override; + +private: + static Solution makeSolution(const result::const_iterator& c); + std::shared_ptr manager; +}; + +#endif diff --git a/server/internal/repository/include/TaskRepository.hpp b/server/internal/repository/include/TaskRepository.hpp new file mode 100644 index 0000000000000000000000000000000000000000..83e5135c7ed26cdac59dd605ea72028f74b5725e --- /dev/null +++ b/server/internal/repository/include/TaskRepository.hpp @@ -0,0 +1,33 @@ +#ifndef SOURCEDOUT_TASKREPOSITORY_HPP +#define SOURCEDOUT_TASKREPOSITORY_HPP + +#include +#include +#include "ITaskRepository.hpp" +#include "pqxx/pqxx" +#include "dbManager.hpp" +#include + +using namespace pqxx; + +class TaskRepository : ITaskRepository { +public: + explicit TaskRepository(); + std::optional getTaskById(size_t id) override; + + std::vector getAllTasks() override; + + void updateTask(const Task& task) override; + + size_t storeTask(Task task) override; + + void deleteTask(Task task) override; + + void deleteTaskById(size_t task_id) override; + +private: + static Task makeTask(const result::const_iterator &c); + std::shared_ptr manager; +}; + +#endif //SOURCEDOUT_TASKREPOSITORY_HPP diff --git a/server/internal/repository/include/UserRepository.hpp b/server/internal/repository/include/UserRepository.hpp new file mode 100644 index 0000000000000000000000000000000000000000..b5a52f306c3bc8ec521c478b67bef75e48544b73 --- /dev/null +++ b/server/internal/repository/include/UserRepository.hpp @@ -0,0 +1,39 @@ +#ifndef SOURCEDOUT_USERREPOSITORY_HPP +#define SOURCEDOUT_USERREPOSITORY_HPP + +#include +#include "IUserRepository.hpp" +#include "dbManager.hpp" +#include +#include +#include +#include + +using namespace pqxx; + +class UserRepository : IUserRepository { +public: + explicit UserRepository(); + + std::optional getUserById(size_t id) override; + + std::optional getUserByLogin(std::string login) override; + + size_t makeUser(User user) override; + + void deleteUser(User user) override; + + void deleteByUserId(size_t user_id) override; + + std::vector getAllUsers() override; + + void update(User user) override; + + +private: + static User makeUser(const result::const_iterator &c); + + std::shared_ptr manager; +}; + +#endif //SOURCEDOUT_USERREPOSITORY_HPP diff --git a/server/internal/repository/src/MetricRepository.cpp b/server/internal/repository/src/MetricRepository.cpp new file mode 100644 index 0000000000000000000000000000000000000000..d6d265a9da042672d8178cb9c39bd223abd384c6 --- /dev/null +++ b/server/internal/repository/src/MetricRepository.cpp @@ -0,0 +1,90 @@ +#include "MetricStat.hpp" +#include "MetricRepository.hpp" +#include + +std::optional MetricRepository::getById(size_t id) { + try { + auto c = manager->connection(); + std::string sql = "SELECT * FROM metricStat WHERE id=" + std::to_string(id); + nontransaction n(*c); + result r(n.exec(sql)); + manager->freeConnection(c); + if(r.empty()) + return std::nullopt; + return makeMetric(r.begin()); + } catch (...) { + + throw; + } +} + + +size_t MetricRepository::storeMetric(MetricStat metric) { + try { + auto c = manager->connection(); + + std::string sql = ( + boost::format( + "INSERT INTO metricStat (solution_id, text_based_res, token_based_res, tree_based_res, verdict, mean_res) " \ + "VALUES ('%s', '%s', '%s', '%s', '%s', '%s') RETURNING id; ") % metric.getSolutionId() % + metric.getTextBasedRes() % metric.getTokenBasedRes() % metric.getTreeBasedRes() % metric.isVerdict() % + metric.getMeanRes()).str(); + work w(*c); + row r = (w.exec1(sql)); + w.commit(); + manager->freeConnection(c); + return r["id"].as(); + } catch (...) { + + throw; + } +} + +void MetricRepository::updateMetric(MetricStat metric) { + try { + auto c = manager->connection(); + + std::string sql = (boost::format( + "UPDATE metricStat SET solution_id = '%s', text_based_res = '%s', token_based_res = '%s', tree_based_res = '%s', verdict = '%s', mean_res = '%s';") + % metric.getSolutionId() % metric.getTextBasedRes() % metric.getTokenBasedRes() % + metric.getTreeBasedRes() % metric.isVerdict() % metric.getMeanRes()).str(); + work w(*c); + w.exec(sql); + manager->freeConnection(c); + } catch (...) { + + throw; + } +} + +void MetricRepository::deleteMetric(MetricStat metric) { + deleteMetricById(metric.getId()); +} + +void MetricRepository::deleteMetricById(size_t id) { + try { + auto c = manager->connection(); + std::string sql = "DELETE FROM metricStat WHERE id=" + std::to_string(id); + work w(*c); + w.exec(sql); + w.commit(); + manager->freeConnection(c); + } catch (...) { + throw; + } +} + +MetricStat MetricRepository::makeMetric(const result::const_iterator &c) { + return {c.at(c.column_number("id")).as(), + c.at(c.column_number("solution_id")).as(), + c.at(c.column_number("text_based_res")).as(), + c.at(c.column_number("token_based_res")).as(), + c.at(c.column_number("tree_based_res")).as(), + c.at(c.column_number("verdict")).as(), + c.at(c.column_number("mean_res")).as() + }; +} + +MetricRepository::MetricRepository() { + manager = std::make_shared(); +} diff --git a/server/internal/repository/src/SolutionRepository.cpp b/server/internal/repository/src/SolutionRepository.cpp new file mode 100644 index 0000000000000000000000000000000000000000..441bab7666fac844a9d7a7a8adc805dc23fbc376 --- /dev/null +++ b/server/internal/repository/src/SolutionRepository.cpp @@ -0,0 +1,146 @@ +#include +#include +#include +#include "Solution.hpp" +#include "SolutionRepository.hpp" + +using namespace pqxx; + +std::optional SolutionRepository::getSolutionById(size_t id) { + try { + auto c = manager->connection(); + std::string sql = "SELECT * FROM solutions WHERE id=" + std::to_string(id); + nontransaction n(*c); + result r(n.exec(sql)); + manager->freeConnection(c); + if (r.empty()) + return std::nullopt; + return makeSolution(r.begin()); + } catch (...) { + + throw; + } +} + +std::vector SolutionRepository::getSolutionsBySenderId(size_t sender_id) { + try { + auto c = manager->connection(); + std::string sql = "SELECT * FROM solutions WHERE sender_id=" + std::to_string(sender_id); + nontransaction n(*c); + result r(n.exec(sql)); + std::vector solutions; + manager->freeConnection(c); + for (result::const_iterator k = r.begin(); k != r.end(); ++k) + solutions.push_back(makeSolution(k)); + return solutions; + } catch (...) { + + throw; + } +} + +std::vector SolutionRepository::getSolutionsByTaskId(size_t task_id) { + try { + auto c = manager->connection(); + std::string sql = "SELECT * FROM solutions WHERE task_id=" + std::to_string(task_id); + nontransaction n(*c); + result r(n.exec(sql)); + std::vector solutions; + manager->freeConnection(c); + for (result::const_iterator k = r.begin(); k != r.end(); ++k) + solutions.push_back(makeSolution(k)); + return solutions; + } catch (...) { + + throw; + } +} + +std::optional SolutionRepository::getOriginalSolution(size_t id) { + try { + auto c = manager->connection(); + std::string sql = "SELECT * FROM solutions WHERE original_solution_id=" + std::to_string(id); + nontransaction n(*c); + result r(n.exec(sql)); + manager->freeConnection(c); + if (r.empty()) + return std::nullopt; + return makeSolution(r.begin()); + } catch (...) { + + throw; + } +} + + +size_t SolutionRepository::storeSolution(Solution solution) { + try { + auto c = manager->connection(); + + std::string sql = ( + boost::format("INSERT INTO solutions (send_date,sender_id, source, task_id, result, tokens, astTree) " \ + "VALUES ('%s', '%s', '%s', '%s', '%s', '%s', '%s') RETURNING id; ") % solution.getSendDate() % + solution.getSenderId() % solution.getSource() % solution.getTaskId() % solution.getResult() % + solution.getTokens() % solution.getAstTree()).str(); + work w(*c); + row r = (w.exec1(sql)); + w.commit(); + manager->freeConnection(c); + return r["id"].as(); + } catch (...) { + throw; + } +} + +void SolutionRepository::updateSolution(Solution solution) { + try { + auto c = manager->connection(); + + std::string sql = (boost::format( + "UPDATE solutions SET send_date = '%s', sender_id = '%s', source = '%s', task_id = '%s', result = '%s', tokens = '%s', astTree = '%s';") + % solution.getSendDate() % solution.getSenderId() % solution.getSource() % + solution.getTaskId() % solution.getResult() % solution.getTokens() % + solution.getAstTree()).str(); + work w(*c); + w.exec(sql); + manager->freeConnection(c); + } catch (...) { + + throw; + } +} + +void SolutionRepository::deleteSolutionById(size_t id) { + try { + auto c = manager->connection(); + std::string sql = "DELETE FROM solutions WHERE id=" + std::to_string(id); + work w(*c); + w.exec(sql); + w.commit(); + manager->freeConnection(c); + } catch (...) { + + throw; + } +} + +void SolutionRepository::deleteSolution(Solution solution) { + deleteSolutionById(solution.getId()); +} + + +Solution SolutionRepository::makeSolution(const result::const_iterator &c) { + return {c.at(c.column_number("id")).as(), + c.at(c.column_number("send_date")).as(), + c.at(c.column_number("sender_id")).as(), + c.at(c.column_number("source")).as(), + c.at(c.column_number("tokens")).as(), + c.at(c.column_number("astTree")).as(), + c.at(c.column_number("task_id")).as(), + c.at(c.column_number("result")).as(), + c.at(c.column_number("original_solution_id")).as()}; +} + +SolutionRepository::SolutionRepository() { + manager = std::make_shared(); +} diff --git a/server/internal/repository/src/TaskRepository.cpp b/server/internal/repository/src/TaskRepository.cpp new file mode 100644 index 0000000000000000000000000000000000000000..f20dffbd21b49ef61676248131f043366880751c --- /dev/null +++ b/server/internal/repository/src/TaskRepository.cpp @@ -0,0 +1,92 @@ +#include +#include "Task.hpp" +#include +#include "TaskRepository.hpp" + +std::optional TaskRepository::getTaskById(size_t id) { + try { + auto c = manager->connection(); + std::string sql = "SELECT * FROM tasks WHERE id=" + std::to_string(id); + nontransaction n(*c); + result r(n.exec(sql)); + manager->freeConnection(c); + if (r.empty()) { + return std::nullopt; + } + return makeTask(r.begin()); + } catch (...) { + throw; + } +} + +std::vector TaskRepository::getAllTasks() { + try { + auto c = manager->connection(); + std::string sql = "SELECT * FROM tasks"; + nontransaction n(*c); + result r(n.exec(sql)); + manager->freeConnection(c); + std::vector users; + for (result::const_iterator k = r.begin(); k != r.end(); ++k) + users.push_back(makeTask(k)); + return users; + } catch (...) { + + throw; + } +} + +void TaskRepository::updateTask(const Task &task) { + try { + auto c = manager->connection(); + std::string sql = (boost::format("UPDATE tasks SET description = '%s', treshold = '%s';") % + task.getDescription() % task.getTreshhold()).str(); + work w(*c); + w.exec(sql); + manager->freeConnection(c); + } catch (...) { + throw; + } +} + +size_t TaskRepository::storeTask(Task task) { + try { + auto c = manager->connection(); + std::string sql = (boost::format("INSERT INTO tasks (description, treshold) " \ + "VALUES ('%s', '%s') RETURNING id; ") % task.getDescription() % task.getTreshhold()).str(); + work w(*c); + row r = w.exec1(sql); + w.commit(); + manager->freeConnection(c); + return r["id"].as(); + } catch (...) { + throw; + } +} + +void TaskRepository::deleteTask(Task task) { + deleteTaskById(task.getId()); +} + +void TaskRepository::deleteTaskById(size_t task_id) { + try { + auto c = manager->connection(); + std::string sql = "DELETE FROM tasks WHERE id=" + std::to_string(task_id); + work w(*c); + w.exec(sql); + w.commit(); + manager->freeConnection(c); + } catch (...) { + throw; + } +} + +Task TaskRepository::makeTask(const result::const_iterator &c) { + return {c.at(c.column_number("id")).as(), + c.at(c.column_number("description")).as(), + c.at(c.column_number("treshold")).as()}; +} + +TaskRepository::TaskRepository() { + manager = std::make_shared(); +} diff --git a/server/internal/repository/src/UserRepository.cpp b/server/internal/repository/src/UserRepository.cpp new file mode 100644 index 0000000000000000000000000000000000000000..216baef6b14964c5fe36c4d7ae0d044b895b7f9a --- /dev/null +++ b/server/internal/repository/src/UserRepository.cpp @@ -0,0 +1,119 @@ + +#include +#include "User.hpp" +#include "UserRepository.hpp" +#include "dbManager.hpp" +#include + +std::optional UserRepository::getUserById(size_t id) { + try { + auto c = manager->connection(); + std::string sql = "SELECT * FROM Users WHERE id=" + std::to_string(id); + nontransaction n(*c); + result r(n.exec(sql)); + manager->freeConnection(c); + if (r.empty()) + return std::nullopt; + return makeUser(r.begin()); + } catch (...) { + + throw; + } +} + +std::optional UserRepository::getUserByLogin(std::string login) { + try { + auto c = manager->connection(); + std::string sql = (boost::format("SELECT * FROM Users WHERE login= '%s'") % login).str(); + nontransaction n(*c); + result r(n.exec(sql)); + manager->freeConnection(c); + if(r.empty()) + return std::nullopt; + return makeUser(r.begin()); + } catch (...) { + + throw; + } +} + +size_t UserRepository::makeUser(User user) { + try { + auto c = manager->connection(); + + std::string sql = (boost::format("INSERT INTO users (login,password,username) " \ + "VALUES ('%s', '%s', '%s') RETURNING id; ") % user.getLogin() % user.getPassword() % + user.getUsername()).str(); + work w(*c); + row r = w.exec1(sql); + w.commit(); + manager->freeConnection(c); + return r["id"].as(); + } catch (...) { + + throw; + } +} + +void UserRepository::deleteByUserId(size_t user_id) { + try { + auto c = manager->connection(); + std::string sql = "DELETE FROM Users WHERE id=" + std::to_string(user_id); + work w(*c); + w.exec(sql); + w.commit(); + manager->freeConnection(c); + } catch (...) { + + throw; + } +} + + +void UserRepository::deleteUser(User user) { + deleteByUserId(user.getId()); +} + +std::vector UserRepository::getAllUsers() { + try { + auto c = manager->connection(); + std::string sql = "SELECT * FROM Users"; + nontransaction n(*c); + result r(n.exec(sql)); + manager->freeConnection(c); + std::vector users; + for (result::const_iterator k = r.begin(); k != r.end(); ++k) + users.push_back(makeUser(k)); + return users; + } catch (...) { + + throw; + } +} + +User UserRepository::makeUser(const result::const_iterator &c) { + return {c.at(c.column_number("id")).as(), + c.at(c.column_number("login")).as(), + c.at(c.column_number("password")).as(), + c.at(c.column_number("username")).as()}; +} + +UserRepository::UserRepository() { + manager = std::make_shared(); +} + +void UserRepository::update(User user) { + try { + auto c = manager->connection(); + + std::string sql = (boost::format( + "UPDATE Users SET login = '%s', password = '%s', username = '%s';") + % user.getLogin() % user.getPassword() % user.getUsername()).str(); + work w(*c); + w.exec(sql); + manager->freeConnection(c); + } catch (...) { + + throw; + } +} diff --git a/server/internal/repository/tests/CMakeLists.txt b/server/internal/repository/tests/CMakeLists.txt new file mode 100644 index 0000000000000000000000000000000000000000..23379e51ffad6c7ea1c1a2e9f15782c50f9c16b8 --- /dev/null +++ b/server/internal/repository/tests/CMakeLists.txt @@ -0,0 +1,39 @@ +cmake_minimum_required(VERSION 3.19) + +project("RepositoryTests") + +set(CMAKE_CXX_STANDARD 20) + +file(GLOB SOURCES *.cpp) + +if(BUILD_TYPE) + set(CMAKE_CXX_FLAGS ${CMAKE_CXX_FLAGS} "-fprofile-arcs -ftest-coverage -O0 -g") + set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -coverage -lgcov" ) +endif(BUILD_TYPE) + + +file(GLOB TEST_SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/*.cpp) +message("${TEST_SOURCES}") +add_executable(${PROJECT_NAME} ${TEST_SOURCES}) + +target_link_libraries(${PROJECT_NAME} ${Boost_LIBRARIES} ${libpqxx_LIBRARIES} ${libEntities_LIB} ${libDbManager_LIB} ${GTest_LIBRARIES} ${libRepository_LIB}) +target_include_directories(${PROJECT_NAME} PUBLIC ${libRepository_INCLUDE_DIRS}) + +target_compile_options(${PROJECT_NAME} PUBLIC --coverage) +target_link_options(${PROJECT_NAME} PUBLIC --coverage) + +gtest_discover_tests(${PROJECT_NAME}) + +add_custom_target( + ${PROJECT_NAME}_TEST + COMMAND ${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME} +) + + +add_custom_target( + ${PROJECT_NAME}_VALGRIND + COMMAND valgrind -s --leak-check=full --show-leak-kinds=all ${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME} +) + + + diff --git a/server/internal/repository/tests/RepositoryTests.cpp b/server/internal/repository/tests/RepositoryTests.cpp new file mode 100644 index 0000000000000000000000000000000000000000..b78c57cb4021dcaeec2d83d04f7513410b733e47 --- /dev/null +++ b/server/internal/repository/tests/RepositoryTests.cpp @@ -0,0 +1,172 @@ +#include +#include +#include "MetricRepository.hpp" +#include "UserRepository.hpp" +#include "SolutionRepository.hpp" +#include "TaskRepository.hpp" +#include + +TEST(UserRepository_CRUD_Test, CRUD) { + UserRepository rep; + + EXPECT_NO_FATAL_FAILURE(rep.getUserById(1)); + + User user("test@test.com", "test", "testuser"); + size_t id = rep.makeUser(user); + user.setId(id); + std::optional new_user_opt = rep.getUserById(id); + User new_user; + if (new_user_opt) { + new_user = new_user_opt.value(); + } + EXPECT_EQ(user, new_user); + new_user.setUsername("new_test_user"); + EXPECT_NO_FATAL_FAILURE(rep.update(new_user)); + + EXPECT_NO_FATAL_FAILURE(rep.deleteUser(new_user)); +} + +TEST(TaskRepository_CRUD_Test, CRUD) { + TaskRepository rep; + + Task task("test task", 0.5); + size_t id = rep.storeTask(task); + EXPECT_NO_FATAL_FAILURE(rep.getTaskById(1)); + task.setId(id); + std::optional new_task_opt = rep.getTaskById(id); + Task new_task; + if (new_task_opt) + new_task = new_task_opt.value(); + EXPECT_EQ(task, new_task); + new_task.setDescription("new_test_description"); + EXPECT_NO_FATAL_FAILURE(rep.updateTask(new_task)); + EXPECT_NO_FATAL_FAILURE(rep.deleteTask(new_task)); +} + +TEST(SolutionRepository_CRUD_Test, CRUD) { + SolutionRepository rep; + + Solution solution("01.01.1970", 1, ":/C/Users", "tokens.txt", "tree.txt", 1, "result"); + size_t id = rep.storeSolution(solution); + EXPECT_NO_FATAL_FAILURE(rep.getSolutionById(1)); + solution.setId(id); + std::optional new_solution_opt = rep.getSolutionById(id); + Solution new_solution; + if (new_solution_opt) + new_solution = new_solution_opt.value(); + EXPECT_EQ(solution, new_solution); + new_solution.setSource(":/D"); + EXPECT_NO_FATAL_FAILURE(rep.updateSolution(new_solution)); + EXPECT_NO_FATAL_FAILURE(rep.deleteSolution(new_solution)); +} + +TEST(MetricRepository_CRUD_Test, CRUD) { + MetricRepository rep; + MetricStat metricStat(1, 0.8f, 0.9f, 0.89f, true, 0.85f); + size_t id = rep.storeMetric(metricStat); + EXPECT_NO_FATAL_FAILURE(rep.getById(1)); + metricStat.setId(id); + std::optional new_stat_opt = rep.getById(id); + MetricStat new_stat; + if (new_stat_opt) + new_stat = new_stat_opt.value(); + EXPECT_EQ(metricStat, new_stat); + new_stat.setMeanRes(1); + EXPECT_NO_FATAL_FAILURE(rep.updateMetric(new_stat)); + EXPECT_NO_FATAL_FAILURE(rep.deleteMetric(new_stat)); +} + +TEST(UserRepository_CRUD_Test, getAllUsers) { + UserRepository rep; + std::vector v = {{"test@test.com", "test", "testuser"}, + {"test2@test.com", "test2", "testuser2"}}; + EXPECT_NO_FATAL_FAILURE(rep.getAllUsers()); + std::vector new_v = rep.getAllUsers(); + EXPECT_EQ(v, new_v); +} + +TEST(UserRepository_CRUD_Test, loginLikeId) { + UserRepository rep; + User user("test@test.com", "test", "testuser"); + size_t id = rep.makeUser(user); + user.setId(id); + std::optional new_user_id = rep.getUserById(id); + std::optional new_user_login = rep.getUserByLogin(user.getLogin()); + User new_user; + EXPECT_EQ(new_user_id, new_user_login); + EXPECT_NO_FATAL_FAILURE(rep.deleteUser(user)); + +} + +TEST(SolutionRepository_CRUD_Test, CRUD_getSolutionsBySenderId) { + SolutionRepository rep; + + Solution solution1("01.01.1970", 1, ":/C/Users", "tokens.txt", "tree.txt", 1, "result"); + Solution solution2("01.01.1970", 1, "/home/usr", "tokens.txt", "tree.txt", 1, "result"); + + size_t id1 = rep.storeSolution(solution1); + solution1.setId(id1); + EXPECT_EQ(solution1, rep.getSolutionById(id1)); + size_t id2 = rep.storeSolution(solution2); + solution2.setId(id2); + EXPECT_EQ(solution2, rep.getSolutionById(id2)); + std::vector v = {{id1, "01.01.1970", 1, ":/C/Users", "tokens.txt", "tree.txt", 1, "result"}, + {id2, "01.01.1970", 1, "/home/usr", "tokens.txt", "tree.txt", 1, "result"}}; + std::vector new_v = rep.getSolutionsBySenderId(solution1.getSenderId()); + EXPECT_EQ(v, new_v); + EXPECT_NO_FATAL_FAILURE(rep.deleteSolution(solution1)); + EXPECT_NO_FATAL_FAILURE(rep.deleteSolution(solution2)); + +} + +TEST(SolutionRepository_CRUD_Test, CRUD_getSolutionsByTaskId) { + SolutionRepository rep; + + Solution solution1("01.01.1970", 1, ":/C/Users", "tokens.txt", "tree.txt", 1, "result"); + Solution solution2("01.01.1970", 1, "/home/usr", "tokens.txt", "tree.txt", 1, "result"); + + size_t id1 = rep.storeSolution(solution1); + solution1.setId(id1); + size_t id2 = rep.storeSolution(solution2); + solution2.setId(id2); + std::vector v = {solution1, solution2}; + std::vector new_v = rep.getSolutionsByTaskId(solution1.getTaskId()); + EXPECT_EQ(v, new_v); + EXPECT_NO_FATAL_FAILURE(rep.deleteSolution(solution1)); + EXPECT_NO_FATAL_FAILURE(rep.deleteSolution(solution2)); + +} +TEST(SolutionRepository_CRUD_Test, tryToAddWithNotExistingTask){ + SolutionRepository rep; + + Solution solution("01.01.1970", 1, ":/C/Users", "tokens.txt", "tree.txt", 100500, "result"); + try{ + rep.storeSolution(solution); + }catch(pqxx::foreign_key_violation &e){ + std::cout< #include -#include "../../entities/include/Solution.hpp" +#include "Solution.hpp" +#include class ISolutionRepository { - public: +public: virtual ~ISolutionRepository() = default; - virtual Solution getSolutionById(size_t id) = 0; - virtual std::vector getSolutionsBySenderId(size_t sender_id) = 0; - virtual std::vector getSolutions(size_t sender_id, size_t task_id) = 0; + virtual std::optional getSolutionById(size_t id) = 0; + virtual std::vector getSolutionsBySenderId(size_t sender_id) = 0; virtual std::vector getSolutionsByTaskId(size_t task_id) = 0; @@ -24,7 +24,7 @@ class ISolutionRepository { virtual void deleteSolution(Solution solution) = 0; - + virtual std::optional getOriginalSolution(size_t id) = 0; }; #endif //SOURCEDOUT_ISOLUTIONREPOSITORY_HPP diff --git a/server/internal/repository/virtual/ITaskRepository.hpp b/server/internal/repository/virtual/ITaskRepository.hpp index c8a3588bf07d11f84c3c37573d9cd267ad539e96..5565a02f9122f4c97846f05cce5995082e57f40b 100644 --- a/server/internal/repository/virtual/ITaskRepository.hpp +++ b/server/internal/repository/virtual/ITaskRepository.hpp @@ -2,19 +2,20 @@ #define SOURCEDOUT_ITASKREPOSITORY_HPP #include -#include -#include "../../entities/include/Task.hpp" +#include "Task.hpp" +#include class ITaskRepository { - public: +public: virtual ~ITaskRepository() = default; - virtual Task getTaskById(size_t id) = 0; + + virtual std::optional getTaskById(size_t id) = 0; virtual std::vector getAllTasks() = 0; virtual void updateTask(Task task) = 0; - virtual int storeTask(Task task) = 0; + virtual size_t storeTask(Task task) = 0; virtual void deleteTask(Task task) = 0; diff --git a/server/internal/repository/virtual/IUserRepository.hpp b/server/internal/repository/virtual/IUserRepository.hpp index 14d7a50ee86692f3768460ce520b78a50cf82f94..feb232692c3731094c8117022b449add8e9e59f4 100644 --- a/server/internal/repository/virtual/IUserRepository.hpp +++ b/server/internal/repository/virtual/IUserRepository.hpp @@ -2,18 +2,23 @@ #define SOURCEDOUT_IUSERREPOSITORY_HPP #include -#include "../../entities/include/User.hpp" +#include "User.hpp" +#include + class IUserRepository { public: virtual ~IUserRepository() = default; - virtual User getUserById(size_t id) = 0; - virtual User getUserByLogin(std::string login) = 0; + virtual std::optional getUserById(size_t id) = 0; + + virtual std::optional getUserByLogin(std::string login) = 0; virtual size_t makeUser(User user) = 0; virtual void deleteUser(User user) = 0; + virtual void update(User user) = 0; + virtual void deleteByUserId(size_t user_id) = 0; virtual std::vector getAllUsers() = 0; diff --git a/server/internal/src/CMakeLists.txt b/server/internal/src/CMakeLists.txt new file mode 100644 index 0000000000000000000000000000000000000000..72e4c50a529e11df35b7cb5041f8f92700da291b --- /dev/null +++ b/server/internal/src/CMakeLists.txt @@ -0,0 +1,5 @@ +set(CMAKE_CXX_STANDARD 20) +cmake_minimum_required(VERSION 3.19) +add_subdirectory(db) +set(DB_Lib_LIB ${DB_Lib_LIB} PARENT_SCOPE) +set(DB_Lib_INCLUDE_DIRS ${DB_Lib_INCLUDE_DIRS} PARENT_SCOPE) \ No newline at end of file diff --git a/server/internal/src/db/CMakeLists.txt b/server/internal/src/db/CMakeLists.txt new file mode 100644 index 0000000000000000000000000000000000000000..df02471d1e844d4f84ebe571d568da19adc26cad --- /dev/null +++ b/server/internal/src/db/CMakeLists.txt @@ -0,0 +1,29 @@ +cmake_minimum_required(VERSION 3.10) + +project("DBLib") + +set(LIB_NAME DB_Lib) + +file(GLOB_RECURSE SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/src/*.cpp) +file(GLOB_RECURSE HEADERS ${CMAKE_CURRENT_SOURCE_DIR}/include/*.hpp ${CMAKE_CURRENT_SOURCE_DIR}/include/*.h) + +message("SOURCES = ${SOURCES}") +message("HEADERS = ${HEADERS}") + + +set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -g -Wall -Wextra -O2 -pedantic -Wformat=2 -Wfloat-equal -Wconversion \ +-Wlogical-op -Wshift-overflow=2 -Wduplicated-cond -Wcast-qual -Wcast-align") + +set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS}") + +add_library(${LIB_NAME} ${SOURCES} ${HEADERS}) +target_include_directories(${LIB_NAME} PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/include) +target_link_libraries(${LIB_NAME} ${libpqxx_LIBRARIES} nlohmann_json::nlohmann_json) + +set(DB_Lib_LIB ${LIB_NAME}) +set(DB_Lib_LIB ${DB_Lib_LIB} PARENT_SCOPE) +set(DB_Lib_INCLUDE_DIRS ${LIB_NAME} ${CMAKE_CURRENT_SOURCE_DIR}/include) +set(DB_Lib_INCLUDE_DIRS ${DB_Lib_INCLUDE_DIRS} PARENT_SCOPE) + +message("DB_Lib_LIB = ${DB_Lib_LIB}") +message("DB_Lib_INCLUDE_DIRS = ${DB_Lib_INCLUDE_DIRS}") diff --git a/server/internal/src/db/config.json b/server/internal/src/db/config.json new file mode 100644 index 0000000000000000000000000000000000000000..81007a5fd8cdc018e6eac3ad8c345f44f5a85d2d --- /dev/null +++ b/server/internal/src/db/config.json @@ -0,0 +1,7 @@ +{ + "dbname": "mydb", + "user": "postgres", + "password": "root", + "hostaddr": "127.0.0.1", + "port": "5432" +} diff --git a/server/internal/src/db/include/conn.hpp b/server/internal/src/db/include/conn.hpp new file mode 100644 index 0000000000000000000000000000000000000000..146836191dbe62ad33d0443f1d2e62b315496b5f --- /dev/null +++ b/server/internal/src/db/include/conn.hpp @@ -0,0 +1,22 @@ +#ifndef SOURCEDOUT_CONN_HPP +#define SOURCEDOUT_CONN_HPP + +#include +#include +#include + +using json = nlohmann::json; + +struct conn { + std::string dbname; + std::string user; + std::string password; + std::string hostaddr; + std::string port; + + conn(); + + [[nodiscard]] std::string getData() const; +}; + +#endif //SOURCEDOUT_CONN_HPP diff --git a/server/internal/src/db/src/conn.cpp b/server/internal/src/db/src/conn.cpp new file mode 100644 index 0000000000000000000000000000000000000000..9fe50742245c19d56e67188c91fc423e24776212 --- /dev/null +++ b/server/internal/src/db/src/conn.cpp @@ -0,0 +1,27 @@ +#pragma once + +#include +#include "conn.hpp" +#include +conn::conn() { + std::ifstream f("../config.json"); + json data = json::parse(R"( +{ + "dbname": "mydb", + "user": "postgres", + "password": "root", + "hostaddr": "172.28.224.1", + "port": "5432" +} +)"); + data.at("dbname").get_to(dbname); + data.at("user").get_to(user); + data.at("password").get_to(password); + data.at("hostaddr").get_to(hostaddr); + data.at("port").get_to(port); +} + +std::string conn::getData() const { + return "dbname = " + dbname + " user = " + user + " password = " + password + + " hostaddr = " + hostaddr + " port = " + port; +} \ No newline at end of file diff --git a/src/main.cpp b/src/main.cpp deleted file mode 100644 index 2eade44ba266eebca7e330a2c219da206e1475b7..0000000000000000000000000000000000000000 --- a/src/main.cpp +++ /dev/null @@ -1,30 +0,0 @@ -#include -#include - -#include "TextMetricsLib.h" - -int main(){ - std::ifstream fin1; - fin1.open("metrics/testProgs/code1.txt"); - assert(fin1.is_open()); - - std::ifstream fin2; - fin2.open("metrics/testProgs/code2.txt"); - assert(fin2.is_open()); - - std::string text1( (std::istreambuf_iterator(fin1) ), - (std::istreambuf_iterator() ) ); - - std::string text2( (std::istreambuf_iterator(fin2) ), - (std::istreambuf_iterator() ) ); - fin1.close(); - fin2.close(); - - LevDistTextMetric livDistTextMetric; - JaccardTextMetric jaccardTextMetric; - - livDistTextMetric.setData(text1, text2); - jaccardTextMetric.setData(text1, text2); - - std::cout << livDistTextMetric.getMetric() << std::endl << jaccardTextMetric.getMetric(); -} \ No newline at end of file