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,43 +35,45 @@ 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()
 
 
 set(SOURCES
-	src/Main.cpp
+    src/Main.cpp
-	src/Managers/ActionManager.cpp
+    src/Managers/ActionManager.cpp
-	src/Managers/CommitManager.cpp
+    src/Managers/CommitManager.cpp
-	src/Managers/FileManager.cpp
+    src/Managers/FileManager.cpp
-	src/Managers/TokenManager.cpp
+    src/Managers/TokenManager.cpp
-	src/Managers/UserManager.cpp
+    src/Managers/UserManager.cpp
-	src/Parsers/APIParser.cpp
+    src/Parsers/APIParser.cpp
-	src/Syncers/Delete.cpp
+    src/Syncers/Delete.cpp
-	src/Syncers/Download.cpp
+    src/Syncers/Download.cpp
-	src/Syncers/Upload.cpp
+    src/Syncers/RetrieveRecords.cpp
-	src/Utilities/Conversions.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/IcarusAction.h

@@ -8,11 +8,11 @@
 
 namespace Models
 {
-	struct IcarusAction
+    struct IcarusAction
-	{
+    {
-		std::string action;
+        std::string action;
-		std::vector<Flags> flags;
+        std::vector<Flags> flags;
-	};
+    };
 }
 
 #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/UploadForm.h

@@ -6,11 +6,11 @@
 
 namespace Models
 {
-	struct UploadForm
+    struct UploadForm
-	{
+    {
-		std::string url;
+        std::string url;
-		std::string filePath;
+        std::string filePath;
-	};
+    };
 } 
 
 #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,22 +12,53 @@ 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)
+    if (argc < 2)
-	{
+    {
-		cout<<"No actions provided"<<endl;
+        printHelp();
-		return 1;
+        return -1;
-	}
+    }
 
-	ActionManager actMgr{argv};
+    ActionManager actMgr(argv, argc);
-	auto chosenAction = actMgr.retrieveIcarusAction();
+    auto chosenAction = actMgr.retrieveIcarusAction();
 
-	CommitManager commitMgr{chosenAction};
+    CommitManager commitMgr(chosenAction);
-	commitMgr.commitAction();
+    commitMgr.commitAction();
 
-	return 0;
+    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;
@@ -14,181 +16,130 @@ using Models::IcarusAction;
 
 namespace Managers
 {
-	#pragma
+    #pragma
-	ActionManager::ActionManager(char **param)
+    ActionManager::ActionManager(char **param, int paramCount) : 
-	{
+        params(std::move(param)), paramCount(paramCount)
-		this->params = param;
+    {
-
+        initialize();
-		action = string{params[1]};
+    }
-		transform(action.begin(), action.end(),
+    #pragma Constructors
-				action.begin(), ::tolower);
-
-		initialize();
-	}
-	#pragma Constructors
 
 
-	#pragma
+    #pragma
-	IcarusAction ActionManager::retrieveIcarusAction() const
+    IcarusAction ActionManager::retrieveIcarusAction() const
-	{
+    {
-		auto icarusAction = IcarusAction{};
+        IcarusAction icarusAction;
-		icarusAction.flags = flags;
+        icarusAction.flags = flags;
-		icarusAction.action = action;
+        icarusAction.action = action;
 
-		return icarusAction;
+        return icarusAction;
-	}
+    }
-	vector<Flags> ActionManager::retrieveFlags() const
-	{
-		return flags;
-	}
 
-	string ActionManager::retrieveAction() const
-	{
-		return action;
-	}
 
-	bool ActionManager::isNumber(string val)
+    constexpr std::array<const char*, 12> ActionManager::supportedFlags() noexcept
-	{
+    {
-		return !val.empty() && std::find_if(val.begin(), 
+        constexpr std::array<const char*, 12> allFlags{"-u", "-p", "-t", "-h", "-s",
-			val.end(), [](char c)
+                "-sd", "-sr", "-d", "-D", "-b", "-rt", "-nc"};
-			{
-				return !std::isdigit(c);
-		       	}) == val.end();
-	}
 
-	void ActionManager::initialize()
+        return allFlags;
-	{
+    }
-		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(), 
-			[&](string val)
-			{
-				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();
+    bool ActionManager::isNumber(string_view val) noexcept
-		initializeSupportedFlags();
+    {
+        return !val.empty() && std::find_if(val.begin(), 
+            val.end(), [](char c)
+            {
+                return !std::isdigit(c);
+                }) == val.end();
+    }
 
-		Flags flg{};
+    void ActionManager::initialize()
+    {
+        validateFlags();
 
-		for (auto flag : flagVals)
+        action = std::move(string{params[1]});
-		{
+        transform(action.begin(), action.end(),
-			//if (flag.size() > 3 ||  flg.flag.compare("-D"))
+                action.begin(), ::tolower);
-			if (flag.size() > 3 || isNumber(flag))
+    }
-			{
+    void ActionManager::validateFlags()
-				flg.value = flag;
+    {
-				cout<<"flag value "<<flg.value<<endl;
+        cout<<"Validating flags"<<endl;
-				flags.push_back(flg);
-				flg = Flags{};
-				continue;
-			}
 
-			if (std::any_of(supportedFlags.begin(), supportedFlags.end(), 
+        auto flagVals = parsedFlags();
-				[&](string val)
-				{
-					return !val.compare(flag);
-				}))
-			{
-				cout<<"flag "<<flag<<endl;
-				flg.flag = flag;
-			}
-			else
-			{
-				cout<<"Action is not valid"<<endl;
-				exit(1);
-			}
-		}
-	}
 
-	vector<string> ActionManager::parsedFlags()
+        Flags flg{};
-	{
-		auto parsed = vector<string>{};
-		try
-		{
-			for (auto i = 2; true; ++i)
-			{
-				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;
+        auto allSupportedFlags = supportedFlags();
-	}
 
-	#pragma
+        for (auto flag : flagVals)
-	void ActionManager::printAction()
+        {
-	{
+            if (flag.compare("-nc") == 0)
-		if (action.empty())
+            {
-		{
+                flg.flag = flag;
-			printf("Action is empty\n");
+                flags.push_back(flg);
-		}
+                continue;
-		else
+            }
-		{
+            if (flag.size() > 3 || isNumber(flag))
-			cout<<"Action is "<<action<<endl;
+            {
-		}
+                flg.value = flag;
-	}
+                //cout<<"flag value "<<flg.value<<endl;
-	void ActionManager::printFlags(vector<string> flagVals)
+                flags.push_back(flg);
-	{
+                flg = Flags{};
-		if (flagVals.empty())
+                continue;
-		{
+            }
-			printf("Flags and values are empty\n");
+
-		}
+            if (std::any_of(allSupportedFlags.begin(), allSupportedFlags.end(), 
-		else
+                [&](const char *val)
-		{
+                {
-			printf("Printing flags and values..\n");
+                    return !flag.compare(val);
-			for (auto flgVal : flagVals)
+                }))
-			{
+            {
-				cout<<flgVal<<endl;
+                //cout<<"flag "<<flag<<endl;
-			}
+                flg.flag = flag;
-		}
+            }
-	}
+            else
-	void ActionManager::printFlags()
+            {
-	{
+                cout<<"Flag is not valid"<<endl;
-		cout<<"\nPrinting flags..."<<endl;
+                exit(1);
-		for (auto flag: flags)
+            }
-		{
+        }
-			cout<<"flag "<<flag.flag<<endl;
+    }
-			cout<<"value "<<flag.value<<endl;
+
-		}
+    vector<string> ActionManager::parsedFlags()
-	}
+    {
-	#pragma Testing
+        auto parsed = vector<string>();
-	#pragma Functions
+        
+        for (auto i = 2; i < paramCount; ++i)
+        {
+            const std::string flag(std::move(*(params + i)));
+            parsed.push_back(std::move(flag));
+        }
+
+        return parsed;
+    }
+
+    #pragma
+    void ActionManager::printAction() noexcept
+    {
+        if (action.empty())
+        {
+            printf("Action is empty\n");
+        }
+        else
+        {
+            cout<<"Action is "<<action<<endl;
+        }
+    }
+    void ActionManager::printFlags() noexcept
+    {
+        cout<<"\nPrinting flags..."<<endl;
+        for (auto flag: flags)
+        {
+            cout<<"flag "<<flag.flag<<endl;
+            cout<<"value "<<flag.value<<endl;
+        }
+    }
+    #pragma Testing
+    #pragma Functions
 }

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()
-	{
-		mapActions = map<string, ActionValues>{
-			{"delete", deleteAct}, {"download", downloadAct},
-			{"retrieve", retrieveAct},
-			{"upload", uploadAct}
-		};
-	}
-	void CommitManager::deleteSong()
-	{
-		cout<<"Deleting song..."<<endl;
 
+    enum class ActionValues;
+
+    std::map<std::string, CommitManager::ActionValues> 
+        CommitManager::mapActions() noexcept
+    {
+        const std::map<std::string, ActionValues> actions{
+            {"delete", ActionValues::deleteAct},
+            {"download", ActionValues::downloadAct},
+            {"retrieve", ActionValues::retrieveAct},
+            {"upload", ActionValues::uploadAct}
+        };
+
+        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,23 +142,52 @@ namespace Managers
 		}
 
 		Download dnld{api};
+        cout<<"downloading song"<<endl;
 		dnld.downloadSong(token, song);
 	}
+    void CommitManager::retrieveObjects()
+    {
+        cout<<"Starting retrieve process..."<<endl;
+        
+        APIParser apiPrs{icaAction};
+        auto api = apiPrs.retrieveAPI();
+
+        auto token = parseToken(api);
+        RetrieveTypes retrieveType;
+
+        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()
 	{
-		cout<<"Uploading song..."<<endl;
+        auto uploadSingleSong = true;
-		UserManager usrMgr{icaAction};
+        auto recursiveDirectory = false;
-		auto user = usrMgr.retrieveUser();
+        auto noConfirm = false;
-
+        string songDirectory;
 		APIParser apiPrs{icaAction};
 		auto api = apiPrs.retrieveAPI();
 
-		TokenManager tk{user, api};
+		auto token = parseToken(api);
-		auto token = tk.requestToken();
 
-		Song song{};
+		Song song;
 
-		for (auto arg : icaAction.flags)
+		for (auto& arg : icaAction.flags)
 		{
 			auto flag = arg.flag;
 			auto value = arg.value;
@@ -151,10 +196,34 @@ 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;
+            }
+            else if (flag.compare("-nc") == 0)
+            {
+                noConfirm = true;
+            }
 		}
 
 		Upload upld{api};
-		upld.uploadSong(token, song);
+        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;
@@ -11,56 +11,56 @@ using std::string;
 
 namespace Managers
 {
-	FileManager::FileManager() {}
+    FileManager::FileManager() {}
-	FileManager::FileManager(string filePath)
+    FileManager::FileManager(string filePath)
-	{
+    {
-		this->filePath = filePath;
+        this->filePath = filePath;
-		readFile();
+        readFile();
-	}	
+    }   
 
 
-	void FileManager::saveFile(string newFilePath)
+    void FileManager::saveFile(string newFilePath)
-	{
+    {
-		if (!fileRead)
+        if (!fileRead)
-			readFile();
+            readFile();
 
-		ofstream of{newFilePath, ofstream::binary};
+        ofstream of{newFilePath, ofstream::binary};
-		of.write(fileBuffer, fileBufferLength);
+        of.write(fileBuffer, fileBufferLength);
-		of.close();
+        of.close();
-	}
+    }
 
-	void FileManager::readFile()
+    void FileManager::readFile()
-	{
+    {
-		ifstream is{filePath, ifstream::binary};
+        ifstream is{filePath, ifstream::binary};
-		if (is)
+        if (is)
-		{
+        {
-			is.seekg (0, is.end);
+            is.seekg (0, is.end);
-    		fileBufferLength = is.tellg();
+            fileBufferLength = is.tellg();
-    		is.seekg (0, is.beg);
+            is.seekg (0, is.beg);
 
-    		fileBuffer = new char [fileBufferLength];
+            fileBuffer = new char [fileBufferLength];
 
-    		cout<< "Reading "<<fileBufferLength<<" characters... "<<endl;;
+            cout<< "Reading "<<fileBufferLength<<" characters... "<<endl;;
-    		is.read (fileBuffer,fileBufferLength);
+            is.read (fileBuffer,fileBufferLength);
 
-    		if (is)
+            if (is)
-      			cout<<"all characters read successfully.";
+                cout<<"all characters read successfully.";
-    		else
+            else
-      			cout<<"error: only "<<is.gcount()<<" could be read";
+                cout<<"error: only "<<is.gcount()<<" could be read";
-			cout<<endl;
+            cout<<endl;
-    		is.close();
+            is.close();
-			fileRead = true;
+            fileRead = true;
-		}
+        }
-	}
+    }
-	void FileManager::modifyFilePath(string filePath)
+    void FileManager::modifyFilePath(string filePath)
-	{
+    {
-		this->filePath = filePath;
+        this->filePath = filePath;
-	}
+    }
 
-	char* FileManager::retrieveFileBuffer() const
+    char* FileManager::retrieveFileBuffer() const
-	{
+    {
-		return fileBuffer;
+        return fileBuffer;
-	}
+    }
 
-	int FileManager::retrieveFileBufferLength() const { return fileBufferLength; }
+    int FileManager::retrieveFileBufferLength() const { return fileBufferLength; }
 }

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>
 
@@ -17,46 +17,44 @@ using Models::User;
 
 namespace Managers
 {
-	#pragma
+    #pragma
-	TokenManager::TokenManager(const User user)
+    TokenManager::TokenManager(const User& user)
-	{
+    {
-		this->user = user;
+        this->user = user;
-	}
+    }
-	TokenManager::TokenManager(const User user, API api)
+    TokenManager::TokenManager(const User& user, API& api)
-	{
+    {
-		this->user = user;
+        this->user = user;
-		this->api = api;
+        this->api = api;
-		this->api.endpoint = "api/" + api.version 
+        this->api.endpoint = "api/" + api.version 
-			+ "/login";
+            + "/login";
-	}
+    }
-	#pragma Constructors
+    #pragma Constructors
 
 
-	#pragma
+    #pragma
-	Token TokenManager::requestToken()
+    Token TokenManager::requestToken()
-	{
+    {
-		Token token{};
+        Token token{};
-		json usrObj;
+        json usrObj;
 
-		usrObj["username"] = user.username;
+        usrObj["username"] = user.username;
-		usrObj["password"] = user.password;
+        usrObj["password"] = user.password;
-		cout<<user.username<<" "<<user.password<<endl;
 
-		cout<<"Sending request for token"<<endl;
+        cout<<"Sending request for token"<<endl;
-		auto url = api.url + api.endpoint;
+        auto url = api.url + api.endpoint;
-		cout<<url<<endl;
+        cout<<url<<endl;
-		auto r = cpr::Post(cpr::Url{url},
+        auto r = cpr::Post(cpr::Url{url},
-				cpr::Body{usrObj.dump()},
+                cpr::Body{usrObj.dump()},
-		   cpr::Header{{"Content-Type", "application/json"}});
+           cpr::Header{{"Content-Type", "application/json"}});
 
-		cout<<r.text<<endl;
+        json res = json::parse(r.text);
-		json res = json::parse(r.text);
+        token.accessToken = res["token"];
-		token.accessToken = res["token"];
+        token.tokenType = res["token_type"];
-		token.tokenType = res["token_type"];
 
-		//cout<<"status code "<<r.status_code<<endl;
+        cout<<"status code "<<r.status_code<<endl;
 
-		return token;
+        return token;
-	}
+    }
-	#pragma Functions
+    #pragma Functions
 }

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>
@@ -12,42 +12,42 @@ using Models::User;
 
 namespace Managers
 {
-	#pragma
+    #pragma
-	UserManager::UserManager(User user)
+    UserManager::UserManager(User user)
-	{
+    {
-		this->user = user;
+        this->user = user;
-	}
+    }
-	UserManager::UserManager(const IcarusAction icaAct)
+    UserManager::UserManager(const IcarusAction icaAct)
-	{
+    {
-		this->icaAction = icaAct;
+        this->icaAction = icaAct;
-		this->user = User{};
+        this->user = User{};
-		parseUserFromActions();
+        parseUserFromActions();
-	}
+    }
-	#pragma Constructors
+    #pragma Constructors
 
 
-	#pragma
+    #pragma
-	User UserManager::retrieveUser() const
+    User UserManager::retrieveUser() const
-	{
+    {
-		return user;
+        return user;
-	}
+    }
 
-	void UserManager::parseUserFromActions()
+    void UserManager::parseUserFromActions()
-	{
+    {
-		auto args = icaAction.flags;
+        auto args = icaAction.flags;
 
-		for (auto arg : args)
+        for (auto arg : args)
-		{
+        {
-			auto flag = arg.flag;
+            auto flag = arg.flag;
-			if (flag.compare("-u") == 0)
+            if (flag.compare("-u") == 0)
-			{
+            {
-				user.username = arg.value;
+                user.username = arg.value;
-			}
+            }
-			if (flag.compare("-p") == 0)
+            if (flag.compare("-p") == 0)
-			{
+            {
-				user.password = arg.value;
+                user.password = arg.value;
-			}
+            }
-		}
+        }
-	}
+    }
-	#pragma Functions
+    #pragma Functions
 }

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>
 
@@ -10,50 +10,43 @@ using Models::IcarusAction;
 
 namespace Parsers
 {
-	#pragma
+    #pragma
-	APIParser::APIParser(IcarusAction icaAct)
+    APIParser::APIParser(IcarusAction icaAct) : icaAct(icaAct)
-	{
+    {
-		this->icaAct = icaAct;
+        api = API{};
-		api = API{};
+        parseAPI();
-		parseAPI();
+    }
-	}
+    #pragma endregion
-	#pragma endregion
 
 
-	#pragma
+    #pragma
-	API APIParser::retrieveAPI() const
+    API APIParser::retrieveAPI() const
-	{
+    {
-		return api;
+        return api;
-	}
+    }
 
-	void APIParser::parseAPI()
+    void APIParser::parseAPI()
-	{
+    {
-		auto flags = icaAct.flags;
+        auto flags = icaAct.flags;
-		cout<<"Parsing api"<<endl;
+        cout<<"Parsing api"<<endl;
 
-		//for (auto flag :  flags)
+        for (auto i =0; i < flags.size(); ++i)
-		for (auto i =0; i < flags.size(); ++i)
+        {
-		{
+            auto arg = flags[i].flag;
-			auto arg = flags[i].flag;
+            auto value = flags[i].value;
-			auto value = flags[i].value;
 
-			if (arg.compare("-h") == 0)
+            if (arg.compare("-h") == 0)
-				
+            {
-			{
+                api.url = (value[value.size()-1] == '/') ? value : value + "/";
-				api.url = 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
+        // TODO: For now I will hard code
-		// the api version since I am only
+        // the api version since I am only
-		// on version 1
+        // on version 1
-		api.version = "v1";
+        api.version = "v1";
-	}
+    }
-	#pragma functions
+    #pragma functions
 }

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>
@@ -16,47 +16,47 @@ using Models::Token;
 
 namespace Syncers
 {
-	#pragma
+    #pragma
-	Delete::Delete(API api)
+    Delete::Delete(API api)
-	{
+    {
-		this->api = api;
+        this->api = api;
-		this->api.endpoint = "song/data";
+        this->api.endpoint = "song/data";
-	}
+    }
-	#pragma Constructors
+    #pragma Constructors
 
 
-	#pragma
+    #pragma
-	void Delete::deleteSong(const Token token, Song song)
+    void Delete::deleteSong(const Token token, Song song)
-	{
+    {
-		try
+        try
-		{
+        {
-			auto url = retrieveUrl(song);
+            auto url = retrieveUrl(song);
-			string auth{token.tokenType};
+            string auth{token.tokenType};
-			auth.append(" " + token.accessToken);
+            auth.append(" " + token.accessToken);
-			auto r = cpr::Delete(cpr::Url(url),
+            auto r = cpr::Delete(cpr::Url(url),
-				cpr::Header{{"authorization", auth}});
+                cpr::Header{{"authorization", auth}});
 
-			auto statusCode = r.status_code;
+            auto statusCode = r.status_code;
 
-			cout<<"Status code "<<statusCode<<endl;
+            cout<<"Status code "<<statusCode<<endl;
-		}
+        }
-		catch (exception e)
+        catch (exception e)
-		{
+        {
-			auto msg = e.what();
+            auto msg = e.what();
-			cout<<msg<<endl;
+            cout<<msg<<endl;
-		}
+        }
-		cout<<"Finished"<<endl;
+        cout<<"Finished"<<endl;
-	}
+    }
 
-	string Delete::retrieveUrl(Song song)
+    string Delete::retrieveUrl(Song song)
-	{
+    {
-		string url{api.url + "api/" + api.version + "/" +
+        string url{api.url + "api/" + api.version + "/" +
-			api.endpoint + "/"};
+            api.endpoint + "/"};
 
-		url.append(std::to_string(song.id));
+        url.append(std::to_string(song.id));
-		cout<<"url "<<url<<endl;
+        cout<<"url "<<url<<endl;
 
-		return url;
+        return url;
-	}
+    }
-	#pragma Functions
+    #pragma Functions
 }

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>
@@ -18,92 +18,74 @@ using Models::Token;
 
 namespace Syncers
 {
-	#pragma
+    #pragma
-	Download::Download() { }
+    Download::Download() { }
-	Download::Download(API api)
+    Download::Download(API api)
-	{
+    {
-		this->api = api;
+        this->api = api;
-		this->api.endpoint = "song/data";
+        this->api.endpoint = "song/data";
-	}
+    }
-	Download::Download(string filePath)
+    Download::Download(string filePath)
-	{
+    {
-		downloadFilePath = filePath;
+        downloadFilePath = filePath;
-	}
+    }
-	#pragma Constructors
+    #pragma Constructors
 
 
-	#pragma
+    #pragma
-	void Download::downloadSong(const int id)
+    void Download::downloadSong(const Token token, Song song)
-	{
+    {
-		string urlRoot = "http://192.168.1.5";
+        try
-		int port = 9349;
+        {
-		string endpoint = "api/song/data/" + std::to_string(id);
+            string url = retrieveUrl(song);
-		string url = urlRoot + ":" + std::to_string(port) + "/" +
+            song.songPath.append("track.mp3");
-					 endpoint;
+            cout<<"song path "<<song.songPath<<endl;
-		auto r = cpr::Get(cpr::Url{url});
+            string auth{token.tokenType};
-		const char* newBuff = r.text.c_str();
+            auth.append(" " + token.accessToken);
-		int bufferLength = r.text.size();
+            
+            auto r = cpr::Get(cpr::Url(url),
+                    cpr::Header{{"Content-type", "audio/mpeg"},
+                                {"Authorization", auth}});
+                
 
-		ofstream saveSong{downloadFilePath, ofstream::binary};
+            int statusCode = r.status_code;
-		saveSong.write(newBuff, bufferLength);
 
-		cout<<"HTTP status code: "<<r.status_code<<endl;
+            if (statusCode == OK) {
-		cout<<"Header info: "<<r.header["content-type"]<<endl;
+                song.data = r.text;
-		cout<<"Header info: "<<endl;
+                saveSong(song);
-		cout<<r.header["content-type"]<<endl;
+            }
-		cout<<r.header["content-disposition"]<<endl;
-	}
-	void Download::downloadSong(const Token token, Song song)
-	{
-		try
-		{
-			string url = retrieveUrl(song);
-			song.songPath.append("track.mp3");
-			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}});
-
-			int statusCode = r.status_code;
-
-			if (statusCode == OK)
-			{
-				song.data = r.text;
-				saveSong(&song);
-			}
 
 
-			cout<<"finsihed with status code "<<statusCode<<endl;
+            cout<<"finsihed with status code "<<statusCode<<endl;
-		}
+        }
-		catch (exception e)
+        catch (exception e)
-		{
+        {
-			auto msg = e.what();
+            auto msg = e.what();
-			cout<<msg<<endl;
+            cout<<msg<<endl;
-		}
+        }
-	}
+    }
 
-	string Download::retrieveUrl(Song song)
+    string Download::retrieveUrl(Song song)
-	{
+    {
-		string url{api.url + "api/" + api.version + "/" + 
+        string url{api.url + "api/" + api.version + "/" + 
-			api.endpoint + "/"};
+            api.endpoint + "/"};
 
-		url.append(std::to_string(song.id));
+        url.append(std::to_string(song.id));
-		cout<<"url "<<url<<endl;
+        cout<<"url "<<url<<endl;
 
-		return url;
+        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;
+        cout<<"buff length  "<<bufferLength<<endl;
 
-		ofstream saveSong{song->songPath, std::ios::binary};
+        ofstream saveSong{song.songPath, std::ios::binary};
-		saveSong.write(data, bufferLength);
+        saveSong.write(data, bufferLength);
-		saveSong.close();
+        saveSong.close();
-	}
+    }
-	#pragma Functions
+    #pragma Functions
 }

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;
@@ -23,136 +24,193 @@ using namespace cpr;
 
 namespace Syncers
 {
-	Upload::Upload() { }
+    Upload::Upload() { }
-	Upload::Upload(string filePath)
+    Upload::Upload(API api) : api(api)
-	{
+    {
-		this->songPath = filePath;
+        this->api.endpoint = "song/data";
-		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
+        try
-		{
+        {
-			auto r = cpr::Post(cpr::Url{url},
+            auto url = retrieveUrl();
-                   		cpr::Multipart{{"key", "small value"},
-                                {"file", cpr::File{songPath}}});
-			cout << r.status_code<< std::endl;
 
-			cout<<"Success"<<endl;
+            cout<<"url "<<url<<endl;
-		}
+            string auth{token.tokenType};
-		catch(std::exception& e)
+            auth.append(" " + token.accessToken);
-		{
+            auto r = cpr::Post(cpr::Url{url},
-			cout<<e.what()<<endl;
+                        cpr::Multipart{{"key", "small value"},
-		}
-		cout<<"Finished"<<endl;
-
-	}
-	void Upload::uploadSong(const Models::Token token, Song song)
-	{
-		try
-		{
-			auto url = retrieveUrl();
-
-			cout<<"url "<<url<<endl;
-			string auth{token.tokenType};
-			auth.append(" " + token.accessToken);
-			auto r = cpr::Post(cpr::Url{url},
-                   		cpr::Multipart{{"key", "small value"},
                                 {"file", cpr::File{song.songPath}}},
-		   		cpr::Header{{"authorization", auth}}
+                cpr::Header{{"authorization", auth}}
-				);
+                );
 
-			cout << r.status_code<< std::endl;
+            cout << "status code: " << r.status_code<< std::endl;
-		}
+            cout << r.text << endl;
-		catch (exception e)
+            auto result = nlohmann::json::parse(r.text);
-		{
+            cout<<"Finished"<<endl;
-			auto msg = e.what();
+            song.id = result["id"].get<int>();
-			cout<<msg<<endl;
+            song.title = result["title"].get<std::string>();
-		}
+            song.artist = result["artist"].get<std::string>();
-		cout<<"Finished"<<endl;
+            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>();
 
-	string Upload::retrieveUrl()
+            return song;
-	{
+        }
-		string url = api.url + "api/" + api.version + "/" +
+        catch (exception& e)
-			api.endpoint;
+        {
-			
+            auto msg = e.what();
-		return url;
+            cout<<msg<<endl;
-	}
+        }
-	#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{};
+        return song;
-		this->song.id = id;
+    }
-		this->song.title = title;
-		this->song.artist = artist;
-		this->song.album = album;
-		this->song.genre = genre;
-		this->song.year = year;
-		this->song.duration = duration;
-		this->song.songData = fMgr.retrieveFileBuffer();
-		cout<<*song.songData<<endl;
-	}
-	void Upload::printSongDetails()
-	{
-		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;
-	}
-	void Upload::printJsonData(json obj)
-	{
-		cout<<endl<<endl<<"JSon data: "<<endl;
-		cout<<"id: "<<obj["id"]<<endl;
-		cout<<"title: "<<obj["title"]<<endl;
-		cout<<"artist: "<<obj["artist"]<<endl;
-		cout<<"album: "<<obj["album"]<<endl;
-		cout<<"genre: "<<obj["genre"]<<endl;
-		cout<<"year: "<<obj["year"]<<endl;
-		cout<<"duration: "<<obj["duration"]<<endl;
-		cout<<"song_data: "<<obj["song_data"]<<endl;
 
-		cout<<endl<<endl;;
+    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;
 
-	json Upload::serializeObject()
+            while (!noConfirm) 
-	{
+            {
-		json jObj{};
+                auto answer = 'a';
-		jObj["id"] = song.id;
+                cout << "are you sure you want to upload " << songs.size() << " songs? [y/n]";
-		jObj["title"] = song.title;
+                cin >> answer;
-		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;
+                if (answer == 'y' || answer == 'Y') 
-	}
+                {
-	#pragma Testing
+                    confirmUpload = true;
-	#pragma Functions
+                    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()
+    {
+        const string url{api.url + "api/" + api.version + "/" +
+            api.endpoint};
+            
+        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()
+    {
+        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;
+    }
+    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;
+        cout<<"title: "<<obj["title"]<<endl;
+        cout<<"artist: "<<obj["artist"]<<endl;
+        cout<<"album: "<<obj["album"]<<endl;
+        cout<<"genre: "<<obj["genre"]<<endl;
+        cout<<"year: "<<obj["year"]<<endl;
+        cout<<"duration: "<<obj["duration"]<<endl;
+        cout<<"song_data: "<<obj["song_data"]<<endl;
+
+        cout<<endl<<endl;;
+    }
+    #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,47 +1,47 @@
-#include"AboutWindow.h"
+#include"UI/AboutWindow.h"
 
 using std::unique_ptr;
 
 namespace UI
 {
-	AboutWindow::AboutWindow(QWidget* parent): QDialog(parent)
+    AboutWindow::AboutWindow(QWidget* parent): QDialog(parent)
-	{
+    {
-		setupWindow();
+        setupWindow();
-	}
+    }
 
 
-	void AboutWindow::setupWindow()
+    void AboutWindow::setupWindow()
-	{
+    {
-		windowWidth = 250;
+        windowWidth = 250;
-		windowHeight = 300;
+        windowHeight = 300;
 
-		mainLayoutQt = unique_ptr<QVBoxLayout>{new QVBoxLayout};
+        mainLayoutQt = unique_ptr<QVBoxLayout>{new QVBoxLayout};
 
-		appName = unique_ptr<QLabel>{new QLabel(tr("IcarusDownloadManager"))};
+        appName = unique_ptr<QLabel>{new QLabel(tr("IcarusDownloadManager"))};
-		actionButtonQt = unique_ptr<QPushButton>{new QPushButton(tr("Close"))};
+        actionButtonQt = unique_ptr<QPushButton>{new QPushButton(tr("Close"))};
 
-		mainLayoutQt->addWidget(appName.get());
+        mainLayoutQt->addWidget(appName.get());
-		mainLayoutQt->addWidget(actionButtonQt.get());
+        mainLayoutQt->addWidget(actionButtonQt.get());
 
 
-		setFixedWidth(windowWidth);
+        setFixedWidth(windowWidth);
-		setFixedHeight(windowHeight);
+        setFixedHeight(windowHeight);
 
-		setLayout(mainLayoutQt.get());
+        setLayout(mainLayoutQt.get());
 
-		setWindowTitle("About");
+        setWindowTitle("About");
 
-		connections();
+        connections();
-	}
+    }
-	void AboutWindow::connections()
+    void AboutWindow::connections()
-	{
+    {
-		QObject::connect(actionButtonQt.get(), SIGNAL(clicked()), this, 
+        QObject::connect(actionButtonQt.get(), SIGNAL(clicked()), this, 
-						SLOT(closeWindow()));
+                        SLOT(closeWindow()));
-	}
+    }
 
 
-	void AboutWindow::closeWindow()
+    void AboutWindow::closeWindow()
-	{
+    {
-		this->hide();	
+        this->hide();   
-	}
+    }
 }

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>
@@ -17,158 +17,158 @@ using Syncers::Upload;
 
 namespace UI
 {
-	MainWindow::MainWindow() 
+    MainWindow::MainWindow() 
-	{
+    {
-		setupMainWindow();
+        setupMainWindow();
-		aboutWindow = unique_ptr<AboutWindow>{new AboutWindow};
+        aboutWindow = unique_ptr<AboutWindow>{new AboutWindow};
-   	}
+    }
 
 
-	void MainWindow::configureDownloadSection()
+    void MainWindow::configureDownloadSection()
-	{
+    {
-	}
+    }
-	void MainWindow::configureUploadSection()
+    void MainWindow::configureUploadSection()
-	{
+    {
-		uploadSongQt = unique_ptr<QPushButton>{new QPushButton(tr("Upload"))};
+        uploadSongQt = unique_ptr<QPushButton>{new QPushButton(tr("Upload"))};
-		urlQt = unique_ptr<QTextEdit>{new QTextEdit()};
+        urlQt = unique_ptr<QTextEdit>{new QTextEdit()};
-		sourceFilePathQt = unique_ptr<QTextEdit>{new QTextEdit()};
+        sourceFilePathQt = unique_ptr<QTextEdit>{new QTextEdit()};
 
-        	urlLabel = unique_ptr<QLabel>{new QLabel(tr("URL"))};
+            urlLabel = unique_ptr<QLabel>{new QLabel(tr("URL"))};
-        	songPath = unique_ptr<QLabel>{new QLabel(tr("Song Path"))};
+            songPath = unique_ptr<QLabel>{new QLabel(tr("Song Path"))};
 
-        	urlPortion = unique_ptr<QHBoxLayout>{new QHBoxLayout};
+            urlPortion = unique_ptr<QHBoxLayout>{new QHBoxLayout};
-        	songPathPortion = unique_ptr<QHBoxLayout>{new QHBoxLayout};
+            songPathPortion = unique_ptr<QHBoxLayout>{new QHBoxLayout};
 
-        	urlPortion.get()->addWidget(urlLabel.get());
+            urlPortion.get()->addWidget(urlLabel.get());
-        	urlPortion.get()->addWidget(urlQt.get());
+            urlPortion.get()->addWidget(urlQt.get());
 
-        	songPathPortion->addWidget(songPath.get());
+            songPathPortion->addWidget(songPath.get());
-        	songPathPortion->addWidget(sourceFilePathQt.get());
+            songPathPortion->addWidget(sourceFilePathQt.get());
 
-		subLayoutOneQt = unique_ptr<QVBoxLayout>{new QVBoxLayout};
+        subLayoutOneQt = unique_ptr<QVBoxLayout>{new QVBoxLayout};
-        	subLayoutOneQt.get()->addLayout(urlPortion.get());
+            subLayoutOneQt.get()->addLayout(urlPortion.get());
-        	subLayoutOneQt->addLayout(songPathPortion.get());
+            subLayoutOneQt->addLayout(songPathPortion.get());
-		mainLayoutQt.get()->addLayout(subLayoutOneQt.get());
+        mainLayoutQt.get()->addLayout(subLayoutOneQt.get());
-	}
+    }
-	void MainWindow::configureWindowDimensions()
+    void MainWindow::configureWindowDimensions()
-	{
+    {
-		windowWidth = 450;
+        windowWidth = 450;
-		windowHeight = 450;
+        windowHeight = 450;
-	}
+    }
-	void MainWindow::configureWindowProperties()
+    void MainWindow::configureWindowProperties()
-	{
+    {
-		setWindowTitle("IcarusDownloadManager");
+        setWindowTitle("IcarusDownloadManager");
-		setFixedHeight(windowHeight);
+        setFixedHeight(windowHeight);
-		setFixedWidth(windowWidth);
+        setFixedWidth(windowWidth);
-	}
+    }
-	void MainWindow::connections()
+    void MainWindow::connections()
-	{
+    {
-		QObject::connect(uploadSongQt.get(), SIGNAL(clicked()), this, SLOT(uploadSong()));
+        QObject::connect(uploadSongQt.get(), SIGNAL(clicked()), this, SLOT(uploadSong()));
-		QObject::connect(closeApplicationQt.get(), SIGNAL(triggered()), this, 
+        QObject::connect(closeApplicationQt.get(), SIGNAL(triggered()), this, 
-						SLOT(exitApplication()));
+                        SLOT(exitApplication()));
-		QObject::connect(aboutApplicationQt.get(), SIGNAL(triggered()), this, 
+        QObject::connect(aboutApplicationQt.get(), SIGNAL(triggered()), this, 
-						SLOT(displaySoftwareInformation()));
+                        SLOT(displaySoftwareInformation()));
-		QObject::connect(windowComboBox.get(), SIGNAL(activated(int)),
+        QObject::connect(windowComboBox.get(), SIGNAL(activated(int)),
-            					this, SLOT(setCurrentIndex(int)));
+                                this, SLOT(setCurrentIndex(int)));
-	}
+    }
-	void MainWindow::createMenus()
+    void MainWindow::createMenus()
-	{
+    {
-		fileMenuQt = unique_ptr<QMenu>{menuBar()->addMenu(tr("File"))};
+        fileMenuQt = unique_ptr<QMenu>{menuBar()->addMenu(tr("File"))};
-		editMenuQt = unique_ptr<QMenu>{menuBar()->addMenu(tr("Edit"))};
+        editMenuQt = unique_ptr<QMenu>{menuBar()->addMenu(tr("Edit"))};
-		helpMenuQt = unique_ptr<QMenu>{menuBar()->addMenu(tr("Help"))};
+        helpMenuQt = unique_ptr<QMenu>{menuBar()->addMenu(tr("Help"))};
 
-		closeApplicationQt = unique_ptr<QAction>{new QAction(new QObject(nullptr))};
+        closeApplicationQt = unique_ptr<QAction>{new QAction(new QObject(nullptr))};
-		closeApplicationQt->setText("Exit Application");
+        closeApplicationQt->setText("Exit Application");
 
-		aboutApplicationQt = unique_ptr<QAction>{new QAction(new QObject(nullptr))};
+        aboutApplicationQt = unique_ptr<QAction>{new QAction(new QObject(nullptr))};
-		aboutApplicationQt->setText("About");
+        aboutApplicationQt->setText("About");
 
-		fileMenuQt->addAction(closeApplicationQt.get());
+        fileMenuQt->addAction(closeApplicationQt.get());
-		helpMenuQt->addAction(aboutApplicationQt.get());
+        helpMenuQt->addAction(aboutApplicationQt.get());
 
-	}
+    }
-	void MainWindow::setupMainWidget()
+    void MainWindow::setupMainWidget()
-	{
+    {
-		mainWidgetQt = unique_ptr<QWidget>{new QWidget};
+        mainWidgetQt = unique_ptr<QWidget>{new QWidget};
 
-		windowComboBox = unique_ptr<QComboBox>{new QComboBox};
+        windowComboBox = unique_ptr<QComboBox>{new QComboBox};
-		setupWindowLists();
+        setupWindowLists();
 
 
-		stackLayout = unique_ptr<QVBoxLayout>{new QVBoxLayout};
+        stackLayout = unique_ptr<QVBoxLayout>{new QVBoxLayout};
-		stackLayout->addWidget(windowComboBox.get());
+        stackLayout->addWidget(windowComboBox.get());
 
-		uploadSongWidgetQt = unique_ptr<QWidget>{new QWidget};
+        uploadSongWidgetQt = unique_ptr<QWidget>{new QWidget};
-		uploadSongWidgetQt->setLayout(mainLayoutQt.get());
+        uploadSongWidgetQt->setLayout(mainLayoutQt.get());
 
-		stackLayout->addWidget(uploadSongWidgetQt.get());
+        stackLayout->addWidget(uploadSongWidgetQt.get());
 
-		mainWidgetQt->setLayout(stackLayout.get());
+        mainWidgetQt->setLayout(stackLayout.get());
-	}
+    }
-	void MainWindow::setupMainWindow()
+    void MainWindow::setupMainWindow()
-	{
+    {
-		configureWindowDimensions();
+        configureWindowDimensions();
 
-		mainLayoutQt = unique_ptr<QVBoxLayout>{new QVBoxLayout};
+        mainLayoutQt = unique_ptr<QVBoxLayout>{new QVBoxLayout};
-		widgetStack = unique_ptr<QStackedWidget>{new QStackedWidget};
+        widgetStack = unique_ptr<QStackedWidget>{new QStackedWidget};
 
-		configureUploadSection();
+        configureUploadSection();
 
-		setupMainWidget();
+        setupMainWidget();
 
-		widgetStack->addWidget(mainWidgetQt.get());
+        widgetStack->addWidget(mainWidgetQt.get());
 
-		MainDockWidgetQt = unique_ptr<QDockWidget>{new QDockWidget};
+        MainDockWidgetQt = unique_ptr<QDockWidget>{new QDockWidget};
-		MainDockWidgetQt.get()->setWindowTitle(tr("Music Manager"));
+        MainDockWidgetQt.get()->setWindowTitle(tr("Music Manager"));
-		MainDockWidgetQt->setWidget(widgetStack.get());
+        MainDockWidgetQt->setWidget(widgetStack.get());
-		MainDockWidgetQt.get()->setFeatures(QDockWidget::NoDockWidgetFeatures);
+        MainDockWidgetQt.get()->setFeatures(QDockWidget::NoDockWidgetFeatures);
 
-		setCentralWidget(MainDockWidgetQt.get());
+        setCentralWidget(MainDockWidgetQt.get());
 
-		createMenus();
+        createMenus();
 
-		configureWindowProperties();
+        configureWindowProperties();
 
-		connections();
+        connections();
-	}
+    }
-	void MainWindow::setupWindowLists()
+    void MainWindow::setupWindowLists()
-	{
+    {
-		windowComboBox->addItem(tr("Upload song"));
+        windowComboBox->addItem(tr("Upload song"));
-		windowComboBox->addItem(tr("Download song"));
+        windowComboBox->addItem(tr("Download song"));
-		windowComboBox->addItem(tr("Display all songs"));
+        windowComboBox->addItem(tr("Display all songs"));
-		windowComboBox->addItem(tr("Display songs"));
+        windowComboBox->addItem(tr("Display songs"));
-	}
+    }
 
 
-	void MainWindow::exitApplication()
+    void MainWindow::exitApplication()
-	{
+    {
-		exit(0);
+        exit(0);
-	}
+    }
-	void MainWindow::displaySoftwareInformation()
+    void MainWindow::displaySoftwareInformation()
-	{
+    {
-		aboutWindow->show();
+        aboutWindow->show();
-	}
+    }
-	void MainWindow::setCurrentIndex(int index)
+    void MainWindow::setCurrentIndex(int index)
-	{
+    {
-		cout<<"index "<<index<<endl;
+        cout<<"index "<<index<<endl;
-		QString qText = windowComboBox->itemText(index);
+        QString qText = windowComboBox->itemText(index);
-		auto cnvert = Utilities::Conversions(qText);
+        auto cnvert = Utilities::Conversions(qText);
-		auto convertedStr = cnvert.convertQStringToString();
+        auto convertedStr = cnvert.convertQStringToString();
-		cout<<"item text"<<endl;
+        cout<<"item text"<<endl;
-	}
+    }
-	void MainWindow::uploadSong()
+    void MainWindow::uploadSong()
-	{
+    {
-		uploadSongQt->setEnabled(false);
+        uploadSongQt->setEnabled(false);
 
-		string url = urlQt->toPlainText().toUtf8().constData();
+        string url = urlQt->toPlainText().toUtf8().constData();
-		string filePath = sourceFilePathQt->toPlainText().toUtf8().constData();
+        string filePath = sourceFilePathQt->toPlainText().toUtf8().constData();
-		cout<<"URL endpoint: "<<url<<endl;
+        cout<<"URL endpoint: "<<url<<endl;
-		cout<<"Music file path: "<<filePath<<endl;
+        cout<<"Music file path: "<<filePath<<endl;
-		UploadForm formData{url, filePath};
+        UploadForm formData{url, filePath};
 
-		Upload upld{formData};
+        Upload upld{formData};
-		upld.uploadSong();
+        upld.uploadSong();
 
-		uploadSongQt->setEnabled(true);
+        uploadSongQt->setEnabled(true);
-	}
+    }
 }

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>
 
@@ -7,18 +7,18 @@ using std::unique_ptr;
 
 namespace Utilities
 {
-	Conversions::Conversions()
+    Conversions::Conversions()
-	{
+    {
-		initializeValues();
+        initializeValues();
-	}
+    }
 
-	void Conversions::initializeValues()
+    void Conversions::initializeValues()
-	{
+    {
-	}
+    }
-	template <typename T>
+    template <typename T>
-	void Conversions::printValue(T val)
+    void Conversions::printValue(T val)
-	{
+    {
-		std::cout<<"going to print value"<<std::endl;
+        std::cout<<"going to print value"<<std::endl;
-		std::cout<<val<<std::endl;
+        std::cout<<val<<std::endl;
-	}
+    }
 }

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