Language Migration (#21)
* Blank slate * Added gitignore * Updated gitignore * Added rust code * Added modules * Fixed build issues * rustfmt * Updated models * Added parsers module * Updated utilities module * Updated main.rs * Updated api_parser and song model * Updated icarus_action model * Updated structs in managers module * Updated main.rs * More changes * Saving changes * Added new struct and methods * More changes. Not functional yet * Changed name of the project * Removed cmake workflow * Adding rust workflow * Adding code to the syncers module * Cargo formatting * Continuing work * Adding code to the syncers module * Added dependencies * Adding more code to the syncers module * Added more code to the syncers module It's not 100 percent done yet, I'll work on other modules * Added more code to the managers module * Added code to request a token * Cargo formatting * Adding more code to multi target upload * Adding more multi-target upload code and formatted code * Added more multi-upload code * cargo fmt * Got uploading functional and cargo fmt-ing * Uploading multi target works, but is buggy Not all of the songs are being uploaded * Added single target upload * Single target upload is functional but need to revisit multi-target upload Multi-target upload is broken now. Needs to be revisited * Fixed multi target upload * Can now retrieve songs * Downloading functionality is working * Delete functionality is operational * Updated README * More cleanup * Added test
This commit was merged in pull request #21.
This commit is contained in:
Kun Deng
@@ -1,79 +0,0 @@
|
||||
#include<iostream>
|
||||
#include<string>
|
||||
|
||||
#include"Managers/ActionManager.h"
|
||||
#include"Managers/CommitManager.h"
|
||||
|
||||
using std::cin;
|
||||
using std::cout;
|
||||
using std::endl;
|
||||
using std::string;
|
||||
|
||||
using Managers::ActionManager;
|
||||
using Managers::CommitManager;
|
||||
|
||||
constexpr static auto IcarusDownloadManager_version()
|
||||
{
|
||||
return "v0.3.2";
|
||||
}
|
||||
|
||||
void printHelp()
|
||||
{
|
||||
cout<<"icd [Action] [flag]\n\n";
|
||||
|
||||
cout<<"Actions\n";
|
||||
cout<<"download\n";
|
||||
cout<<"upload\n";
|
||||
cout<<"upload-meta\n";
|
||||
cout<<"retrieve\n";
|
||||
cout<<"delete\n\n";
|
||||
|
||||
cout<<"Flags\n";
|
||||
cout<<"Required for all actions\n";
|
||||
cout<<"-u username\n";
|
||||
cout<<"-p password\n";
|
||||
cout<<"-h host\n\n";
|
||||
|
||||
cout<<"Required for upload\n";
|
||||
cout<<"-s path of song\n";
|
||||
cout<<"-sd directory where to search for songs to upload (Optional)\n";
|
||||
cout<<"-sr directory where to recursively search for songs to upload (Optional)\n";
|
||||
cout<<"-nc will not prompt the user when uploading from a directory\n\n";
|
||||
|
||||
cout<<"Required for upload with metadata\n";
|
||||
cout<<"-s path of song\n";
|
||||
cout<<"-t track number\n";
|
||||
cout<<"-m metadata filepath\n";
|
||||
cout<<"-ca coverart filepath\n";
|
||||
cout<<"-scma directory where songs, metadata, and cover art exists and will be uploaded (Optional)\n\n";
|
||||
|
||||
cout<<"Required for download\n";
|
||||
cout<<"-b song id\n";
|
||||
cout<<"-d path to download song (Optional)\n\n";
|
||||
|
||||
cout<<"Required for retrieving records\n";
|
||||
cout<<"-rt retrieve type (songs is only accepted)\n\n";
|
||||
|
||||
cout<<"Required for deleting a song\n";
|
||||
cout<<"-D song id\n\n";
|
||||
}
|
||||
|
||||
|
||||
int main(int argc, char** argv)
|
||||
{
|
||||
if (argc < 2)
|
||||
{
|
||||
printHelp();
|
||||
return -1;
|
||||
}
|
||||
|
||||
ActionManager actMgr(argv, argc);
|
||||
auto chosenAction = actMgr.retrieveIcarusAction();
|
||||
|
||||
chosenAction.print_action_and_flags();
|
||||
|
||||
CommitManager commitMgr(chosenAction);
|
||||
commitMgr.commitAction();
|
||||
|
||||
return 0;
|
||||
}
|
||||
@@ -1,118 +0,0 @@
|
||||
#include"Managers/ActionManager.h"
|
||||
|
||||
#include<algorithm>
|
||||
#include<iostream>
|
||||
#include<utility>
|
||||
#include<cstring>
|
||||
|
||||
using std::cout;
|
||||
using std::endl;
|
||||
using std::string;
|
||||
using std::string_view;
|
||||
using std::vector;
|
||||
|
||||
using Models::Flags;
|
||||
using Models::IcarusAction;
|
||||
|
||||
namespace Managers
|
||||
{
|
||||
|
||||
#pragma region Constructors
|
||||
ActionManager::ActionManager(char **param, int paramCount) :
|
||||
params(std::move(param)), paramCount(paramCount)
|
||||
{
|
||||
initialize();
|
||||
}
|
||||
#pragma endregion
|
||||
|
||||
|
||||
#pragma region Functions
|
||||
IcarusAction ActionManager::retrieveIcarusAction() const
|
||||
{
|
||||
IcarusAction icarusAction;
|
||||
icarusAction.flags = flags;
|
||||
icarusAction.action = action;
|
||||
|
||||
return icarusAction;
|
||||
}
|
||||
|
||||
|
||||
|
||||
void ActionManager::initialize()
|
||||
{
|
||||
validateFlags();
|
||||
|
||||
action = std::move(string{params[1]});
|
||||
transform(action.begin(), action.end(),
|
||||
action.begin(), ::tolower);
|
||||
}
|
||||
void ActionManager::validateFlags()
|
||||
{
|
||||
cout<<"Validating flags\n";
|
||||
|
||||
const auto flagVals = parsedFlags();
|
||||
|
||||
for (auto flag = flagVals.begin(); flag != flagVals.end(); ++flag)
|
||||
{
|
||||
Flags flg;
|
||||
cout<<"Value: "<<*flag<<"\n";
|
||||
|
||||
if (isValidFlag<string>(*flag) && doesFlagHaveValue<string>(*flag))
|
||||
{
|
||||
cout<<"Flag has value\n";
|
||||
flg.flag = *flag;
|
||||
flg.value = *(++flag);
|
||||
}
|
||||
else if (isValidFlag<string>(*flag))
|
||||
{
|
||||
cout<<"Flag does not have a value\n";
|
||||
flg.flag = *flag;
|
||||
}
|
||||
else
|
||||
{
|
||||
cout<<"Flag "<<*flag<<" is not valid"<<endl;
|
||||
exit(1);
|
||||
}
|
||||
|
||||
flags.emplace_back(std::move(flg));
|
||||
}
|
||||
}
|
||||
|
||||
vector<string> ActionManager::parsedFlags()
|
||||
{
|
||||
auto parsed = vector<string>();
|
||||
|
||||
for (auto i = 2; i < paramCount; ++i)
|
||||
{
|
||||
const std::string flag(std::move(*(params + i)));
|
||||
parsed.push_back(std::move(flag));
|
||||
}
|
||||
|
||||
return parsed;
|
||||
}
|
||||
|
||||
#pragma region Testing
|
||||
void ActionManager::printAction() noexcept
|
||||
{
|
||||
if (action.empty())
|
||||
{
|
||||
printf("Action is empty\n");
|
||||
}
|
||||
else
|
||||
{
|
||||
cout<<"Action is "<<action<<endl;
|
||||
}
|
||||
}
|
||||
void ActionManager::printFlags() noexcept
|
||||
{
|
||||
cout<<"\nPrinting flags..."<<endl;
|
||||
for (auto flag: flags)
|
||||
{
|
||||
cout<<"flag "<<flag.flag<<endl;
|
||||
cout<<"value "<<flag.value<<endl;
|
||||
}
|
||||
}
|
||||
#pragma endregion
|
||||
#pragma endregion
|
||||
|
||||
}
|
||||
@@ -1,457 +0,0 @@
|
||||
#include"Managers/CommitManager.h"
|
||||
|
||||
#include <iostream>
|
||||
#include <fstream>
|
||||
#include <sstream>
|
||||
#include <filesystem>
|
||||
|
||||
#include "nlohmann/json.hpp"
|
||||
|
||||
#include "Models/API.h"
|
||||
#include "Models/Song.h"
|
||||
#include "Models/Token.h"
|
||||
#include "Parsers/APIParser.h"
|
||||
#include "Syncers/Delete.h"
|
||||
#include "Syncers/Download.h"
|
||||
#include "Syncers/RetrieveRecords.h"
|
||||
#include "Syncers/Upload.h"
|
||||
|
||||
#include "Managers/TokenManager.h"
|
||||
#include "Managers/UserManager.h"
|
||||
|
||||
using std::cout;
|
||||
using std::endl;
|
||||
using std::map;
|
||||
using std::string;
|
||||
|
||||
using Managers::TokenManager;
|
||||
using Managers::UserManager;
|
||||
using Models::API;
|
||||
using Models::Song;
|
||||
using Models::Token;
|
||||
using Parsers::APIParser;
|
||||
using Models::IcarusAction;
|
||||
using Syncers::Delete;
|
||||
using Syncers::Download;
|
||||
using Syncers::RetrieveRecords;
|
||||
using Syncers::Upload;
|
||||
|
||||
namespace filesystem = std::filesystem;
|
||||
|
||||
namespace Managers
|
||||
{
|
||||
|
||||
#pragma region Constructors
|
||||
CommitManager::CommitManager(IcarusAction& icaAct) : icaAction(std::move(icaAct))
|
||||
{ }
|
||||
#pragma endregion
|
||||
|
||||
|
||||
#pragma region Functions
|
||||
void CommitManager::commitAction()
|
||||
{
|
||||
auto action = icaAction.action;
|
||||
cout<<"Commiting "<<action<<" action"<<endl;
|
||||
|
||||
switch (mapActions()[action])
|
||||
{
|
||||
case ActionValues::deleteAct:
|
||||
deleteSong();
|
||||
break;
|
||||
case ActionValues::downloadAct:
|
||||
downloadSong();
|
||||
break;
|
||||
case ActionValues::retrieveAct:
|
||||
retrieveObjects();
|
||||
break;
|
||||
case ActionValues::uploadAct:
|
||||
uploadSong();
|
||||
break;
|
||||
case ActionValues::UPLOAD_SONG_WITH_METADATA:
|
||||
uploadSongWithMetadata();
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
std::map<std::string, CommitManager::ActionValues>
|
||||
CommitManager::mapActions() noexcept
|
||||
{
|
||||
const std::map<std::string, ActionValues> actions{
|
||||
{"delete", ActionValues::deleteAct},
|
||||
{"download", ActionValues::downloadAct},
|
||||
{"retrieve", ActionValues::retrieveAct},
|
||||
{"upload", ActionValues::uploadAct},
|
||||
{"upload-meta", ActionValues::UPLOAD_SONG_WITH_METADATA}
|
||||
};
|
||||
|
||||
return actions;
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
Token CommitManager::parseToken(API api)
|
||||
{
|
||||
cout<<"fetching token\n";
|
||||
UserManager usrMgr{icaAction};
|
||||
auto user = usrMgr.retrieveUser();
|
||||
|
||||
TokenManager tk{user, api};
|
||||
|
||||
return tk.requestToken();
|
||||
}
|
||||
|
||||
void CommitManager::deleteSong()
|
||||
{
|
||||
APIParser apiPrs{icaAction};
|
||||
auto api = apiPrs.retrieveAPI();
|
||||
|
||||
auto token = parseToken(api);
|
||||
|
||||
Song song{};
|
||||
|
||||
for (auto arg : icaAction.flags)
|
||||
{
|
||||
auto flag = arg.flag;
|
||||
auto value = arg.value;
|
||||
|
||||
if (flag.compare("-D") == 0)
|
||||
{
|
||||
song.id = atoi(value.c_str());
|
||||
}
|
||||
}
|
||||
|
||||
Delete del{api};
|
||||
cout<<"Deleting song..."<<endl;
|
||||
del.deleteSong(token, song);
|
||||
}
|
||||
void CommitManager::downloadSong()
|
||||
{
|
||||
cout<<"Starting downloading process..."<<endl;
|
||||
|
||||
APIParser apiPrs{icaAction};
|
||||
auto api = apiPrs.retrieveAPI();
|
||||
|
||||
auto token = parseToken(api);
|
||||
|
||||
Song song{};
|
||||
|
||||
for (auto arg : icaAction.flags)
|
||||
{
|
||||
auto flag = arg.flag;
|
||||
auto value = arg.value;
|
||||
|
||||
if (flag.compare("-d") == 0)
|
||||
{
|
||||
song.songPath.assign(arg.value);
|
||||
}
|
||||
if (flag.compare("-b") == 0)
|
||||
{
|
||||
song.id = atoi(value.c_str());
|
||||
}
|
||||
}
|
||||
|
||||
Download dnld{api};
|
||||
cout<<"downloading song"<<endl;
|
||||
dnld.downloadSong(token, song);
|
||||
}
|
||||
void CommitManager::retrieveObjects()
|
||||
{
|
||||
cout<<"Starting retrieve process..."<<endl;
|
||||
|
||||
APIParser apiPrs{icaAction};
|
||||
auto api = apiPrs.retrieveAPI();
|
||||
|
||||
auto token = parseToken(api);
|
||||
RetrieveTypes retrieveType;
|
||||
|
||||
for (auto arg : icaAction.flags)
|
||||
{
|
||||
auto flag = arg.flag;
|
||||
auto value = arg.value;
|
||||
|
||||
if (flag.compare("-rt") == 0)
|
||||
{
|
||||
if (value.compare("songs") == 0)
|
||||
{
|
||||
retrieveType = RetrieveTypes::songs;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
RetrieveRecords songs{api, token};
|
||||
songs.retrieve(retrieveType);
|
||||
|
||||
}
|
||||
|
||||
void CommitManager::uploadSong()
|
||||
{
|
||||
auto uploadSingleSong = true;
|
||||
auto recursiveDirectory = false;
|
||||
const auto noConfirm = checkForNoConfirm();
|
||||
string songDirectory;
|
||||
APIParser apiPrs{icaAction};
|
||||
auto api = apiPrs.retrieveAPI();
|
||||
|
||||
auto token = parseToken(api);
|
||||
|
||||
Song song;
|
||||
|
||||
for (auto& arg : icaAction.flags)
|
||||
{
|
||||
auto flag = arg.flag;
|
||||
auto value = arg.value;
|
||||
|
||||
if (flag.compare("-s") == 0)
|
||||
{
|
||||
song.songPath.assign(arg.value);
|
||||
}
|
||||
else if (flag.compare("-sd") == 0)
|
||||
{
|
||||
songDirectory = value;
|
||||
uploadSingleSong = false;
|
||||
}
|
||||
else if (flag.compare("-sr") == 0)
|
||||
{
|
||||
songDirectory = value;
|
||||
uploadSingleSong = false;
|
||||
recursiveDirectory = true;
|
||||
}
|
||||
}
|
||||
|
||||
Upload upld{api, token};
|
||||
if (uploadSingleSong)
|
||||
{
|
||||
cout<<"Uploading song..."<<endl;
|
||||
upld.uploadSong(song);
|
||||
}
|
||||
else
|
||||
{
|
||||
cout<<"Uploading songs from " << songDirectory << endl;
|
||||
upld.uploadSongsFromDirectory(songDirectory, noConfirm, recursiveDirectory);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
void CommitManager::uploadSongWithMetadata()
|
||||
{
|
||||
cout<<"Uploading single song with metadata\n\n";
|
||||
|
||||
// Either the set of "-s", "-m", "-ca", "-t" flags or "-smca" must exist with values
|
||||
// in order to be valid but not both
|
||||
const auto songPath = this->icaAction.retrieveFlagValue("-s");
|
||||
const auto metadataPath = this->icaAction.retrieveFlagValue("-m");
|
||||
const auto coverPath = this->icaAction.retrieveFlagValue("-ca");
|
||||
const auto trackID = this->icaAction.retrieveFlagValue("-t");
|
||||
const auto singleTarget = !songPath.empty() && !metadataPath.empty() &&
|
||||
!coverPath.empty() && !trackID.empty() ? true : false;
|
||||
|
||||
const auto uni = this->icaAction.retrieveFlagValue("-smca");
|
||||
const auto multiTarget = !uni.empty() ? true : false;
|
||||
|
||||
if (singleTarget && multiTarget)
|
||||
{
|
||||
cout<<"Cannot upload from source and directory\n";
|
||||
return;
|
||||
}
|
||||
|
||||
cout<<"Song path: "<<songPath<<"\n";
|
||||
cout<<"TrackID: "<<trackID<<"\n";
|
||||
cout<<"Metadata path: "<<metadataPath<<"\n";
|
||||
cout<<"Cover Art path: "<<coverPath<<"\n";
|
||||
|
||||
if (singleTarget)
|
||||
{
|
||||
singTargetUpload(songPath, trackID, metadataPath, coverPath);
|
||||
}
|
||||
else if (multiTarget)
|
||||
{
|
||||
multiTargetUpload(uni);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void CommitManager::singTargetUpload(const std::string &songPath, const std::string &trackID,
|
||||
const std::string &metaPath, const std::string &coverPath)
|
||||
{
|
||||
APIParser apiPrs(icaAction);
|
||||
auto api = apiPrs.retrieveAPI();
|
||||
const auto token = parseToken(api);
|
||||
|
||||
auto album = retrieveMetadata(metaPath);
|
||||
album.printInfo();
|
||||
|
||||
Song song;
|
||||
song.track = 1;
|
||||
song.disc = 1;
|
||||
|
||||
cout<<"TrackID: "<<trackID<<"\n";
|
||||
|
||||
parseDiscAndTrack<Song, std::string>(song, trackID);
|
||||
|
||||
auto c = [](const Song &songA, const Song &songB) { return songA.track == songB.track && songA.disc == songB.disc; };
|
||||
auto sng = Utilities::Checks::itemIterInContainer<Song, std::vector<Song>>(album.songs, song, c);
|
||||
|
||||
if (sng == album.songs.end())
|
||||
{
|
||||
cout<<"Not found with disc "<<song.disc<<" track "<<song.track<<"\n";
|
||||
std::exit(-1);
|
||||
}
|
||||
|
||||
song = *sng;
|
||||
const auto p = filesystem::path(songPath);
|
||||
song.directory = p.parent_path().string();
|
||||
song.generate_filename_from_track();
|
||||
|
||||
Models::CoverArt cover;
|
||||
cover.title = song.title;
|
||||
cover.path = coverPath;
|
||||
|
||||
Upload up(api, token);
|
||||
up.uploadSongWithMetadata(album, song, cover);
|
||||
}
|
||||
|
||||
void CommitManager::multiTargetUpload(const std::string &sourcePath)
|
||||
{
|
||||
APIParser apiPrs(icaAction);
|
||||
auto api = apiPrs.retrieveAPI();
|
||||
const auto token = parseToken(api);
|
||||
|
||||
if (!fs::is_directory(sourcePath))
|
||||
{
|
||||
cout<<sourcePath<<" is not a directory\n";
|
||||
std::exit(-1);
|
||||
}
|
||||
|
||||
std::vector<Song> songs;
|
||||
Models::CoverArt cover;
|
||||
string metadataPath;
|
||||
|
||||
for (auto &p: fs::directory_iterator(sourcePath))
|
||||
{
|
||||
const auto &pp = p.path();
|
||||
const auto stem = pp.stem();
|
||||
const auto file = pp.filename();
|
||||
const auto extension = pp.extension();
|
||||
|
||||
cout<<"Stem "<<stem<<" Extension "<<extension<<"\n";
|
||||
|
||||
auto validImg = [](const std::string& ext)
|
||||
{
|
||||
std::vector<string> extensions;
|
||||
extensions.reserve(3);
|
||||
extensions.push_back(".jpg");
|
||||
extensions.push_back(".jpeg");
|
||||
extensions.push_back(".");
|
||||
|
||||
return ext.compare(extensions[0]) == 0 || ext.compare(extensions[1]) == 0 || ext.compare(extensions[2]) == 0;
|
||||
};
|
||||
|
||||
if (extension.compare(".mp3") == 0)
|
||||
{
|
||||
Song song;
|
||||
song.songPath = pp.string();
|
||||
|
||||
initializeDiscAndTrack<Song, std::string>(song);
|
||||
|
||||
songs.emplace_back(std::move(song));
|
||||
}
|
||||
// else if (extension.compare(".jpg") == 0 || extension.compare(".png") == 0)
|
||||
else if (validImg(extension.string()))
|
||||
{
|
||||
cover.path.assign(pp.string());
|
||||
}
|
||||
else if (extension.compare(".json") == 0)
|
||||
{
|
||||
metadataPath.assign(pp.string());
|
||||
}
|
||||
}
|
||||
|
||||
auto album = retrieveMetadata(metadataPath);
|
||||
songs.clear();
|
||||
songs.assign(album.songs.begin(), album.songs.end());
|
||||
|
||||
Upload up(api, token);
|
||||
|
||||
for (auto &song : songs)
|
||||
{
|
||||
up.uploadSongWithMetadata(album, song, cover);
|
||||
}
|
||||
}
|
||||
|
||||
#pragma region private
|
||||
CommitManager::Album CommitManager::retrieveMetadata(const std::string_view path)
|
||||
{
|
||||
CommitManager::Album album;
|
||||
const auto fileContent = retrieveFileContent(path);
|
||||
cout<<"Parsing...\n";
|
||||
auto serialized = nlohmann::json::parse(fileContent);
|
||||
cout<<"Parsed\n";
|
||||
|
||||
album.album = serialized["album"].get<std::string>();
|
||||
album.albumArtist = serialized["album_artist"].get<std::string>();
|
||||
album.genre = serialized["genre"].get<std::string>();
|
||||
album.year = serialized["year"].get<int>();
|
||||
album.trackCount = serialized["track_count"].get<int>();
|
||||
album.discCount = serialized["disc_count"].get<int>();
|
||||
album.songs.reserve(album.trackCount);
|
||||
|
||||
for (auto &j : serialized["tracks"])
|
||||
{
|
||||
Song song;
|
||||
song.title = j["title"].get<std::string>();
|
||||
song.track = j["track"].get<int>();
|
||||
song.disc = j["disc"].get<int>();
|
||||
song.artist = j["artist"].get<std::string>();
|
||||
song.album = album.album;
|
||||
song.year = album.year;
|
||||
song.genre = album.genre;
|
||||
song.generate_filename_from_track();
|
||||
const auto p = fs::path(path);
|
||||
song.directory = p.parent_path().string();
|
||||
|
||||
album.songs.push_back(song);
|
||||
}
|
||||
|
||||
return album;
|
||||
}
|
||||
|
||||
string CommitManager::retrieveFileContent(const std::string_view path)
|
||||
{
|
||||
string path_str(path);
|
||||
string value;
|
||||
|
||||
std::stringstream buffer;
|
||||
std::fstream file(path_str, std::ios::in);
|
||||
buffer<<file.rdbuf();
|
||||
file.close();
|
||||
|
||||
value.assign(buffer.str());
|
||||
|
||||
return value;
|
||||
}
|
||||
#pragma endregion
|
||||
|
||||
void CommitManager::Album::printInfo()
|
||||
{
|
||||
std::cout<<"Album: "<<this->album<<"\n";
|
||||
std::cout<<"Album Artist: "<<this->albumArtist<<"\n";
|
||||
std::cout<<"Genre: "<<this->genre<<"\n";
|
||||
std::cout<<"Year: "<<this->year<<"\n";
|
||||
std::cout<<"Track count: "<<this->trackCount<<"\n";
|
||||
std::cout<<"Disc count: "<<this->discCount<<"\n";
|
||||
std::cout<<"\n";
|
||||
}
|
||||
|
||||
#pragma region Functions
|
||||
|
||||
}
|
||||
@@ -1,73 +0,0 @@
|
||||
#include<iostream>
|
||||
#include<fstream>
|
||||
|
||||
#include"Managers/FileManager.h"
|
||||
|
||||
using std::cout;
|
||||
using std::endl;
|
||||
using std::ifstream;
|
||||
using std::ofstream;
|
||||
using std::string;
|
||||
|
||||
namespace Managers
|
||||
{
|
||||
|
||||
#pragma region Constructors
|
||||
FileManager::FileManager() {}
|
||||
FileManager::FileManager(string filePath)
|
||||
{
|
||||
this->filePath = filePath;
|
||||
readFile();
|
||||
}
|
||||
#pragma endregion
|
||||
|
||||
|
||||
#pragma region Functions
|
||||
void FileManager::saveFile(string newFilePath)
|
||||
{
|
||||
if (!fileRead)
|
||||
readFile();
|
||||
|
||||
ofstream of{newFilePath, ofstream::binary};
|
||||
of.write(fileBuffer, fileBufferLength);
|
||||
of.close();
|
||||
}
|
||||
|
||||
void FileManager::readFile()
|
||||
{
|
||||
ifstream is{filePath, ifstream::binary};
|
||||
if (is)
|
||||
{
|
||||
is.seekg (0, is.end);
|
||||
fileBufferLength = is.tellg();
|
||||
is.seekg (0, is.beg);
|
||||
|
||||
fileBuffer = new char [fileBufferLength];
|
||||
|
||||
cout<< "Reading "<<fileBufferLength<<" characters... "<<endl;;
|
||||
is.read (fileBuffer,fileBufferLength);
|
||||
|
||||
if (is)
|
||||
cout<<"all characters read successfully.";
|
||||
else
|
||||
cout<<"error: only "<<is.gcount()<<" could be read";
|
||||
cout<<endl;
|
||||
is.close();
|
||||
fileRead = true;
|
||||
}
|
||||
}
|
||||
void FileManager::modifyFilePath(string filePath)
|
||||
{
|
||||
this->filePath = filePath;
|
||||
}
|
||||
|
||||
char* FileManager::retrieveFileBuffer() const
|
||||
{
|
||||
return fileBuffer;
|
||||
}
|
||||
|
||||
int FileManager::retrieveFileBufferLength() const { return fileBufferLength; }
|
||||
|
||||
#pragma endregion
|
||||
|
||||
}
|
||||
@@ -1,62 +0,0 @@
|
||||
#include"Managers/TokenManager.h"
|
||||
|
||||
#include<iostream>
|
||||
|
||||
#include<cpr/cpr.h>
|
||||
#include<nlohmann/json.hpp>
|
||||
|
||||
using std::cout;
|
||||
using std::endl;
|
||||
|
||||
using json = nlohmann::json;
|
||||
|
||||
using Managers::TokenManager;
|
||||
using Models::API;
|
||||
using Models::Token;
|
||||
using Models::User;
|
||||
|
||||
namespace Managers
|
||||
{
|
||||
|
||||
#pragma region Constructors
|
||||
TokenManager::TokenManager(const User& user)
|
||||
{
|
||||
this->user = user;
|
||||
}
|
||||
TokenManager::TokenManager(const User& user, API& api)
|
||||
{
|
||||
this->user = user;
|
||||
this->api = api;
|
||||
this->api.endpoint = "api/" + api.version
|
||||
+ "/login";
|
||||
}
|
||||
#pragma endregion
|
||||
|
||||
|
||||
#pragma region Functions
|
||||
Token TokenManager::requestToken()
|
||||
{
|
||||
Token token{};
|
||||
json usrObj;
|
||||
|
||||
usrObj["username"] = user.username;
|
||||
usrObj["password"] = user.password;
|
||||
|
||||
cout<<"Sending request for token"<<endl;
|
||||
auto url = api.url + api.endpoint;
|
||||
cout<<url<<endl;
|
||||
auto r = cpr::Post(cpr::Url{url},
|
||||
cpr::Body{usrObj.dump()},
|
||||
cpr::Header{{"Content-Type", "application/json"}});
|
||||
|
||||
json res = json::parse(r.text);
|
||||
token.accessToken = res["token"];
|
||||
token.tokenType = res["token_type"];
|
||||
|
||||
cout<<"status code "<<r.status_code<<endl;
|
||||
|
||||
return token;
|
||||
}
|
||||
#pragma endregion
|
||||
|
||||
}
|
||||
@@ -1,55 +0,0 @@
|
||||
#include"Managers/UserManager.h"
|
||||
|
||||
#include<iostream>
|
||||
#include<string>
|
||||
#include<vector>
|
||||
|
||||
using std::string;
|
||||
using std::vector;
|
||||
|
||||
using Models::IcarusAction;
|
||||
using Models::User;
|
||||
|
||||
namespace Managers
|
||||
{
|
||||
|
||||
#pragma region Constructors
|
||||
UserManager::UserManager(User user)
|
||||
{
|
||||
this->user = user;
|
||||
}
|
||||
UserManager::UserManager(const IcarusAction icaAct)
|
||||
{
|
||||
this->icaAction = icaAct;
|
||||
this->user = User{};
|
||||
parseUserFromActions();
|
||||
}
|
||||
#pragma endregion
|
||||
|
||||
|
||||
#pragma region Functions
|
||||
User UserManager::retrieveUser() const
|
||||
{
|
||||
return user;
|
||||
}
|
||||
|
||||
void UserManager::parseUserFromActions()
|
||||
{
|
||||
auto args = icaAction.flags;
|
||||
|
||||
for (auto arg : args)
|
||||
{
|
||||
auto flag = arg.flag;
|
||||
if (flag.compare("-u") == 0)
|
||||
{
|
||||
user.username = arg.value;
|
||||
}
|
||||
if (flag.compare("-p") == 0)
|
||||
{
|
||||
user.password = arg.value;
|
||||
}
|
||||
}
|
||||
}
|
||||
#pragma endregion
|
||||
|
||||
}
|
||||
@@ -1,22 +0,0 @@
|
||||
#include "Models/Song.h"
|
||||
|
||||
#include "nlohmann/json.hpp"
|
||||
|
||||
using std::string;
|
||||
|
||||
namespace Models
|
||||
{
|
||||
string Song::toMetadataJson()
|
||||
{
|
||||
nlohmann::json s;
|
||||
s["title"] = this->title;
|
||||
s["artist"] = this->artist;
|
||||
s["album"] = this->album;
|
||||
s["genre"] = this->genre;
|
||||
s["year"] = this->year;
|
||||
s["track"] = this->track;
|
||||
s["disc"] = this->disc;
|
||||
|
||||
return s.dump();
|
||||
}
|
||||
}
|
||||
@@ -1,53 +0,0 @@
|
||||
#include "Parsers/APIParser.h"
|
||||
|
||||
#include <iostream>
|
||||
|
||||
using std::cout;
|
||||
using std::endl;
|
||||
|
||||
using Models::API;
|
||||
using Models::IcarusAction;
|
||||
|
||||
namespace Parsers
|
||||
{
|
||||
|
||||
#pragma region Constructors
|
||||
APIParser::APIParser(IcarusAction icaAct) : icaAct(icaAct)
|
||||
{
|
||||
api = API{};
|
||||
parseAPI();
|
||||
}
|
||||
#pragma endregion
|
||||
|
||||
|
||||
#pragma region Functions
|
||||
API APIParser::retrieveAPI() const
|
||||
{
|
||||
return api;
|
||||
}
|
||||
|
||||
void APIParser::parseAPI()
|
||||
{
|
||||
auto flags = icaAct.flags;
|
||||
cout << "Parsing api" << endl;
|
||||
|
||||
for (auto i =0; i < flags.size(); ++i)
|
||||
{
|
||||
auto arg = flags[i].flag;
|
||||
auto value = flags[i].value;
|
||||
|
||||
if (arg.compare("-h") == 0)
|
||||
{
|
||||
api.url = (value[value.size()-1] == '/') ? value : value + "/";
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
// NOTE: For now I will hard code
|
||||
// the api version since I am only
|
||||
// on version 1
|
||||
api.version = "v1";
|
||||
}
|
||||
#pragma endregion
|
||||
|
||||
}
|
||||
@@ -1,64 +0,0 @@
|
||||
#include "Syncers/Delete.h"
|
||||
|
||||
#include <exception>
|
||||
#include <iostream>
|
||||
|
||||
#include <cpr/cpr.h>
|
||||
|
||||
using std::cout;
|
||||
using std::endl;
|
||||
using std::exception;
|
||||
using std::string;
|
||||
|
||||
using Models::API;
|
||||
using Models::Song;
|
||||
using Models::Token;
|
||||
|
||||
namespace Syncers
|
||||
{
|
||||
|
||||
#pragma region Constructors
|
||||
Delete::Delete(API api)
|
||||
{
|
||||
this->api = api;
|
||||
this->api.endpoint = "song/data";
|
||||
}
|
||||
#pragma endregion
|
||||
|
||||
|
||||
#pragma region Functions
|
||||
void Delete::deleteSong(const Token token, Song song)
|
||||
{
|
||||
try
|
||||
{
|
||||
auto url = retrieveUrl(song);
|
||||
string auth{token.tokenType};
|
||||
auth.append(" " + token.accessToken);
|
||||
auto r = cpr::Delete(cpr::Url(url),
|
||||
cpr::Header{{"authorization", auth}});
|
||||
|
||||
auto statusCode = r.status_code;
|
||||
|
||||
cout<<"Status code "<<statusCode<<endl;
|
||||
}
|
||||
catch (exception e)
|
||||
{
|
||||
auto msg = e.what();
|
||||
cout<<msg<<endl;
|
||||
}
|
||||
cout<<"Finished"<<endl;
|
||||
}
|
||||
|
||||
string Delete::retrieveUrl(Song song)
|
||||
{
|
||||
string url{api.url + "api/" + api.version + "/" +
|
||||
api.endpoint + "/"};
|
||||
|
||||
url.append(std::to_string(song.id));
|
||||
cout<<"url "<<url<<endl;
|
||||
|
||||
return url;
|
||||
}
|
||||
#pragma endregion
|
||||
|
||||
}
|
||||
@@ -1,93 +0,0 @@
|
||||
#include "Syncers/Download.h"
|
||||
|
||||
#include <exception>
|
||||
#include <iostream>
|
||||
#include <fstream>
|
||||
|
||||
#include <cpr/cpr.h>
|
||||
|
||||
using std::cout;
|
||||
using std::endl;
|
||||
using std::exception;
|
||||
using std::ofstream;
|
||||
using std::string;
|
||||
|
||||
using Models::API;
|
||||
using Models::Song;
|
||||
using Models::Token;
|
||||
|
||||
namespace Syncers
|
||||
{
|
||||
|
||||
#pragma region Constructors
|
||||
Download::Download() { }
|
||||
Download::Download(API api)
|
||||
{
|
||||
this->api = api;
|
||||
this->api.endpoint = "song/data";
|
||||
}
|
||||
Download::Download(string filePath)
|
||||
{
|
||||
downloadFilePath = filePath;
|
||||
}
|
||||
#pragma endregion
|
||||
|
||||
|
||||
#pragma region Functions
|
||||
void Download::downloadSong(const Token token, Song song)
|
||||
{
|
||||
try
|
||||
{
|
||||
string url = retrieveUrl(song);
|
||||
song.songPath.append("track.mp3");
|
||||
cout<<"song path "<<song.songPath<<endl;
|
||||
string auth{token.tokenType};
|
||||
auth.append(" " + token.accessToken);
|
||||
|
||||
auto r = cpr::Get(cpr::Url(url),
|
||||
cpr::Header{{"Content-type", "audio/mpeg"},
|
||||
{"Authorization", auth}});
|
||||
|
||||
|
||||
int statusCode = r.status_code;
|
||||
|
||||
if (statusCode == OK) {
|
||||
song.data = r.text;
|
||||
saveSong(song);
|
||||
}
|
||||
|
||||
|
||||
cout<<"finsihed with status code "<<statusCode<<endl;
|
||||
}
|
||||
catch (exception e)
|
||||
{
|
||||
auto msg = e.what();
|
||||
cout<<msg<<endl;
|
||||
}
|
||||
}
|
||||
|
||||
string Download::retrieveUrl(Song song)
|
||||
{
|
||||
string url{api.url + "api/" + api.version + "/" +
|
||||
api.endpoint + "/"};
|
||||
|
||||
url.append(std::to_string(song.id));
|
||||
cout<<"url "<<url<<endl;
|
||||
|
||||
return url;
|
||||
}
|
||||
|
||||
void Download::saveSong(Song& song)
|
||||
{
|
||||
cout<<"\nSaving song to: "<<song.songPath<<endl;
|
||||
int bufferLength = song.data.length();
|
||||
const char *data = song.data.c_str();
|
||||
cout<<"buff length "<<bufferLength<<endl;
|
||||
|
||||
ofstream saveSong{song.songPath, std::ios::binary};
|
||||
saveSong.write(data, bufferLength);
|
||||
saveSong.close();
|
||||
}
|
||||
#pragma endregion
|
||||
|
||||
}
|
||||
@@ -1,67 +0,0 @@
|
||||
#include "Syncers/RetrieveRecords.h"
|
||||
|
||||
#include <iostream>
|
||||
#include <fstream>
|
||||
|
||||
#include <cpr/cpr.h>
|
||||
#include <nlohmann/json.hpp>
|
||||
|
||||
#include "Utilities/Conversions.h"
|
||||
|
||||
using std::cout;
|
||||
using std::endl;
|
||||
using std::ofstream;
|
||||
|
||||
using Managers::CommitManager;
|
||||
using Models::API;
|
||||
using Models::Token;
|
||||
using Utilities::Conversions;
|
||||
|
||||
namespace Syncers
|
||||
{
|
||||
|
||||
#pragma region Constructors
|
||||
RetrieveRecords::RetrieveRecords() { }
|
||||
RetrieveRecords::RetrieveRecords(API api, Token token)
|
||||
: token(token), api(api) { }
|
||||
#pragma endregion
|
||||
|
||||
#pragma region Functions
|
||||
void RetrieveRecords::retrieve(CommitManager::RetrieveTypes type)
|
||||
{
|
||||
switch (type)
|
||||
{
|
||||
case CommitManager::RetrieveTypes::songs:
|
||||
fetchSongs();
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
}
|
||||
void RetrieveRecords::fetchSongs()
|
||||
{
|
||||
cout<<"fetching songs"<<endl;
|
||||
auto url = api.url + "api/" + api.version + "/" + "song";
|
||||
|
||||
auto auth = token.tokenType;
|
||||
auth.append(" " + token.accessToken);
|
||||
auto r = cpr::Get(cpr::Url{url},
|
||||
cpr::Header{{"authorization", auth},
|
||||
});
|
||||
|
||||
if (r.status_code != (int)Result::OK) {
|
||||
cout<<"something went wrong\n";
|
||||
cout<<"status code: "<<r.status_code<<endl;
|
||||
cout<<"message: "<<r.text<<endl;
|
||||
return;
|
||||
}
|
||||
auto songData = nlohmann::json::parse(r.text);
|
||||
|
||||
ofstream writeData{};
|
||||
writeData.open("songs.json");
|
||||
writeData<<songData.dump(4);
|
||||
writeData.close();
|
||||
}
|
||||
#pragma endregion
|
||||
|
||||
}
|
||||
@@ -1,243 +0,0 @@
|
||||
#include <iostream>
|
||||
#include <filesystem>
|
||||
#include <exception>
|
||||
|
||||
#include "cpr/cpr.h"
|
||||
|
||||
#include "Syncers/Upload.h"
|
||||
#include "Utilities/Conversions.h"
|
||||
|
||||
using std::cout;
|
||||
using std::cin;
|
||||
using std::endl;
|
||||
using std::exception;
|
||||
using std::string;
|
||||
|
||||
using json = nlohmann::json;
|
||||
|
||||
using Managers::FileManager;
|
||||
using Models::API;
|
||||
using Models::Song;
|
||||
using Models::UploadForm;
|
||||
|
||||
using namespace cpr;
|
||||
|
||||
namespace Syncers
|
||||
{
|
||||
|
||||
#pragma region Constructors
|
||||
#pragma endregion
|
||||
|
||||
|
||||
#pragma region Functions
|
||||
Song Upload::uploadSong(Song& song)
|
||||
{
|
||||
try
|
||||
{
|
||||
auto url = retrieveUrl();
|
||||
|
||||
cout<<"url "<<url<<endl;
|
||||
string auth{this->m_token.tokenType};
|
||||
auth.append(" " + this->m_token.accessToken);
|
||||
auto r = cpr::Post(cpr::Url{url},
|
||||
cpr::Multipart{{"key", "small value"},
|
||||
{"file", cpr::File{song.songPath}}},
|
||||
cpr::Header{{"authorization", auth}}
|
||||
);
|
||||
|
||||
cout << "status code: " << r.status_code<< std::endl;
|
||||
cout << r.text << endl;
|
||||
auto result = nlohmann::json::parse(r.text);
|
||||
cout<<"Finished"<<endl;
|
||||
song.id = result["id"].get<int>();
|
||||
song.title = result["title"].get<std::string>();
|
||||
song.artist = result["artist"].get<std::string>();
|
||||
song.album = result["album"].get<std::string>();
|
||||
song.genre = result["genre"].get<std::string>();
|
||||
song.year = result["year"].get<int>();
|
||||
song.duration = result["duration"].get<int>();
|
||||
song.track = result["track"].get<int>();
|
||||
|
||||
return song;
|
||||
}
|
||||
catch (exception& e)
|
||||
{
|
||||
auto msg = e.what();
|
||||
cout<<msg<<endl;
|
||||
}
|
||||
|
||||
return song;
|
||||
}
|
||||
|
||||
void Upload::uploadSongsFromDirectory(const std::string& directory,
|
||||
const bool noConfirm, bool recursive = false)
|
||||
{
|
||||
try
|
||||
{
|
||||
auto songs = retrieveAllSongsFromDirectory(directory, recursive);
|
||||
auto confirmUpload = true;
|
||||
|
||||
while (!noConfirm)
|
||||
{
|
||||
auto answer = 'a';
|
||||
cout << "are you sure you want to upload " << songs.size() << " songs? [y/n]";
|
||||
cin >> answer;
|
||||
Utilities::Conversions::toLowerChar(answer);
|
||||
|
||||
if (answer == 'y' || answer == 'Y')
|
||||
{
|
||||
confirmUpload = true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
cout << "uploading songs\n";
|
||||
for (auto& song: songs)
|
||||
{
|
||||
song = uploadSong(song);
|
||||
}
|
||||
}
|
||||
catch (exception& e)
|
||||
{
|
||||
cout<<e.what()<<endl;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void Upload::uploadSongWithMetadata(Managers::CommitManager::Album &album, Models::Song& song, Models::CoverArt &cover)
|
||||
{
|
||||
this->api.endpoint.assign("song/data/upload/with/data");
|
||||
|
||||
try
|
||||
{
|
||||
auto url = retrieveUrl();
|
||||
|
||||
cout << "url " << url << "\n";
|
||||
string auth(this->m_token.tokenType);
|
||||
auth.append(" " + this->m_token.accessToken);
|
||||
|
||||
nlohmann::json s;
|
||||
s["title"] = song.title;
|
||||
s["album"] = album.album;
|
||||
s["album_artist"] = album.albumArtist;
|
||||
s["artist"] = song.artist;
|
||||
s["year"] = album.year;
|
||||
s["genre"] = album.genre;
|
||||
s["disc"] = song.disc;
|
||||
s["track"] = song.track;
|
||||
s["disc_count"] = album.discCount;
|
||||
s["track_count"] = album.trackCount;
|
||||
|
||||
const auto meta = s.dump();
|
||||
|
||||
cout<<"\n\nMeta:\n"<<meta<<"\n";
|
||||
cout << "Filepath: " << song.song_path() << "\n";
|
||||
|
||||
auto multipart = cpr::Multipart{{"cover", cpr::File{cover.path}},
|
||||
{"metadata", meta},
|
||||
{"file", cpr::File{song.song_path()}}};
|
||||
|
||||
auto r = cpr::Post(cpr::Url{url}, multipart,
|
||||
cpr::Header{{"authorization", auth}}
|
||||
);
|
||||
|
||||
cout << "status code: " << r.status_code<< std::endl;
|
||||
cout << r.text << endl;
|
||||
}
|
||||
catch (exception &e)
|
||||
{
|
||||
auto msg = e.what();
|
||||
cout<<"Error: "<<msg<<"\n";
|
||||
}
|
||||
}
|
||||
std::vector<Song> Upload::retrieveAllSongsFromDirectory(const std::string& directory,
|
||||
bool recursive)
|
||||
{
|
||||
std::vector<Song> allSongs;
|
||||
|
||||
if (recursive)
|
||||
{
|
||||
for (auto p: fs::recursive_directory_iterator(directory))
|
||||
{
|
||||
auto song = retrieveSongPath(p);
|
||||
if (!song.songPath.empty())
|
||||
allSongs.push_back(song);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
for (auto p: fs::directory_iterator(directory))
|
||||
{
|
||||
auto song = retrieveSongPath(p);
|
||||
if (!song.songPath.empty())
|
||||
allSongs.push_back(song);
|
||||
}
|
||||
}
|
||||
|
||||
return allSongs;
|
||||
}
|
||||
|
||||
|
||||
string Upload::retrieveUrl()
|
||||
{
|
||||
const string url{api.url + "api/" + api.version + "/" +
|
||||
api.endpoint};
|
||||
|
||||
return url;
|
||||
}
|
||||
|
||||
|
||||
Song Upload::retrieveSongPath(fs::directory_entry& dirEntry)
|
||||
{
|
||||
constexpr auto mp3Ext = ".mp3";
|
||||
Song song;
|
||||
if (fs::is_regular_file(dirEntry.path()))
|
||||
{
|
||||
const auto ext = dirEntry.path().extension().string();
|
||||
if (ext.compare(mp3Ext) == 0)
|
||||
{
|
||||
cout << "found mp3 file" << endl;
|
||||
song.songPath = dirEntry.path().string();
|
||||
}
|
||||
}
|
||||
|
||||
return song;
|
||||
}
|
||||
|
||||
|
||||
#pragma region Testing
|
||||
|
||||
void Upload::printSongDetails(std::vector<Song>& songs)
|
||||
{
|
||||
for (auto& song: songs)
|
||||
{
|
||||
cout<<"Song details: "<<endl;
|
||||
cout<<"Id: "<<song.id<<endl;
|
||||
cout<<"Title: "<<song.title<<endl;
|
||||
cout<<"Artist: "<<song.artist<<endl;
|
||||
cout<<"Album: "<<song.album<<endl;
|
||||
cout<<"Genre: "<<song.genre<<endl;
|
||||
cout<<"Year: "<<song.year<<endl;
|
||||
cout<<"Duration: "<<song.duration<<endl;
|
||||
cout<<"Path: "<<song.songPath<<endl;
|
||||
}
|
||||
}
|
||||
|
||||
void Upload::printJsonData(const json& obj)
|
||||
{
|
||||
cout<<endl<<endl<<"JSon data: "<<endl;
|
||||
cout<<"id: "<<obj["id"]<<endl;
|
||||
cout<<"title: "<<obj["title"]<<endl;
|
||||
cout<<"artist: "<<obj["artist"]<<endl;
|
||||
cout<<"album: "<<obj["album"]<<endl;
|
||||
cout<<"genre: "<<obj["genre"]<<endl;
|
||||
cout<<"year: "<<obj["year"]<<endl;
|
||||
cout<<"duration: "<<obj["duration"]<<endl;
|
||||
cout<<"song_data: "<<obj["song_data"]<<endl;
|
||||
|
||||
cout<<endl<<endl;
|
||||
}
|
||||
#pragma endregion
|
||||
#pragma endregion
|
||||
|
||||
}
|
||||
@@ -1,52 +0,0 @@
|
||||
#include "UI/AboutWindow.h"
|
||||
|
||||
using std::unique_ptr;
|
||||
|
||||
namespace UI
|
||||
{
|
||||
#pragma region Constructors
|
||||
AboutWindow::AboutWindow(QWidget* parent): QDialog(parent)
|
||||
{
|
||||
setupWindow();
|
||||
}
|
||||
#pragma endregion
|
||||
|
||||
|
||||
#pragma region Functions
|
||||
void AboutWindow::setupWindow()
|
||||
{
|
||||
windowWidth = 250;
|
||||
windowHeight = 300;
|
||||
|
||||
mainLayoutQt = unique_ptr<QVBoxLayout>{new QVBoxLayout};
|
||||
|
||||
appName = unique_ptr<QLabel>{new QLabel(tr("IcarusDownloadManager"))};
|
||||
actionButtonQt = unique_ptr<QPushButton>{new QPushButton(tr("Close"))};
|
||||
|
||||
mainLayoutQt->addWidget(appName.get());
|
||||
mainLayoutQt->addWidget(actionButtonQt.get());
|
||||
|
||||
|
||||
setFixedWidth(windowWidth);
|
||||
setFixedHeight(windowHeight);
|
||||
|
||||
setLayout(mainLayoutQt.get());
|
||||
|
||||
setWindowTitle("About");
|
||||
|
||||
connections();
|
||||
}
|
||||
void AboutWindow::connections()
|
||||
{
|
||||
QObject::connect(actionButtonQt.get(), SIGNAL(clicked()), this,
|
||||
SLOT(closeWindow()));
|
||||
}
|
||||
|
||||
|
||||
void AboutWindow::closeWindow()
|
||||
{
|
||||
this->hide();
|
||||
}
|
||||
#pragma endregion
|
||||
|
||||
}
|
||||
@@ -1,180 +0,0 @@
|
||||
#include "UI/MainWindow.h"
|
||||
|
||||
#include <iostream>
|
||||
#include <string>
|
||||
|
||||
#include "Models/UploadForm.h"
|
||||
#include "Syncers/Upload.h"
|
||||
#include "Utilities/Conversions.h"
|
||||
|
||||
using std::cout;
|
||||
using std::endl;
|
||||
using std::string;
|
||||
using std::unique_ptr;
|
||||
|
||||
using Models::UploadForm;
|
||||
using Syncers::Upload;
|
||||
|
||||
namespace UI
|
||||
{
|
||||
|
||||
#pragma region Constructors
|
||||
MainWindow::MainWindow()
|
||||
{
|
||||
setupMainWindow();
|
||||
aboutWindow = unique_ptr<AboutWindow>{new AboutWindow};
|
||||
}
|
||||
#pragma endregion
|
||||
|
||||
|
||||
#pragma region Functions
|
||||
void MainWindow::configureDownloadSection()
|
||||
{
|
||||
}
|
||||
void MainWindow::configureUploadSection()
|
||||
{
|
||||
uploadSongQt = unique_ptr<QPushButton>{new QPushButton(tr("Upload"))};
|
||||
urlQt = unique_ptr<QTextEdit>{new QTextEdit()};
|
||||
sourceFilePathQt = unique_ptr<QTextEdit>{new QTextEdit()};
|
||||
|
||||
urlLabel = unique_ptr<QLabel>{new QLabel(tr("URL"))};
|
||||
songPath = unique_ptr<QLabel>{new QLabel(tr("Song Path"))};
|
||||
|
||||
urlPortion = unique_ptr<QHBoxLayout>{new QHBoxLayout};
|
||||
songPathPortion = unique_ptr<QHBoxLayout>{new QHBoxLayout};
|
||||
|
||||
urlPortion.get()->addWidget(urlLabel.get());
|
||||
urlPortion.get()->addWidget(urlQt.get());
|
||||
|
||||
songPathPortion->addWidget(songPath.get());
|
||||
songPathPortion->addWidget(sourceFilePathQt.get());
|
||||
|
||||
subLayoutOneQt = unique_ptr<QVBoxLayout>{new QVBoxLayout};
|
||||
subLayoutOneQt.get()->addLayout(urlPortion.get());
|
||||
subLayoutOneQt->addLayout(songPathPortion.get());
|
||||
mainLayoutQt.get()->addLayout(subLayoutOneQt.get());
|
||||
}
|
||||
void MainWindow::configureWindowDimensions()
|
||||
{
|
||||
windowWidth = 450;
|
||||
windowHeight = 450;
|
||||
}
|
||||
void MainWindow::configureWindowProperties()
|
||||
{
|
||||
setWindowTitle("IcarusDownloadManager");
|
||||
setFixedHeight(windowHeight);
|
||||
setFixedWidth(windowWidth);
|
||||
}
|
||||
void MainWindow::connections()
|
||||
{
|
||||
QObject::connect(uploadSongQt.get(), SIGNAL(clicked()), this, SLOT(uploadSong()));
|
||||
QObject::connect(closeApplicationQt.get(), SIGNAL(triggered()), this,
|
||||
SLOT(exitApplication()));
|
||||
QObject::connect(aboutApplicationQt.get(), SIGNAL(triggered()), this,
|
||||
SLOT(displaySoftwareInformation()));
|
||||
QObject::connect(windowComboBox.get(), SIGNAL(activated(int)),
|
||||
this, SLOT(setCurrentIndex(int)));
|
||||
}
|
||||
void MainWindow::createMenus()
|
||||
{
|
||||
fileMenuQt = unique_ptr<QMenu>{menuBar()->addMenu(tr("File"))};
|
||||
editMenuQt = unique_ptr<QMenu>{menuBar()->addMenu(tr("Edit"))};
|
||||
helpMenuQt = unique_ptr<QMenu>{menuBar()->addMenu(tr("Help"))};
|
||||
|
||||
closeApplicationQt = unique_ptr<QAction>{new QAction(new QObject(nullptr))};
|
||||
closeApplicationQt->setText("Exit Application");
|
||||
|
||||
aboutApplicationQt = unique_ptr<QAction>{new QAction(new QObject(nullptr))};
|
||||
aboutApplicationQt->setText("About");
|
||||
|
||||
fileMenuQt->addAction(closeApplicationQt.get());
|
||||
helpMenuQt->addAction(aboutApplicationQt.get());
|
||||
|
||||
}
|
||||
void MainWindow::setupMainWidget()
|
||||
{
|
||||
mainWidgetQt = unique_ptr<QWidget>{new QWidget};
|
||||
|
||||
windowComboBox = unique_ptr<QComboBox>{new QComboBox};
|
||||
setupWindowLists();
|
||||
|
||||
|
||||
stackLayout = unique_ptr<QVBoxLayout>{new QVBoxLayout};
|
||||
stackLayout->addWidget(windowComboBox.get());
|
||||
|
||||
uploadSongWidgetQt = unique_ptr<QWidget>{new QWidget};
|
||||
uploadSongWidgetQt->setLayout(mainLayoutQt.get());
|
||||
|
||||
stackLayout->addWidget(uploadSongWidgetQt.get());
|
||||
|
||||
mainWidgetQt->setLayout(stackLayout.get());
|
||||
}
|
||||
void MainWindow::setupMainWindow()
|
||||
{
|
||||
configureWindowDimensions();
|
||||
|
||||
mainLayoutQt = unique_ptr<QVBoxLayout>{new QVBoxLayout};
|
||||
widgetStack = unique_ptr<QStackedWidget>{new QStackedWidget};
|
||||
|
||||
configureUploadSection();
|
||||
|
||||
setupMainWidget();
|
||||
|
||||
widgetStack->addWidget(mainWidgetQt.get());
|
||||
|
||||
MainDockWidgetQt = unique_ptr<QDockWidget>{new QDockWidget};
|
||||
MainDockWidgetQt.get()->setWindowTitle(tr("Music Manager"));
|
||||
MainDockWidgetQt->setWidget(widgetStack.get());
|
||||
MainDockWidgetQt.get()->setFeatures(QDockWidget::NoDockWidgetFeatures);
|
||||
|
||||
setCentralWidget(MainDockWidgetQt.get());
|
||||
|
||||
createMenus();
|
||||
|
||||
configureWindowProperties();
|
||||
|
||||
connections();
|
||||
}
|
||||
void MainWindow::setupWindowLists()
|
||||
{
|
||||
windowComboBox->addItem(tr("Upload song"));
|
||||
windowComboBox->addItem(tr("Download song"));
|
||||
windowComboBox->addItem(tr("Display all songs"));
|
||||
windowComboBox->addItem(tr("Display songs"));
|
||||
}
|
||||
|
||||
|
||||
void MainWindow::exitApplication()
|
||||
{
|
||||
exit(0);
|
||||
}
|
||||
void MainWindow::displaySoftwareInformation()
|
||||
{
|
||||
aboutWindow->show();
|
||||
}
|
||||
void MainWindow::setCurrentIndex(int index)
|
||||
{
|
||||
cout<<"index "<<index<<endl;
|
||||
QString qText = windowComboBox->itemText(index);
|
||||
auto cnvert = Utilities::Conversions(qText);
|
||||
auto convertedStr = cnvert.convertQStringToString();
|
||||
cout<<"item text"<<endl;
|
||||
}
|
||||
void MainWindow::uploadSong()
|
||||
{
|
||||
uploadSongQt->setEnabled(false);
|
||||
|
||||
string url = urlQt->toPlainText().toUtf8().constData();
|
||||
string filePath = sourceFilePathQt->toPlainText().toUtf8().constData();
|
||||
cout<<"URL endpoint: "<<url<<endl;
|
||||
cout<<"Music file path: "<<filePath<<endl;
|
||||
UploadForm formData{url, filePath};
|
||||
|
||||
Upload upld{formData};
|
||||
upld.uploadSong();
|
||||
|
||||
uploadSongQt->setEnabled(true);
|
||||
}
|
||||
#pragma endregion
|
||||
|
||||
}
|
||||
@@ -1,26 +0,0 @@
|
||||
#include "Utilities/Conversions.h"
|
||||
|
||||
#include <iostream>
|
||||
|
||||
using std::string;
|
||||
using std::unique_ptr;
|
||||
|
||||
namespace Utilities
|
||||
{
|
||||
|
||||
Conversions::Conversions()
|
||||
{
|
||||
initializeValues();
|
||||
}
|
||||
|
||||
void Conversions::initializeValues()
|
||||
{
|
||||
}
|
||||
template <typename T>
|
||||
void Conversions::printValue(T val)
|
||||
{
|
||||
std::cout<<"going to print value\n";
|
||||
std::cout<<val<< "\n";
|
||||
}
|
||||
|
||||
}
|
||||
@@ -0,0 +1,3 @@
|
||||
pub const WAV_FILE_EXTENSION: &str = ".wav";
|
||||
pub const _MP3_FILE_EXTENSION: &str = ".mp3";
|
||||
pub const JPG_FILE_EXTENSION: &str = ".jpg";
|
||||
@@ -0,0 +1 @@
|
||||
pub mod file_extensions;
|
||||
+81
@@ -0,0 +1,81 @@
|
||||
mod constants;
|
||||
mod managers;
|
||||
mod models;
|
||||
mod parsers;
|
||||
mod syncers;
|
||||
mod utilities;
|
||||
|
||||
use std::env;
|
||||
use std::process;
|
||||
|
||||
fn exit_program(code: i32) {
|
||||
process::exit(code);
|
||||
}
|
||||
|
||||
fn print_help() {
|
||||
let msg: String = String::from(
|
||||
r#"icd [Action] [flag]
|
||||
|
||||
Actions
|
||||
download
|
||||
upload-meta
|
||||
retrieve
|
||||
delete
|
||||
|
||||
Flags
|
||||
Required for all actions
|
||||
-u username
|
||||
-p password
|
||||
-h host
|
||||
|
||||
Required for upload with metadata
|
||||
-s path of song
|
||||
-t track number
|
||||
-m metadata filepath
|
||||
-ca coverart filepath
|
||||
-scma directory where songs, metadata, and cover art exists and will be uploaded (Optional)
|
||||
|
||||
Required for download
|
||||
-b song id
|
||||
-d path to download song (Optional)
|
||||
|
||||
Required for retrieving records
|
||||
-rt retrieve type (songs is only accepted)
|
||||
|
||||
Required for deleting a song
|
||||
-D song id"#,
|
||||
);
|
||||
|
||||
println!("{}", msg);
|
||||
}
|
||||
|
||||
fn main() {
|
||||
let args: Vec<String> = env::args().collect();
|
||||
|
||||
if args.len() == 1 {
|
||||
print_help();
|
||||
exit_program(-1);
|
||||
}
|
||||
|
||||
let args_len = args.len() as i32;
|
||||
|
||||
println!("Argument count: {}", args_len);
|
||||
|
||||
let mut act_mgr = managers::action_managers::ActionManager {
|
||||
action: String::new(),
|
||||
flags: Vec::new(),
|
||||
params: args,
|
||||
param_count: args_len,
|
||||
};
|
||||
act_mgr.initialize();
|
||||
|
||||
let chosen_act = act_mgr.retrieve_icarus_action();
|
||||
|
||||
chosen_act.print_action_and_flags();
|
||||
|
||||
let mut cmt_mgr = managers::commit_manager::CommitManager {
|
||||
ica_action: chosen_act,
|
||||
};
|
||||
|
||||
cmt_mgr.commit_action();
|
||||
}
|
||||
@@ -0,0 +1,221 @@
|
||||
use serde::{Deserialize, Serialize};
|
||||
|
||||
use crate::models;
|
||||
|
||||
#[derive(Debug, Deserialize, Serialize)]
|
||||
pub struct ActionManager {
|
||||
pub action: String,
|
||||
pub flags: Vec<models::flags::Flags>,
|
||||
pub params: Vec<String>,
|
||||
pub param_count: i32,
|
||||
}
|
||||
|
||||
impl ActionManager {
|
||||
pub fn retrieve_icarus_action(&self) -> models::icarus_action::IcarusAction {
|
||||
return models::icarus_action::IcarusAction {
|
||||
flags: self.flags.clone(),
|
||||
action: String::from(&self.action),
|
||||
};
|
||||
}
|
||||
|
||||
fn supported_flags(&self) -> Vec<String> {
|
||||
return vec![
|
||||
String::from("-u"),
|
||||
String::from("-p"),
|
||||
String::from("-t"),
|
||||
String::from("-h"),
|
||||
String::from("-s"),
|
||||
String::from("-sd"),
|
||||
String::from("-sr"),
|
||||
String::from("-d"),
|
||||
String::from("-D"),
|
||||
String::from("-b"),
|
||||
String::from("-rt"),
|
||||
String::from("-nc"),
|
||||
String::from("-m"),
|
||||
String::from("-ca"),
|
||||
String::from("-smca"),
|
||||
String::from("-t"),
|
||||
];
|
||||
}
|
||||
|
||||
pub fn initialize(&mut self) {
|
||||
self.validate_flags();
|
||||
self.validate_action();
|
||||
self.action = self.action.to_lowercase();
|
||||
}
|
||||
|
||||
fn validate_flags(&mut self) {
|
||||
println!("Validating flags");
|
||||
|
||||
let flag_vals = self.parsed_flags();
|
||||
|
||||
let mut i = 0;
|
||||
println!("Flag count: {}", flag_vals.len());
|
||||
|
||||
while i < flag_vals.len() {
|
||||
let flag = &flag_vals[i];
|
||||
println!("Index: {} | Value: {}", i, flag);
|
||||
|
||||
let mut flg = models::flags::Flags::default();
|
||||
|
||||
if self.is_valid_flag(flag) && self.does_flag_have_value(flag) {
|
||||
println!("Flag has value");
|
||||
flg.flag = String::from(flag);
|
||||
flg.value = String::from(&flag_vals[i + 1]);
|
||||
|
||||
i = i + 1;
|
||||
} else if self.is_valid_flag(flag) {
|
||||
println!("Flag does not have a value");
|
||||
flg.flag = String::from(flag);
|
||||
} else {
|
||||
println!("Flag {} is not valid", flag);
|
||||
std::process::exit(-1);
|
||||
}
|
||||
|
||||
self.flags.push(flg);
|
||||
println!("");
|
||||
i += 1;
|
||||
}
|
||||
}
|
||||
|
||||
fn validate_action(&mut self) {
|
||||
if self.params.len() >= 2 {
|
||||
let act = &self.params[1];
|
||||
self.action = String::from(act);
|
||||
}
|
||||
}
|
||||
|
||||
fn is_valid_flag(&self, flag: &String) -> bool {
|
||||
let flags = self.supported_flags();
|
||||
let mut found: bool = false;
|
||||
|
||||
for flg in &flags {
|
||||
if flg == flag {
|
||||
found = true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
return found;
|
||||
}
|
||||
|
||||
fn does_flag_have_value(&self, flag: &String) -> bool {
|
||||
let flags_tmp = self.parsed_flags();
|
||||
|
||||
let mut i_found: i32 = -1;
|
||||
|
||||
for i in 0..flags_tmp.len() {
|
||||
let flg = &flags_tmp[i];
|
||||
if flg == flag {
|
||||
i_found = i as i32;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if i_found >= 0 {
|
||||
if (i_found + 1) < flags_tmp.len().try_into().unwrap() {
|
||||
return true;
|
||||
} else {
|
||||
return false;
|
||||
}
|
||||
} else {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
fn _print_action(&self) {
|
||||
if self.action.len() == 0 {
|
||||
println!("Action is empty");
|
||||
} else {
|
||||
println!("Action is {}", self.action);
|
||||
}
|
||||
}
|
||||
|
||||
fn _print_flags(&self) {
|
||||
println!("Printing flags...");
|
||||
for flag in &self.flags {
|
||||
println!("Flag {}", flag.flag);
|
||||
println!("Value {}", flag.value);
|
||||
}
|
||||
}
|
||||
|
||||
fn parsed_flags(&self) -> Vec<String> {
|
||||
let mut parsed: Vec<String> = Vec::new();
|
||||
|
||||
for i in 2..self.params.len() {
|
||||
let flag = String::from(&self.params[i]);
|
||||
parsed.push(flag);
|
||||
}
|
||||
|
||||
return parsed;
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use crate::managers::action_managers::ActionManager;
|
||||
|
||||
#[test]
|
||||
fn minimum_action_and_args() {
|
||||
let args: Vec<String> = vec![
|
||||
"icarus-dm".to_string(),
|
||||
"download".to_string(),
|
||||
"-u".to_string(),
|
||||
"jamborie".to_string(),
|
||||
"-p".to_string(),
|
||||
"somethingsecr3t!".to_string(),
|
||||
"-h".to_string(),
|
||||
"https://music-server.com".to_string(),
|
||||
];
|
||||
let arg_count = args.len() as i32;
|
||||
let minimum_arg_count = 8;
|
||||
assert!(arg_count >= minimum_arg_count);
|
||||
|
||||
let mut act_mgr = ActionManager {
|
||||
action: String::new(),
|
||||
flags: Vec::new(),
|
||||
params: args,
|
||||
param_count: arg_count,
|
||||
};
|
||||
act_mgr.initialize();
|
||||
let ica = act_mgr.retrieve_icarus_action();
|
||||
let action = &ica.action;
|
||||
let flags = &ica.flags;
|
||||
|
||||
assert!(action != "");
|
||||
assert!(flags.len() > 2);
|
||||
assert!(
|
||||
!(action != "download"
|
||||
&& action != "upload"
|
||||
&& action != "retrieve"
|
||||
&& action != "upload-meta")
|
||||
);
|
||||
|
||||
let mut all_flags_found = false;
|
||||
let mut found_count = 0;
|
||||
let mut flags_already_read = Vec::new();
|
||||
|
||||
for flag in flags {
|
||||
if flags_already_read.contains(&flag.flag) {
|
||||
continue;
|
||||
}
|
||||
|
||||
if flag.flag == "-u" {
|
||||
found_count += 1;
|
||||
flags_already_read.push(flag.flag.clone());
|
||||
} else if flag.flag == "-p" {
|
||||
found_count += 1;
|
||||
flags_already_read.push(flag.flag.clone());
|
||||
} else if flag.flag == "-h" {
|
||||
found_count += 1;
|
||||
flags_already_read.push(flag.flag.clone());
|
||||
}
|
||||
}
|
||||
|
||||
all_flags_found = found_count == 3;
|
||||
|
||||
assert_eq!(found_count, 3, "Three flags are required: -u, -p, -h");
|
||||
assert!(all_flags_found, "All flags have not been found");
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,745 @@
|
||||
use std::collections::HashMap;
|
||||
use std::default::Default;
|
||||
use std::fs::read_dir;
|
||||
use std::io::{Result, Write};
|
||||
use std::str::FromStr;
|
||||
|
||||
use serde::{Deserialize, Serialize};
|
||||
use tokio::runtime::Runtime;
|
||||
|
||||
use crate::managers;
|
||||
use crate::models::song::Album;
|
||||
use crate::models::{self};
|
||||
use crate::syncers;
|
||||
use crate::utilities;
|
||||
use crate::{constants, parsers};
|
||||
|
||||
#[derive(Debug, Deserialize, Serialize)]
|
||||
pub struct CommitManager {
|
||||
pub ica_action: models::icarus_action::IcarusAction,
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug)]
|
||||
enum ActionValues {
|
||||
DeleteAct,
|
||||
DownloadAct,
|
||||
RetrieveAct,
|
||||
UploadAct,
|
||||
UploadSongWithMetadata,
|
||||
None,
|
||||
}
|
||||
|
||||
enum _RetrieveTypes {
|
||||
Songs,
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug)]
|
||||
enum En {
|
||||
ImageFile,
|
||||
SongFile,
|
||||
MetadataFile,
|
||||
Other,
|
||||
}
|
||||
|
||||
impl Album {
|
||||
pub fn _print_info(&self) {
|
||||
println!("Album: {}", self.title);
|
||||
println!("Album Artist: {}", self.album_artist);
|
||||
println!("Genre: {}", self.genre);
|
||||
println!("Year: {}", self.year);
|
||||
println!("Track Count: {}", self.track_count);
|
||||
println!("Disc Count: {}\n", self.disc_count);
|
||||
}
|
||||
|
||||
pub fn retrieve_song(&self, track: i32, disc: i32) -> Result<models::song::Song> {
|
||||
let mut found = false;
|
||||
let mut song = models::song::Song::default();
|
||||
|
||||
for song_i in &self.songs {
|
||||
if song_i.track.unwrap() == track && song_i.disc.unwrap() == disc {
|
||||
song = song_i.clone();
|
||||
found = true;
|
||||
}
|
||||
}
|
||||
|
||||
if found {
|
||||
return Ok(song);
|
||||
}
|
||||
|
||||
return Err(std::io::Error::new(
|
||||
std::io::ErrorKind::NotFound,
|
||||
"Song not found",
|
||||
));
|
||||
}
|
||||
}
|
||||
|
||||
impl CommitManager {
|
||||
pub fn commit_action(&mut self) {
|
||||
let action = &self.ica_action.action;
|
||||
println!("Committing {} action", action);
|
||||
|
||||
let mapped_actions = &self.map_actions();
|
||||
let mapped_action = self.find_mapped_action(&mapped_actions, action);
|
||||
|
||||
println!("{:?}", mapped_action);
|
||||
|
||||
match mapped_action {
|
||||
ActionValues::DeleteAct => self.delete_song(),
|
||||
ActionValues::DownloadAct => self.download_song(),
|
||||
ActionValues::RetrieveAct => self.retrieve_object(),
|
||||
ActionValues::UploadAct => self.upload_song(),
|
||||
ActionValues::UploadSongWithMetadata => self.upload_song_with_metadata(),
|
||||
_ => {
|
||||
println!("Nothing good here");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn find_mapped_action(
|
||||
&self,
|
||||
actions: &HashMap<String, ActionValues>,
|
||||
action: &String,
|
||||
) -> ActionValues {
|
||||
for (key, act) in actions {
|
||||
if key == action {
|
||||
return act.clone();
|
||||
}
|
||||
}
|
||||
|
||||
return ActionValues::None;
|
||||
}
|
||||
|
||||
fn map_actions(&self) -> HashMap<String, ActionValues> {
|
||||
let mut actions: HashMap<String, ActionValues> = HashMap::new();
|
||||
actions.insert("download".to_string(), ActionValues::DownloadAct);
|
||||
actions.insert("upload".to_string(), ActionValues::UploadAct);
|
||||
actions.insert(
|
||||
"upload-meta".to_string(),
|
||||
ActionValues::UploadSongWithMetadata,
|
||||
);
|
||||
actions.insert("retrieve".to_string(), ActionValues::RetrieveAct);
|
||||
actions.insert("delete".to_string(), ActionValues::DeleteAct);
|
||||
|
||||
return actions;
|
||||
}
|
||||
|
||||
fn delete_song(&self) {
|
||||
let mut prsr = parsers::api_parser::APIParser {
|
||||
ica_act: self.ica_action.clone(),
|
||||
api: models::api::API::default(),
|
||||
};
|
||||
prsr.parse_api();
|
||||
let api = prsr.retrieve_api();
|
||||
|
||||
let token = self.parse_token(&api);
|
||||
|
||||
println!("Deleting song");
|
||||
|
||||
let mut song = models::song::Song::default();
|
||||
|
||||
for arg in &self.ica_action.flags {
|
||||
let flag = &arg.flag;
|
||||
let value = &arg.value;
|
||||
|
||||
if flag == "-D" {
|
||||
song.id = Some(value.parse::<i32>().unwrap());
|
||||
}
|
||||
}
|
||||
|
||||
let mut del = syncers::delete::Delete { api: api.clone() };
|
||||
|
||||
println!("Deleting song..");
|
||||
|
||||
let res_fut = del.delete_song(&token, &song);
|
||||
let result = Runtime::new().unwrap().block_on(res_fut);
|
||||
match result {
|
||||
Ok(o) => {
|
||||
println!("Song (Id {:?}) has been successfully deleted", o.id);
|
||||
}
|
||||
Err(er) => {
|
||||
println!("Error {:?}", er);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn download_song(&self) {
|
||||
println!("Deleting song");
|
||||
let dwn = self.ica_action.retrieve_flag_value(&String::from("-b"));
|
||||
let num: i32 = dwn.parse::<i32>().unwrap();
|
||||
|
||||
let mut prsr = parsers::api_parser::APIParser {
|
||||
api: models::api::API::default(),
|
||||
ica_act: self.ica_action.clone(),
|
||||
};
|
||||
prsr.parse_api();
|
||||
|
||||
let api = prsr.retrieve_api();
|
||||
let token = self.parse_token(&api);
|
||||
|
||||
let mut dwn_loader = syncers::download::Download { api: api.clone() };
|
||||
let mut song = models::song::Song::default();
|
||||
song.id = Some(num);
|
||||
let result_fut = dwn_loader.download_song(&token, &song);
|
||||
let result = Runtime::new().unwrap().block_on(result_fut);
|
||||
match result {
|
||||
Ok(o) => {
|
||||
println!("Success");
|
||||
let mut filename = String::from("audio");
|
||||
filename += constants::file_extensions::WAV_FILE_EXTENSION;
|
||||
let data = o.as_bytes();
|
||||
let mut file = std::fs::File::create(filename).expect("Failed to save");
|
||||
file.write_all(&data).expect("ff");
|
||||
}
|
||||
Err(er) => {
|
||||
println!("Error {:?}", er);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn retrieve_object(&self) {
|
||||
println!("Deleting song");
|
||||
let rt = self.ica_action.retrieve_flag_value(&String::from("-rt"));
|
||||
|
||||
if rt != "songs" {
|
||||
panic!("Unsupported -rt: {}", rt);
|
||||
}
|
||||
|
||||
let mut prsr = parsers::api_parser::APIParser {
|
||||
api: models::api::API::default(),
|
||||
ica_act: self.ica_action.clone(),
|
||||
};
|
||||
prsr.parse_api();
|
||||
|
||||
let api = prsr.retrieve_api();
|
||||
let token = self.parse_token(&api);
|
||||
let mut repo = syncers::retrieve_records::RetrieveRecords { api: api.clone() };
|
||||
let result_fut = repo.get_all_songs(&token);
|
||||
|
||||
let result = Runtime::new().unwrap().block_on(result_fut);
|
||||
match result {
|
||||
Ok(o) => {
|
||||
for son in o {
|
||||
son.print_info();
|
||||
}
|
||||
}
|
||||
Err(er) => {
|
||||
println!("Error: {:?}", er);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn upload_song(&self) {
|
||||
println!("Deleting song");
|
||||
panic!("Not supported");
|
||||
}
|
||||
|
||||
fn parse_token(&self, api: &models::api::API) -> models::token::Token {
|
||||
println!("Fetching token");
|
||||
|
||||
let mut usr_mgr: managers::user_manager::UserManager =
|
||||
managers::user_manager::UserManager {
|
||||
user: models::user::User {
|
||||
username: String::new(),
|
||||
password: String::new(),
|
||||
},
|
||||
ica_action: self.ica_action.clone(),
|
||||
};
|
||||
usr_mgr.parse_user_from_actions();
|
||||
|
||||
let usr = usr_mgr.retrieve_user();
|
||||
let mut tok_mgr = managers::token_manager::TokenManager {
|
||||
user: usr,
|
||||
api: api.clone(),
|
||||
};
|
||||
tok_mgr.init();
|
||||
|
||||
let token = Runtime::new().unwrap().block_on(tok_mgr.request_token());
|
||||
|
||||
return token.unwrap();
|
||||
}
|
||||
|
||||
fn upload_song_with_metadata(&mut self) {
|
||||
println!("Uplodaring song with metadara");
|
||||
|
||||
let songpath = self.ica_action.retrieve_flag_value(&String::from("-s"));
|
||||
let metadata_path = self.ica_action.retrieve_flag_value(&String::from("-m"));
|
||||
let coverpath = self.ica_action.retrieve_flag_value(&String::from("-ca"));
|
||||
let track_id = self.ica_action.retrieve_flag_value(&String::from("-t"));
|
||||
|
||||
let single_target = songpath.len() > 0
|
||||
&& metadata_path.len() > 0
|
||||
&& coverpath.len() > 0
|
||||
&& track_id.len() > 0;
|
||||
|
||||
let uni = self.ica_action.retrieve_flag_value(&String::from("-smca"));
|
||||
let multitarget = uni.len() > 0;
|
||||
|
||||
if single_target && multitarget {
|
||||
println!("Cannot upload from source and directory");
|
||||
panic!("What??");
|
||||
}
|
||||
|
||||
if single_target {
|
||||
println!("Song path: {}", songpath);
|
||||
println!("Track ID: {}", track_id);
|
||||
println!("metadata path: {}", metadata_path);
|
||||
println!("cover art path: {}", coverpath);
|
||||
|
||||
let _ = self.sing_target_upload(&songpath, &track_id, &metadata_path, &coverpath);
|
||||
} else if multitarget {
|
||||
let _ = self.multi_target_upload(&uni);
|
||||
} else {
|
||||
println!("Single or Multi target has not been chosen");
|
||||
}
|
||||
}
|
||||
|
||||
fn sing_target_upload(
|
||||
&mut self,
|
||||
songpath: &String,
|
||||
track_id: &String,
|
||||
meta_path: &String,
|
||||
cover_path: &String,
|
||||
) -> Result<()> {
|
||||
let mut prsr = parsers::api_parser::APIParser {
|
||||
api: models::api::API::default(),
|
||||
ica_act: self.ica_action.clone(),
|
||||
};
|
||||
prsr.parse_api();
|
||||
|
||||
let api = prsr.retrieve_api();
|
||||
let token = self.parse_token(&api);
|
||||
|
||||
let song_file = std::path::Path::new(&songpath);
|
||||
|
||||
if !song_file.exists() {
|
||||
println!("Song file does not exist");
|
||||
panic!("Error");
|
||||
}
|
||||
|
||||
let mut cover_art = models::song::CoverArt::default();
|
||||
let mut song = models::song::Song::default();
|
||||
let mut filenames = Vec::new();
|
||||
let mut fp = String::new();
|
||||
let mut dir = String::new();
|
||||
|
||||
let entry = &song_file;
|
||||
|
||||
let file_name = std::ffi::OsString::from(entry.file_name().unwrap());
|
||||
|
||||
println!("file name: {:?}", file_name);
|
||||
|
||||
match self.find_file_extension(&file_name) {
|
||||
En::ImageFile => {}
|
||||
En::MetadataFile => {}
|
||||
En::SongFile => {
|
||||
let fname = self.o_to_string(&file_name);
|
||||
|
||||
match fname {
|
||||
Ok(s) => {
|
||||
filenames.push(s.clone());
|
||||
fp = s.clone();
|
||||
dir = song_file.parent().unwrap().display().to_string();
|
||||
song.filepath = Some(s.clone());
|
||||
song.directory = Some(dir.clone());
|
||||
self.initialize_disc_and_track(&mut song);
|
||||
}
|
||||
Err(er) => println!("Error: {:?}", er),
|
||||
}
|
||||
}
|
||||
_ => {}
|
||||
}
|
||||
|
||||
cover_art.path = Some(cover_path.clone());
|
||||
|
||||
let album = self.retrieve_metadata(&meta_path);
|
||||
let trck = i32::from_str(track_id).unwrap();
|
||||
let mut s = album.retrieve_song(trck, 1).unwrap();
|
||||
s.filepath = Some(fp);
|
||||
s.directory = Some(dir);
|
||||
s.genre = Some(album.genre.clone());
|
||||
s.year = Some(album.year.clone());
|
||||
s.album = Some(album.title.clone());
|
||||
s.data = Some(s.to_data().unwrap());
|
||||
|
||||
cover_art.data = Some(cover_art.to_data().unwrap());
|
||||
|
||||
let mut up = syncers::upload::Upload::default();
|
||||
let host = self.ica_action.retrieve_flag_value(&String::from("-h"));
|
||||
up.set_api(&host);
|
||||
|
||||
let res = up.upload_song_with_metadata(&token, &s, &cover_art, &album);
|
||||
let tken = Runtime::new().unwrap().block_on(res);
|
||||
|
||||
match &tken {
|
||||
Ok(o) => {
|
||||
println!("Successfully sent {:?}", o);
|
||||
}
|
||||
Err(er) => {
|
||||
println!("Some error {:?}", er);
|
||||
}
|
||||
}
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn multi_target_upload(&mut self, sourcepath: &String) -> std::io::Result<()> {
|
||||
let mut prsr = parsers::api_parser::APIParser {
|
||||
api: models::api::API::default(),
|
||||
ica_act: self.ica_action.clone(),
|
||||
};
|
||||
prsr.parse_api();
|
||||
let api = prsr.retrieve_api();
|
||||
let token = self.parse_token(&api);
|
||||
|
||||
let directory_path = std::path::Path::new(&sourcepath);
|
||||
|
||||
if !directory_path.exists() {
|
||||
panic!("Directory does not exist");
|
||||
}
|
||||
|
||||
let mut cover_art = models::song::CoverArt::default();
|
||||
let mut songs: Vec<models::song::Song> = Vec::new();
|
||||
let mut filenames: Vec<String> = Vec::new();
|
||||
let mut metadatapath: String = String::new();
|
||||
|
||||
// iterate files in metadatapath
|
||||
let path = std::path::Path::new(directory_path);
|
||||
|
||||
for entry in read_dir(path)? {
|
||||
let entry = entry?;
|
||||
|
||||
let file_type = entry.file_type();
|
||||
let file_name = entry.file_name();
|
||||
|
||||
println!("file type: {:?}", file_type);
|
||||
println!("file name: {:?}", file_name);
|
||||
|
||||
match self.find_file_extension(&file_name) {
|
||||
En::ImageFile => {
|
||||
let directory_part = sourcepath.clone();
|
||||
let fname = self.o_to_string(&file_name);
|
||||
let fullpath = directory_part + "/" + &fname.unwrap();
|
||||
cover_art.path = Some(fullpath);
|
||||
}
|
||||
En::MetadataFile => {
|
||||
let directory_part = sourcepath.clone();
|
||||
let fname = self.o_to_string(&file_name);
|
||||
metadatapath = directory_part + "/" + &fname.unwrap();
|
||||
}
|
||||
En::SongFile => {
|
||||
let mut song = models::song::Song::default();
|
||||
let fname = self.o_to_string(&file_name);
|
||||
|
||||
match fname {
|
||||
Ok(s) => {
|
||||
filenames.push(s.clone());
|
||||
song.filepath = Some(s.clone());
|
||||
song.directory = Some(sourcepath.clone());
|
||||
song.data = Some(song.to_data().unwrap());
|
||||
self.initialize_disc_and_track(&mut song);
|
||||
}
|
||||
Err(er) => println!("Error: {:?}", er),
|
||||
}
|
||||
|
||||
songs.push(song)
|
||||
}
|
||||
_ => {}
|
||||
}
|
||||
}
|
||||
|
||||
filenames.sort();
|
||||
|
||||
let mut album = self.retrieve_metadata(&metadatapath);
|
||||
|
||||
self.song_parsing(&mut album, &sourcepath, &filenames);
|
||||
|
||||
let mut up = syncers::upload::Upload::default();
|
||||
let host = self.ica_action.retrieve_flag_value(&String::from("-h"));
|
||||
up.set_api(&host);
|
||||
|
||||
cover_art.data = Some(cover_art.to_data().unwrap());
|
||||
|
||||
println!("");
|
||||
|
||||
for sng in &mut album.songs {
|
||||
match sng.data {
|
||||
Some(_) => {}
|
||||
None => {
|
||||
sng.data = Some(sng.to_data().unwrap());
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
for song in &album.songs {
|
||||
// Upload each song
|
||||
println!("Sending song...");
|
||||
let res = up.upload_song_with_metadata(&token, &song, &cover_art, &album);
|
||||
let tken = Runtime::new().unwrap().block_on(res);
|
||||
|
||||
match &tken {
|
||||
Ok(o) => {
|
||||
println!("Successfully sent {:?}", o);
|
||||
}
|
||||
Err(er) => {
|
||||
println!("Some error {:?}", er);
|
||||
}
|
||||
}
|
||||
|
||||
println!("");
|
||||
}
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
// Makes sure the elements in album.songs is populated
|
||||
fn song_parsing(
|
||||
&self,
|
||||
album: &mut models::song::Album,
|
||||
directory: &String,
|
||||
filenames: &Vec<String>,
|
||||
) {
|
||||
// Apply directory
|
||||
for song in &mut album.songs {
|
||||
let dir = &song.directory;
|
||||
match dir {
|
||||
Some(s) => println!("{}", s),
|
||||
None => {
|
||||
song.directory = Some(directory.clone());
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Apply filename
|
||||
let mut index = 0;
|
||||
for song in &mut album.songs {
|
||||
let filename = filenames[index].clone();
|
||||
song.filepath = Some(filename);
|
||||
index += 1;
|
||||
}
|
||||
|
||||
for song in &mut album.songs {
|
||||
match &mut song.album {
|
||||
Some(_) => {}
|
||||
None => {
|
||||
song.album = Some(album.title.clone());
|
||||
}
|
||||
}
|
||||
|
||||
match &mut song.genre {
|
||||
Some(_) => {}
|
||||
None => {
|
||||
song.genre = Some(album.genre.clone());
|
||||
}
|
||||
}
|
||||
|
||||
match &mut song.year {
|
||||
Some(_) => {}
|
||||
None => {
|
||||
song.year = Some(album.year.clone());
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn find_file_extension(&self, file_name: &std::ffi::OsString) -> En {
|
||||
let file_name_str = Some(file_name.clone().into_string());
|
||||
|
||||
match file_name_str {
|
||||
Some(string) => {
|
||||
let a = string.unwrap();
|
||||
let split = a.split(".");
|
||||
let mut last_index = 0;
|
||||
|
||||
for _ in split.clone() {
|
||||
last_index += 1;
|
||||
}
|
||||
|
||||
let mut extension = String::new();
|
||||
let mut index = 1;
|
||||
|
||||
for word in split {
|
||||
if index == last_index {
|
||||
extension = word.to_string();
|
||||
break;
|
||||
}
|
||||
|
||||
index += 1;
|
||||
}
|
||||
|
||||
if extension == "wav" || extension == "flac" {
|
||||
return En::SongFile;
|
||||
} else if extension == "json" {
|
||||
return En::MetadataFile;
|
||||
} else if extension == "jpg" || extension == "jpeg" || extension == "png" {
|
||||
return En::ImageFile;
|
||||
}
|
||||
}
|
||||
_ => {
|
||||
return En::Other;
|
||||
}
|
||||
}
|
||||
|
||||
return En::Other;
|
||||
}
|
||||
|
||||
fn o_to_string(&self, val: &std::ffi::OsString) -> Result<std::string::String> {
|
||||
let res = val.clone().into_string();
|
||||
return match res {
|
||||
Ok(sss) => Ok(sss),
|
||||
Err(_) => Ok(String::from("Error")),
|
||||
};
|
||||
}
|
||||
|
||||
// Standards
|
||||
// * track01.cdda.wav - Disc 1, Track 1
|
||||
// * track02d02.cdda.wav - Disc 2, Track 2
|
||||
fn initialize_disc_and_track(&mut self, song: &mut models::song::Song) {
|
||||
let mut disc = 1;
|
||||
let mut track = 1;
|
||||
let mut mode = 0;
|
||||
let filename =
|
||||
&<std::option::Option<std::string::String> as Clone>::clone(&song.filepath).unwrap();
|
||||
|
||||
let trd = filename.contains("trackd");
|
||||
let tr = filename.contains("track");
|
||||
|
||||
if tr {
|
||||
mode = 1;
|
||||
}
|
||||
|
||||
if trd {
|
||||
mode = 2;
|
||||
}
|
||||
|
||||
let dl = |a: &char, b: &char| -> bool {
|
||||
return a == b;
|
||||
};
|
||||
let d = utilities::checks::Checks::index_of_item_in_container(&filename, &'d', dl);
|
||||
let k = utilities::checks::Checks::index_of_item_in_container(&filename, &'k', dl);
|
||||
let dot = utilities::checks::Checks::index_of_item_in_container(&filename, &'.', dl);
|
||||
let end = filename.len() as i32;
|
||||
|
||||
match mode {
|
||||
1 => {
|
||||
if k != end && dot != end {
|
||||
let st = k + 1;
|
||||
let ed = dot - 1;
|
||||
let mut t: String = String::new();
|
||||
let mut index = 0;
|
||||
for a in filename.chars() {
|
||||
if index >= st && index <= ed {
|
||||
t.push(a);
|
||||
}
|
||||
|
||||
index += 1;
|
||||
}
|
||||
|
||||
if utilities::checks::Checks::is_numeric(&t) {
|
||||
track = t.parse::<i32>().unwrap();
|
||||
}
|
||||
disc = 1
|
||||
}
|
||||
}
|
||||
2 => {
|
||||
if k != end && dot != end && d != end {
|
||||
let st = k + 1;
|
||||
let ed = dot - 1;
|
||||
let mut t: String = String::new();
|
||||
let mut index = 0;
|
||||
for a in filename.chars() {
|
||||
if index <= ed {
|
||||
t.push(a);
|
||||
} else if index >= st {
|
||||
t.push(a);
|
||||
}
|
||||
|
||||
index += 1;
|
||||
}
|
||||
|
||||
if utilities::checks::Checks::is_numeric(&t) {
|
||||
track = t.parse::<i32>().unwrap();
|
||||
}
|
||||
|
||||
let sst = d + 1;
|
||||
let eed = dot;
|
||||
let mut d_s = String::new();
|
||||
index = 0;
|
||||
for a in filename.chars() {
|
||||
if index <= eed {
|
||||
d_s.push(a);
|
||||
} else if index >= sst {
|
||||
d_s.push(a);
|
||||
}
|
||||
|
||||
index += 1;
|
||||
}
|
||||
|
||||
if utilities::checks::Checks::is_numeric(&d_s) {
|
||||
track = d_s.parse::<i32>().unwrap();
|
||||
}
|
||||
}
|
||||
}
|
||||
_ => println!(""),
|
||||
}
|
||||
|
||||
song.disc = Some(disc);
|
||||
song.track = Some(track);
|
||||
}
|
||||
|
||||
fn _parse_disc_and_track(&self, song: &mut models::song::Song, track_id: &String) {
|
||||
let sep = |_a: &char, _b: &char| -> bool {
|
||||
return false;
|
||||
};
|
||||
|
||||
let index = utilities::checks::Checks::index_of_item_in_container(track_id, &':', sep);
|
||||
|
||||
if index == -1 {
|
||||
let mut d_str: String = String::new();
|
||||
let t_str = String::new();
|
||||
|
||||
for c in track_id.chars().skip(0).take(index as usize) {
|
||||
d_str.push(c);
|
||||
}
|
||||
|
||||
let start = index + 1;
|
||||
let end = track_id.len() - 1;
|
||||
|
||||
for c in track_id.chars().skip(start as usize).take(end as usize) {
|
||||
d_str.push(c);
|
||||
}
|
||||
|
||||
song.disc = Some(d_str.parse::<i32>().unwrap());
|
||||
song.track = Some(t_str.parse::<i32>().unwrap());
|
||||
} else {
|
||||
if utilities::checks::Checks::is_numeric(track_id) {
|
||||
song.track = Some(track_id.parse::<i32>().unwrap());
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn _check_for_no_confirm(&self) -> bool {
|
||||
for flag in self.ica_action.flags.iter() {
|
||||
if flag.flag == "-nc" {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
fn retrieve_metadata(&self, path: &String) -> Album {
|
||||
let content = self.retrieve_file_content(&path);
|
||||
let val = content.unwrap();
|
||||
|
||||
let converted = serde_json::from_str(&val);
|
||||
|
||||
match &converted {
|
||||
Ok(_) => println!("Good!"),
|
||||
Err(er) => println!("Error {:?}", er),
|
||||
}
|
||||
return converted.unwrap();
|
||||
}
|
||||
|
||||
fn retrieve_file_content(&self, path: &String) -> Result<String> {
|
||||
return std::fs::read_to_string(path);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,64 @@
|
||||
use std::default::Default;
|
||||
|
||||
|
||||
pub struct FileManager {
|
||||
pub filepath: String,
|
||||
pub filebuffer: String,
|
||||
pub file_read: bool,
|
||||
pub file_buffer_length: i32,
|
||||
}
|
||||
|
||||
impl Default for FileManager {
|
||||
fn default() -> Self {
|
||||
FileManager {
|
||||
filepath: String::new(),
|
||||
filebuffer: String::new(),
|
||||
file_read: false,
|
||||
file_buffer_length: -1
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
impl FileManager {
|
||||
// TODO: Implement
|
||||
pub fn init(&mut self) {
|
||||
self.read_file()
|
||||
}
|
||||
|
||||
pub fn save_file(&mut self, filepath: &String) {
|
||||
if !self.file_read {
|
||||
self.read_file();
|
||||
}
|
||||
|
||||
let mut file = File::open(filepath)?;
|
||||
let mut buffer = Vec::new();
|
||||
file.read_to_end(&mut buffer)?;
|
||||
self.file_buffer_length = buffer.len();
|
||||
self.filebuffer = String::from_utf8(buffer); // Assuming UTF-8 encoding
|
||||
}
|
||||
|
||||
pub fn modify_file_path(&mut self, file: &String) {
|
||||
self.filepath = file;
|
||||
}
|
||||
|
||||
pub fn retrieve_file_buffer(&self) -> String {
|
||||
self.filebuffer;
|
||||
}
|
||||
|
||||
pub fn retrieve_file_length(&self) -> i32 {
|
||||
self.file_buffer_length;
|
||||
}
|
||||
|
||||
fn read_file(&mut self) -> Vec<u8> {
|
||||
let mut file = File::open(self.filepath)?;
|
||||
let mut buffer = Vec::new();
|
||||
file.read_to_end(&mut buffer)?;
|
||||
self.file_buffer_length = buffer.len();
|
||||
self.filebuffer = String::from_utf8(buffer); // Assuming UTF-8 encoding
|
||||
self.file_read = true;
|
||||
|
||||
return buffer;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,4 @@
|
||||
pub mod action_managers;
|
||||
pub mod commit_manager;
|
||||
pub mod token_manager;
|
||||
pub mod user_manager;
|
||||
@@ -0,0 +1,73 @@
|
||||
use std::default::Default;
|
||||
|
||||
use crate::models;
|
||||
|
||||
pub struct TokenManager {
|
||||
pub user: models::user::User,
|
||||
pub api: models::api::API,
|
||||
}
|
||||
|
||||
impl Default for TokenManager {
|
||||
fn default() -> Self {
|
||||
let mut token = TokenManager {
|
||||
user: models::user::User::default(),
|
||||
api: models::api::API::default(),
|
||||
};
|
||||
|
||||
token.init();
|
||||
|
||||
return token;
|
||||
}
|
||||
}
|
||||
|
||||
impl TokenManager {
|
||||
pub async fn request_token(&self) -> Result<models::token::Token, std::io::Error> {
|
||||
println!("Sending request for a token");
|
||||
|
||||
let url = self.retrieve_url();
|
||||
|
||||
println!("URL: {}", url);
|
||||
|
||||
let mut token = models::token::Token::default();
|
||||
|
||||
let client = reqwest::Client::new();
|
||||
let response = client.post(&url).json(&self.user).send().await.unwrap();
|
||||
|
||||
match response.status() {
|
||||
reqwest::StatusCode::OK => {
|
||||
// on success, parse our JSON to an APIResponse
|
||||
let s = response.json::<models::token::Token>().await;
|
||||
match s {
|
||||
//
|
||||
Ok(parsed) => {
|
||||
token = parsed;
|
||||
}
|
||||
Err(_) => println!("Hm, the response didn't match the shape we expected."),
|
||||
};
|
||||
}
|
||||
reqwest::StatusCode::UNAUTHORIZED => {
|
||||
println!("Need to grab a new token");
|
||||
}
|
||||
other => {
|
||||
panic!("Uh oh! Something unexpected happened: {:?}", other);
|
||||
}
|
||||
}
|
||||
|
||||
return Ok(token);
|
||||
}
|
||||
|
||||
pub fn init(&mut self) {
|
||||
let api = &mut self.api;
|
||||
api.version = String::from("v1");
|
||||
api.endpoint = String::from(format!("api/{}/login", api.version));
|
||||
}
|
||||
|
||||
pub fn retrieve_url(&self) -> String {
|
||||
let api = &self.api;
|
||||
let mut url = String::from(&api.url);
|
||||
url += &String::from(&api.endpoint);
|
||||
url += &String::from("/");
|
||||
|
||||
return url;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,42 @@
|
||||
use std::default::Default;
|
||||
|
||||
use serde::{Deserialize, Serialize};
|
||||
|
||||
use crate::models::{self};
|
||||
|
||||
#[derive(Debug, Deserialize, Serialize)]
|
||||
pub struct UserManager {
|
||||
pub user: models::user::User,
|
||||
pub ica_action: models::icarus_action::IcarusAction,
|
||||
}
|
||||
|
||||
impl Default for UserManager {
|
||||
fn default() -> Self {
|
||||
UserManager {
|
||||
user: models::user::User::default(),
|
||||
ica_action: models::icarus_action::IcarusAction::default(),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl UserManager {
|
||||
pub fn retrieve_user(&self) -> models::user::User {
|
||||
return self.user.clone();
|
||||
}
|
||||
|
||||
pub fn parse_user_from_actions(&mut self) {
|
||||
let args = &self.ica_action.flags;
|
||||
|
||||
for arg in args {
|
||||
let flag = &arg.flag;
|
||||
|
||||
if flag == "-u" {
|
||||
self.user.username = String::from(&arg.value);
|
||||
}
|
||||
|
||||
if flag == "-p" {
|
||||
self.user.password = String::from(&arg.value);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,20 @@
|
||||
use std::default::Default;
|
||||
|
||||
use serde::{Deserialize, Serialize};
|
||||
|
||||
#[derive(Clone, Debug, Deserialize, Serialize)]
|
||||
pub struct API {
|
||||
pub url: String,
|
||||
pub endpoint: String,
|
||||
pub version: String,
|
||||
}
|
||||
|
||||
impl Default for API {
|
||||
fn default() -> Self {
|
||||
API {
|
||||
url: String::new(),
|
||||
endpoint: String::new(),
|
||||
version: String::new(),
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,18 @@
|
||||
use std::default::Default;
|
||||
|
||||
use serde::{Deserialize, Serialize};
|
||||
|
||||
#[derive(Clone, Debug, Deserialize, Serialize)]
|
||||
pub struct Flags {
|
||||
pub flag: String,
|
||||
pub value: String,
|
||||
}
|
||||
|
||||
impl Default for Flags {
|
||||
fn default() -> Self {
|
||||
Flags {
|
||||
flag: String::new(),
|
||||
value: String::new(),
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,44 @@
|
||||
use std::default::Default;
|
||||
|
||||
use serde::{Deserialize, Serialize};
|
||||
|
||||
use crate::models;
|
||||
|
||||
#[derive(Clone, Debug, Deserialize, Serialize)]
|
||||
pub struct IcarusAction {
|
||||
pub action: String,
|
||||
pub flags: Vec<models::flags::Flags>,
|
||||
}
|
||||
|
||||
impl Default for IcarusAction {
|
||||
fn default() -> Self {
|
||||
IcarusAction {
|
||||
action: String::new(),
|
||||
flags: Vec::new(),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl IcarusAction {
|
||||
pub fn retrieve_flag_value(&self, flag: &String) -> String {
|
||||
let mut val: String = String::new();
|
||||
|
||||
for f in self.flags.iter() {
|
||||
if f.flag == *flag {
|
||||
val = f.value.clone();
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
return val;
|
||||
}
|
||||
|
||||
pub fn print_action_and_flags(&self) {
|
||||
println!("Action: {}", self.action);
|
||||
println!("Flag count: {}", self.flags.len());
|
||||
|
||||
for flag in self.flags.iter() {
|
||||
println!("flag {} value {}", flag.flag, flag.value);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,7 @@
|
||||
pub mod api;
|
||||
pub mod flags;
|
||||
pub mod icarus_action;
|
||||
pub mod song;
|
||||
pub mod token;
|
||||
pub mod upload_form;
|
||||
pub mod user;
|
||||
@@ -0,0 +1,171 @@
|
||||
use std::default::Default;
|
||||
use std::io::Read;
|
||||
|
||||
use serde::{Deserialize, Serialize};
|
||||
|
||||
use crate::constants;
|
||||
|
||||
#[derive(Clone, Debug, Deserialize, Serialize)]
|
||||
pub struct Song {
|
||||
#[serde(alias = "song_id")]
|
||||
pub id: Option<i32>,
|
||||
pub title: Option<String>,
|
||||
pub artist: Option<String>,
|
||||
pub album: Option<String>,
|
||||
pub genre: Option<String>,
|
||||
pub year: Option<i32>,
|
||||
pub duration: Option<f64>,
|
||||
pub track: Option<i32>,
|
||||
pub disc: Option<i32>,
|
||||
pub data: Option<Vec<u8>>,
|
||||
pub filepath: Option<String>,
|
||||
pub directory: Option<String>,
|
||||
}
|
||||
|
||||
#[derive(Debug, Deserialize, Serialize)]
|
||||
pub struct Album {
|
||||
#[serde(alias = "album")]
|
||||
pub title: String,
|
||||
pub album_artist: String,
|
||||
pub genre: String,
|
||||
pub year: i32,
|
||||
pub track_count: i32,
|
||||
pub disc_count: i32,
|
||||
#[serde(alias = "tracks")]
|
||||
pub songs: Vec<Song>,
|
||||
}
|
||||
|
||||
impl Default for Album {
|
||||
fn default() -> Self {
|
||||
Album {
|
||||
title: String::new(),
|
||||
album_artist: String::new(),
|
||||
genre: String::new(),
|
||||
year: 0,
|
||||
track_count: 0,
|
||||
disc_count: 0,
|
||||
songs: Vec::new(),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl Default for Song {
|
||||
fn default() -> Self {
|
||||
Song {
|
||||
id: None,
|
||||
title: None,
|
||||
artist: None,
|
||||
album: None,
|
||||
genre: None,
|
||||
year: None,
|
||||
duration: None,
|
||||
track: None,
|
||||
disc: None,
|
||||
data: None,
|
||||
filepath: None,
|
||||
directory: None,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl Song {
|
||||
pub fn print_info(&self) {
|
||||
println!("Title: {:?}", self.title);
|
||||
println!("Artist: {:?}", self.artist);
|
||||
}
|
||||
|
||||
pub fn song_path(&self) -> String {
|
||||
let directory =
|
||||
&<std::option::Option<std::string::String> as Clone>::clone(&self.directory).unwrap();
|
||||
|
||||
let mut buffer: String = directory.to_string();
|
||||
let count = buffer.len();
|
||||
|
||||
if buffer.chars().nth(count - 1) != Some('/') {
|
||||
buffer += "/";
|
||||
}
|
||||
|
||||
let filename =
|
||||
&<std::option::Option<std::string::String> as Clone>::clone(&self.filepath).unwrap();
|
||||
buffer += filename;
|
||||
|
||||
return buffer;
|
||||
}
|
||||
|
||||
pub fn to_data(&self) -> Result<Vec<u8>, std::io::Error> {
|
||||
let path = self.song_path();
|
||||
println!("Converting song to data");
|
||||
println!("Path: {:?}", path);
|
||||
|
||||
let mut file = std::fs::File::open(path)?;
|
||||
let mut buffer = Vec::new();
|
||||
file.read_to_end(&mut buffer)?;
|
||||
if buffer.len() == 0 {
|
||||
println!("Why is it empty?");
|
||||
}
|
||||
|
||||
Ok(buffer)
|
||||
}
|
||||
|
||||
// if 1 - wav, if 0 - mp3, anything else defaults to wav
|
||||
pub fn _generate_filename_from_track(&mut self, i_type: i32) -> i32 {
|
||||
let mut filename: String = String::new();
|
||||
if self.track.unwrap() < 10 {
|
||||
filename += "0";
|
||||
}
|
||||
|
||||
filename += &self.track.unwrap().to_string();
|
||||
|
||||
if i_type == 0 {
|
||||
filename += constants::file_extensions::_MP3_FILE_EXTENSION;
|
||||
} else {
|
||||
filename += constants::file_extensions::WAV_FILE_EXTENSION;
|
||||
}
|
||||
|
||||
self.filepath = Some(filename);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
pub fn _to_metadata_json(&self) -> Result<String, serde_json::Error> {
|
||||
return serde_json::to_string_pretty(&self);
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug, Deserialize, Serialize)]
|
||||
pub struct CoverArt {
|
||||
pub id: Option<i32>,
|
||||
pub title: Option<String>,
|
||||
pub path: Option<String>,
|
||||
pub data: Option<Vec<u8>>,
|
||||
}
|
||||
|
||||
impl Default for CoverArt {
|
||||
fn default() -> Self {
|
||||
CoverArt {
|
||||
id: None,
|
||||
title: None,
|
||||
path: None,
|
||||
data: None,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl CoverArt {
|
||||
pub fn to_data(&self) -> Result<Vec<u8>, std::io::Error> {
|
||||
let mut path: String = String::new();
|
||||
match &self.path {
|
||||
Some(val) => {
|
||||
path = String::from(val);
|
||||
}
|
||||
None => {
|
||||
();
|
||||
}
|
||||
}
|
||||
|
||||
let mut file = std::fs::File::open(path)?;
|
||||
let mut buffer = Vec::new();
|
||||
file.read_to_end(&mut buffer)?;
|
||||
Ok(buffer)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,47 @@
|
||||
use std::default::Default;
|
||||
|
||||
use serde::{Deserialize, Serialize};
|
||||
|
||||
#[derive(Debug, Deserialize, Serialize)]
|
||||
pub struct Token {
|
||||
#[serde(alias = "user_id")]
|
||||
pub user_id: i32,
|
||||
#[serde(alias = "username")]
|
||||
pub username: Option<String>,
|
||||
#[serde(alias = "token")]
|
||||
pub access_token: Option<String>,
|
||||
#[serde(alias = "token_type")]
|
||||
pub token_type: Option<String>,
|
||||
#[serde(alias = "expiration")]
|
||||
pub expiration: Option<i32>,
|
||||
#[serde(alias = "message")]
|
||||
pub message: Option<String>,
|
||||
}
|
||||
|
||||
impl Default for Token {
|
||||
fn default() -> Self {
|
||||
Token {
|
||||
user_id: -1,
|
||||
username: None,
|
||||
access_token: None,
|
||||
token_type: None,
|
||||
expiration: None,
|
||||
message: None,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl Token {
|
||||
pub fn bearer_token(&self) -> String {
|
||||
let mut token: String = String::from("Bearer ");
|
||||
|
||||
match &self.access_token {
|
||||
Some(tok) => {
|
||||
token += tok;
|
||||
}
|
||||
None => {}
|
||||
}
|
||||
|
||||
return token;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,18 @@
|
||||
use std::default::Default;
|
||||
|
||||
use serde::{Deserialize, Serialize};
|
||||
|
||||
#[derive(Debug, Deserialize, Serialize)]
|
||||
pub struct UploadForm {
|
||||
pub url: Option<String>,
|
||||
pub filepath: Option<String>,
|
||||
}
|
||||
|
||||
impl Default for UploadForm {
|
||||
fn default() -> Self {
|
||||
UploadForm {
|
||||
url: None,
|
||||
filepath: None,
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,24 @@
|
||||
use std::default::Default;
|
||||
|
||||
use serde::{Deserialize, Serialize};
|
||||
|
||||
#[derive(Clone, Debug, Deserialize, Serialize)]
|
||||
pub struct User {
|
||||
pub username: String,
|
||||
pub password: String,
|
||||
}
|
||||
|
||||
impl Default for User {
|
||||
fn default() -> Self {
|
||||
User {
|
||||
username: String::new(),
|
||||
password: String::new(),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl User {
|
||||
pub fn _to_json(&self) -> Result<String, serde_json::Error> {
|
||||
return serde_json::to_string_pretty(&self);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,34 @@
|
||||
use crate::models;
|
||||
|
||||
#[derive(Clone, Debug)]
|
||||
pub struct APIParser {
|
||||
pub api: models::api::API,
|
||||
pub ica_act: models::icarus_action::IcarusAction,
|
||||
}
|
||||
|
||||
impl APIParser {
|
||||
pub fn retrieve_api(&self) -> models::api::API {
|
||||
return self.api.clone();
|
||||
}
|
||||
|
||||
pub fn parse_api(&mut self) {
|
||||
let flags = self.ica_act.flags.clone();
|
||||
println!("Parsing api");
|
||||
|
||||
for elem in flags {
|
||||
let arg = elem.flag;
|
||||
let value = elem.value;
|
||||
|
||||
if arg == "-h" {
|
||||
if value.chars().nth(value.len() - 1) == Some('/') {
|
||||
self.api.url = value;
|
||||
} else {
|
||||
self.api.url = value + "/";
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
self.api.version = "v1".to_string();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1 @@
|
||||
pub mod api_parser;
|
||||
@@ -0,0 +1,72 @@
|
||||
use std::default::Default;
|
||||
|
||||
use reqwest;
|
||||
|
||||
use crate::models;
|
||||
|
||||
#[derive(Clone, Debug)]
|
||||
pub struct Delete {
|
||||
pub api: models::api::API,
|
||||
}
|
||||
|
||||
impl Default for Delete {
|
||||
fn default() -> Self {
|
||||
Delete {
|
||||
api: models::api::API::default(),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl Delete {
|
||||
pub async fn delete_song(
|
||||
&mut self,
|
||||
token: &models::token::Token,
|
||||
song: &models::song::Song,
|
||||
) -> Result<models::song::Song, std::io::Error> {
|
||||
self.api.endpoint = "song/data/delete".to_owned();
|
||||
let url = self.retrieve_url(&song);
|
||||
let client = reqwest::Client::builder().build().unwrap();
|
||||
let access_token = token.bearer_token();
|
||||
let response = client
|
||||
.delete(&url)
|
||||
.header(reqwest::header::AUTHORIZATION, access_token)
|
||||
.send()
|
||||
.await
|
||||
.unwrap();
|
||||
let mut sng = models::song::Song::default();
|
||||
|
||||
match response.status() {
|
||||
reqwest::StatusCode::OK => {
|
||||
println!("Success!");
|
||||
let s = response.json::<models::song::Song>().await;
|
||||
match s {
|
||||
//
|
||||
Ok(parsed) => {
|
||||
sng = parsed;
|
||||
}
|
||||
Err(er) => {
|
||||
println!("Error {:?}", er);
|
||||
}
|
||||
};
|
||||
}
|
||||
other => {
|
||||
panic!("Issue occurred: {:?}", other);
|
||||
}
|
||||
}
|
||||
|
||||
return Ok(sng);
|
||||
}
|
||||
|
||||
fn retrieve_url(&self, song: &models::song::Song) -> String {
|
||||
let api = &self.api;
|
||||
let mut url: String = String::from(&api.url);
|
||||
url += &String::from("api/");
|
||||
url += &String::from(&api.version);
|
||||
url += &String::from("/");
|
||||
url += &String::from(&api.endpoint);
|
||||
url += &String::from("/");
|
||||
url += &song.id.unwrap().to_string();
|
||||
|
||||
return url;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,82 @@
|
||||
use std::default::Default;
|
||||
|
||||
use crate::models;
|
||||
|
||||
pub struct Download {
|
||||
pub api: models::api::API,
|
||||
}
|
||||
|
||||
impl Default for Download {
|
||||
fn default() -> Self {
|
||||
Download {
|
||||
api: models::api::API::default(),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug)]
|
||||
pub enum MyError {
|
||||
_Request(reqwest::Error),
|
||||
Other(String),
|
||||
}
|
||||
|
||||
impl Download {
|
||||
pub async fn download_song(
|
||||
&mut self,
|
||||
token: &models::token::Token,
|
||||
song: &models::song::Song,
|
||||
) -> Result<String, MyError> {
|
||||
self.api.endpoint = String::from("song/data/download");
|
||||
let url = self.retrieve_url(&song);
|
||||
let access_token = token.bearer_token();
|
||||
|
||||
let mut headers = reqwest::header::HeaderMap::new();
|
||||
headers.insert(
|
||||
reqwest::header::AUTHORIZATION,
|
||||
http::header::HeaderValue::from_str(&access_token.clone()).unwrap(),
|
||||
);
|
||||
|
||||
let client = reqwest::Client::builder().build().unwrap();
|
||||
let response = client
|
||||
.get(&url)
|
||||
.header(reqwest::header::AUTHORIZATION, &access_token)
|
||||
.send()
|
||||
.await
|
||||
.unwrap();
|
||||
|
||||
match response.status() {
|
||||
reqwest::StatusCode::OK => {
|
||||
let data = response.text();
|
||||
match data.await {
|
||||
Ok(e) => {
|
||||
return Ok(e);
|
||||
}
|
||||
Err(er) => {
|
||||
println!("Error {:?}", er);
|
||||
}
|
||||
}
|
||||
}
|
||||
reqwest::StatusCode::UNAUTHORIZED => {
|
||||
println!("Need to grab a new token");
|
||||
}
|
||||
other => {
|
||||
panic!("Uh oh! Something unexpected happened: {:?}", other);
|
||||
}
|
||||
}
|
||||
|
||||
return Err(MyError::Other(String::from("Error downloading")));
|
||||
}
|
||||
|
||||
fn retrieve_url(&self, song: &models::song::Song) -> String {
|
||||
let api = &self.api;
|
||||
let mut url: String = String::from(&api.url);
|
||||
url += &String::from("api/");
|
||||
url += &String::from(&api.version);
|
||||
url += &String::from("/");
|
||||
url += &String::from(&api.endpoint);
|
||||
url += &String::from("/");
|
||||
url += &song.id.unwrap().to_string();
|
||||
|
||||
return url;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,4 @@
|
||||
pub mod delete;
|
||||
pub mod download;
|
||||
pub mod retrieve_records;
|
||||
pub mod upload;
|
||||
@@ -0,0 +1,80 @@
|
||||
use std::default::Default;
|
||||
use std::io::Error;
|
||||
|
||||
use crate::models;
|
||||
|
||||
pub struct RetrieveRecords {
|
||||
pub api: models::api::API,
|
||||
}
|
||||
|
||||
impl Default for RetrieveRecords {
|
||||
fn default() -> Self {
|
||||
RetrieveRecords {
|
||||
api: models::api::API::default(),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl RetrieveRecords {
|
||||
pub async fn get_all_songs(
|
||||
&mut self,
|
||||
token: &models::token::Token,
|
||||
) -> Result<Vec<models::song::Song>, Error> {
|
||||
self.api.endpoint = String::from("song");
|
||||
let mut songs: Vec<models::song::Song> = Vec::new();
|
||||
let url = self.retrieve_url();
|
||||
let access_token = token.bearer_token();
|
||||
|
||||
let mut headers = reqwest::header::HeaderMap::new();
|
||||
headers.insert(
|
||||
reqwest::header::AUTHORIZATION,
|
||||
http::header::HeaderValue::from_str(&access_token.clone()).unwrap(),
|
||||
);
|
||||
headers.insert(
|
||||
reqwest::header::CONTENT_TYPE,
|
||||
http::header::HeaderValue::from_static("application/json"),
|
||||
);
|
||||
|
||||
let client = reqwest::Client::builder().build().unwrap();
|
||||
let response = client
|
||||
.get(&url)
|
||||
.header(reqwest::header::AUTHORIZATION, access_token)
|
||||
.send()
|
||||
.await
|
||||
.unwrap();
|
||||
|
||||
match response.status() {
|
||||
reqwest::StatusCode::OK => {
|
||||
// on success, parse our JSON to an APIResponse
|
||||
let s = response.json::<Vec<models::song::Song>>().await;
|
||||
match s {
|
||||
//
|
||||
Ok(parsed) => {
|
||||
songs = parsed;
|
||||
}
|
||||
Err(_) => println!("Hm, the response didn't match the shape we expected."),
|
||||
};
|
||||
}
|
||||
reqwest::StatusCode::UNAUTHORIZED => {
|
||||
println!("Need to grab a new token");
|
||||
}
|
||||
other => {
|
||||
panic!("Uh oh! Something unexpected happened: {:?}", other);
|
||||
}
|
||||
}
|
||||
|
||||
return Ok(songs);
|
||||
}
|
||||
|
||||
fn retrieve_url(&self) -> String {
|
||||
let api = &self.api;
|
||||
let mut url: String = String::from(&api.url);
|
||||
url += &String::from("api/");
|
||||
url += &String::from(&api.version);
|
||||
url += &String::from("/");
|
||||
url += &String::from(&api.endpoint);
|
||||
url += &String::from("/");
|
||||
|
||||
return url;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,195 @@
|
||||
use std::default::Default;
|
||||
|
||||
use http::HeaderMap;
|
||||
use http::HeaderValue;
|
||||
use reqwest;
|
||||
use reqwest::multipart::Form;
|
||||
use serde::{Deserialize, Serialize};
|
||||
|
||||
use crate::constants;
|
||||
use crate::models;
|
||||
|
||||
pub struct Upload {
|
||||
pub api: models::api::API,
|
||||
}
|
||||
|
||||
#[derive(Debug, Deserialize, Serialize)]
|
||||
struct Song {
|
||||
title: String,
|
||||
album: String,
|
||||
artist: String,
|
||||
album_artist: String,
|
||||
year: i32,
|
||||
genre: String,
|
||||
duration: i32,
|
||||
track: i32,
|
||||
track_count: i32,
|
||||
disc: i32,
|
||||
disc_count: i32,
|
||||
#[serde(skip_serializing)]
|
||||
songpath: String,
|
||||
}
|
||||
|
||||
impl Song {
|
||||
pub fn to_metadata_json(&self) -> Result<String, serde_json::Error> {
|
||||
return serde_json::to_string_pretty(&self);
|
||||
}
|
||||
}
|
||||
|
||||
impl Default for Upload {
|
||||
fn default() -> Self {
|
||||
Upload {
|
||||
api: models::api::API::default(),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl Upload {
|
||||
pub async fn upload_song_with_metadata(
|
||||
&mut self,
|
||||
token: &models::token::Token,
|
||||
song: &models::song::Song,
|
||||
cover: &models::song::CoverArt,
|
||||
album: &models::song::Album,
|
||||
) -> Result<reqwest::Response, std::io::Error> {
|
||||
self.api.endpoint = String::from("song/data/upload/with/data");
|
||||
let url = self.retrieve_url();
|
||||
let mut new_song = self.initialize_song(&song, &album);
|
||||
new_song.songpath = song.song_path();
|
||||
let access_token = token.bearer_token();
|
||||
|
||||
if url.is_empty() {
|
||||
println!("Url is empty");
|
||||
}
|
||||
|
||||
println!("Url: {}", url);
|
||||
println!("Token: {}", access_token);
|
||||
|
||||
let mut headers = reqwest::header::HeaderMap::new();
|
||||
headers.insert(
|
||||
reqwest::header::AUTHORIZATION,
|
||||
HeaderValue::from_str(&access_token.clone()).unwrap(),
|
||||
);
|
||||
headers.insert(reqwest::header::ACCEPT, HeaderValue::from_static("*/*"));
|
||||
|
||||
let form = self.init_form(&new_song, &cover);
|
||||
let client = reqwest::Client::builder().build().unwrap();
|
||||
let response = client
|
||||
.post(url)
|
||||
.headers(headers)
|
||||
.multipart(form)
|
||||
.send()
|
||||
.await;
|
||||
let response_text = response.unwrap();
|
||||
|
||||
println!("Something was sent");
|
||||
println!("{:?}", response_text);
|
||||
|
||||
return Ok(response_text);
|
||||
}
|
||||
|
||||
fn _initialize_form(
|
||||
&self,
|
||||
song_raw_data: Vec<u8>,
|
||||
cover_raw_data: Vec<u8>,
|
||||
song_detail: String,
|
||||
) -> Form {
|
||||
let mut headers = HeaderMap::new();
|
||||
headers.insert(
|
||||
http::header::CONTENT_TYPE,
|
||||
http::HeaderValue::from_static("application/octet-stream"),
|
||||
);
|
||||
|
||||
let file = reqwest::multipart::Part::bytes(song_raw_data).headers(headers);
|
||||
let mut headers_i = HeaderMap::new();
|
||||
headers_i.insert(
|
||||
http::header::CONTENT_TYPE,
|
||||
http::HeaderValue::from_static("image/jpeg"),
|
||||
);
|
||||
|
||||
let cover = reqwest::multipart::Part::bytes(cover_raw_data).headers(headers_i);
|
||||
|
||||
let mut song_filename = String::from("audio");
|
||||
song_filename += constants::file_extensions::WAV_FILE_EXTENSION;
|
||||
let mut cover_filename = String::from("cover");
|
||||
cover_filename += constants::file_extensions::JPG_FILE_EXTENSION;
|
||||
|
||||
return reqwest::multipart::Form::new()
|
||||
.part("cover", cover.file_name(cover_filename))
|
||||
.text("metadata", song_detail)
|
||||
.part("file", file.file_name(song_filename));
|
||||
}
|
||||
|
||||
fn init_form(&self, song: &Song, cover: &models::song::CoverArt) -> reqwest::multipart::Form {
|
||||
let songpath = song.songpath.clone();
|
||||
let coverpath = cover.path.clone().unwrap();
|
||||
let song_detail = song.to_metadata_json().unwrap();
|
||||
|
||||
println!("\n{}\n", song_detail);
|
||||
|
||||
let mut song_filename = String::from("audio");
|
||||
song_filename += constants::file_extensions::WAV_FILE_EXTENSION;
|
||||
let mut cover_filename = String::from("cover");
|
||||
cover_filename += constants::file_extensions::JPG_FILE_EXTENSION;
|
||||
|
||||
let form = reqwest::multipart::Form::new()
|
||||
.part(
|
||||
"file",
|
||||
reqwest::multipart::Part::bytes(std::fs::read(songpath).unwrap())
|
||||
.file_name(song_filename),
|
||||
)
|
||||
.part(
|
||||
"cover",
|
||||
reqwest::multipart::Part::bytes(std::fs::read(coverpath).unwrap())
|
||||
.file_name(cover_filename),
|
||||
)
|
||||
.text("metadata", song_detail);
|
||||
|
||||
return form;
|
||||
}
|
||||
|
||||
pub fn set_api(&mut self, host: &String) {
|
||||
let mut api = models::api::API::default();
|
||||
api.url = host.clone();
|
||||
api.version = String::from("v1");
|
||||
self.api = api;
|
||||
}
|
||||
|
||||
fn retrieve_url(&self) -> String {
|
||||
let api = &self.api;
|
||||
let mut buffer = api.url.clone();
|
||||
let count = buffer.len();
|
||||
|
||||
if buffer.chars().nth(count - 1) != Some('/') {
|
||||
buffer += "/";
|
||||
}
|
||||
|
||||
let mut url: String = String::from(&buffer);
|
||||
url += &String::from("api/");
|
||||
url += &String::from(&api.version);
|
||||
url += &String::from("/");
|
||||
url += &String::from(&api.endpoint);
|
||||
|
||||
return url;
|
||||
}
|
||||
|
||||
fn initialize_song(&self, song: &models::song::Song, album: &models::song::Album) -> Song {
|
||||
let dur = song.duration.clone().unwrap();
|
||||
println!("Duration: {}", dur);
|
||||
|
||||
return Song {
|
||||
title: String::from(&song.title.clone().unwrap()),
|
||||
album: album.title.clone(),
|
||||
artist: String::from(&song.artist.clone().unwrap().clone()),
|
||||
album_artist: album.album_artist.clone(),
|
||||
year: album.year.clone(),
|
||||
genre: album.genre.clone(),
|
||||
duration: f64::round(dur) as i32,
|
||||
track: (song.track.clone().unwrap()),
|
||||
track_count: album.track_count.clone(),
|
||||
disc: song.disc.clone().unwrap(),
|
||||
disc_count: album.disc_count.clone(),
|
||||
songpath: String::new(),
|
||||
};
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,28 @@
|
||||
use serde::{Deserialize, Serialize};
|
||||
|
||||
#[derive(Debug, Deserialize, Serialize)]
|
||||
pub struct Checks {}
|
||||
|
||||
impl Checks {
|
||||
pub fn is_numeric(text: &String) -> bool {
|
||||
text.parse::<f64>().is_ok()
|
||||
}
|
||||
|
||||
pub fn index_of_item_in_container<F>(container: &String, item: &char, func: F) -> i32
|
||||
where
|
||||
F: Fn(&char, &char) -> bool,
|
||||
{
|
||||
let mut index = -1;
|
||||
|
||||
for c in container.chars() {
|
||||
if func(&c, item) {
|
||||
index += 1;
|
||||
break;
|
||||
}
|
||||
|
||||
index += 1;
|
||||
}
|
||||
|
||||
return index;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1 @@
|
||||
pub mod checks;
|
||||
Reference in New Issue
Block a user