Got functionality working

include/Managers/CommitManager.h

@@ -10,6 +10,7 @@
 #include"Models/IcarusAction.h"
 #include"Models/Song.h"
 #include"Models/Token.h"
+#include"Utilities/Checks.h"
 
 namespace Managers
 {
@@ -63,15 +64,116 @@ namespace Managers
         // * 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
-	    // 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
+        // Disc and Track is retrieved from the filename if the filename conforms to a standard.
+        // If not, then the disc and track will default to 1
+        //
+        // Standards
+        // * track01.mp3 - Disc 1, Track 1
+        // * track05d02.mp3 - Disc 2, Track 5
 		void multiTargetUpload(const std::string &sourcePath);
 
+        // Standards
+        // * track01.mp3 - Disc 1, Track 1
+        // * track05d02.mp3 - Disc 2, Track 5
+        template<typename Song, typename Str>
+        void initializeDiscAndTrack(Song &song)
+        {
+            auto disc = 1;
+            auto track = 1;
+            // If 1 go with first standard, if 2 go with the second, if 0 then will default to 1 for disc and track
+            auto mode = 0;
+            const Str &songPath = song.songPath;
+
+            auto trd = song.songPath.find("trackd");
+            auto tr = song.songPath.find("track");
+
+            if (tr != Str::npos)
+            {
+                mode = 1;
+            }
+
+            if (trd != Str::npos)
+            {
+                mode = 2;
+            }
+
+            auto dl = [](char c, char t){ return c == t; };
+            auto d = Utilities::Checks::itemIterInContainer<char, Str>(songPath, 'd', dl);
+            auto k = Utilities::Checks::itemIterInContainer<char, Str>(songPath, 'k', dl);
+            auto dot = Utilities::Checks::itemIterInContainer<char, Str>(songPath, '.', dl);
+
+            switch(mode)
+            {
+            case 1:
+            {
+                if (k != songPath.end() && dot != songPath.end())
+                {
+                    auto tStr = std::string(++k, dot);
+                    std::cout << "TStr: " << tStr<<"\n";
+
+                    if (Utilities::Checks::isNumber(tStr))
+                    {
+                        track = std::atoi(tStr.c_str());
+                    }
+                }
+                break;
+            }
+            case 2:
+            {
+                if (k != songPath.end() && dot != songPath.end() && d != songPath.end())
+                {
+                    auto tStr = std::string(++k, d);
+                    auto dStr = std::string(++d, dot);
+                    std::cout<<"DStr: "<<dStr<<" TStr: " << tStr<<"\n";
+
+                    if (Utilities::Checks::isNumber(tStr))
+                    {
+                        track = std::atoi(tStr.c_str());
+                    }
+                    else if (Utilities::Checks::isNumber(dStr))
+                    {
+                        disc = std::atoi(dStr.c_str());
+                    }
+                }
+                break;
+            }
+            }
+
+
+            song.disc = disc;
+            song.track = track;
+        }
+
+        template<typename Song, typename Str>
+        void parseDiscAndTrack(Song &song, const Str &trackID)
+        {
+            auto sep = [](char c, char t) { return c == t; };
+            auto separator = Utilities::Checks::itemIterInContainer<char, Str>(trackID, ':', sep);
+
+            if (separator != trackID.end())
+            {
+                auto dStr = Str(trackID.begin(), separator);
+                auto tStr = Str(++separator, trackID.end());
+
+                song.disc = std::atoi(dStr.c_str());
+                song.track = std::atoi(tStr.c_str());
+            }
+            else
+            {
+                auto isNumber = Utilities::Checks::isNumber(trackID);
+                if (isNumber)
+                {
+                    song.track = std::atoi(trackID.c_str());
+                }
+            }
+        }
+
 
         // Checks for the no confirm flag. Used when uploading songs from a directory
         bool checkForNoConfirm()

include/Models/Song.h

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

include/Utilities/Checks.h

@@ -12,7 +12,7 @@ namespace Utilities
     public:
         Checks() = delete;
 
-        static bool isNumber(const std::string &val)
+        static auto isNumber(const std::string &val)
         {
             return !val.empty() && std::find_if(val.begin(), 
                 val.end(), [](char c)
@@ -20,6 +20,44 @@ namespace Utilities
                     return !std::isdigit(c);
                     }) == val.end();
         }
+
+        // Note: Not implemented
+        template<typename Item, typename Container, typename Func>
+        static auto itemInContainer(const Container container, const Item item, Func func)
+        {
+            auto result = false;
+            auto i = std::find_if(container.begin(), container.end(), [&](Item i)
+            {
+                return func(item, i);
+            });
+
+            if (i != container.end())
+            {
+                result = true;
+            }
+
+            return result;
+        }
+
+        template<typename Item, typename Container, typename Func>
+        static auto itemIterInContainer(const Container &container, const Item &item, Func func)
+        {
+            auto result = false;
+            // std::cout<<container<<"\n";
+            auto ii = std::find_if(container.begin(), container.end(), [&](Item i)
+            {
+                // std::cout<<"iter "<<i<<" target "<<item<<"\n";
+                return func(i, item);
+            });
+
+            if (ii == container.end())
+            {
+                // std::cout<<item<<" not found in container\n";
+                ii = container.end();
+            }
+
+            return ii;
+        }
     private:
     };
 }