Updates

Updating required flags for uploading a song with metadata

CMakeLists.txt

@@ -42,6 +42,7 @@ set(SOURCES
     src/Managers/FileManager.cpp
     src/Managers/TokenManager.cpp
     src/Managers/UserManager.cpp
+    src/Models/Song.cpp
     src/Parsers/APIParser.cpp
     src/Syncers/Delete.cpp
     src/Syncers/Download.cpp

README.md

@@ -43,7 +43,7 @@ The program has been built and can be executed by the binary file *icd*. For inf
 ### Uploading Song with metadata
 
 ```BASH
-icd upload-meta -u spacecadet -p stellar40 -h https://icarus.com -s /path/of/song.mp3 -m /path/to/metadata/config/collection.json -ca /path/to/cover/art/image.png
+icd upload-meta -u spacecadet -p stellar40 -h https://icarus.com -s /path/of/song.mp3 -t 1 -m /path/to/metadata/config/collection.json -ca /path/to/cover/art/image.png
 ```
 
 ### Uploading Song with metadata from directory

include/Managers/ActionManager.h

@@ -19,26 +19,58 @@ namespace Managers
 
         Models::IcarusAction retrieveIcarusAction() const;
     private:
-        constexpr std::array<const char*, 15> supportedFlags() noexcept
+        constexpr std::array<const char*, 16> supportedFlags() noexcept
         {
-            constexpr std::array<const char*, 15> allFlags{"-u", "-p", "-t", "-h", "-s",
+            constexpr std::array<const char*, 16> allFlags{"-u", "-p", "-t", "-h", "-s",
                 "-sd", "-sr", "-d", "-D", "-b", "-rt", "-nc",
-                "-m", "-ca", "-smca"};
+                "-m", "-ca", "-smca", "-t"};
 
             return allFlags;
         }
         constexpr std::array<const char*, 4> supportedActions() noexcept;
 
-        bool isNumber(const std::string_view val) noexcept
-        {
-            return !val.empty() && std::find_if(val.begin(), 
-                val.end(), [](char c)
-                {
-                    return !std::isdigit(c);
-                    }) == val.end();
-        }
         void initialize();
         void validateFlags();
+        // Checks to see if the flag is valid
+        template<typename Str>
+        bool isValidFlag(const Str flag)
+        {
+            const auto flags = supportedFlags();
+            const auto i = std::find_if(flags.begin(), flags.end(), [&](const Str &f)
+            {
+                return f.compare(flag) == 0 ? true : false;
+            });
+
+            auto result = i != flags.end() ? true : false;
+
+            return result;
+        }
+
+        template<typename Str>
+        bool doesFlagHaveValue(const Str flag)
+        {
+            const auto flags = parsedFlags();
+            auto i = std::find_if(flags.begin(), flags.end(), [&](const Str &f)
+            {
+                return f.compare(flag) == 0 ? true : false;
+            });
+
+            if (i != flags.end())
+            {
+                if (++i != flags.end() && !isValidFlag<Str>(*i))
+                {
+                    return true;
+                }
+                else
+                {
+                    return false;
+                }
+            }
+            else
+            {
+                return false;
+            }
+        }
 
         std::vector<std::string> parsedFlags();
 

include/Managers/CommitManager.h

@@ -60,9 +60,18 @@ namespace Managers
         //
         // Expects
         // * Song - mp3 file path
+        // * TrackID - track number to chose from when retrieving metadata. "1" and "1:1" are similar
         // * Metadata - Source file containing metadata of the song
         // * Cover art - path to image cover art
-	    void uploadSingleSong();
+	    // TODO: Change the name
+	    void uploadSongWithMetadata();
+
+        // Expects the song path, trackID, metadata file path, and cover path
+		void singTargetUpload(const std::string &songPath, const std::string &trackID, 
+            const std::string &metaPath, const std::string &coverPath);
+        // Expects the source directory that contains songs, a metadata file, and cover image
+		void multiTargetUpload(const std::string &sourcePath);
+
 
         // Checks for the no confirm flag. Used when uploading songs from a directory
         bool checkForNoConfirm()

include/Models/Song.h

@@ -18,6 +18,10 @@ namespace Models
             std::cout<<"\n";
         }
 
+        // TODO: Incomplete implementation
+        std::string toMetadataJson();
+        
+
         int id;
         std::string title;
         std::string artist;

include/Utilities/Checks.h

@@ -0,0 +1,30 @@
+#ifndef CHECKS_H_
+#define CHECKS_H_
+
+#include<algorithm>
+#include<cstdlib>
+#include<ctype.h>
+
+namespace Utilities
+{
+    class Checks
+    {
+    public:
+        Checks() = delete;
+
+        static bool isNumber(const std::string &val)
+        {
+            return !val.empty() && std::find_if(val.begin(), 
+                val.end(), [](char c)
+                {
+                    return !std::isdigit(c);
+                    }) == val.end();
+        }
+    private:
+    };
+}
+
+#endif
+
+
+

include/Utilities/Conversions.h

@@ -11,6 +11,15 @@ namespace Utilities
     public:
         Conversions();
 
+
+        static void toLowerChar(char &c)
+        {
+            if (std::isalpha(c))
+            {
+                c = std::tolower(c);
+            }
+        }
+
         void initializeValues();
 
         template <typename T>

src/Managers/ActionManager.cpp

@@ -52,40 +52,29 @@ namespace Managers
 
         const auto flagVals = parsedFlags();
 
-        Flags flg;
+        for (auto flag = flagVals.begin(); flag != flagVals.end(); ++flag)
-
-        auto allSupportedFlags = supportedFlags();
-
-        for (auto flag : flagVals)
         {
-            if (flag.compare("-nc") == 0)
+            Flags flg;
-            {
+            cout<<"Value: "<<*flag<<"\n";
-                flg.flag = flag;
-                flags.push_back(flg);
-                continue;
-            }
-            if (flag.size() > 3 || isNumber(flag))
-            {
-                flg.value = flag;
 
-                flags.push_back(flg);
+            if (isValidFlag<string>(*flag) && doesFlagHaveValue<string>(*flag))
-                flg = Flags{};
-                continue;
-            }
-
-            if (std::any_of(allSupportedFlags.begin(), allSupportedFlags.end(), 
-                [&](const char *val)
-                {
-                    return !flag.compare(val);
-                }))
             {
-                flg.flag = 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 is not valid"<<endl;
+                cout<<"Flag "<<*flag<<" is not valid"<<endl;
                 exit(1);
             }
+
+            flags.emplace_back(std::move(flg));
         }
     }
 
@@ -97,7 +86,7 @@ namespace Managers
         for (auto i = 2; i < paramCount; ++i)
         {
             const std::string flag(std::move(*(params + i)));
-            parsed.push_back(std::move(flag));
+            parsed.emplace_back(std::move(flag));
         }
 
         return parsed;

src/Managers/CommitManager.cpp

@@ -15,6 +15,7 @@
 #include"Syncers/Download.h"
 #include"Syncers/RetrieveRecords.h"
 #include"Syncers/Upload.h"
+#include"Utilities/Checks.h"
 
 #include"Managers/TokenManager.h"
 #include"Managers/UserManager.h"
@@ -67,7 +68,7 @@ namespace Managers
 				uploadSong();
 				break;
 			case ActionValues::UPLOAD_SONG_WITH_METADATA:
-				uploadSingleSong();
+				uploadSongWithMetadata();
 				break;
             default:
                 break;
@@ -234,22 +235,18 @@ namespace Managers
         }
 	}
 
-	// TODO: Change the name
+	void CommitManager::uploadSongWithMetadata()
-	void CommitManager::uploadSingleSong()
 	{
 		cout<<"Uploading single song with metadata\n\n";
 
-		APIParser apiPrs{icaAction};
+		// Either the set of "-s", "-m", "-ca", "-t" flags or "-smca" must exist with values
-		auto api = apiPrs.retrieveAPI();
-		const auto token = parseToken(api);
-
-		// Either the set of "-s", "-m", "-ca" 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() ? true : false;
+			!coverPath.empty() && !trackID.empty() ? true : false;
 
 		const auto uni = this->icaAction.retrieveFlagValue("-smca");
 		const auto multiTarget = !uni.empty() ? true : false;
@@ -260,20 +257,63 @@ namespace Managers
 			return;
 		}
 
-		cout<<"song path: "<<songPath<<"\n";
+		cout<<"Song path: "<<songPath<<"\n";
+		cout<<"TrackID: "<<trackID<<"\n";
 		cout<<"Metadata path: "<<metadataPath<<"\n";
 		cout<<"Cover Art path: "<<coverPath<<"\n";
 
-		auto album = retrieveMetadata(metadataPath);
+		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();
 		for (auto sng : album.songs)
 		{
 			// sng.printInfo();
 		}
 
-		auto disc = 0;
+		auto disc = 1;
 		auto track = 1;
 
+		auto separator = std::find_if(trackID.begin(), trackID.end(), [&](char c)
+		{
+			return c == ':';
+		});
+
+		if (separator != trackID.end())
+		{
+			cout<<"Found colon\n";
+			auto dStr = string(trackID.begin(), separator);
+			auto tStr = string(++separator, trackID.end());
+
+			cout<<"disc "<<dStr<<" track "<<tStr<<"\n";
+			disc = std::atoi(dStr.c_str());
+			track = std::atoi(tStr.c_str());
+		}
+		else
+		{
+			auto isNumber = Utilities::Checks::isNumber(trackID);
+			if (isNumber)
+			{
+				track = std::atoi(trackID.c_str());
+			}
+		}
+
 		auto sng = std::find_if(album.songs.begin(), album.songs.end(), [&](Song s)
 		{
 			return s.track == track && s.disc == disc;
@@ -281,7 +321,8 @@ namespace Managers
 
 		if (sng == album.songs.end())
 		{
-			cout<<"Not found\n";
+			cout<<"Not found with disc "<<disc<<" track "<<track<<"\n";
+			std::exit(-1);
 		}
 
 		auto song = *sng;
@@ -291,12 +332,16 @@ namespace Managers
 		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);
+	}
 
 	#pragma region private
 	CommitManager::Album CommitManager::retrieveMetadata(const std::string_view path)

src/Models/Song.cpp

@@ -0,0 +1,16 @@
+#include "Models/Song.h"
+
+#include "nlohmann/json.hpp"
+
+using std::string;
+
+namespace Models
+{
+    string Song::toMetadataJson()
+    {
+        nlohmann::json s;
+        s["title"] = this->title;
+
+        return s.dump();
+    }
+}

src/Syncers/Upload.cpp

@@ -6,6 +6,7 @@
 #include<nlohmann/json.hpp>
 
 #include"Syncers/Upload.h"
+#include"Utilities/Conversions.h"
 
 using std::cout;
 using std::cin;
@@ -24,6 +25,7 @@ using namespace cpr;
 
 namespace Syncers
 {
+    #pragma region Functions
     Song Upload::uploadSong(Song& song)
     {
         try
@@ -76,17 +78,13 @@ namespace Syncers
                 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;
                 } 
-                else if (answer == 'n' || answer == 'N') 
-                {
-                    confirmUpload = false;
-                    break;
-                }
             }
 
             if (!confirmUpload) 
@@ -110,12 +108,55 @@ namespace Syncers
 
     void Upload::uploadSongWithMetadata(Managers::CommitManager::Album &album, Models::Song& song, Models::CoverArt &cover)
     {
-        // TODO: Implement
+        this->api.endpoint.append("/upload/with/data");
+
+        try
+        {
+            auto url = retrieveUrl();
+
+            cout<<"url "<<url<<endl;
+            string auth{this->m_token.tokenType};
+            auth.append(" " + this->m_token.accessToken);
+
+            // const auto meta = song.toMetadataJson();
+            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";
+
+            auto multipart = cpr::Multipart{{"cover", cpr::File{cover.path}},
+                {"metadata", meta},
+                {"file", cpr::File{song.songPath}}};
+
+            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))
@@ -166,7 +207,7 @@ namespace Syncers
     }
 
 
-    #pragma
+    #pragma region Testing
     void Upload::printSongDetails()
     {
         cout<<"Song details: "<<endl;
@@ -207,6 +248,6 @@ namespace Syncers
 
         cout<<endl<<endl;;
     }
-    #pragma Testing
+    #pragma endregion
-    #pragma Functions
+    #pragma endregion
 }