Made progress

include/Managers/ActionManager.h

@@ -1,6 +1,7 @@
 #ifndef ACTIONMANAGER_H_
 #define ACTIONMANAGER_H_
 
+#include<algorithm>
 #include<string>
 #include<string_view>
 #include<array>
@@ -18,11 +19,24 @@ namespace Managers
 
         Models::IcarusAction retrieveIcarusAction() const;
     private:
-        constexpr std::array<const char*, 12> supportedFlags() noexcept;
+        constexpr std::array<const char*, 15> supportedFlags() noexcept
+        {
+            constexpr std::array<const char*, 15> allFlags{"-u", "-p", "-t", "-h", "-s",
+                "-sd", "-sr", "-d", "-D", "-b", "-rt", "-nc",
+                "-m", "-ca", "-smca"};
+
+            return allFlags;
+        }
         constexpr std::array<const char*, 4> supportedActions() noexcept;
 
-        bool isNumber(const std::string_view) 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();
 

include/Managers/CommitManager.h

@@ -2,11 +2,14 @@
 #define COMMITMANAGER_H_
 
 #include<map>
+#include<iostream>
 #include<string>
+#include<string_view>
 
 #include"Models/API.h"
-#include"Models/Token.h"
 #include"Models/IcarusAction.h"
+#include"Models/Song.h"
+#include"Models/Token.h"
 
 namespace Managers
 {
@@ -22,6 +25,24 @@ namespace Managers
             songs
         };
 
+        // Used for parsing songs from the metadata file
+        class Album
+        {
+        public:
+            Album() = default;
+
+            void printInfo();
+            
+
+            std::string album;
+            std::string albumArtist;
+            std::string genre;
+            int year;
+            int trackCount;
+            int discCount;
+            std::vector<Models::Song> songs;
+        };
+
     private:
         enum class ActionValues;
 
@@ -33,15 +54,44 @@ namespace Managers
         void downloadSong();
         void retrieveObjects();
         void uploadSong();
+        // Uploads a single song. The song is constructed from a metadata file that contains
+        // information about the album the song is from. Also, the cover art of the song must
+        // be present.
+        //
+        // Expects
+        // * Song - mp3 file path
+        // * Metadata - Source file containing metadata of the song
+        // * Cover art - path to image cover art
+	    void uploadSingleSong();
+
+        // Checks for the no confirm flag. Used when uploading songs from a directory
+        bool checkForNoConfirm()
+        {
+            for (const auto &arg: this->icaAction.flags)
+            {
+                if (arg.flag.compare("-nc") == 0)
+                {
+                    return true;
+                }
+            }
+
+            return false;
+        }
+
+
+        Album retrieveMetadata(const std::string_view path);
+        std::string retrieveFileContent(const std::string_view path);
 
         enum class ActionValues
         {
             deleteAct,
             downloadAct,
             retrieveAct,
-            uploadAct
+            uploadAct,
+            UPLOAD_SONG_WITH_METADATA // Uploads the song with metadata, including cover art
         };
 
+
         Models::IcarusAction icaAction;
     };
 }

include/Models/Flags.h

@@ -5,8 +5,9 @@
 
 namespace Models
 {
-    struct Flags
+    class Flags
     {
+    public:
         std::string flag;
         std::string value;
     };

include/Models/IcarusAction.h

@@ -2,14 +2,47 @@
 #define ICARUSACTION_H_
 
 #include<string>
+#include<algorithm>
+#include<string_view>
 #include<vector>
+#include<iostream>
 
 #include"Flags.h"
 
 namespace Models
 {
-    struct IcarusAction
+    class IcarusAction
     {
+    public:
+        std::string retrieveFlagValue(const std::string_view flag)
+        {
+            std::string value;
+
+            const auto fg = std::find_if(flags.begin(), flags.end(), [&](Flags f)
+            {
+                return f.flag.compare(flag) == 0 ? true : false;
+            });
+
+            if (fg != flags.end())
+            {
+                value.assign(fg->value);
+            }
+
+            return value;
+        }
+        void print_action_and_flags() noexcept
+        {
+            std::cout<<"Action: "<<this->action<<"\n";
+            std::cout<<"Flag count: "<<this->flags.size()<<"\n";
+            
+            for (const auto &flag : this->flags)
+            {
+                std::cout<<"flag "<<flag.flag<<" value "<<flag.value<<"\n";
+            }
+
+            std::cout<<"\n";
+        }
+
         std::string action;
         std::vector<Flags> flags;
     };

include/Models/Song.h

@@ -2,12 +2,22 @@
 #define SONG_H_
 
 #include<string>
+#include<iostream>
 
 
 namespace Models
 {
-    struct Song
+    class Song
     {
+    public:
+        Song() = default;
+
+        void printInfo()
+        {
+            std::cout<<"Title: "<<this->title<<"\n";
+            std::cout<<"\n";
+        }
+
         int id;
         std::string title;
         std::string artist;
@@ -16,9 +26,18 @@ namespace Models
         int year;
         int duration;
         int track;
+        int disc;
         std::string data;
         std::string songPath;
     };
+
+    class CoverArt
+    {
+    public:
+        int id;
+        std::string title;
+        std::string path;
+    };
 } 
 
 #endif

include/Syncers/Upload.h

@@ -7,6 +7,7 @@
 
 #include<nlohmann/json.hpp>
 
+#include"Managers/CommitManager.h"
 #include"Managers/FileManager.h"
 #include"Models/API.h"
 #include"Models/Song.h"
@@ -21,16 +22,19 @@ namespace Syncers
     class Upload
     {
         public:
-            Upload();
-            Upload(Models::API);
+            Upload(Models::API api, Models::Token token) : m_token(token), api(api)
+            {
+                this->api.endpoint = "song/data";
+            }
 
-            Models::Song uploadSong(const Models::Token&, Models::Song&);
-            void uploadSongsFromDirectory(const Models::Token&, 
-                    const std::string&, const bool, bool);
+            Models::Song uploadSong(Models::Song&);
+            void uploadSongsFromDirectory(const std::string&, const bool, bool);
+            void uploadSongWithMetadata(Managers::CommitManager::Album&, Models::Song&, Models::CoverArt&);
         private:
             Managers::FileManager fMgr;
             Models::API api;
             Models::Song song;
+            Models::Token m_token;
 
             std::vector<Models::Song> retrieveAllSongsFromDirectory(const std::string&,
                 bool);