Able to save song and cover art to the appropriate paths. Next is saving it to the database

src/controller/songController.hpp

@@ -14,8 +14,8 @@
 #include "oatpp/web/server/api/ApiController.hpp"
 
 #include "managers/song_manager.h"
-#include "models/models.h"
 #include "managers/token_manager.h"
+#include "models/models.h"
 #include "types/scopes.h"
 
 class songController : public oatpp::web::server::api::ApiController

src/database/coverArtRepository.cpp

@@ -0,0 +1 @@
+#include "database/coverArtRepository.h"

src/main.cpp

@@ -48,6 +48,7 @@ void test_database()
     mysqlD.database = "";	// the databse to pick
 
     base_repository base;
+    /**
     auto conn = base.setup_mysql_connection(mysqlD);
 
     // assign the results return to the MYSQL_RES pointer
@@ -72,10 +73,11 @@ void test_database()
         std::cout << std::endl;
     }
 
-    /* clean up the database result set */
+    // clean up the database result set //
     mysql_free_result(res);
-    /* clean up the database link */
+    // clean up the database link //
     mysql_close(conn);
+    */
 }
 
 
@@ -84,7 +86,6 @@ int main(int argc, char **argv)
     oatpp::base::Environment::init();
     std::string working_path = argv[0];
 
-    //test_database();
     run(working_path);
 
     oatpp::base::Environment::destroy();

src/managers/coverArtManager.cpp

@@ -0,0 +1,14 @@
+#include "managers/coverArtManager.h"
+
+#include "utilities/metadata_retriever.h"
+
+Cover coverArtManager::saveCover(const Song& song, std::string& rootPath, const std::string& stockCoverPath)
+{
+    metadata_retriever meta;
+    Cover cov;
+    cov.imagePath = rootPath;
+    cov = meta.update_cover_art(song, cov, stockCoverPath);
+    cov.songTitle = song.title;
+
+    return cov;
+}

src/managers/directory_manager.cpp

@@ -36,6 +36,45 @@ std::string directory_manager::create_directory_process(Song song, const std::st
 
     return alb_path.string() + "/";
 }
+
+std::string directory_manager::configPath(std::string_view path)
+{
+    return fs::canonical(path).parent_path().string();
+}
+std::string directory_manager::contentOfPath(std::string_view path)
+{
+    std::string configPath(path);
+    std::fstream a(configPath, std::ios::in);
+    std::stringstream s;
+    s << a.rdbuf();
+    a.close();
+
+    return s.str();
+}
+
+nlohmann::json directory_manager::credentialConfigContent(const std::string& exe_path)
+{
+    auto path = configPath(exe_path);
+    path.append("/authcredentials.json");
+
+    return nlohmann::json::parse(contentOfPath(path));
+}
+nlohmann::json directory_manager::databaseConfigContent(const std::string& exe_path)
+{
+    auto path = configPath(exe_path);
+    path.append("/database.json");
+
+    return nlohmann::json::parse(contentOfPath(path));
+}
+nlohmann::json directory_manager::pathConfigContent(const std::string& exe_path)
+{
+    auto path = configPath(exe_path);
+    path.append("/paths.json");
+
+    return nlohmann::json::parse(contentOfPath(path));
+}
+
+/**
 std::string directory_manager::read_cover_art(const std::string& source)
 {
     auto source_path = fs::path(source);
@@ -80,6 +119,7 @@ void directory_manager::copy_song_to_path(const std::string& target, const std::
     fs::remove(source);
     std::cout<<"copy finished"<<std::endl;
 }
+*/
 void directory_manager::delete_cover_art_file(const std::string& cov_path, const std::string& stock_cover_path)
 {
     if (cov_path.compare(stock_cover_path) == 0) {
@@ -129,74 +169,3 @@ void directory_manager::delete_song(const Song song)
     std::cout<<"deleted song"<<std::endl;
 }
 
-//extern "C"
-//{
-
-//void create_directory(Song, const char*, char*);
-//void copy_stock_cover_art(const char*, const char*);
-//void copy_song(const char*, const char*);
-//void delete_cover_art(const char*, const char*);
-//void delete_empty_directories(Song, const char*);
-//void delete_from_filesystem(Song);
-//void delete_song_empty_directories(Song, const char*);
-//void print_song_details(const Song);
-
-/**
-void create_directory(Song song, const char *root_path, char *dir)
-{
-    const auto tmp = create_directory_process(song, root_path);
-    size_t tmp_sz = tmp.size();
-    tmp.copy(dir, tmp_sz, 0);
-}
-void copy_stock_cover_art(const char *target, const char *source)
-{
-    const auto buff = read_cover_art(source);
-    copy_stock_to_root(target, buff);
-}
-*/
-/**
-void copy_song(const char *target, const char *source)
-{
-    copy_song_to_path(target, source);
-}
-void delete_cover_art(const char *cover_path, const char *stock_path)
-{
-    std::cout<<"starting process to delete cover art"<<std::endl;
-    const auto cov_path = std::string{cover_path};
-    const auto s_path = std::string{stock_path};
-    if (cov_path.compare(s_path) != 0) {
-        std::cout<<"cover art is not the stock path"<<std::endl;
-        delete_cover_art_file(cov_path);
-    } else {
-        std::cout<<"cover art is the stock path and will not be deleted"<<std::endl;
-    }
-}
-void delete_empty_directories(Song song, const char *root_path)
-{
-    delete_directories(song, root_path);
-}
-void delete_from_filesystem(Song song)
-{
-    if (delete_song(&song)) {
-        std::cout<<"successfully deleted song from filesystem"<<std::endl;
-    } else {
-        std::cout<<"failed to deleted song from filesystem"<<std::endl;
-    }
-}
-void delete_song_empty_directories(Song song, const char *root_path)
-{
-    delete_song(song);
-    delete_directories(song, root_path);
-}
-void print_song_details(const Song song)
-{
-    std::cout<<"song details"<<std::endl;
-    std::cout<<"title: "<<song.Title<<std::endl;
-    std::cout<<"artist: "<<song.Artist<<std::endl;
-    std::cout<<"album: "<<song.Album<<std::endl;
-    std::cout<<"genre: "<<song.Genre<<std::endl;
-    std::cout<<"year: "<<song.Year<<std::endl;
-}
-
-}
-*/

src/managers/song_manager.cpp

@@ -2,6 +2,13 @@
 
 #include <fstream>
 #include <filesystem>
+#include <random>
+
+#include <nlohmann/json.hpp>
+
+#include "managers/coverArtManager.h"
+#include "managers/directory_manager.h"
+#include "utilities/metadata_retriever.h"
 
 namespace fs = std::filesystem;
 
@@ -9,14 +16,74 @@ song_manager::song_manager(std::string& x_path)
     : exe_path(x_path)
 { }
 
+/**
+std::string song_manager::retrieveMusicPath()
+{
+    std::string pathConfig = directory_manager::configPath(exe_path);
+    pathConfig.append("/paths.json");
+    nlohmann::json config = nlohmann::json::parse(directory_manager::contentOfPath(pathConfig));
+
+    return config["root_music_path"].get<std::string>();
+}
+std::string song_manager::retrieveTempPath()
+{
+    auto pathConfig = directory_manager::configPath(exe_path);
+    pathConfig.append("/paths");
+
+    return std::string();
+}
+
+nlohmann::json song_manager::pathConfigContent()
+{
+    auto path = directory_manager::configPath(exe_path);
+    path.append("/paths.json");
+
+    return nlohmann::json::parse(directory_manager::contentOfPath(path));
+}
+*/
+
 void song_manager::saveSong(Song& song)
 {
-    constexpr auto tmp_song = "/tmp/song.mp3";
-    if (fs::exists(fs::path(tmp_song))) {
-        std::cout << "deleting old song " << std::endl;
-        fs::remove(fs::path(tmp_song));
-    }
+    saveSongTemp(song);
+    metadata_retriever meta;
+    auto data = std::move(song.data);
+    song = meta.retrieve_metadata(song.songPath);
+    song.data = std::move(data);
+    printSong(song);
+
+    coverArtManager covMgr;
+    auto coverRootPath = directory_manager::pathConfigContent(exe_path)["cover_root_path"].get<std::string>();
+    auto stockCoverPath = directory_manager::configPath(exe_path);
+    stockCoverPath.append("/CoverArt.png");
+    auto cov = covMgr.saveCover(song, coverRootPath, stockCoverPath);
+}
+
+void song_manager::printSong(const Song& song)
+{
+    std::cout << "song" << std::endl;
+    std::cout << "title: " << song.title << std::endl;
+    std::cout << "artist: " << song.artist << std::endl;
+    std::cout << "album: " << song.album << std::endl;
+    std::cout << "genre: " << song.genre << std::endl;
+    std::cout << "duration: " << song.duration << std::endl;
+    std::cout << "year: " << song.year << std::endl;
+    std::cout << "song path: " << song.songPath << std::endl;
+}
+
+void song_manager::saveSongTemp(Song& song)
+{
+    auto config = directory_manager::pathConfigContent(exe_path);
+
+    auto tmp_song = config["temp_root_path"].get<std::string>();
+    std::random_device dev;
+    std::mt19937 rng(dev());
+    std::uniform_int_distribution<std::mt19937::result_type> dist(1,1000);
+    tmp_song.append(std::to_string(dist(rng)));
+    tmp_song.append(".mp3");
+
     std::fstream s(tmp_song, std::fstream::binary | std::fstream::out);
     s.write((char*)&song.data[0], song.data.size());
     s.close();
+
+    song.songPath = tmp_song;
 }

src/managers/token_manager.cpp

@@ -1,3 +1,5 @@
+#include "managers/token_manager.h"
+
 #include <iostream>
 #include <iterator>
 #include <fstream>
@@ -10,7 +12,7 @@
 #include <cpr/cpr.h>
 #include <nlohmann/json.hpp>
 
-#include "managers/token_manager.h"
+#include "managers/directory_manager.h"
 
 namespace fs = std::filesystem;
 
@@ -87,22 +89,26 @@ bool token_manager::is_token_valid(std::string& auth, Scope scope)
 
 auth_credentials token_manager::parse_auth_credentials(std::string_view path)
 {
-    auto exe_path = fs::canonical(path).parent_path().string();
+    auto exe_path = directory_manager::configPath(path);
     exe_path.append("/authcredentials.json");
     
+    //auto content = directory_manager::contentOfPath(exe_path);
+    /**
     std::fstream a(exe_path, std::ios::in);
     std::stringstream s;
     s << a.rdbuf();
     a.close();
+    */
 
-    auto con = nlohmann::json::parse(s.str());
+    //auto con = nlohmann::json::parse(directory_manager::contentOfPath(exe_path));
+    auto con = directory_manager::credentialConfigContent(exe_path);
 
     auth_credentials auth;
     auth.uri = "https://";
-    auth.uri.append(con["Domain"]);
-    auth.api_identifier = con["ApiIdentifier"];
-    auth.client_id = con["ClientId"];
-    auth.client_secret = con["ClientSecret"];
+    auth.uri.append(con["domain"]);
+    auth.api_identifier = con["api_identifier"];
+    auth.client_id = con["client_id"];
+    auth.client_secret = con["client_secret"];
     auth.endpoint = "oauth/token";
 
     return auth;

src/utilities/metadata_retriever.cpp

@@ -14,6 +14,8 @@
 #include "utilities/imageFile.h"
 #include "utilities/metadata_retriever.h"
 
+namespace fs = std::filesystem;
+
 Song metadata_retriever::retrieve_metadata(std::string& song_path)
 {
     TagLib::FileRef file(song_path.c_str());
@@ -26,30 +28,23 @@ Song metadata_retriever::retrieve_metadata(std::string& song_path)
     song.duration = file.audioProperties()->lengthInSeconds();
     song.songPath = song_path;
 
-    /**
-    strcpy(sng->Title, file.tag()->title().toCString());
-    strcpy(sng->Artist, file.tag()->artist().toCString());
-    strcpy(sng->Album, file.tag()->album().toCString());
-    strcpy(sng->Genre, file.tag()->genre().toCString());
-    sng->Year = file.tag()->year();
-    sng->Duration = file.audioProperties()->lengthInSeconds();
-    strcpy(sng->SongPath, song_path);
-    */
 
     return song;
 }
 
-Cover metadata_retriever::update_cover_art(Cover cov, const Song song, const std::string& root_path)
+Cover metadata_retriever::update_cover_art(const Song& song, Cover& cov, const std::string& stockCoverPath)
 {
     TagLib::MPEG::File sngF(song.songPath.c_str());
-    TagLib::ID3v2::Tag *tag = sngF.ID3v2Tag();
+    auto tag = sngF.ID3v2Tag();
     auto frameList = tag->frameListMap()["APIC"];
 
     if (frameList.isEmpty()) {
-        std::string stock_path{root_path};
-        stock_path.append("CoverArt.png");
-        cov.imagePath = stock_path;
-        //strcpy(cov->ImagePath, stock_path.c_str());
+        cov.imagePath.append("CoverArt.png");
+        
+        if (!fs::exists(cov.imagePath)) {
+            std::cout << "copying stock cover path" << std::endl;
+            fs::copy(stockCoverPath, cov.imagePath);
+        }
 
         imageFile stock_img(cov.imagePath.c_str());
 
@@ -61,23 +56,23 @@ Cover metadata_retriever::update_cover_art(Cover cov, const Song song, const std
         tag->addFrame(pic);
 
         sngF.save();
-        std::cout<<"applied stock cover art"<<std::endl;
+        std::cout << "applied stock cover art" << std::endl;
     } else {
         auto frame = dynamic_cast<TagLib::ID3v2::AttachedPictureFrame*>(
                 frameList.front());
         directory_manager dir;
-        auto img_path = dir.create_directory_process(song, root_path);
+        auto img_path = dir.create_directory_process(song, cov.imagePath);
         img_path.append(song.title);
         img_path.append(".png");
         cov.imagePath = img_path;
-        //strcpy(cov->ImagePath, img_path.c_str());
-        std::cout<<cov.imagePath<<std::endl;
+
+        std::cout << cov.imagePath << std::endl;
 
         std::fstream img_save(cov.imagePath, std::ios::out | 
                 std::ios::binary);
         img_save.write(frame->picture().data(), frame->picture().size());
         img_save.close();
-        std::cout<<"saved to "<<cov.imagePath<<std::endl;
+        std::cout << "saved to " << cov.imagePath << std::endl;
     }
 
     return cov;