Able to save and retrieve records (Artist, Album, Genre, etc.)

Scripts/MySQL/create_database.sql

@@ -34,6 +34,7 @@ CREATE TABLE Genre (
 
 CREATE TABLE Year (
     YearId INT NOT NULL AUTO_INCREMENT,
+    Year INT NOT NULL,
 
     PRIMARY KEY (YearId)
 );

include/controller/loginController.hpp

@@ -31,7 +31,6 @@ namespace Controller
             OATPP_LOGI("icarus", "logging in");
 
             Manager::token_manager tok;
-            //auto token = tok.retrieve_token(exe_path);
             auto token = tok.retrieve_token(m_bConf);
 
             auto logRes = Dto::loginResultDto::createShared();

include/database/artistRepository.h

@@ -3,7 +3,7 @@
 
 #include "database/base_repository.h"
 #include "models/models.h"
-#include "types/coverFilter.h"
+#include "types/artistFilter.h"
 
 namespace Database
 {
@@ -11,7 +11,12 @@ namespace Database
     {
     public:
         artistRepository(const Model::BinaryPath&);
+
+        Model::Artist retrieveRecord(Model::Artist&, Type::artistFilter);
+
+        void saveRecord(const Model::Artist&);
     private:
+        Model::Artist parseRecord(MYSQL_RES*);
     };
 }
 

include/database/genreRepository.h

@@ -3,6 +3,7 @@
 
 #include "database/base_repository.h"
 #include "models/models.h"
+#include "types/genreFilter.h"
 
 namespace Database
 {
@@ -10,7 +11,12 @@ namespace Database
     {
     public:
         genreRepository(const Model::BinaryPath&);
+
+        Model::Genre retrieveRecord(Model::Genre&, Type::genreFilter);
+
+        void saveRecord(const Model::Genre&);
     private:
+        Model::Genre parseRecord(MYSQL_RES*);
     };
 }
 

include/database/yearRepository.h

@@ -3,6 +3,7 @@
 
 #include "database/base_repository.h"
 #include "models/models.h"
+#include "types/yearFilter.h"
 
 namespace Database
 {
@@ -10,7 +11,12 @@ namespace Database
     {
     public:
         yearRepository(const Model::BinaryPath&);
+
+        Model::Year retrieveRecord(Model::Year&, Type::yearFilter);
+
+        void saveRecord(const Model::Year&);
     private:
+        Model::Year parseRecord(MYSQL_RES*);
     };
 }
 

include/managers/albumManager.h

@@ -10,7 +10,10 @@ namespace Manager
     public:
         albumManager(const Model::BinaryPath&);
 
-        void saveAlbum(const Model::Song&);
+        Model::Album retrieveAlbum(Model::Album&);
+        Model::Album saveAlbum(const Model::Song&);
+
+        static void printAlbum(const Model::Album&);
     private:
         Model::BinaryPath m_bConf;
     };

include/managers/artistManager.h

@@ -9,6 +9,11 @@ namespace Manager
     {
     public:
         artistManager(const Model::BinaryPath&);
+
+        Model::Artist retrieveArtist(Model::Artist&);
+        Model::Artist saveArtist(const Model::Song&);
+
+        static void printArtist(const Model::Artist&);
     private:
         Model::BinaryPath m_bConf;
     };

include/managers/directory_manager.h

@@ -18,11 +18,11 @@ namespace Manager
         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 std::string&);
         static nlohmann::json credentialConfigContent(const Model::BinaryPath&);
-        static nlohmann::json databaseConfigContent(const std::string&);
+        //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 std::string&);
         static nlohmann::json pathConfigContent(const Model::BinaryPath&);
 
         void delete_cover_art_file(const std::string&, const std::string&);

include/managers/genreManager.h

@@ -9,6 +9,11 @@ namespace Manager
     {
     public:
         genreManager(const Model::BinaryPath&);
+
+        Model::Genre retrieveGenre(Model::Genre&);
+        Model::Genre saveGenre(const Model::Song&);
+
+        static void printGenre(const Model::Genre&);
     private:
         Model::BinaryPath m_bConf;
     };

include/managers/yearManager.h

@@ -9,6 +9,11 @@ namespace Manager
     {
     public:
         yearManager(const Model::BinaryPath&);
+
+        Model::Year retrieveYear(Model::Year&);
+        Model::Year saveYear(const Model::Song&);
+
+        static void printYear(const Model::Year&);
     private:
         Model::BinaryPath m_bConf;
     };

include/models/models.h

@@ -94,6 +94,8 @@ namespace Model
     {
         BinaryPath() = default;
         BinaryPath(const char *p) : path(std::move(p)) { }
+        BinaryPath(std::string& p) : path(std::move(p)) { }
+        BinaryPath(const std::string& p) : path(std::move(p)) { }
         std::string path;
     };
 }

src/database/albumRepository.cpp

@@ -21,6 +21,7 @@ std::vector<Model::Album> Database::albumRepository::retrieveRecords()
 
 Model::Album Database::albumRepository::retrieveRecord(Model::Album& album, Type::albumFilter filter)
 {
+    std::cout << "retrieving album record" << std::endl;
     std::stringstream qry;
     auto conn = setup_mysql_connection();
     qry << "SELECT alb.* FROM Album alb WHERE ";
@@ -35,12 +36,12 @@ Model::Album Database::albumRepository::retrieveRecord(Model::Album& album, Type
             mysql_real_escape_string(conn, *param, album.title.c_str(), album.title.size());
             qry << "alb.Title = '" << *param << "'";
             break;
-        case Type::albumFilter::year:
-            break;
         default:
             break;
     }
 
+    qry << " ORDER BY AlbumId DESC LIMIT 1";
+
     const std::string query = qry.str();
     auto results = perform_mysql_query(conn, query);
 
@@ -57,13 +58,11 @@ void Database::albumRepository::saveAlbum(const Model::Album& album)
     std::cout << "beginning to insert album record" << std::endl;
 
     auto conn = setup_mysql_connection();
-    auto status = 0;
-
     MYSQL_STMT *stmt = mysql_stmt_init(conn);
 
-    std::string query = "INSERT INTO Album(Title, Year) VALUES(?, ?)";
+    const std::string query = "INSERT INTO Album(Title, Year) VALUES(?, ?)";
 
-    status = mysql_stmt_prepare(stmt, query.c_str(), query.size());
+    auto status = mysql_stmt_prepare(stmt, query.c_str(), query.size());
 
     MYSQL_BIND params[2];
     memset(params, 0, sizeof(params));
@@ -71,7 +70,7 @@ void Database::albumRepository::saveAlbum(const Model::Album& album)
     params[0].buffer_type = MYSQL_TYPE_STRING;
     params[0].buffer = (char*)album.title.c_str();
     auto titleLength = album.title.size();
-    params[0].buffer = &titleLength;
+    params[0].length= &titleLength;
     params[0].is_null = 0;
 
     params[1].buffer_type = MYSQL_TYPE_LONG;
@@ -99,9 +98,10 @@ std::vector<Model::Album> Database::albumRepository::parseRecords(MYSQL_RES* res
 
 Model::Album Database::albumRepository::parseRecord(MYSQL_RES* results)
 {
+    std::cout << "parsing album record" << std::endl;
     Model::Album album;
-    auto fieldNum = mysql_num_fields(results);
 
+    auto fieldNum = mysql_num_fields(results);
     auto row = mysql_fetch_row(results);
 
     for (auto i = 0; i != fieldNum; ++i) {

src/database/artistRepository.cpp

@@ -1,6 +1,102 @@
 #include "database/artistRepository.h"
 
+#include <iostream>
+#include <memory>
+#include <sstream>
+#include <string>
+#include <cstring>
+
 Database::artistRepository::artistRepository(const Model::BinaryPath& binConf)
     : base_repository(binConf)
 {
 }
+
+
+Model::Artist Database::artistRepository::retrieveRecord(Model::Artist& artist, Type::artistFilter filter)
+{
+    std::cout << "retrieving artist record" << std::endl;
+    std::stringstream qry;
+    auto conn = setup_mysql_connection();
+    qry << "SELECT art.* FROM Artist art WHERE ";
+
+    std::unique_ptr<char*> param;
+    switch (filter) {
+        case Type::artistFilter::id:
+            qry << "art.ArtistId = " << artist.id;
+            break;
+        case Type::artistFilter::artist:
+            param = std::make_unique<char*>(new char[artist.artist.size()]);
+            mysql_real_escape_string(conn, *param, artist.artist.c_str(), artist.artist.size());
+            qry << "art.Artist ='" << *param << "'";
+            break;
+        default:
+            break;
+    }
+
+    qry << " ORDER BY ArtistId DESC LIMIT 1";
+
+    const auto query = qry.str();
+    auto results = perform_mysql_query(conn, query);
+
+    artist = parseRecord(results);
+
+    mysql_close(conn);
+
+    std::cout << "retrieved record" << std::endl;
+
+    return artist;
+}
+
+void Database::artistRepository::saveRecord(const Model::Artist& artist)
+{
+    std::cout << "inserting artist record" << std::endl;
+
+    auto conn = setup_mysql_connection();
+    MYSQL_STMT *stmt = mysql_stmt_init(conn);
+
+    const std::string query = "INSERT INTO Artist(Artist) VALUES(?)";
+
+    auto status = mysql_stmt_prepare(stmt, query.c_str(), query.size());
+
+    MYSQL_BIND params[1];
+    memset(params, 0, sizeof(params));
+
+    params[0].buffer_type = MYSQL_TYPE_STRING;
+    params[0].buffer = (char*)artist.artist.c_str();
+    auto artistLength = artist.artist.size();
+    params[0].length = &artistLength;
+    params[0].is_null = 0;
+
+    status = mysql_stmt_bind_param(stmt, params);
+    status = mysql_stmt_execute(stmt);
+
+    mysql_stmt_close(stmt);
+    mysql_close(conn);
+
+    std::cout<< "inserted artist record" << std::endl;
+}
+
+
+Model::Artist Database::artistRepository::parseRecord(MYSQL_RES* results)
+{
+    std::cout << "parsing artist record" << std::endl;
+    Model::Artist artist;
+
+    auto fieldNum = mysql_num_fields(results);
+    auto row = mysql_fetch_row(results);
+
+    for (auto i = 0; i != fieldNum; ++i) {
+        const std::string field(mysql_fetch_field(results)->name);
+
+        if (field.compare("ArtistId") == 0) {
+            artist.id = std::stoi(row[i]);
+        }
+        if (field.compare("Artist") == 0) {
+            artist.artist = row[i];
+        }
+    }
+
+    std::cout << "parsed artist record" << std::endl;
+
+    return artist;
+}

src/database/coverArtRepository.cpp

@@ -25,13 +25,11 @@ Model::Cover Database::coverArtRepository::retrieveRecord(Model::Cover& cov, Typ
         case Type::coverFilter::songTitle:
             param = std::make_unique<char*>(new char[cov.songTitle.size()]);
             mysql_real_escape_string(conn, *param, cov.songTitle.c_str(), cov.songTitle.size());
-            std::cout << *param << std::endl;
             qry << "SongTitle = '" << *param << "'";
             break;
         case Type::coverFilter::imagePath:
             param = std::make_unique<char*>(new char[cov.imagePath.size()]);
             mysql_real_escape_string(conn, *param, cov.imagePath.c_str(), cov.imagePath.size());
-            std::cout << *param << std::endl;
             qry << "ImagePath = '" << *param << "'";
             break;
     }

src/database/genreRepository.cpp

@@ -1,5 +1,99 @@
 #include "database/genreRepository.h"
 
+#include <iostream>
+#include <memory>
+#include <sstream>
+#include <cstring>
+
 Database::genreRepository::genreRepository(const Model::BinaryPath& bConf)
     : base_repository(bConf)
 { }
+
+
+Model::Genre Database::genreRepository::retrieveRecord(Model::Genre& genre, Type::genreFilter filter)
+{
+    std::cout << "retrieving genre record" << std::endl;
+    std::stringstream qry;
+    auto conn = setup_mysql_connection();
+    qry << "SELECT gnr.* FROM Genre gnr WHERE ";
+
+    std::unique_ptr<char*> param;
+    switch (filter) {
+        case Type::genreFilter::id:
+            qry << "gnr.GenreId = " << genre.id;
+            break;
+        case Type::genreFilter::category:
+            param = std::make_unique<char*>(new char[genre.category.size()]);
+            mysql_real_escape_string(conn, *param, genre.category.c_str(), genre.category.size());
+            qry << "gnr.Category ='" << *param << "'";
+            break;
+        default:
+            break;
+    }
+
+    qry << " ORDER BY GenreId DESC LIMIT 1";
+
+    const auto query = qry.str();
+    auto results = perform_mysql_query(conn, query);
+
+    genre = parseRecord(results);
+
+    mysql_close(conn);
+
+    std::cout << "retrieved record" << std::endl;
+
+    return genre;
+}
+
+void Database::genreRepository::saveRecord(const Model::Genre& genre)
+{
+    std::cout << "inserting genre record" << std::endl;
+
+    auto conn = setup_mysql_connection();
+    MYSQL_STMT *stmt = mysql_stmt_init(conn);
+
+    const std::string query("INSERT INTO Genre(Category) VALUES(?)");
+
+    auto status = mysql_stmt_prepare(stmt, query.c_str(), query.size());
+
+    MYSQL_BIND params[1];
+    memset(params, 0, sizeof(params));
+
+    params[0].buffer_type = MYSQL_TYPE_STRING;
+    params[0].buffer = (char*)genre.category.c_str();
+    auto categoryLength = genre.category.size();
+    params[0].length = &categoryLength;
+    params[0].is_null = 0;
+
+    status = mysql_stmt_bind_param(stmt, params);
+    status = mysql_stmt_execute(stmt);
+
+    mysql_stmt_close(stmt);
+    mysql_close(conn);
+
+    std::cout << "inserted record" << std::endl;
+}
+
+Model::Genre Database::genreRepository::parseRecord(MYSQL_RES* results)
+{
+    std::cout << "parsing genre record" << std::endl;
+    Model::Genre genre;
+
+    auto fieldNum = mysql_num_fields(results);
+    auto row = mysql_fetch_row(results);
+
+    for (auto i =0; i != fieldNum; ++i) {
+        const std::string field(mysql_fetch_field(results)->name);
+
+        if (field.compare("GenreId") == 0) {
+            genre.id = std::stoi(row[i]);
+        }
+        if (field.compare("Category") == 0) {
+            genre.category = row[i];
+        }
+    }
+
+    std::cout << "parsed genre record" << std::endl;
+
+    return genre;
+}

src/database/songRepository.cpp

@@ -41,7 +41,6 @@ Model::Song Database::songRepository::retrieveRecord(Model::Song& song, Type::so
         case Type::songFilter::title:
             param = std::make_unique<char*>(new char[song.title.size()]);
             mysql_real_escape_string(conn, *param, song.title.c_str(), song.title.size());
-            std::cout << *param << std::endl;
             qry << "Title = '" << *param << "'";
             break;
         default:
@@ -81,11 +80,12 @@ void Database::songRepository::saveRecord(const Model::Song& song)
     MYSQL_STMT *stmt = mysql_stmt_init(conn);
 
     std::string query = "INSERT INTO Song(Title, Artist, Album, Genre, ";
-    query.append("Year, Duration, Track, Disc, SongPath, CoverArtId) VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?, ?)");
+    query.append("Year, Duration, Track, Disc, SongPath, CoverArtId, ArtistId, ");
+    query.append("AlbumId, GenreId, YearId) VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)");
 
     status = mysql_stmt_prepare(stmt, query.c_str(), query.size());
 
-    MYSQL_BIND params[10];
+    MYSQL_BIND params[14];
     memset(params, 0, sizeof(params));
 
     params[0].buffer_type = MYSQL_TYPE_STRING;
@@ -143,6 +143,26 @@ void Database::songRepository::saveRecord(const Model::Song& song)
     params[9].length = 0;
     params[9].is_null = 0;
 
+    params[10].buffer_type = MYSQL_TYPE_LONG;
+    params[10].buffer = (char*)&song.artistId;
+    params[10].length = 0;
+    params[10].is_null = 0;
+
+    params[11].buffer_type = MYSQL_TYPE_LONG;
+    params[11].buffer = (char*)&song.albumId;
+    params[11].length = 0;
+    params[11].is_null = 0;
+    
+    params[12].buffer_type = MYSQL_TYPE_LONG;
+    params[12].buffer = (char*)&song.genreId;
+    params[12].length = 0;
+    params[12].is_null = 0;
+
+    params[13].buffer_type = MYSQL_TYPE_LONG;
+    params[13].buffer = (char*)&song.yearId;
+    params[13].length = 0;
+    params[13].is_null = 0;
+
     status = mysql_stmt_bind_param(stmt, params);
     status = mysql_stmt_execute(stmt);
 

src/database/yearRepository.cpp

@@ -1,5 +1,97 @@
 #include "database/yearRepository.h"
 
+#include <iostream>
+#include <memory>
+#include <sstream>
+#include <string>
+#include <cstring>
+
+
 Database::yearRepository::yearRepository(const Model::BinaryPath& bConf)
     : base_repository(bConf)
 { }
+
+
+Model::Year Database::yearRepository::retrieveRecord(Model::Year& year, Type::yearFilter filter)
+{
+    std::cout << "retrieving year record" << std::endl;
+    std::stringstream qry;
+    auto conn = setup_mysql_connection();
+    qry << "SELECT yr.* FROM Year yr WHERE ";
+
+    switch (filter) {
+        case Type::yearFilter::id:
+            qry << "yr.YearId = " << year.id;
+            break;
+        case Type::yearFilter::year:
+            qry << "yr.Year = " << year.year;
+            break;
+        default:
+            break;
+    }
+
+    qry << " ORDER BY yr.YearId DESC LIMIT 1";
+
+    const auto query = qry.str();
+    auto results = perform_mysql_query(conn, query);
+
+    year = parseRecord(results);
+
+    mysql_close(conn);
+
+    std::cout << "retrieved record" << std::endl;
+
+    return year;
+}
+
+void Database::yearRepository::saveRecord(const Model::Year& year)
+{
+    std::cout << "saving year record" << std::endl;
+
+    auto conn = setup_mysql_connection();
+    MYSQL_STMT *stmt = mysql_stmt_init(conn);
+
+    const std::string query("INSERT INTO Year(Year) VALUES(?)");
+
+    auto status = mysql_stmt_prepare(stmt, query.c_str(), query.size());
+
+    MYSQL_BIND params[1];
+    memset(params, 0 , sizeof(params));
+
+    params[0].buffer_type = MYSQL_TYPE_LONG;
+    params[0].buffer = (char*)&year.year;
+    params[0].length = 0;
+    params[0].is_null = 0;
+
+    status = mysql_stmt_bind_param(stmt, params);
+    status = mysql_stmt_execute(stmt);
+
+    mysql_stmt_close(stmt);
+    mysql_close(conn);
+
+    std::cout << "saved record" << std::endl;
+}
+
+Model::Year Database::yearRepository::parseRecord(MYSQL_RES *results)
+{
+    std::cout << "parsing year record" << std::endl;
+    Model::Year year;
+
+    auto fieldNum = mysql_num_fields(results);
+    auto row = mysql_fetch_row(results);
+
+    for (auto i = 0; i != fieldNum; ++i) {
+        const std::string field(mysql_fetch_field(results)->name);
+
+        if (field.compare("YearId") == 0) {
+            year.id= std::stoi(row[i]);
+        }
+        if (field.compare("Year") == 0) {
+            year.year = std::stoi(row[i]);
+        }
+    }
+
+    std::cout << "parse year record" << std::endl;
+
+    return year;
+}

src/main.cpp

@@ -43,6 +43,7 @@ void run(const Model::BinaryPath& bConf)
 int main(int argc, char **argv)
 {
     oatpp::base::Environment::init();
+    
     Model::BinaryPath bConf(argv[0]);
 
     run(bConf);

src/managers/albumManager.cpp

@@ -1,14 +1,25 @@
 #include "managers/albumManager.h"
 
+#include <iostream>
+
 #include "database/albumRepository.h"
 #include "models/models.h"
+#include "types/albumFilter.h"
 
 Manager::albumManager::albumManager(const Model::BinaryPath& bConf)
     : m_bConf(bConf)
 { }
 
 
-void Manager::albumManager::saveAlbum(const Model::Song& song)
+Model::Album Manager::albumManager::retrieveAlbum(Model::Album& album)
+{
+    Database::albumRepository albRepo(m_bConf);
+    album = std::move(albRepo.retrieveRecord(album, Type::albumFilter::title));
+
+    return album;
+}
+
+Model::Album Manager::albumManager::saveAlbum(const Model::Song& song)
 {
     Model::Album album;
     album.title = song.album;
@@ -16,4 +27,14 @@ void Manager::albumManager::saveAlbum(const Model::Song& song)
     
     Database::albumRepository albRepo(m_bConf);
     albRepo.saveAlbum(album);
+
+    return album;
+}
+
+void Manager::albumManager::printAlbum(const Model::Album& album)
+{
+    std::cout << "\nalbum record" << std::endl;
+    std::cout << "id: " << album.id << std::endl;
+    std::cout << "title: " << album.title << std::endl;
+    std::cout << "year: " << album.year << std::endl;
 }

src/managers/artistManager.cpp

@@ -1,5 +1,38 @@
 #include "managers/artistManager.h"
 
+#include <iostream>
+
+#include "database/artistRepository.h"
+#include "types/artistFilter.h"
+
 Manager::artistManager::artistManager(const Model::BinaryPath& bConf)
     : m_bConf(bConf)
 { }
+
+
+Model::Artist Manager::artistManager::retrieveArtist(Model::Artist& artist)
+{
+    Database::artistRepository artRepo(m_bConf);
+    artist = artRepo.retrieveRecord(artist, Type::artistFilter::artist);
+
+    return artist;
+}
+
+Model::Artist Manager::artistManager::saveArtist(const Model::Song& song)
+{
+    Model::Artist artist;
+    artist.artist = song.artist;
+
+    Database::artistRepository artRepo(m_bConf);
+    artRepo.saveRecord(artist);
+
+
+    return artist;
+}
+
+void Manager::artistManager::printArtist(const Model::Artist& artist)
+{
+    std::cout << "\nartist record" << std::endl;
+    std::cout << "id: " << artist.id << std::endl;
+    std::cout << "artist: " << artist.artist << std::endl;
+}

src/managers/coverArtManager.cpp

@@ -20,9 +20,9 @@ Model::Cover Manager::coverArtManager::saveCover(const Model::Song& song, std::s
     cov.songTitle = song.title;
 
     Database::coverArtRepository covRepo(m_bConf);
-    std::cout << "saving record to the database" << std::endl;
+    std::cout << "saving image record to the database" << std::endl;
     covRepo.saveRecord(cov);
-    std::cout << "retrieving record from database" << std::endl;
+    std::cout << "retrieving image record from database" << std::endl;
     cov = covRepo.retrieveRecord(cov, Type::coverFilter::songTitle);
 
     return cov;

src/managers/directory_manager.cpp

@@ -55,6 +55,7 @@ std::string Manager::directory_manager::contentOfPath(const std::string& path)
     return s.str();
 }
 
+/**
 nlohmann::json Manager::directory_manager::credentialConfigContent(const std::string& exe_path)
 {
     auto path = configPath(exe_path);
@@ -62,6 +63,7 @@ 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);
@@ -69,6 +71,7 @@ nlohmann::json Manager::directory_manager::credentialConfigContent(const Model::
 
     return nlohmann::json::parse(contentOfPath(path));
 }
+/**
 nlohmann::json Manager::directory_manager::databaseConfigContent(const std::string& exe_path)
 {
     auto path = configPath(exe_path);
@@ -76,6 +79,7 @@ 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);
@@ -83,6 +87,7 @@ nlohmann::json Manager::directory_manager::databaseConfigContent(const Model::Bi
 
     return nlohmann::json::parse(contentOfPath(path));
 }
+/**
 nlohmann::json Manager::directory_manager::pathConfigContent(const std::string& exe_path)
 {
     auto path = configPath(exe_path);
@@ -90,6 +95,7 @@ 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);

src/managers/genreManager.cpp

@@ -1,5 +1,37 @@
 #include "managers/genreManager.h"
 
+#include <iostream>
+
+#include "database/genreRepository.h"
+#include "types/genreFilter.h"
+
 Manager::genreManager::genreManager(const Model::BinaryPath& bConf)
     : m_bConf(bConf)
 { }
+
+
+Model::Genre Manager::genreManager::retrieveGenre(Model::Genre& genre)
+{
+    Database::genreRepository gnrRepo(m_bConf);
+    genre = gnrRepo.retrieveRecord(genre, Type::genreFilter::category);
+
+    return genre;
+}
+
+Model::Genre Manager::genreManager::saveGenre(const Model::Song& song)
+{
+    Model::Genre genre;
+    genre.category = song.genre;
+    
+    Database::genreRepository gnrRepo(m_bConf);
+    gnrRepo.saveRecord(genre);
+
+    return genre;
+}
+
+void Manager::genreManager::printGenre(const Model::Genre& genre)
+{
+    std::cout << "genre record" << std::endl;
+    std::cout << "id: " << genre.id << std::endl;
+    std::cout << "category: " << genre.category << std::endl;
+}

src/managers/song_manager.cpp

@@ -35,10 +35,8 @@ void Manager::song_manager::saveSong(Model::Song& song)
     song = meta.retrieve_metadata(song.songPath);
     song.data = std::move(data);
 
-
     saveMisc(song);
 
-
     printSong(song);
 
     Database::songRepository songRepo(m_bConf);
@@ -47,6 +45,9 @@ void Manager::song_manager::saveSong(Model::Song& song)
 
 void Manager::song_manager::deleteSong(Model::Song& song)
 {
+    // TODO: handle what happens to miscellanes records
+    // like Album, Artist, Genre, etc. when a song
+    // is deleted
     Database::coverArtRepository covRepo(m_bConf);
     Database::songRepository songRepo(m_bConf);
 
@@ -75,7 +76,7 @@ void Manager::song_manager::deleteSong(Model::Song& song)
 
 void Manager::song_manager::printSong(const Model::Song& song)
 {
-    std::cout << "\n\nsong" << std::endl;
+    std::cout << "\nsong" << std::endl;
     std::cout << "title: " << song.title << std::endl;
     std::cout << "artist: " << song.artist << std::endl;
     std::cout << "album: " << song.album << std::endl;
@@ -85,9 +86,11 @@ void Manager::song_manager::printSong(const Model::Song& song)
     std::cout << "track: " << song.track << std::endl;
     std::cout << "disc: " << song.disc << std::endl;
     std::cout << "song path: " << song.songPath << std::endl;
-    if (song.coverArtId != 0) {
+    std::cout << "cover art id: " << song.coverArtId << std::endl;
-        std::cout << "cover art id: " << song.coverArtId << std::endl;
+    std::cout << "album id: " << song.albumId << std::endl;
-    }
+    std::cout << "artist id: " << song.artistId << std::endl;
+    std::cout << "genre id: " << song.genreId << std::endl;
+    std::cout << "year id: " << song.yearId << std::endl;
 }
 
 void Manager::song_manager::saveSongTemp(Model::Song& song)
@@ -119,19 +122,42 @@ void Manager::song_manager::saveMisc(Model::Song& song)
     stockCoverPath.append("/CoverArt.png");
 
     auto cov = covMgr.saveCover(song, coverRootPath, stockCoverPath);
-    song.coverArtId = cov.id;
 
     auto songPath = Manager::directory_manager::create_directory_process(song, musicRootPath);
     songPath.append(song.title);
     songPath.append(".mp3");
-    std::cout << "\n\ntemp path: " << song.songPath << std::endl;
+    if (fs::exists(songPath)) {
-    std::cout << "new path: " << songPath << std::endl;
+        std::cout << "deleting old song with the same metadata" << std::endl;
+        fs::remove(songPath);
+    }
+    std::cout << "copying song to the appropriate directory" << std::endl;
     fs::copy(song.songPath, songPath);
     fs::remove(song.songPath);
     song.songPath = std::move(songPath);
 
-    artistManager artMgr(m_bConf);
     albumManager albMgr(m_bConf);
+    auto album = albMgr.saveAlbum(song);
+    album = albMgr.retrieveAlbum(album);
+    Manager::albumManager::printAlbum(album);
+
+    artistManager artMgr(m_bConf);
+    auto artist = artMgr.saveArtist(song);
+    artist = artMgr.retrieveArtist(artist);
+    Manager::artistManager::printArtist(artist);
+
     genreManager gnrMgr(m_bConf);
+    auto genre = gnrMgr.saveGenre(song);
+    genre = gnrMgr.retrieveGenre(genre);
+    Manager::genreManager::printGenre(genre);
+
     yearManager yrMgr(m_bConf);
+    auto year = yrMgr.saveYear(song);
+    year = yrMgr.retrieveYear(year);
+    Manager::yearManager::printYear(year);
+
+    song.coverArtId = cov.id;
+    song.albumId = album.id;
+    song.artistId = artist.id;
+    song.genreId = genre.id;
+    song.yearId = year.id;
 }

src/managers/token_manager.cpp

@@ -135,7 +135,7 @@ Model::auth_credentials Manager::token_manager::parse_auth_credentials(std::stri
 Model::auth_credentials Manager::token_manager::parse_auth_credentials(const Model::BinaryPath& bConf)
 {
     auto exePath = Manager::directory_manager::configPath(bConf);
-    exePath.append("/auth_credentials.json");
+    exePath.append("/authcredentials.json");
 
     auto con = Manager::directory_manager::credentialConfigContent(exePath);
 

src/managers/yearManager.cpp

@@ -1,5 +1,37 @@
 #include "managers/yearManager.h"
 
+#include <iostream>
+
+#include "database/yearRepository.h"
+#include "types/yearFilter.h"
+
 Manager::yearManager::yearManager(const Model::BinaryPath& bConf)
     : m_bConf(bConf)
 { }
+
+
+Model::Year Manager::yearManager::retrieveYear(Model::Year& year)
+{
+    Database::yearRepository yearRepo(m_bConf);
+    year = yearRepo.retrieveRecord(year, Type::yearFilter::year);
+
+    return year;
+}
+
+Model::Year Manager::yearManager::saveYear(const Model::Song& song)
+{
+    Model::Year year;
+    year.year = song.year;
+
+    Database::yearRepository yearRepo(m_bConf);
+    yearRepo.saveRecord(year);
+
+    return year;
+}
+
+void Manager::yearManager::printYear(const Model::Year& year)
+{
+    std::cout << "\nyear record" << std::endl;
+    std::cout << "id: " << year.id << std::endl;
+    std::cout << "year: " << year.year << std::endl;
+}