added flag to prevent the user from being prompted when uploading songs from a directory

CMakeLists.txt

@@ -1,4 +1,4 @@
-cmake_minimum_required(VERSION 3.2)
+cmake_minimum_required(VERSION 3.10)
 
 
 include("cmake/HunterGate.cmake")
@@ -15,17 +15,17 @@ if(NOT ${CMAKE_VERSION} LESS 3.2)
     set(CMAKE_CXX_STANDARD 11)
     set(CMAKE_CXX_STANDARD_REQUIRED ON)
 else()
-    message(STATUS "Checking compiler flags for C++11 support.")
+    message(STATUS "Checking compiler flags for C++17 support.")
-    # Set C++11 support flags for various compilers
+    # Set C++17 support flags for various compilers
     include(CheckCXXCompilerFlag)
-    check_cxx_compiler_flag("-std=c++11" COMPILER_SUPPORTS_CXX11)
+    check_cxx_compiler_flag("-std=c++17" COMPILER_SUPPORTS_CXX17)
     check_cxx_compiler_flag("-std=c++0x" COMPILER_SUPPORTS_CXX0X)
-    if(COMPILER_SUPPORTS_CXX11)
+    if(COMPILER_SUPPORTS_CXX17)
-        message(STATUS "C++11 is supported.")
+        message(STATUS "C++17 is supported.")
         if(${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
-            set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11 -stdlib=libc++")
+            set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++17 -stdlib=libc++")
         else()
-            set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11")
+            set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++17")
         endif()
     elseif(COMPILER_SUPPORTS_CXX0X)
         message(STATUS "C++0x is supported.")
@@ -35,7 +35,7 @@ else()
             set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++0x")
         endif()
     else()
-        message(STATUS "The compiler ${CMAKE_CXX_COMPILER} has no C++11 support. Please use a different C++ compiler.")
+        message(STATUS "The compiler ${CMAKE_CXX_COMPILER} has no C++17 support. Please use a different C++ compiler.")
     endif()
 endif()
 
@@ -50,28 +50,30 @@ set(SOURCES
     src/Parsers/APIParser.cpp
     src/Syncers/Delete.cpp
     src/Syncers/Download.cpp
+    src/Syncers/RetrieveRecords.cpp
     src/Syncers/Upload.cpp
     src/Utilities/Conversions.cpp
 )
 set(HEADERS
-	src/Managers/ActionManager.h
+    include/Managers/ActionManager.h
-	src/Managers/CommitManager.h
+    include/Managers/CommitManager.h
-	src/Managers/FileManager.h
+    include/Managers/FileManager.h
-	src/Managers/TokenManager.h
+    include/Managers/TokenManager.h
-	src/Managers/UserManager.h
+    include/Managers/UserManager.h
-	src/Models/API.h
+    include/Models/API.h
-	src/Models/Flags.h
+    include/Models/Flags.h
-	src/Models/IcarusAction.h
+    include/Models/IcarusAction.h
-	src/Models/Song.h
+    include/Models/Song.h
-	src/Models/Token.h
+    include/Models/Token.h
-	src/Models/UploadForm.h
+    include/Models/UploadForm.h
-	src/Models/User.h
+    include/Models/User.h
-	src/Parsers/APIParser.h
+    include/Parsers/APIParser.h
-	src/Syncers/Delete.h
+    include/Syncers/Delete.h
-	src/Syncers/Download.h
+    include/Syncers/Download.h
-	src/Syncers/SyncerBase.h
+    include/Syncers/RetrieveRecords.h
-	src/Syncers/Upload.h
+    include/Syncers/SyncerBase.h
-	src/Utilities/Conversions.h
+    include/Syncers/Upload.h
+    include/Utilities/Conversions.h
 )
 
 
@@ -84,4 +86,4 @@ find_package(cpr CONFIG REQUIRED)
 
 add_executable(icd ${SOURCES} ${HEADERS})
 target_link_libraries(icd PUBLIC nlohmann_json::nlohmann_json cpr::cpr)
-include_directories(src/)
+include_directories(include/)

README.md

@@ -1,25 +1,6 @@
 # IcarusDownloadManager
 
-IcarusDownloadManager is a Linux UI software client application that has the feature of uploading and downloading songs from the [Icarus](https://github.com/amazing-username/Icarus) Music Server. 
+IcarusDownloadManager is a Linux CLI software client application that has the feature of uploading and downloading songs from the [Icarus](https://github.com/amazing-username/Icarus) Music Server. 
-
-
-### Getting Started
-
-Clone the repository and esnure that the cpr c++ module is implemented by checking the contents of the cpr directory. If you notice a directory structure and a *CMakeList.txt* file then you are fine. Otherwise implement the modules with the following command:
-
-
-```
-git submodule update --init --recursive
-```
-
-Once that is complete, verify the contents of the cpr directory and there should be a *CMakeList.txt* file. Now you must compile and link the project
-
-```
-cmake .
-make
-```
-
-The program has been built and can be executed by the binary file *icd*
 
 
 ## Built With
@@ -27,17 +8,48 @@ The program has been built and can be executed by the binary file *icd*
 * C++
 * CMake
 * GCC
+* [Hunter](https://github.com/ruslo/hunter)
 * libCurl
-* Qt 5
+* [json](https://github.com/nlohmann/json)
 * [cpr](http://whoshuu.github.io/cpr/)
 
+
+### Getting Started
+
+Build the project:
+
+```
+export HUNTER_ROOT=/path/to/download/hunter/files/for/dependencies
+mkdir _build
+cd _build
+cmake -H. -B_builds -DHUNTER_STATUS_DEBUG=ON -DCMAKE_BUILD_TYPE=DEBUG
+cmake --build _builds --config Debug
+make
+```
+
+The program has been built and can be executed by the binary file *icd*. For information on how to use icd, merely execute the program without any command line arguments.
+
+### Downloading Song
+``icd download -u spacecadet -p stellar40 -h https://icarus.com -b 15``
+
+### Uploading Song
+``icd upload -u spacecadet -p stellar40 -h https://icarus.com -s /path/of/song.mp3``
+
+### Retrieving Song in json
+``icd retrieve -u spacecadet -p stellar40 -h https://icarus.com -rt songs``
+
+### Deleting Song
+``icd delete -u spacecadet -p stellar40 -h https://icarus.com -D 15``
+
+
 ## Contributing
 
 Please read [CONTRIBUTING.md](CONTRIBUTING.md) for details on the code of conduct, and the process for submitting pull requests to the project.
 
 ## Versioning
 
-No version has been released 
+[v0.1.1](https://github.com/kdeng00/IcarusDownloadManager/releases/tag/v0.1.1)  
+[v0.1.0](https://github.com/kdeng00/IcarusDownloadManager/releases/tag/0.1.0)
 
 ## Authors
 

include/Managers/ActionManager.h

@@ -0,0 +1,43 @@
+#ifndef ACTIONMANAGER_H_
+#define ACTIONMANAGER_H_
+
+#include<string>
+#include<string_view>
+#include<array>
+#include<vector>
+
+#include"Models/Flags.h"
+#include"Models/IcarusAction.h"
+
+namespace Managers
+{
+    class ActionManager
+    {
+    public:
+        ActionManager(char**, int);
+
+        Models::IcarusAction retrieveIcarusAction() const;
+    private:
+        constexpr std::array<const char*, 12> supportedFlags() noexcept;
+        constexpr std::array<const char*, 4> supportedActions() noexcept;
+
+        bool isNumber(const std::string_view) noexcept;
+
+        void initialize();
+        void validateFlags();
+
+        std::vector<std::string> parsedFlags();
+
+        void printAction() noexcept;
+        void printFlags() noexcept;
+
+        std::string action;
+        
+        std::vector<Models::Flags> flags;
+
+        char **params;
+        int paramCount;
+    };
+}
+
+#endif

include/Managers/CommitManager.h

@@ -0,0 +1,49 @@
+#ifndef COMMITMANAGER_H_
+#define COMMITMANAGER_H_
+
+#include<map>
+#include<string>
+
+#include"Models/API.h"
+#include"Models/Token.h"
+#include"Models/IcarusAction.h"
+
+namespace Managers
+{
+    class CommitManager
+    {
+    public:
+        CommitManager(Models::IcarusAction&);
+
+        void commitAction();
+
+        enum class RetrieveTypes
+        {
+            songs
+        };
+
+    private:
+        enum class ActionValues;
+
+        std::map<std::string, ActionValues> mapActions() noexcept;
+
+        Models::Token parseToken(Models::API);
+
+        void deleteSong();
+        void downloadSong();
+        void retrieveObjects();
+        void uploadSong();
+
+        enum class ActionValues
+        {
+            deleteAct,
+            downloadAct,
+            retrieveAct,
+            uploadAct
+        };
+
+        Models::IcarusAction icaAction;
+    };
+}
+
+#endif

include/Managers/FileManager.h

@@ -0,0 +1,29 @@
+#ifndef FILEMANAGER_H_
+#define FILEMANAGER_H_
+
+#include<string>
+
+namespace Managers
+{
+    class FileManager
+    {
+    public:
+        FileManager();
+        FileManager(std::string);
+
+        void saveFile(std::string);
+        void modifyFilePath(std::string);
+
+        char* retrieveFileBuffer() const;
+        int retrieveFileBufferLength() const;
+    private:
+        void readFile();
+
+        std::string filePath;
+        char* fileBuffer;
+        bool fileRead;
+        int fileBufferLength;
+    };
+}
+
+#endif

include/Managers/TokenManager.h

@@ -0,0 +1,23 @@
+#ifndef TOKENMANAGER_H_
+#define TOKENMANAGER_H_
+
+#include"Models/API.h"
+#include"Models/Token.h"
+#include"Models/User.h"
+
+namespace Managers
+{
+    class TokenManager
+    {
+    public:
+        TokenManager(const Models::User&);
+        TokenManager(const Models::User&, Models::API&);
+
+        Models::Token requestToken();
+    private:
+        Models::API api;
+        Models::User user;
+    };
+}
+
+#endif

include/Managers/UserManager.h

@@ -0,0 +1,26 @@
+#ifndef USERMANAGER_H_
+#define USERMANAGER_H_
+
+#include<iostream>
+
+#include"Models/IcarusAction.h"
+#include"Models/User.h"
+
+namespace Managers
+{
+    class UserManager
+    {
+    public:
+        UserManager(Models::User);
+        UserManager(const Models::IcarusAction);
+
+        Models::User retrieveUser() const;
+    private:
+        void parseUserFromActions();
+
+        Models::User user;
+        Models::IcarusAction icaAction;
+    };
+}
+
+#endif

include/Models/API.h

@@ -0,0 +1,16 @@
+#ifndef API_H_
+#define API_H_
+
+#include<string>
+
+namespace Models
+{
+    struct API
+    {
+        std::string url;
+        std::string endpoint;
+        std::string version;
+    };
+}
+
+#endif

include/Models/Flags.h

@@ -0,0 +1,15 @@
+#ifndef FLAGS_H_
+#define FLAGS_H_
+
+#include<string>
+
+namespace Models
+{
+    struct Flags
+    {
+        std::string flag;
+        std::string value;
+    };
+}
+
+#endif

include/Models/Song.h

@@ -0,0 +1,24 @@
+#ifndef SONG_H_
+#define SONG_H_
+
+#include<string>
+
+
+namespace Models
+{
+    struct Song
+    {
+        int id;
+        std::string title;
+        std::string artist;
+        std::string album;
+        std::string genre;
+        int year;
+        int duration;
+        int track;
+        std::string data;
+        std::string songPath;
+    };
+} 
+
+#endif

include/Models/Token.h

@@ -0,0 +1,16 @@
+#ifndef TOKEN_H_
+#define TOKEN_H_
+
+#include<string>
+
+namespace Models
+{
+    struct Token
+    {
+        std::string accessToken;
+        std::string tokenType;
+        int expiration;
+    };
+}
+
+#endif

include/Models/User.h

@@ -0,0 +1,15 @@
+#ifndef USER_H_
+#define USER_H_
+
+#include<string>
+
+namespace Models
+{
+    struct User
+    {
+        std::string username;
+        std::string password;
+    };
+}
+
+#endif

include/Parsers/APIParser.h

@@ -0,0 +1,23 @@
+#ifndef APIPARSER_H_
+#define APIPARSER_H_
+
+#include"Models/API.h"
+#include"Models/IcarusAction.h"
+
+namespace Parsers
+{
+    class APIParser
+    {
+    public:
+        APIParser(Models::IcarusAction);
+
+        Models::API retrieveAPI() const;
+    private:
+        void parseAPI();
+
+        Models::API api;
+        Models::IcarusAction icaAct;
+    };
+}
+
+#endif

include/Syncers/Delete.h

@@ -0,0 +1,23 @@
+#ifndef DELETE_H_
+#define DELETE_H_
+
+#include"Models/API.h"
+#include"Models/Song.h"
+#include"Models/Token.h"
+
+#include"SyncerBase.h"
+
+namespace Syncers
+{
+    class Delete : SyncerBase
+    {
+    public:
+        Delete(Models::API);
+
+        void deleteSong(const Models::Token, Models::Song);
+    private:
+        std::string retrieveUrl(Models::Song);
+    };
+}
+
+#endif

include/Syncers/Download.h

@@ -0,0 +1,31 @@
+#ifndef DOWNLOAD_H_
+#define DOWNLOAD_H_
+
+#include<iostream>
+#include<string>
+
+#include"Models/API.h"
+#include"Models/Song.h"
+#include"Models/Token.h"
+
+#include"SyncerBase.h"
+
+namespace Syncers
+{
+    class Download : SyncerBase
+    {
+    public:
+        Download();
+        Download(Models::API);
+        Download(std::string);
+
+        void downloadSong(const Models::Token token, Models::Song);
+    private:
+        std::string retrieveUrl(Models::Song);
+
+        std::string downloadFilePath;
+        void saveSong(Models::Song&);
+    };
+}
+
+#endif

include/Syncers/RetrieveRecords.h

@@ -0,0 +1,26 @@
+#ifndef RETRIEVERECORDS_H_
+#define RETRIEVERECORDS_H_
+
+#include "Managers/CommitManager.h"
+#include "Models/API.h"
+#include "Models/Token.h"
+#include "Syncers/SyncerBase.h"
+
+namespace Syncers
+{
+    class RetrieveRecords: public SyncerBase
+    {
+    public:
+        RetrieveRecords();
+        RetrieveRecords(Models::API, Models::Token);
+
+        void retrieve(Managers::CommitManager::RetrieveTypes);
+    private:
+        void fetchSongs();
+
+        Models::API api;
+        Models::Token token;
+    };
+}
+
+#endif

include/Syncers/SyncerBase.h

@@ -0,0 +1,27 @@
+#ifndef SYNCERBASE_H_
+#define SYNCERBASE_H_
+
+#include<string>
+
+#include"Models/API.h"
+
+namespace Syncers
+{
+    class SyncerBase
+    {
+    protected:
+        Models::API api;
+        const int OK = 200;
+        const int UNAUTHORIZED = 401;
+        const int NOTFOUND = 404;
+
+        enum class Result 
+        {
+            OK = 200,
+            UNAUTHORIZED = 401,
+            NOTFOUND = 404
+        };
+    };
+}
+
+#endif

include/Syncers/Upload.h

@@ -0,0 +1,48 @@
+#ifndef UPLOAD_H_
+#define UPLOAD_H_
+
+#include<filesystem>
+#include<string>
+#include<vector>
+
+#include<nlohmann/json.hpp>
+
+#include"Managers/FileManager.h"
+#include"Models/API.h"
+#include"Models/Song.h"
+#include"Models/Token.h"
+#include"Models/UploadForm.h"
+
+namespace fs = std::filesystem;
+
+
+namespace Syncers
+{
+    class Upload
+    {
+        public:
+            Upload();
+            Upload(Models::API);
+
+            Models::Song uploadSong(const Models::Token&, Models::Song&);
+            void uploadSongsFromDirectory(const Models::Token&, 
+                    const std::string&, const bool, 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(const nlohmann::json&);
+    };
+}
+
+#endif

include/UI/AboutWindow.h

@@ -0,0 +1,34 @@
+#ifndef ABOUTWINDOW_H_
+#define ABOUTWINDOW_H_
+
+#include<memory>
+
+#include<QDialog>
+#include<QDockWidget>
+#include<QLabel>
+#include<QPushButton>
+#include<QWidget>
+
+#include"UI/CommonWindow.h"
+
+namespace UI
+{
+    class AboutWindow: public QDialog, public CommonWindow
+    {
+        Q_OBJECT
+    public:
+        AboutWindow(QWidget* parent=0);
+        ~AboutWindow() = default;
+
+    private:
+        void connections();
+        void setupWindow();
+
+        std::unique_ptr<QLabel> appName;
+
+    private slots:
+        void closeWindow();
+    };
+}
+
+#endif

include/UI/CommonWindow.h

@@ -0,0 +1,27 @@
+#ifndef COMMONWINDOW_H_
+#define COMMONWINDOW_H_
+
+#include<memory>
+
+#include<QDialog>
+#include<QHBoxLayout>
+#include<QVBoxLayout>
+#include<QComboBox>
+#include<QPushButton>
+
+
+class CommonWindow
+{
+public:
+    CommonWindow() = default;
+    ~CommonWindow() = default;
+protected:
+    virtual void connections()=0;
+    std::unique_ptr<QComboBox> selectionBoxQt;
+    std::unique_ptr<QPushButton> actionButtonQt;
+    std::unique_ptr<QVBoxLayout> mainLayoutQt;
+    std::unique_ptr<QVBoxLayout> subLayoutOneQt;
+    std::unique_ptr<QVBoxLayout> subLayoutTwoQt;
+    int windowHeight, windowWidth;
+};
+#endif

include/UI/MainWindow.h

@@ -0,0 +1,82 @@
+#ifndef MAINWINDOW_H_
+#define MAINWINDOW_H_
+
+#include<iostream>
+#include<memory>
+
+#include<QAction>
+#include<QComboBox>
+#include<QDialog>
+#include<QDockWidget>
+#include<QLabel>
+#include<QMenu>
+#include<QMenuBar>
+#include<QMainWindow>
+#include<QPushButton>
+#include<QStackedWidget>
+#include<QTextEdit>
+#include<QWidget>
+
+#include"UI/CommonWindow.h"
+#include"UI/AboutWindow.h"
+
+namespace UI
+{
+    class MainWindow: public QMainWindow, public CommonWindow
+    {
+        Q_OBJECT
+    public:
+        MainWindow();
+        ~MainWindow() = default;
+    private:
+        void configureDownloadSection();
+        void configureUploadSection();
+        void configureWindowDimensions();
+        void configureWindowProperties();
+        void connections();
+        void createMenus();
+        void setupMainWidget();
+        void setupMainWindow();
+        void setupWindowLists();
+
+
+        std::unique_ptr<QStackedWidget> widgetStack;
+
+        std::unique_ptr<QVBoxLayout> stackLayout;
+
+            std::unique_ptr<QHBoxLayout> urlPortion;
+            std::unique_ptr<QHBoxLayout> songPathPortion;
+
+        std::unique_ptr<QWidget> mainWidgetQt;
+        std::unique_ptr<QWidget> uploadSongWidgetQt;
+
+        std::unique_ptr<QDockWidget> MainDockWidgetQt;
+
+        std::unique_ptr<QComboBox> windowComboBox;
+        
+        std::unique_ptr<QPushButton> uploadSongQt;
+
+        std::unique_ptr<QTextEdit> urlQt;
+        std::unique_ptr<QTextEdit> sourceFilePathQt;
+
+            std::unique_ptr<QLabel> urlLabel;
+            std::unique_ptr<QLabel> songPath;
+
+        std::unique_ptr<QMenu> fileMenuQt;
+        std::unique_ptr<QMenu> editMenuQt;
+        std::unique_ptr<QMenu> helpMenuQt;
+
+        std::unique_ptr<QAction> closeApplicationQt;
+        std::unique_ptr<QAction> aboutApplicationQt;
+
+        std::unique_ptr<AboutWindow> aboutWindow;
+    signals:
+    private slots:
+        void uploadSong();
+        void exitApplication();
+        void displaySoftwareInformation();
+        void setCurrentIndex(int);
+    };
+}
+
+#endif

include/Utilities/Conversions.h

@@ -0,0 +1,22 @@
+#ifndef CONVERSIONS_H_
+#define CONVERSIONS_H_
+
+#include<memory>
+#include<string>
+
+namespace Utilities
+{
+    class Conversions
+    {
+    public:
+        Conversions();
+
+        void initializeValues();
+
+        template <typename T>
+        void printValue(T);
+    private:
+    };
+}
+
+#endif

src/Main.cpp

@@ -12,21 +12,52 @@ using std::string;
 using Managers::ActionManager;
 using Managers::CommitManager;
 
-string songPath{};
+void printHelp()
-string newSongPath{};
+{
+    cout<<"icd [Action] [flag]\n\n";
+
+    cout<<"Actions\n";
+    cout<<"download\n";
+    cout<<"upload\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 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)
     {
-		cout<<"No actions provided"<<endl;
+        printHelp();
-		return 1;
+        return -1;
     }
 
-	ActionManager actMgr{argv};
+    ActionManager actMgr(argv, argc);
     auto chosenAction = actMgr.retrieveIcarusAction();
 
-	CommitManager commitMgr{chosenAction};
+    CommitManager commitMgr(chosenAction);
     commitMgr.commitAction();
 
     return 0;

src/Managers/ActionManager.cpp

@@ -1,12 +1,14 @@
-#include"ActionManager.h"
+#include"Managers/ActionManager.h"
+
 #include<algorithm>
 #include<iostream>
-#include<exception>
+#include<utility>
 #include<cstring>
 
 using std::cout;
 using std::endl;
 using std::string;
+using std::string_view;
 using std::vector;
 
 using Models::Flags;
@@ -15,14 +17,9 @@ using Models::IcarusAction;
 namespace Managers
 {
     #pragma
-	ActionManager::ActionManager(char **param)
+    ActionManager::ActionManager(char **param, int paramCount) : 
+        params(std::move(param)), paramCount(paramCount)
     {
-		this->params = param;
-
-		action = string{params[1]};
-		transform(action.begin(), action.end(),
-				action.begin(), ::tolower);
-
         initialize();
     }
     #pragma Constructors
@@ -31,23 +28,24 @@ namespace Managers
     #pragma
     IcarusAction ActionManager::retrieveIcarusAction() const
     {
-		auto icarusAction = IcarusAction{};
+        IcarusAction icarusAction;
         icarusAction.flags = flags;
         icarusAction.action = action;
 
         return icarusAction;
     }
-	vector<Flags> ActionManager::retrieveFlags() const
+
+
+    constexpr std::array<const char*, 12> ActionManager::supportedFlags() noexcept
     {
-		return flags;
+        constexpr std::array<const char*, 12> allFlags{"-u", "-p", "-t", "-h", "-s",
+                "-sd", "-sr", "-d", "-D", "-b", "-rt", "-nc"};
+
+        return allFlags;
     }
 
-	string ActionManager::retrieveAction() const
-	{
-		return action;
-	}
 
-	bool ActionManager::isNumber(string val)
+    bool ActionManager::isNumber(string_view val) noexcept
     {
         return !val.empty() && std::find_if(val.begin(), 
             val.end(), [](char c)
@@ -58,75 +56,51 @@ namespace Managers
 
     void ActionManager::initialize()
     {
-		initializeSupportedActions();
-		validateAction();
         validateFlags();
-	}
-	void ActionManager::initializeSupportedActions()
-	{
-		supportedActions = vector<string>{
-			"download", "delete",
-			"retrieve", "upload"
-		};
-	}
-	void ActionManager::initializeSupportedFlags()
-	{
-		supportedFlags = vector<string>{
-			"-u", "-p", "-t", "-h", "-s",
-			"-d", "-D", "-b"
-		};
-	}
-	void ActionManager::validateAction()
-	{
-		cout<<"Validating action"<<endl;
 
-		if (std::any_of(supportedActions.begin(), supportedActions.end(), 
+        action = std::move(string{params[1]});
-			[&](string val)
+        transform(action.begin(), action.end(),
-			{
+                action.begin(), ::tolower);
-				return !val.compare(action);
-			}))
-		{
-			cout<<"Action: "<<action<<" is valid"<<endl;
-		}
-		else
-		{
-			cout<<"Action is not valid"<<endl;
-			exit(1);
-		}
     }
     void ActionManager::validateFlags()
     {
         cout<<"Validating flags"<<endl;
 
         auto flagVals = parsedFlags();
-		initializeSupportedFlags();
 
         Flags flg{};
 
+        auto allSupportedFlags = supportedFlags();
+
         for (auto flag : flagVals)
         {
-			//if (flag.size() > 3 ||  flg.flag.compare("-D"))
+            if (flag.compare("-nc") == 0)
+            {
+                flg.flag = flag;
+                flags.push_back(flg);
+                continue;
+            }
             if (flag.size() > 3 || isNumber(flag))
             {
                 flg.value = flag;
-				cout<<"flag value "<<flg.value<<endl;
+                //cout<<"flag value "<<flg.value<<endl;
                 flags.push_back(flg);
                 flg = Flags{};
                 continue;
             }
 
-			if (std::any_of(supportedFlags.begin(), supportedFlags.end(), 
+            if (std::any_of(allSupportedFlags.begin(), allSupportedFlags.end(), 
-				[&](string val)
+                [&](const char *val)
                 {
-					return !val.compare(flag);
+                    return !flag.compare(val);
                 }))
             {
-				cout<<"flag "<<flag<<endl;
+                //cout<<"flag "<<flag<<endl;
                 flg.flag = flag;
             }
             else
             {
-				cout<<"Action is not valid"<<endl;
+                cout<<"Flag is not valid"<<endl;
                 exit(1);
             }
         }
@@ -134,27 +108,19 @@ namespace Managers
 
     vector<string> ActionManager::parsedFlags()
     {
-		auto parsed = vector<string>{};
+        auto parsed = vector<string>();
-		try
+        
+        for (auto i = 2; i < paramCount; ++i)
         {
-			for (auto i = 2; true; ++i)
+            const std::string flag(std::move(*(params + i)));
-			{
+            parsed.push_back(std::move(flag));
-				string val{*(params + i)};
-				cout<<"Parsed flag "<<val<<endl;
-				parsed.push_back(val);
-			}
-		}
-		catch (std::exception e)
-		{
-			auto msg = e.what();
-			cout<<"This happend: "<<msg<<endl<<endl;
         }
 
         return parsed;
     }
 
     #pragma
-	void ActionManager::printAction()
+    void ActionManager::printAction() noexcept
     {
         if (action.empty())
         {
@@ -165,22 +131,7 @@ namespace Managers
             cout<<"Action is "<<action<<endl;
         }
     }
-	void ActionManager::printFlags(vector<string> flagVals)
+    void ActionManager::printFlags() noexcept
-	{
-		if (flagVals.empty())
-		{
-			printf("Flags and values are empty\n");
-		}
-		else
-		{
-			printf("Printing flags and values..\n");
-			for (auto flgVal : flagVals)
-			{
-				cout<<flgVal<<endl;
-			}
-		}
-	}
-	void ActionManager::printFlags()
     {
         cout<<"\nPrinting flags..."<<endl;
         for (auto flag: flags)

src/Managers/ActionManager.h

@@ -1,43 +0,0 @@
-#ifndef ACTIONMANAGER_H_
-#define ACTIONMANAGER_H_
-
-#include<string>
-#include<vector>
-
-#include"Models/Flags.h"
-#include"Models/IcarusAction.h"
-
-namespace Managers
-{
-	class ActionManager
-	{
-	public:
-		ActionManager(char**);
-
-		Models::IcarusAction retrieveIcarusAction() const;
-		std::vector<Models::Flags> retrieveFlags() const;
-		std::string retrieveAction() const;
-	private:
-		bool isNumber(std::string);
-
-		void initialize();
-		void initializeSupportedActions();
-		void initializeSupportedFlags();
-		void validateAction();
-		void validateFlags();
-
-		std::vector<std::string> parsedFlags();
-
-		void printAction();
-		void printFlags(std::vector<std::string>);
-		void printFlags();
-
-		std::string action;
-		std::vector<std::string> supportedActions;
-		std::vector<std::string> supportedFlags;
-		std::vector<Models::Flags> flags;
-		char **params;
-	};
-}
-
-#endif

src/Managers/CommitManager.cpp

@@ -1,16 +1,18 @@
-#include"CommitManager.h"
+#include"Managers/CommitManager.h"
 
 #include<iostream>
 
 #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"TokenManager.h"
+#include"Managers/TokenManager.h"
-#include"UserManager.h"
+#include"Managers/UserManager.h"
 
 using std::cout;
 using std::endl;
@@ -21,64 +23,80 @@ 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 Managers
 {
 	#pragma
-	CommitManager::CommitManager(IcarusAction icaAct)
+	CommitManager::CommitManager(IcarusAction& icaAct) : icaAction(std::move(icaAct))
-	{
+	{ }
-		icaAction = icaAct;
+	#pragma Constructors
-		initializeMapActions();
-	}
-	#pragma Constructors;
 
 
 	#pragma
 	void CommitManager::commitAction()
 	{
 		auto action = icaAction.action;
-		cout<<"Commitning "<<action<<" action"<<endl;
+		cout<<"Commiting "<<action<<" action"<<endl;
-		switch (mapActions[action])
+		switch (mapActions()[action])
 		{
-			case deleteAct:
+            case ActionValues::deleteAct:
 				deleteSong();
 				break;
-			case downloadAct:
+            case ActionValues::downloadAct:
 				downloadSong();
 				break;
-			case retrieveAct: // No plans to imeplement
+            case ActionValues::retrieveAct:
+                retrieveObjects();
 				break;
-			case uploadAct:
+            case ActionValues::uploadAct:
 				uploadSong();
 				break;
+            default:
+                break;
 		}
 	}
 
-	void CommitManager::initializeMapActions()
+
+    enum class ActionValues;
+
+    std::map<std::string, CommitManager::ActionValues> 
+        CommitManager::mapActions() noexcept
     {
-		mapActions = map<string, ActionValues>{
+        const std::map<std::string, ActionValues> actions{
-			{"delete", deleteAct}, {"download", downloadAct},
+            {"delete", ActionValues::deleteAct},
-			{"retrieve", retrieveAct},
+            {"download", ActionValues::downloadAct},
-			{"upload", uploadAct}
+            {"retrieve", ActionValues::retrieveAct},
+            {"upload", ActionValues::uploadAct}
         };
-	}
-	void CommitManager::deleteSong()
-	{
-		cout<<"Deleting song..."<<endl;
 
+        return actions;
+    }
+
+
+    Token CommitManager::parseToken(API api)
+    {
+        cout<<"fetching token"<<endl;
 		UserManager usrMgr{icaAction};
 		auto user = usrMgr.retrieveUser();
 
+		TokenManager tk{user, api};
+        
+        return tk.requestToken();
+    }
+
+	void CommitManager::deleteSong()
+	{
 		APIParser apiPrs{icaAction};
 		auto api = apiPrs.retrieveAPI();
 
-		TokenManager tk{user, api};
+		auto token = parseToken(api);
-		auto token = tk.requestToken();
 
 		Song song{};
 
@@ -94,19 +112,17 @@ namespace Managers
 		}
 
 		Delete del{api};
+		cout<<"Deleting song..."<<endl;
 		del.deleteSong(token, song);
 	}
 	void CommitManager::downloadSong()
 	{
 		cout<<"Starting downloading process..."<<endl;
-		UserManager usrMgr{icaAction};
-		auto user = usrMgr.retrieveUser();
 
 		APIParser apiPrs{icaAction};
 		auto api = apiPrs.retrieveAPI();
 
-		TokenManager tk{user, api};
+		auto token = parseToken(api);
-		auto token = tk.requestToken();
 
 		Song song{};
 
@@ -126,35 +142,88 @@ namespace Managers
 		}
 
 		Download dnld{api};
+        cout<<"downloading song"<<endl;
 		dnld.downloadSong(token, song);
 	}
-	void CommitManager::uploadSong()
+    void CommitManager::retrieveObjects()
     {
-		cout<<"Uploading song..."<<endl;
+        cout<<"Starting retrieve process..."<<endl;
-		UserManager usrMgr{icaAction};
-		auto user = usrMgr.retrieveUser();
         
         APIParser apiPrs{icaAction};
         auto api = apiPrs.retrieveAPI();
 
-		TokenManager tk{user, api};
+        auto token = parseToken(api);
-		auto token = tk.requestToken();
+        RetrieveTypes retrieveType;
-
-		Song song{};
 
         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;
+        auto noConfirm = false;
+        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;
+            }
+            else if (flag.compare("-nc") == 0)
+            {
+                noConfirm = true;
+            }
 		}
 
 		Upload upld{api};
+        if (uploadSingleSong)
+        {
+		    cout<<"Uploading song..."<<endl;
 		    upld.uploadSong(token, song);
         }
+        else
+        {
+            cout<<"Uploading songs from " << songDirectory << endl;
+            upld.uploadSongsFromDirectory(token, songDirectory, noConfirm, recursiveDirectory);
+        }
+	}
 	#pragma Functions
 }

src/Managers/CommitManager.h

@@ -1,35 +0,0 @@
-#ifndef COMMITMANAGER_H_
-#define COMMITMANAGER_H_
-
-#include<map>
-#include<string>
-
-#include"Models/IcarusAction.h"
-
-namespace Managers
-{
-	class CommitManager
-	{
-	public:
-		CommitManager(Models::IcarusAction);
-
-		void commitAction();
-	private:
-		void initializeMapActions();
-		void deleteSong();
-		void downloadSong();
-		void uploadSong();
-
-		enum ActionValues
-		{
-			deleteAct,
-			downloadAct,
-			retrieveAct,
-			uploadAct
-		};
-		std::map<std::string, ActionValues> mapActions;
-		Models::IcarusAction icaAction;
-	};
-}
-
-#endif

src/Managers/FileManager.cpp

@@ -1,7 +1,7 @@
 #include<iostream>
 #include<fstream>
 
-#include"FileManager.h"
+#include"Managers/FileManager.h"
 
 using std::cout;
 using std::endl;

src/Managers/FileManager.h

@@ -1,29 +0,0 @@
-#ifndef FILEMANAGER_H_
-#define FILEMANAGER_H_
-
-#include<string>
-
-namespace Managers
-{
-	class FileManager
-	{
-	public:
-		FileManager();
-		FileManager(std::string);
-
-		void saveFile(std::string);
-		void modifyFilePath(std::string);
-
-		char* retrieveFileBuffer() const;
-		int retrieveFileBufferLength() const;
-	private:
-		void readFile();
-
-		std::string filePath;
-		char* fileBuffer;
-		bool fileRead;
-		int fileBufferLength;
-	};
-}
-
-#endif

src/Managers/TokenManager.cpp

@@ -1,4 +1,4 @@
-#include"TokenManager.h"
+#include"Managers/TokenManager.h"
 
 #include<iostream>
 
@@ -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;
@@ -40,7 +40,6 @@ namespace Managers
 
         usrObj["username"] = user.username;
         usrObj["password"] = user.password;
-		cout<<user.username<<" "<<user.password<<endl;
 
         cout<<"Sending request for token"<<endl;
         auto url = api.url + api.endpoint;
@@ -49,12 +48,11 @@ namespace Managers
                 cpr::Body{usrObj.dump()},
            cpr::Header{{"Content-Type", "application/json"}});
 
-		cout<<r.text<<endl;
         json res = json::parse(r.text);
         token.accessToken = res["token"];
         token.tokenType = res["token_type"];
 
-		//cout<<"status code "<<r.status_code<<endl;
+        cout<<"status code "<<r.status_code<<endl;
 
         return token;
     }

src/Managers/TokenManager.h

@@ -1,23 +0,0 @@
-#ifndef TOKENMANAGER_H_
-#define TOKENMANAGER_H_
-
-#include"Models/API.h"
-#include"Models/Token.h"
-#include"Models/User.h"
-
-namespace Managers
-{
-	class TokenManager
-	{
-	public:
-		TokenManager(const Models::User);
-		TokenManager(const Models::User, Models::API);
-
-		Models::Token requestToken();
-	private:
-		Models::API api;
-		Models::User user;
-	};
-}
-
-#endif

src/Managers/UserManager.cpp

@@ -1,4 +1,4 @@
-#include"UserManager.h"
+#include"Managers/UserManager.h"
 
 #include<iostream>
 #include<string>

src/Managers/UserManager.h

@@ -1,26 +0,0 @@
-#ifndef USERMANAGER_H_
-#define USERMANAGER_H_
-
-#include<iostream>
-
-#include"Models/IcarusAction.h"
-#include"Models/User.h"
-
-namespace Managers
-{
-	class UserManager
-	{
-	public:
-		UserManager(Models::User);
-		UserManager(const Models::IcarusAction);
-
-		Models::User retrieveUser() const;
-	private:
-		void parseUserFromActions();
-
-		Models::User user;
-		Models::IcarusAction icaAction;
-	};
-}
-
-#endif

src/Models/API.h

@@ -1,16 +0,0 @@
-#ifndef API_H_
-#define API_H_
-
-#include<string>
-
-namespace Models
-{
-	struct API
-	{
-		std::string url;
-		std::string endpoint;
-		std::string version;
-	};
-}
-
-#endif

src/Models/Flags.h

@@ -1,15 +0,0 @@
-#ifndef FLAGS_H_
-#define FLAGS_H_
-
-#include<string>
-
-namespace Models
-{
-	struct Flags
-	{
-		std::string flag;
-		std::string value;
-	};
-}
-
-#endif

src/Models/Song.h

@@ -1,24 +0,0 @@
-#ifndef SONG_H_
-#define SONG_H_
-
-#include<string>
-
-
-namespace Models
-{
-	struct Song
-	{
-		int id;
-		std::string title;
-		std::string artist;
-		std::string album;
-		std::string genre;
-		int year;
-		int duration;
-		char *songData;
-		std::string  data;
-		std::string songPath;
-	};
-} 
-
-#endif

src/Models/Token.h

@@ -1,17 +0,0 @@
-#ifndef TOKEN_H_
-#define TOKEN_H_
-
-#include<string>
-
-namespace Models
-{
-	struct Token
-	{
-		std::string accessToken;
-		std::string tokenType;
-		int expiration;
-
-	};
-}
-
-#endif

src/Models/User.h

@@ -1,15 +0,0 @@
-#ifndef USER_H_
-#define USER_H_
-
-#include<string>
-
-namespace Models
-{
-	struct User
-	{
-		std::string username;
-		std::string password;
-	};
-}
-
-#endif

src/Parsers/APIParser.cpp

@@ -1,4 +1,4 @@
-#include"APIParser.h"
+#include"Parsers/APIParser.h"
 
 #include<iostream>
 
@@ -11,9 +11,8 @@ using Models::IcarusAction;
 namespace Parsers
 {
     #pragma
-	APIParser::APIParser(IcarusAction icaAct)
+    APIParser::APIParser(IcarusAction icaAct) : icaAct(icaAct)
     {
-		this->icaAct = icaAct;
         api = API{};
         parseAPI();
     }
@@ -31,23 +30,17 @@ namespace Parsers
         auto flags = icaAct.flags;
         cout<<"Parsing api"<<endl;
 
-		//for (auto flag :  flags)
         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;
+                api.url = (value[value.size()-1] == '/') ? value : value + "/";
-			}
+                break;
-			if (value.compare("-h") == 0)
-			{
-				api.url = flags[i + 1].value;
             }
 
-			cout<<"url is "<<api.url<<endl;
         }
 
         // TODO: For now I will hard code

src/Parsers/APIParser.h

@@ -1,23 +0,0 @@
-#ifndef APIPARSER_H_
-#define APIPARSER_H_
-
-#include"Models/API.h"
-#include"Models/IcarusAction.h"
-
-namespace Parsers
-{
-	class APIParser
-	{
-	public:
-		APIParser(Models::IcarusAction);
-
-		Models::API retrieveAPI() const;
-	private:
-		void parseAPI();
-
-		Models::API api;
-		Models::IcarusAction icaAct;
-	};
-}
-
-#endif

src/Syncers/Delete.cpp

@@ -1,4 +1,4 @@
-#include"Delete.h"
+#include"Syncers/Delete.h"
 
 #include<exception>
 #include<iostream>

src/Syncers/Delete.h

@@ -1,23 +0,0 @@
-#ifndef DELETE_H_
-#define DELETE_H_
-
-#include"Models/API.h"
-#include"Models/Song.h"
-#include"Models/Token.h"
-
-#include"SyncerBase.h"
-
-namespace Syncers
-{
-	class Delete : SyncerBase
-	{
-	public:
-		Delete(Models::API);
-
-		void deleteSong(const Models::Token, Models::Song);
-	private:
-		std::string retrieveUrl(Models::Song);
-	};
-}
-
-#endif

src/Syncers/Download.cpp

@@ -1,4 +1,4 @@
-#include"Download.h"
+#include"Syncers/Download.h"
 
 #include<exception>
 #include<iostream>
@@ -33,26 +33,6 @@ namespace Syncers
 
 
     #pragma
-	void Download::downloadSong(const int id)
-	{
-		string urlRoot = "http://192.168.1.5";
-		int port = 9349;
-		string endpoint = "api/song/data/" + std::to_string(id);
-		string url = urlRoot + ":" + std::to_string(port) + "/" +
-					 endpoint;
-		auto r = cpr::Get(cpr::Url{url});
-		const char* newBuff = r.text.c_str();
-		int bufferLength = r.text.size();
-
-		ofstream saveSong{downloadFilePath, ofstream::binary};
-		saveSong.write(newBuff, bufferLength);
-
-		cout<<"HTTP status code: "<<r.status_code<<endl;
-		cout<<"Header info: "<<r.header["content-type"]<<endl;
-		cout<<"Header info: "<<endl;
-		cout<<r.header["content-type"]<<endl;
-		cout<<r.header["content-disposition"]<<endl;
-	}
     void Download::downloadSong(const Token token, Song song)
     {
         try
@@ -62,15 +42,17 @@ 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}});
+                    cpr::Header{{"Content-type", "audio/mpeg"},
+                                {"Authorization", auth}});
+                
 
             int statusCode = r.status_code;
 
-			if (statusCode == OK)
+            if (statusCode == OK) {
-			{
                 song.data = r.text;
-				saveSong(&song);
+                saveSong(song);
             }
 
 
@@ -94,14 +76,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/Download.h

@@ -1,32 +0,0 @@
-#ifndef DOWNLOAD_H_
-#define DOWNLOAD_H_
-
-#include<iostream>
-#include<string>
-
-#include"Models/API.h"
-#include"Models/Song.h"
-#include"Models/Token.h"
-
-#include"SyncerBase.h"
-
-namespace Syncers
-{
-	class Download : SyncerBase
-	{
-	public:
-		Download();
-		Download(Models::API);
-		Download(std::string);
-
-		void downloadSong(int);
-		void downloadSong(const Models::Token token, Models::Song);
-	private:
-		std::string retrieveUrl(Models::Song);
-
-		std::string downloadFilePath;
-		void saveSong(Models::Song*);
-	};
-}
-
-#endif

src/Syncers/RetrieveRecords.cpp

@@ -0,0 +1,62 @@
+#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
+{
+
+    RetrieveRecords::RetrieveRecords() { }
+    RetrieveRecords::RetrieveRecords(API api, Token token) 
+        : token(token), api(api) { }
+
+    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();
+    }
+}

src/Syncers/SyncerBase.h

@@ -1,20 +0,0 @@
-#ifndef SYNCERBASE_H_
-#define SYNCERBASE_H_
-
-#include<string>
-
-#include"Models/API.h"
-
-namespace Syncers
-{
-	class SyncerBase
-	{
-	protected:
-		Models::API api;
-		const int OK = 200;
-		const int UNAUTHORIZED = 401;
-		const int NOTFOUND = 404;
-	};
-}
-
-#endif

src/Syncers/Upload.cpp

@@ -1,13 +1,14 @@
 #include<iostream>
+#include<filesystem>
 #include<exception>
-#include<string>
 
 #include<cpr/cpr.h>
 #include<nlohmann/json.hpp>
 
-#include"Upload.h"
+#include"Syncers/Upload.h"
 
 using std::cout;
+using std::cin;
 using std::endl;
 using std::exception;
 using std::string;
@@ -24,42 +25,13 @@ using namespace cpr;
 namespace Syncers
 {
     Upload::Upload() { }
-	Upload::Upload(string filePath)
+    Upload::Upload(API api) : api(api)
     {
-		this->songPath = filePath;
-		this->fMgr = FileManager(songPath);
-	}
-	Upload::Upload(API api)
-	{
-		this->api = api;
         this->api.endpoint = "song/data";
     }
-	Upload::Upload(UploadForm formData)
-	{
-		this->url = formData.url;
-		this->songPath = formData.filePath;
-	}
 
 
-	void Upload::uploadSong()
+    Song Upload::uploadSong(const Models::Token& token, Song& song)
-	{
-		try
-		{
-			auto r = cpr::Post(cpr::Url{url},
-                   		cpr::Multipart{{"key", "small value"},
-                                {"file", cpr::File{songPath}}});
-			cout << r.status_code<< std::endl;
-
-			cout<<"Success"<<endl;
-		}
-		catch(std::exception& e)
-		{
-			cout<<e.what()<<endl;
-		}
-		cout<<"Finished"<<endl;
-
-	}
-	void Upload::uploadSong(const Models::Token token, Song song)
     {
         try
         {
@@ -74,45 +46,131 @@ namespace Syncers
                 cpr::Header{{"authorization", auth}}
                 );
 
-			cout << r.status_code<< std::endl;
+            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)
+        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, 
+        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;
+
+                if (answer == 'y' || answer == 'Y') 
+                {
+                    confirmUpload = true;
+                    break;
+                } 
+                else if (answer == 'n' || answer == 'N') 
+                {
+                    confirmUpload = false;
+                    break;
+                }
+            }
+
+            if (!confirmUpload) 
+            {
+                cout << "exiting...\n";
+                std::exit(-1);
+            }
+
+            cout << "uploading songs\n";
+            for (auto& song: songs)
+            {
+                song = uploadSong(token, song);
+            }
+        }
+        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()
     {
-		string url = api.url + "api/" + api.version + "/" +
+        const string url{api.url + "api/" + api.version + "/" +
-			api.endpoint;
+            api.endpoint};
             
         return url;
     }
-	#pragma
-	void Upload::configureSongDemo()
-	{
-		int id = 0;
-		string title = "What of it?";
-		string artist = "Kuoth";
-		string album = "I";
-		string genre = "Untitled";
-		int year = 2019;
-		int duration = 260;
 
-		this->song = Models::Song{};
+
-		this->song.id = id;
+    Song Upload::retrieveSongPath(fs::directory_entry& dirEntry)
-		this->song.title = title;
+    {
-		this->song.artist = artist;
+        constexpr auto mp3Ext = ".mp3";
-		this->song.album = album;
+        Song song;
-		this->song.genre = genre;
+        if (fs::is_regular_file(dirEntry.path()))
-		this->song.year = year;
+        {
-		this->song.duration = duration;
+            const auto ext = dirEntry.path().extension().string();
-		this->song.songData = fMgr.retrieveFileBuffer();
+            if (ext.compare(mp3Ext) == 0)
-		cout<<*song.songData<<endl;
+            {
+                cout << "found mp3 file" << endl;
+                song.songPath = dirEntry.path().string();
             }
+        }
+
+        return song;
+    }
+
+
+    #pragma
     void Upload::printSongDetails()
     {
         cout<<"Song details: "<<endl;
@@ -124,7 +182,22 @@ namespace Syncers
         cout<<"Year: "<<song.year<<endl;
         cout<<"Duration: "<<song.duration<<endl;
     }
-	void Upload::printJsonData(json obj)
+    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;
@@ -138,21 +211,6 @@ namespace Syncers
 
         cout<<endl<<endl;;
     }
-
-	json Upload::serializeObject()
-	{
-		json jObj{};
-		jObj["id"] = song.id;
-		jObj["title"] = song.title;
-		jObj["artist"] = song.artist;
-		jObj["album"] = song.album;
-		jObj["genre"] = song.genre;
-		jObj["year"] = song.year;
-		jObj["duration"] = song.duration;
-		jObj["song_data"] = *song.songData;
-
-		return jObj;
-	}
     #pragma Testing
     #pragma Functions
 }

src/Syncers/Upload.h

@@ -1,47 +0,0 @@
-#ifndef UPLOAD_H_
-#define UPLOAD_H_
-
-#include<string>
-
-#include<nlohmann/json.hpp>
-
-#include"Managers/FileManager.h"
-#include"Models/API.h"
-#include"Models/Song.h"
-#include"Models/Token.h"
-#include"Models/UploadForm.h"
-
-
-namespace Syncers
-{
-	class Upload
-	{
-		public:
-			Upload();
-			Upload(std::string);
-			Upload(Models::API);
-			Upload(Models::UploadForm);
-
-			void uploadSong();
-			void uploadSong(const Models::Token, Models::Song);
-		private:
-			Managers::FileManager fMgr;
-			Models::API api;
-			Models::Song song;
-			std::string apiUrl{""}; // Not being used
-			std::string apiEndPoint{""}; // Not being used
-			std::string songPath; // Not being used
-			std::string url; // Not being used
-			int port{9349}; // Not being used
-
-			std::string retrieveUrl();
-
-			void configureSongDemo();
-			void printSongDetails();
-			void printJsonData(nlohmann::json);
-
-			nlohmann::json serializeObject(); // Not being used
-	};
-}
-
-#endif

src/UI/AboutWindow.cpp

@@ -1,4 +1,4 @@
-#include"AboutWindow.h"
+#include"UI/AboutWindow.h"
 
 using std::unique_ptr;
 

src/UI/AboutWindow.h

@@ -1,34 +0,0 @@
-#ifndef ABOUTWINDOW_H_
-#define ABOUTWINDOW_H_
-
-#include<memory>
-
-#include<QDialog>
-#include<QDockWidget>
-#include<QLabel>
-#include<QPushButton>
-#include<QWidget>
-
-#include"UI/CommonWindow.h"
-
-namespace UI
-{
-	class AboutWindow: public QDialog, public CommonWindow
-	{
-		Q_OBJECT
-	public:
-		AboutWindow(QWidget* parent=0);
-		~AboutWindow() = default;
-
-	private:
-		void connections();
-		void setupWindow();
-
-		std::unique_ptr<QLabel> appName;
-
-	private slots:
-		void closeWindow();
-	};
-}
-
-#endif

src/UI/CommonWindow.h

@@ -1,27 +0,0 @@
-#ifndef COMMONWINDOW_H_
-#define COMMONWINDOW_H_
-
-#include<memory>
-
-#include<QDialog>
-#include<QHBoxLayout>
-#include<QVBoxLayout>
-#include<QComboBox>
-#include<QPushButton>
-
-
-class CommonWindow
-{
-public:
-	CommonWindow() = default;
-	~CommonWindow() = default;
-protected:
-	virtual void connections()=0;
-	std::unique_ptr<QComboBox> selectionBoxQt;
-	std::unique_ptr<QPushButton> actionButtonQt;
-	std::unique_ptr<QVBoxLayout> mainLayoutQt;
-	std::unique_ptr<QVBoxLayout> subLayoutOneQt;
-	std::unique_ptr<QVBoxLayout> subLayoutTwoQt;
-	int windowHeight, windowWidth;
-};
-#endif

src/UI/MainWindow.cpp

@@ -1,4 +1,4 @@
-#include"MainWindow.h"
+#include"UI/MainWindow.h"
 
 #include<iostream>
 #include<string>

src/UI/MainWindow.h

@@ -1,82 +0,0 @@
-#ifndef MAINWINDOW_H_
-#define MAINWINDOW_H_
-
-#include<iostream>
-#include<memory>
-
-#include<QAction>
-#include<QComboBox>
-#include<QDialog>
-#include<QDockWidget>
-#include<QLabel>
-#include<QMenu>
-#include<QMenuBar>
-#include<QMainWindow>
-#include<QPushButton>
-#include<QStackedWidget>
-#include<QTextEdit>
-#include<QWidget>
-
-#include"UI/CommonWindow.h"
-#include"UI/AboutWindow.h"
-
-namespace UI
-{
-	class MainWindow: public QMainWindow, public CommonWindow
-	{
-		Q_OBJECT
-	public:
-		MainWindow();
-		~MainWindow() = default;
-	private:
-		void configureDownloadSection();
-		void configureUploadSection();
-		void configureWindowDimensions();
-		void configureWindowProperties();
-		void connections();
-		void createMenus();
-		void setupMainWidget();
-		void setupMainWindow();
-		void setupWindowLists();
-
-
-		std::unique_ptr<QStackedWidget> widgetStack;
-
-		std::unique_ptr<QVBoxLayout> stackLayout;
-
-        	std::unique_ptr<QHBoxLayout> urlPortion;
-        	std::unique_ptr<QHBoxLayout> songPathPortion;
-
-		std::unique_ptr<QWidget> mainWidgetQt;
-		std::unique_ptr<QWidget> uploadSongWidgetQt;
-
-		std::unique_ptr<QDockWidget> MainDockWidgetQt;
-
-		std::unique_ptr<QComboBox> windowComboBox;
-		
-		std::unique_ptr<QPushButton> uploadSongQt;
-
-		std::unique_ptr<QTextEdit> urlQt;
-		std::unique_ptr<QTextEdit> sourceFilePathQt;
-
-        	std::unique_ptr<QLabel> urlLabel;
-        	std::unique_ptr<QLabel> songPath;
-
-		std::unique_ptr<QMenu> fileMenuQt;
-		std::unique_ptr<QMenu> editMenuQt;
-		std::unique_ptr<QMenu> helpMenuQt;
-
-		std::unique_ptr<QAction> closeApplicationQt;
-		std::unique_ptr<QAction> aboutApplicationQt;
-
-		std::unique_ptr<AboutWindow> aboutWindow;
-	signals:
-	private slots:
-		void uploadSong();
-		void exitApplication();
-		void displaySoftwareInformation();
-		void setCurrentIndex(int);
-	};
-}
-
-#endif

src/Utilities/Conversions.cpp

@@ -1,4 +1,4 @@
-#include"Conversions.h"
+#include"Utilities/Conversions.h"
 
 #include<iostream>
 

src/Utilities/Conversions.h

@@ -1,22 +0,0 @@
-#ifndef CONVERSIONS_H_
-#define CONVERSIONS_H_
-
-#include<memory>
-#include<string>
-
-namespace Utilities
-{
-	class Conversions
-	{
-	public:
-		Conversions();
-
-		void initializeValues();
-
-		template <typename T>
-		void printValue(T);
-	private:
-	};
-}
-
-#endif