phoenix/soaricarus_api
1
0
Fork 0
Code Issues Pull Requests 1 Actions Packages Projects Releases 33 Wiki Activity

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

Browse Source
This commit is contained in:
kdeng00
2019-08-22 22:40:49 -04:00
parent 592853695d
commit 764185da7d
17 changed files with 235 additions and 111 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/managers/coverArtManager.cpp
+14
View File
@@ -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
+40 -71
View File
@@ -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
+72 -5
View File
@@ -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
+13 -7
View File
@@ -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;