Added Controller namespace

include/database/base_repository.h

@@ -14,7 +14,7 @@ namespace Database
     public:
         base_repository();
         base_repository(const std::string&);
-        base_repository(const BinaryPath&);
+        base_repository(const Model::BinaryPath&);
     protected:
         MYSQL* setup_mysql_connection();
         MYSQL* setup_mysql_connection(Model::database_connection);
@@ -24,6 +24,7 @@ namespace Database
         Model::database_connection details;
     private:
         void intitalizeDetails();
+        void initializeDetails(const Model::BinaryPath&);
 
         std::string path;
         Model::BinaryPath m_binConf;

include/database/coverArtRepository.h

@@ -7,17 +7,21 @@
 #include "models/models.h"
 #include "types/coverFilter.h"
 
-class coverArtRepository : public base_repository
+namespace Database
 {
-public:
+    class coverArtRepository : public base_repository
-    coverArtRepository(const std::string&);
+    {
+    public:
+        coverArtRepository(const std::string&);
+        coverArtRepository(const Model::BinaryPath&);
 
-    Model::Cover retrieveRecord(Model::Cover&, coverFilter);
+        Model::Cover retrieveRecord(Model::Cover&, coverFilter);
 
-    void deleteRecord(const Model::Cover&);
+        void deleteRecord(const Model::Cover&);
-    void saveRecord(const Model::Cover&);
+        void saveRecord(const Model::Cover&);
-private:
+    private:
-    Model::Cover parseRecord(MYSQL_RES*);
+        Model::Cover parseRecord(MYSQL_RES*);
-};
+    };
+}
 
 #endif

include/database/songRepository.h

@@ -10,21 +10,25 @@
 #include "models/models.h"
 #include "types/songFilter.h"
 
-class songRepository : public base_repository
+namespace Database
 {
-public:
+    class songRepository : public base_repository
-    songRepository(const std::string&);
+    {
+    public:
+        songRepository(const std::string&);
+        songRepository(const Model::BinaryPath&);
 
-    std::vector<Model::Song> retrieveRecords();
+        std::vector<Model::Song> retrieveRecords();
 
-    Model::Song retrieveRecord(Model::Song&, songFilter);
+        Model::Song retrieveRecord(Model::Song&, songFilter);
 
-    void deleteRecord(const Model::Song&);
+        void deleteRecord(const Model::Song&);
-    void saveRecord(const Model::Song&);
+        void saveRecord(const Model::Song&);
-private:
+    private:
-    std::vector<Model::Song> parseRecords(MYSQL_RES*);
+        std::vector<Model::Song> parseRecords(MYSQL_RES*);
 
-    Model::Song parseRecord(MYSQL_RES*);
+        Model::Song parseRecord(MYSQL_RES*);
-};
+    };
+}
 
 #endif

include/managers/coverArtManager.h

@@ -11,9 +11,11 @@ namespace Manager
     {
     public:
         coverArtManager(const std::string&);
+        coverArtManager(const Model::BinaryPath& bConf);
 
         Model::Cover saveCover(const Model::Song&, std::string&, const std::string&);
     private:
+        Model::BinaryPath m_bConf;
         std::string path;
     };
 }

include/managers/directory_manager.h

@@ -15,11 +15,15 @@ namespace Manager
     public:
         static std::string create_directory_process(Model::Song, const std::string&);
         static std::string configPath(std::string_view);
-        static std::string contentOfPath(std::string_view);
+        static std::string configPath(const Model::BinaryPath&);
+        static std::string contentOfPath(const std::string&);
 
         static nlohmann::json credentialConfigContent(const std::string&);
+        static nlohmann::json credentialConfigContent(const Model::BinaryPath&);
         static nlohmann::json databaseConfigContent(const std::string&);
+        static nlohmann::json databaseConfigContent(const Model::BinaryPath&);
         static nlohmann::json pathConfigContent(const std::string&);
+        static nlohmann::json pathConfigContent(const Model::BinaryPath&);
 
         void delete_cover_art_file(const std::string&, const std::string&);
         static void delete_directories(Model::Song, const std::string&);

include/managers/song_manager.h

@@ -14,6 +14,7 @@ namespace Manager
     {
     public:
         song_manager(std::string&);
+        song_manager(const Model::BinaryPath&);
 
         void saveSong(Model::Song&);
         void deleteSong(Model::Song&);
@@ -22,6 +23,7 @@ namespace Manager
     private:
         void saveSongTemp(Model::Song&);
 
+        Model::BinaryPath m_bConf;
         std::string exe_path;
     };
 }

include/managers/token_manager.h

@@ -20,12 +20,12 @@ namespace Manager
 
         Model::loginResult retrieve_token();
         Model::loginResult retrieve_token(std::string_view);
-        Model::loginResult retrieve_token(const BinaryPath&);
+        Model::loginResult retrieve_token(const Model::BinaryPath&);
 
         bool is_token_valid(std::string&, Scope);
     private:
         Model::auth_credentials parse_auth_credentials(std::string_view);
-        Model::auth_credentials parse_auth_credentials(const BinaryPath&);
+        Model::auth_credentials parse_auth_credentials(const Model::BinaryPath&);
 
         std::vector<std::string> extract_scopes(const jwt::decoded_jwt&&);
         std::pair<bool, std::vector<std::string>> fetch_auth_header(const std::string&);

src/controller/loginController.hpp

@@ -12,42 +12,43 @@
 #include "../dto/loginResultDto.hpp"
 #include "managers/token_manager.h"
 
-class loginController : public oatpp::web::server::api::ApiController
+namespace Controller
 {
-public:
+    class loginController : public oatpp::web::server::api::ApiController
-    loginController(std::string p, OATPP_COMPONENT(std::shared_ptr<ObjectMapper>, objectMapper))
-        : oatpp::web::server::api::ApiController(objectMapper), exe_path(p)
-    { }
-    loginController(const Model::BinaryPath& bConf, OATPP_COMPONENT(std::shared_ptr<ObjectMapper>, objectMapper))
-        :oatpp::web::server::api::ApiController(objectMapper), m_bConf(bConf)
-    { }
-
-
-    #include OATPP_CODEGEN_BEGIN(ApiController)
-    
-    ENDPOINT("POST", "/api/v1/login", data, BODY_DTO(userDto::ObjectWrapper, usr))
     {
-        OATPP_LOGI("icarus", "logging in");
+    public:
+        loginController(std::string p, OATPP_COMPONENT(std::shared_ptr<ObjectMapper>, objectMapper))
+            : oatpp::web::server::api::ApiController(objectMapper), exe_path(p)
+        { }
+        loginController(const Model::BinaryPath& bConf, OATPP_COMPONENT(std::shared_ptr<ObjectMapper>, objectMapper))
+            :oatpp::web::server::api::ApiController(objectMapper), m_bConf(bConf)
+        { }
 
-        Manager::token_manager tok;
-        //auto token = tok.retrieve_token(exe_path);
-        auto token = tok.retrieve_token(bconf);
 
-        auto logRes = loginResultDto::createShared();
+        #include OATPP_CODEGEN_BEGIN(ApiController)
-        logRes->id = 0; // TODO: change this later on to something meaningful
+    
-        logRes->username = usr->username->c_str();
+        ENDPOINT("POST", "/api/v1/login", data, BODY_DTO(userDto::ObjectWrapper, usr)) {
-        logRes->token = token.access_token.c_str();
+            OATPP_LOGI("icarus", "logging in");
-        logRes->token_type = token.token_type.c_str();
-        logRes->expiration = token.expiration;
-        logRes->message = "Successful";
 
-        return createDtoResponse(Status::CODE_200, logRes);
+            Manager::token_manager tok;
-    }
+            //auto token = tok.retrieve_token(exe_path);
+            auto token = tok.retrieve_token(m_bConf);
 
-    #include OATPP_CODEGEN_END(ApiController)
+            auto logRes = loginResultDto::createShared();
-private:
+            logRes->id = 0; // TODO: change this later on to something meaningful
-    std::string exe_path;
+            logRes->username = usr->username->c_str();
-    Model::BinaryPath m_bConf;
+            logRes->token = token.access_token.c_str();
-};
+            logRes->token_type = token.token_type.c_str();
+            logRes->expiration = token.expiration;
+            logRes->message = "Successful";
 
+            return createDtoResponse(Status::CODE_200, logRes);
+        }
+
+        #include OATPP_CODEGEN_END(ApiController)
+    private:
+        std::string exe_path;
+        Model::BinaryPath m_bConf;
+    };
+}
 #endif

src/controller/songController.hpp

@@ -27,65 +27,98 @@
 
 namespace fs = std::filesystem;
 
-class songController : public oatpp::web::server::api::ApiController
+namespace Controller
 {
-public:
+    class songController : public oatpp::web::server::api::ApiController
-    songController(std::string p, OATPP_COMPONENT(std::shared_ptr<ObjectMapper>, objectMapper))
-        : oatpp::web::server::api::ApiController(objectMapper), m_exe_path(p)
-    { }
-
-    #include OATPP_CODEGEN_BEGIN(ApiController)
-
-    // endpoint for uploading a song
-    ENDPOINT("POST", "/api/v1/song/data", songUpload, 
-            REQUEST(std::shared_ptr<IncomingRequest>, request))
     {
-        auto authHeader = request->getHeader("Authorization");
+    public:
+        songController(std::string p, OATPP_COMPONENT(std::shared_ptr<ObjectMapper>, objectMapper))
+            : oatpp::web::server::api::ApiController(objectMapper), m_exe_path(p)
+        { }
 
-        OATPP_ASSERT_HTTP(authHeader, Status::CODE_403, "Nope");
+        songController(const Model::BinaryPath& bConf, OATPP_COMPONENT(std::shared_ptr<ObjectMapper>, objectMapper))
+            : oatpp::web::server::api::ApiController(objectMapper), m_bConf(bConf)
+        { }
 
-        auto auth = authHeader->std_str();
+        #include OATPP_CODEGEN_BEGIN(ApiController)
-        
-        Manager::token_manager tok;
-        OATPP_ASSERT_HTTP(tok.is_token_valid(auth, Scope::upload), Status::CODE_403, "Not allowed");
 
-        auto mp = std::make_shared<oatpp::web::mime::multipart::Multipart>(request->getHeaders());
+        // endpoint for uploading a song
-
+        ENDPOINT("POST", "/api/v1/song/data", songUpload, 
-        oatpp::web::mime::multipart::Reader mp_reader(mp.get());
-
-        mp_reader.setPartReader("file", oatpp::web::mime::multipart::createInMemoryPartReader(m_dataSize));
-
-        request->transferBody(&mp_reader);
-
-        auto file = mp->getNamedPart("file");
-
-        OATPP_ASSERT_HTTP(file, Status::CODE_400, "file is null");
-
-        auto buff = std::unique_ptr<char>(new char[file->getKnownSize()]);
-        auto buffSize = file->getInputStream()->read(buff.get(), file->getKnownSize());
-
-        std::vector<unsigned char> data(buff.get(), buff.get() + buffSize);
-
-        Model::Song sng;
-        sng.data = std::move(data);
-        
-        Manager::song_manager s_mgr(m_exe_path);
-        s_mgr.saveSong(sng);
-
-        return createResponse(Status::CODE_200, "OK");
-    }
-
-    // endpoint for retrieving all song records in json format
-    ENDPOINT("GET", "/api/v1/song", songRecords, 
             REQUEST(std::shared_ptr<IncomingRequest>, request))
-    {
+        {
-        std::cout << "starting process of retrieving songs" << std::endl;
+            auto authHeader = request->getHeader("Authorization");
-        Database::songRepository songRepo(m_exe_path);
+
-        auto songsDb = songRepo.retrieveRecords();
+            OATPP_ASSERT_HTTP(authHeader, Status::CODE_403, "Nope");
-        auto songs = oatpp::data::mapping::type::List<songDto::ObjectWrapper>::createShared();
+
+            auto auth = authHeader->std_str();
+        
+            Manager::token_manager tok;
+            OATPP_ASSERT_HTTP(tok.is_token_valid(auth, Scope::upload), Status::CODE_403, "Not allowed");
+
+            auto mp = std::make_shared<oatpp::web::mime::multipart::Multipart>(request->getHeaders());
+
+            oatpp::web::mime::multipart::Reader mp_reader(mp.get());
+
+            mp_reader.setPartReader("file", oatpp::web::mime::multipart::createInMemoryPartReader(m_dataSize));
+
+            request->transferBody(&mp_reader);
+
+            auto file = mp->getNamedPart("file");
+
+            OATPP_ASSERT_HTTP(file, Status::CODE_400, "file is null");
+
+            auto buff = std::unique_ptr<char>(new char[file->getKnownSize()]);
+            auto buffSize = file->getInputStream()->read(buff.get(), file->getKnownSize());
+
+            std::vector<unsigned char> data(buff.get(), buff.get() + buffSize);
+
+            Model::Song sng;
+            sng.data = std::move(data);
+        
+            Manager::song_manager s_mgr(m_bConf);
+            s_mgr.saveSong(sng);
+
+            return createResponse(Status::CODE_200, "OK");
+        }
+
+        // endpoint for retrieving all song records in json format
+        ENDPOINT("GET", "/api/v1/song", songRecords, 
+            REQUEST(std::shared_ptr<IncomingRequest>, request))
+        {
+            std::cout << "starting process of retrieving songs" << std::endl;
+            Database::songRepository songRepo(m_bConf);
+            auto songsDb = songRepo.retrieveRecords();
+            auto songs = oatpp::data::mapping::type::List<songDto::ObjectWrapper>::createShared();
+
+            std::cout << "creating object to send" << std::endl;
+            for (auto& songDb : songsDb) {
+                auto song = songDto::createShared();
+                song->id = songDb.id;
+                song->title = songDb.title.c_str();
+                song->artist = songDb.artist.c_str();
+                song->album = songDb.album.c_str();
+                song->genre = songDb.genre.c_str();
+                song->year = songDb.year;
+                song->duration = songDb.duration;
+                song->track = songDb.track;
+                song->disc = songDb.disc;
+
+                songs->pushBack(song);
+            }
+
+            return createDtoResponse(Status::CODE_200, songs);
+        }
+
+        // endpoint for retrieving song record by the song id in json format
+        ENDPOINT("GET", "/api/v1/song/{id}", songRecord, 
+            PATH(Int32, id)) {
+
+            Database::songRepository songRepo(m_bConf);
+            Model::Song songDb;
+            songDb.id = id;
+
+            songDb = songRepo.retrieveRecord(songDb, songFilter::id);
 
-        std::cout << "creating object to send" << std::endl;
-        for (auto& songDb : songsDb) {
             auto song = songDto::createShared();
             song->id = songDb.id;
             song->title = songDb.title.c_str();
@@ -97,80 +130,54 @@ public:
             song->track = songDb.track;
             song->disc = songDb.disc;
 
-            songs->pushBack(song);
+            return createDtoResponse(Status::CODE_200, song);
         }
 
-        return createDtoResponse(Status::CODE_200, songs);
+        ENDPOINT("GET", "/api/v1/song/data/{id}", downloadSong, 
-    }
-
-    // endpoint for retrieving song record by the song id in json format
-    ENDPOINT("GET", "/api/v1/song/{id}", songRecord, 
             PATH(Int32, id)) {
 
-        Database::songRepository songRepo(m_exe_path);
+            Database::songRepository songRepo(m_bConf);
-        Model::Song songDb;
+            Model::Song songDb;
-        songDb.id = id;
+            songDb.id = id;
+            songDb = songRepo.retrieveRecord(songDb, songFilter::id);
 
-        songDb = songRepo.retrieveRecord(songDb, songFilter::id);
+            std::ifstream fl(songDb.songPath.c_str(), std::ios::in | std::ios::binary | std::ios::ate);
+            fl.seekg(0);
 
-        auto song = songDto::createShared();
+            std::stringstream buf;
-        song->id = songDb.id;
+            std::copy(std::istreambuf_iterator<char>(fl),
-        song->title = songDb.title.c_str();
+                std::istreambuf_iterator<char>(),
-        song->artist = songDb.artist.c_str();
+                std::ostreambuf_iterator<char>(buf));
-        song->album = songDb.album.c_str();
+            fl.close();
-        song->genre = songDb.genre.c_str();
-        song->year = songDb.year;
-        song->duration = songDb.duration;
-        song->track = songDb.track;
-        song->disc = songDb.disc;
 
-        return createDtoResponse(Status::CODE_200, song);
+            auto rawSong = std::make_shared<oatpp::String>(oatpp::String(buf.str().data(), (v_int32)buf.str().size(), true));
-    }
-
-    ENDPOINT("GET", "/api/v1/song/data/{id}", downloadSong, 
-            PATH(Int32, id)) {
-
-        Database::songRepository songRepo(m_exe_path);
-        Model::Song songDb;
-        songDb.id = id;
-        songDb = songRepo.retrieveRecord(songDb, songFilter::id);
-
-        std::ifstream fl(songDb.songPath.c_str(), std::ios::in | std::ios::binary | std::ios::ate);
-        fl.seekg(0);
-
-        std::stringstream buf;
-        std::copy(std::istreambuf_iterator<char>(fl),
-            std::istreambuf_iterator<char>(),
-            std::ostreambuf_iterator<char>(buf));
-        fl.close();
-
-        auto rawSong = std::make_shared<oatpp::String>(oatpp::String(buf.str().data(), (v_int32)buf.str().size(), true));
         
-        auto response = createResponse(Status::CODE_200, *rawSong);
+            auto response = createResponse(Status::CODE_200, *rawSong);
-        response->putHeader(Header::CONTENT_TYPE, "audio/mpeg");
+            response->putHeader(Header::CONTENT_TYPE, "audio/mpeg");
 
-        return response;
+            return response;
-    }
+        }
 
-    // TODO: create endpoint for updating songs
+        // TODO: create endpoint for updating songs
 
-    ENDPOINT("DELETE", "api/v1/song/data/{id}", songDelete, PATH(Int32, id)) {
+        ENDPOINT("DELETE", "api/v1/song/data/{id}", songDelete, PATH(Int32, id)) {
 
-        Model::Song song;
+            Model::Song song;
-        song.id = id;
+            song.id = id;
 
-        Manager::song_manager sngMgr(m_exe_path);
+            Manager::song_manager sngMgr(m_bConf);
-        sngMgr.deleteSong(song);
+            sngMgr.deleteSong(song);
 
-        return createResponse(Status::CODE_200, "OK");
+            return createResponse(Status::CODE_200, "OK");
-    }
+        }
 
-    // TODO: create endpoint for streaming songs
+        // TODO: create endpoint for streaming songs
-
-    #include OATPP_CODEGEN_END(ApiController)
-private:
-    std::string m_exe_path;
-    const long m_dataSize = std::numeric_limits<long long int>::max();
-};
 
+        #include OATPP_CODEGEN_END(ApiController)
+    private:
+        std::string m_exe_path;
+        Model::BinaryPath m_bConf;
+        const long m_dataSize = std::numeric_limits<long long int>::max();
+    };
+}
 #endif

src/database/base_repository.cpp

@@ -6,15 +6,19 @@
 
 #include "managers/directory_manager.h"
 
-base_repository::base_repository() 
+Database::base_repository::base_repository() 
 { }
 
-base_repository::base_repository(const std::string& path) : path(path)
+Database::base_repository::base_repository(const std::string& path) : path(path)
 { 
     intitalizeDetails();
 }
+Database::base_repository::base_repository(const Model::BinaryPath& bConf)
+{
+    initializeDetails(bConf);
+}
 
-MYSQL* base_repository::setup_mysql_connection()
+MYSQL* Database::base_repository::setup_mysql_connection()
 {
     MYSQL *conn = mysql_init(nullptr);
 
@@ -25,7 +29,7 @@ MYSQL* base_repository::setup_mysql_connection()
 
     return conn;
 }
-MYSQL* base_repository::setup_mysql_connection(Model::database_connection details)
+MYSQL* Database::base_repository::setup_mysql_connection(Model::database_connection details)
 {
     MYSQL *connection = mysql_init(NULL);
 
@@ -37,7 +41,7 @@ MYSQL* base_repository::setup_mysql_connection(Model::database_connection detail
     return connection;
 }
 
-MYSQL_RES* base_repository::perform_mysql_query(MYSQL *conn, const std::string& query)
+MYSQL_RES* Database::base_repository::perform_mysql_query(MYSQL *conn, const std::string& query)
 {
    // send the query to the database
    if (mysql_query(conn, query.c_str()))
@@ -49,7 +53,7 @@ MYSQL_RES* base_repository::perform_mysql_query(MYSQL *conn, const std::string&
    return mysql_use_result(conn);
 }
 
-void base_repository::intitalizeDetails()
+void Database::base_repository::intitalizeDetails()
 {
     auto databaseConfig = Manager::directory_manager::databaseConfigContent(path);
     
@@ -58,3 +62,12 @@ void base_repository::intitalizeDetails()
     details.server = databaseConfig["server"].get<std::string>();
     details.username = databaseConfig["username"].get<std::string>();
 }
+void Database::base_repository::initializeDetails(const Model::BinaryPath& bConf)
+{
+    auto databaseConfig = Manager::directory_manager::databaseConfigContent(bConf);
+
+    details.database = databaseConfig["database"].get<std::string>();
+    details.server = databaseConfig["server"].get<std::string>();
+    details.username = databaseConfig["username"].get<std::string>();
+    details.password = databaseConfig["password"].get<std::string>();
+}

src/database/coverArtRepository.cpp

@@ -5,10 +5,13 @@
 #include <sstream>
 #include <cstring>
 
-coverArtRepository::coverArtRepository(const std::string& path) : base_repository(path)
+Database::coverArtRepository::coverArtRepository(const std::string& path) : base_repository(path)
 { }
 
-Model::Cover coverArtRepository::retrieveRecord(Model::Cover& cov, coverFilter filter = coverFilter::id)
+Database::coverArtRepository::coverArtRepository(const Model::BinaryPath& bConf) : base_repository(bConf)
+{ }
+
+Model::Cover Database::coverArtRepository::retrieveRecord(Model::Cover& cov, coverFilter filter = coverFilter::id)
 {
     std::stringstream qry;
     auto conn = setup_mysql_connection();
@@ -45,7 +48,7 @@ Model::Cover coverArtRepository::retrieveRecord(Model::Cover& cov, coverFilter f
     return covDb;
 }
 
-void coverArtRepository::deleteRecord(const Model::Cover& cov)
+void Database::coverArtRepository::deleteRecord(const Model::Cover& cov)
 {
     auto conn = setup_mysql_connection();
     const std::string query("DELETE FROM CoverArt WHERE CoverArtId = " + std::to_string(cov.id));
@@ -55,7 +58,7 @@ void coverArtRepository::deleteRecord(const Model::Cover& cov)
     mysql_close(conn);
 }
 
-void coverArtRepository::saveRecord(const Model::Cover& cov)
+void Database::coverArtRepository::saveRecord(const Model::Cover& cov)
 {
     auto conn = setup_mysql_connection();
 
@@ -93,7 +96,7 @@ void coverArtRepository::saveRecord(const Model::Cover& cov)
     std::cout << "done" << std::endl;
 }
 
-Model::Cover coverArtRepository::parseRecord(MYSQL_RES *results)
+Model::Cover Database::coverArtRepository::parseRecord(MYSQL_RES *results)
 {
     std::cout << "parsing record" << std::endl;
     Model::Cover cov;

src/database/songRepository.cpp

@@ -7,10 +7,13 @@
 
 #include "types/songFilter.h"
 
-songRepository::songRepository(const std::string& path) : base_repository(path)
+Database::songRepository::songRepository(const std::string& path) : base_repository(path)
 { }
 
-std::vector<Model::Song> songRepository::retrieveRecords()
+Database::songRepository::songRepository(const Model::BinaryPath& bConf) : base_repository(bConf)
+{ }
+
+std::vector<Model::Song> Database::songRepository::retrieveRecords()
 {
     auto conn = setup_mysql_connection();
     const std::string query = "SELECT * FROM Song";
@@ -24,7 +27,7 @@ std::vector<Model::Song> songRepository::retrieveRecords()
     return songs;
 }
 
-Model::Song songRepository::retrieveRecord(Model::Song& song, songFilter filter)
+Model::Song Database::songRepository::retrieveRecord(Model::Song& song, songFilter filter)
 {
     std::stringstream qry;
     auto conn = setup_mysql_connection();
@@ -57,7 +60,7 @@ Model::Song songRepository::retrieveRecord(Model::Song& song, songFilter filter)
     return song;
 }
 
-void songRepository::deleteRecord(const Model::Song& song)
+void Database::songRepository::deleteRecord(const Model::Song& song)
 {
     auto conn = setup_mysql_connection();
     auto status = 0;
@@ -69,7 +72,7 @@ void songRepository::deleteRecord(const Model::Song& song)
     mysql_close(conn);
 }
 
-void songRepository::saveRecord(const Model::Song& song)
+void Database::songRepository::saveRecord(const Model::Song& song)
 {
     auto conn = setup_mysql_connection();
     auto status = 0;
@@ -148,7 +151,7 @@ void songRepository::saveRecord(const Model::Song& song)
     std::cout << "done inserting song record" << std::endl;
 }
 
-std::vector<Model::Song> songRepository::parseRecords(MYSQL_RES* results)
+std::vector<Model::Song> Database::songRepository::parseRecords(MYSQL_RES* results)
 {
     auto fieldNum = mysql_num_fields(results);
     auto numRows = mysql_num_rows(results);
@@ -203,7 +206,7 @@ std::vector<Model::Song> songRepository::parseRecords(MYSQL_RES* results)
     return songs;
 }
 
-Model::Song songRepository::parseRecord(MYSQL_RES* results)
+Model::Song Database::songRepository::parseRecord(MYSQL_RES* results)
 {
     Model::Song song;
     auto fieldNum = mysql_num_fields(results);

src/main.cpp

@@ -24,8 +24,8 @@ void run(const Model::BinaryPath& bConf)
 
     OATPP_COMPONENT(std::shared_ptr<oatpp::web::server::HttpRouter>, router);
 
-    auto logController = std::make_shared<loginController>(bConf);
+    auto logController = std::make_shared<Controller::loginController>(bConf);
-    auto sngController = std::make_shared<songController>(bConf);
+    auto sngController = std::make_shared<Controller::songController>(bConf);
     logController->addEndpointsToRouter(router);
     sngController->addEndpointsToRouter(router);
 
@@ -45,7 +45,7 @@ int main(int argc, char **argv)
     oatpp::base::Environment::init();
     //const std::string working_path = argv[0];
     Model::BinaryPath bConf; 
-    bConf.path = argv[0]
+    bConf.path = argv[0];
 
     //run(working_path);
     run(bConf);

src/managers/coverArtManager.cpp

@@ -7,6 +7,9 @@
 Manager::coverArtManager::coverArtManager(const std::string& configPath) : path(configPath)
 { }
 
+Manager::coverArtManager::coverArtManager(const Model::BinaryPath& bConf) : m_bConf(bConf)
+{ }
+
 
 Model::Cover Manager::coverArtManager::saveCover(const Model::Song& song, std::string& rootPath, const std::string& stockCoverPath)
 {
@@ -16,7 +19,7 @@ Model::Cover Manager::coverArtManager::saveCover(const Model::Song& song, std::s
     cov = meta.update_cover_art(song, cov, stockCoverPath);
     cov.songTitle = song.title;
 
-    Database::coverArtRepository covRepo(path);
+    Database::coverArtRepository covRepo(m_bConf);
     std::cout << "saving record to the database" << std::endl;
     covRepo.saveRecord(cov);
     std::cout << "retrieving record from database" << std::endl;

src/managers/directory_manager.cpp

@@ -41,10 +41,13 @@ std::string Manager::directory_manager::configPath(std::string_view path)
 {
     return fs::canonical(path).parent_path().string();
 }
-std::string Manager::directory_manager::contentOfPath(std::string_view path)
+std::string Manager::directory_manager::configPath(const Model::BinaryPath& bConf)
 {
-    std::string configPath(path);
+    return fs::canonical(bConf.path).parent_path().string();
-    std::fstream a(configPath, std::ios::in);
+}
+std::string Manager::directory_manager::contentOfPath(const std::string& path)
+{
+    std::fstream a(path, std::ios::in);
     std::stringstream s;
     s << a.rdbuf();
     a.close();
@@ -59,6 +62,13 @@ nlohmann::json Manager::directory_manager::credentialConfigContent(const std::st
 
     return nlohmann::json::parse(contentOfPath(path));
 }
+nlohmann::json Manager::directory_manager::credentialConfigContent(const Model::BinaryPath& bConf)
+{
+    auto path = configPath(bConf);
+    path.append("/authcredentials.json");
+
+    return nlohmann::json::parse(contentOfPath(path));
+}
 nlohmann::json Manager::directory_manager::databaseConfigContent(const std::string& exe_path)
 {
     auto path = configPath(exe_path);
@@ -66,6 +76,13 @@ nlohmann::json Manager::directory_manager::databaseConfigContent(const std::stri
 
     return nlohmann::json::parse(contentOfPath(path));
 }
+nlohmann::json Manager::directory_manager::databaseConfigContent(const Model::BinaryPath& bConf)
+{
+    auto path = configPath(bConf);
+    path.append("/database.json");
+
+    return nlohmann::json::parse(contentOfPath(path));
+}
 nlohmann::json Manager::directory_manager::pathConfigContent(const std::string& exe_path)
 {
     auto path = configPath(exe_path);
@@ -73,6 +90,13 @@ nlohmann::json Manager::directory_manager::pathConfigContent(const std::string&
 
     return nlohmann::json::parse(contentOfPath(path));
 }
+nlohmann::json Manager::directory_manager::pathConfigContent(const Model::BinaryPath& bConf)
+{
+    auto path = configPath(bConf);
+    path.append("/paths.json");
+
+    return nlohmann::json::parse(contentOfPath(path));
+}
 
 void Manager::directory_manager::delete_cover_art_file(const std::string& cov_path, const std::string& stock_cover_path)
 {

src/managers/song_manager.cpp

@@ -18,6 +18,10 @@ Manager::song_manager::song_manager(std::string& x_path)
     : exe_path(x_path)
 { }
 
+Manager::song_manager::song_manager(const Model::BinaryPath& bConf)
+    : m_bConf(bConf)
+{ }
+
 
 void Manager::song_manager::saveSong(Model::Song& song)
 {
@@ -27,12 +31,12 @@ void Manager::song_manager::saveSong(Model::Song& song)
     song = meta.retrieve_metadata(song.songPath);
     song.data = std::move(data);
 
-    coverArtManager covMgr(exe_path);
+    coverArtManager covMgr(m_bConf);
-    auto pathConfigContent = Manager::directory_manager::pathConfigContent(exe_path);
+    auto pathConfigContent = Manager::directory_manager::pathConfigContent(m_bConf);
     auto coverRootPath = pathConfigContent["cover_root_path"].get<std::string>();
     auto musicRootPath = pathConfigContent["root_music_path"].get<std::string>();
 
-    auto stockCoverPath = Manager::directory_manager::configPath(exe_path);
+    auto stockCoverPath = Manager::directory_manager::configPath(m_bConf);
     stockCoverPath.append("/CoverArt.png");
 
     auto cov = covMgr.saveCover(song, coverRootPath, stockCoverPath);
@@ -49,14 +53,14 @@ void Manager::song_manager::saveSong(Model::Song& song)
 
     printSong(song);
 
-    Database::songRepository songRepo(exe_path);
+    Database::songRepository songRepo(m_bConf);
     songRepo.saveRecord(song);
 }
 
 void Manager::song_manager::deleteSong(Model::Song& song)
 {
-    Database::coverArtRepository covRepo(exe_path);
+    Database::coverArtRepository covRepo(m_bConf);
-    Database::songRepository songRepo(exe_path);
+    Database::songRepository songRepo(m_bConf);
 
     song = songRepo.retrieveRecord(song, songFilter::id);
     songRepo.deleteRecord(song);
@@ -66,7 +70,7 @@ void Manager::song_manager::deleteSong(Model::Song& song)
     cov = covRepo.retrieveRecord(cov, coverFilter::id);
     covRepo.deleteRecord(cov);
 
-    auto paths = Manager::directory_manager::pathConfigContent(exe_path);
+    auto paths = Manager::directory_manager::pathConfigContent(m_bConf);
     const auto coverArtPath = paths["cover_root_path"].get<std::string>();
     std::string stockCoverArtPath = coverArtPath;
     stockCoverArtPath.append("CoverArt.png");
@@ -100,7 +104,7 @@ void Manager::song_manager::printSong(const Model::Song& song)
 
 void Manager::song_manager::saveSongTemp(Model::Song& song)
 {
-    auto config = Manager::directory_manager::pathConfigContent(exe_path);
+    auto config = Manager::directory_manager::pathConfigContent(m_bConf);
 
     auto tmp_song = config["temp_root_path"].get<std::string>();
     std::random_device dev;

src/managers/token_manager.cpp

@@ -57,6 +57,34 @@ Model::loginResult Manager::token_manager::retrieve_token(std::string_view path)
 
     return lr;
 }
+Model::loginResult Manager::token_manager::retrieve_token(const Model::BinaryPath& bConf)
+{
+    auto cred = parse_auth_credentials(bConf);
+
+    nlohmann::json reqObj;
+    reqObj["client_id"] = cred.client_id;
+    reqObj["client_secret"] = cred.client_secret;
+    reqObj["audience"] = cred.api_identifier;
+    reqObj["grant_type"] = "client_credentials";
+
+    std::string uri{cred.uri};
+    uri.append("/");
+    uri.append(cred.endpoint);
+
+    auto r = cpr::Post(cpr::Url{uri},
+        cpr::Body{reqObj.dump()},
+        cpr::Header{{"Content-Type", "application/json"},
+        {"Connection", "keep-alive"}});
+
+    auto post_res = nlohmann::json::parse(r.text);
+
+    Model::loginResult lr;
+    lr.access_token = post_res["access_token"].get<std::string>();
+    lr.token_type = post_res["token_type"].get<std::string>();
+    lr.expiration = post_res["expires_in"].get<int>();
+
+    return lr;
+}
 
 bool Manager::token_manager::is_token_valid(std::string& auth, Scope scope)
 {
@@ -104,10 +132,10 @@ Model::auth_credentials Manager::token_manager::parse_auth_credentials(std::stri
 
     return auth;
 }
-Model::auth_credentials Manager::token_manager::parse_auth_credentials(const BinaryPath& bConf)
+Model::auth_credentials Manager::token_manager::parse_auth_credentials(const Model::BinaryPath& bConf)
 {
     auto exePath = Manager::directory_manager::configPath(bConf);
-    exe_path.append("/auth_credentials.json");
+    exePath.append("/auth_credentials.json");
 
     auto con = Manager::directory_manager::credentialConfigContent(exePath);