Added feature to upload all songs from a directory (optional recursive). Need to document the use of it as well as how to even use this CLI

include/Managers/ActionManager.h

@@ -31,9 +31,9 @@ namespace Managers
         std::array<std::string, 4> supportedActions{
             "download", "upload", "retrieve", "delete"
         };
-        std::array<std::string, 9> supportedFlags{
+        std::array<std::string, 11> supportedFlags{
-            "-u", "-p", "-t", "-h", "-s",
+            "-u", "-p", "-t", "-h", "-s", "-sd",
-            "-d", "-D", "-b", "-rt"
+            "-sr", "-d", "-D", "-b", "-rt"
         };
         std::vector<Models::Flags> flags;
         char **params;

include/Managers/CommitManager.h

@@ -38,8 +38,7 @@ namespace Managers
             uploadAct
         };
 
-        std::map<std::string, ActionValues> mapActions = 
+        std::map<std::string, ActionValues> mapActions{
-            std::map<std::string, ActionValues>{
 			{"delete", deleteAct}, {"download", downloadAct},
 			{"retrieve", retrieveAct},
 			{"upload", uploadAct}

include/Managers/TokenManager.h

@@ -10,8 +10,8 @@ namespace Managers
     class TokenManager
     {
     public:
-        TokenManager(const Models::User);
+        TokenManager(const Models::User&);
-        TokenManager(const Models::User, Models::API);
+        TokenManager(const Models::User&, Models::API&);
 
         Models::Token requestToken();
     private:

include/Models/Song.h

@@ -15,7 +15,8 @@ namespace Models
         std::string genre;
         int year;
         int duration;
-        std::string  data;
+        int track;
+        std::string data;
         std::string songPath;
     };
 } 

include/Syncers/Download.h

@@ -24,7 +24,7 @@ namespace Syncers
         std::string retrieveUrl(Models::Song);
 
         std::string downloadFilePath;
-        void saveSong(Models::Song*);
+        void saveSong(Models::Song&);
     };
 }
 

include/Syncers/Upload.h

@@ -1,7 +1,9 @@
 #ifndef UPLOAD_H_
 #define UPLOAD_H_
 
+#include<filesystem>
 #include<string>
+#include<vector>
 
 #include<nlohmann/json.hpp>
 
@@ -11,6 +13,8 @@
 #include"Models/Token.h"
 #include"Models/UploadForm.h"
 
+namespace fs = std::filesystem;
+
 
 namespace Syncers
 {
@@ -20,15 +24,22 @@ namespace Syncers
             Upload();
             Upload(Models::API);
 
-            void uploadSong(const Models::Token, Models::Song);
+            Models::Song uploadSong(const Models::Token&, Models::Song&);
+            void uploadSongsFromDirectory(const Models::Token&, const std::string&, bool);
         private:
             Managers::FileManager fMgr;
             Models::API api;
             Models::Song song;
 
+            std::vector<Models::Song> retrieveAllSongsFromDirectory(const std::string&,
+                bool);
+
             std::string retrieveUrl();
 
+            Models::Song retrieveSongPath(fs::directory_entry&);
+
             void printSongDetails();
+            void printSongDetails(std::vector<Models::Song>&);
             void printJsonData(nlohmann::json);
     };
 }

src/Managers/ActionManager.cpp

@@ -71,7 +71,7 @@ namespace Managers
             }
 
             if (std::any_of(supportedFlags.begin(), supportedFlags.end(), 
-                [&](string val)
+                [&](string& val)
                 {
                     return !val.compare(flag);
                 }))

src/Managers/CommitManager.cpp

@@ -157,14 +157,17 @@ namespace Managers
     }
 	void CommitManager::uploadSong()
 	{
+        bool uploadSingleSong = true;
+        bool recursiveDirectory = false;
+        string songDirectory;
 		APIParser apiPrs{icaAction};
 		auto api = apiPrs.retrieveAPI();
 
 		auto token = parseToken(api);
 
-		Song song{};
+		Song song;
 
-		for (auto arg : icaAction.flags)
+		for (auto& arg : icaAction.flags)
 		{
 			auto flag = arg.flag;
 			auto value = arg.value;
@@ -173,11 +176,30 @@ namespace Managers
 			{
 				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};
-		cout<<"Uploading song..."<<endl;
+        if (uploadSingleSong)
-		upld.uploadSong(token, song);
+        {
+		    cout<<"Uploading song..."<<endl;
+		    upld.uploadSong(token, song);
+        }
+        else
+        {
+            cout<<"Uploading songs from " << songDirectory << endl;
+            upld.uploadSongsFromDirectory(token, songDirectory, recursiveDirectory);
+        }
 	}
 	#pragma Functions
 }

src/Managers/TokenManager.cpp

@@ -18,11 +18,11 @@ using Models::User;
 namespace Managers
 {
     #pragma
-    TokenManager::TokenManager(const User user)
+    TokenManager::TokenManager(const User& user)
     {
         this->user = user;
     }
-    TokenManager::TokenManager(const User user, API api)
+    TokenManager::TokenManager(const User& user, API& api)
     {
         this->user = user;
         this->api = api;

src/Syncers/Download.cpp

@@ -42,15 +42,19 @@ namespace Syncers
             cout<<"song path "<<song.songPath<<endl;
             string auth{token.tokenType};
             auth.append(" " + token.accessToken);
+            /**
             auto r = cpr::Get(cpr::Url(url), 
                 cpr::Header{{"authorization", auth}});
+                */
+            auto r = cpr::Get(cpr::Url(url),
+                    cpr::Header{{"Content-type", "audio/mpeg"}});
+                
 
             int statusCode = r.status_code;
 
-            if (statusCode == OK)
+            if (statusCode == OK) {
-            {
                 song.data = r.text;
-                saveSong(&song);
+                saveSong(song);
             }
 
 
@@ -74,14 +78,14 @@ namespace Syncers
         return url;
     }
 
-    void Download::saveSong(Song *song)
+    void Download::saveSong(Song& song)
     {
-        cout<<"\nSaving song to: "<<song->songPath<<endl;
+        cout<<"\nSaving song to: "<<song.songPath<<endl;
-        int bufferLength = song->data.length();
+        int bufferLength = song.data.length();
-        const char *data = song->data.c_str();
+        const char *data = song.data.c_str();
         cout<<"buff length  "<<bufferLength<<endl;
 
-        ofstream saveSong{song->songPath, std::ios::binary};
+        ofstream saveSong{song.songPath, std::ios::binary};
         saveSong.write(data, bufferLength);
         saveSong.close();
     }

src/Syncers/Upload.cpp

@@ -1,6 +1,6 @@
 #include<iostream>
+#include<filesystem>
 #include<exception>
-#include<string>
 
 #include<cpr/cpr.h>
 #include<nlohmann/json.hpp>
@@ -30,7 +30,7 @@ namespace Syncers
     }
 
 
-    void Upload::uploadSong(const Models::Token token, Song song)
+    Song Upload::uploadSong(const Models::Token& token, Song& song)
     {
         try
         {
@@ -45,16 +45,77 @@ namespace Syncers
                 cpr::Header{{"authorization", auth}}
                 );
 
-            cout << r.status_code<< std::endl;
+            cout << "status code: " << r.status_code<< std::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;
         }
-        cout<<"Finished"<<endl;
+
+        return song;
     }
 
+    void Upload::uploadSongsFromDirectory(const Models::Token& token, 
+        const std::string& directory, 
+        bool recursive = false)
+    {
+        try
+        {
+            auto songs = retrieveAllSongsFromDirectory(directory, recursive);
+            for (auto& song: songs)
+            {
+                song = uploadSong(token, song);
+            }
+            printSongDetails(songs);
+
+        }
+        catch (exception& e)
+        {
+            cout<<e.what()<<endl;
+        }
+    }
+
+
+    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 + "/" +
@@ -62,6 +123,26 @@ namespace Syncers
             
         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
     void Upload::printSongDetails()
     {
@@ -74,6 +155,21 @@ namespace Syncers
         cout<<"Year: "<<song.year<<endl;
         cout<<"Duration: "<<song.duration<<endl;
     }
+    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(json obj)
     {
         cout<<endl<<endl<<"JSon data: "<<endl;