Added functionality to upload a song. Need to write parse classes to parse the base API HTTP endpoint, and the source path. #7

CMakeLists.txt

@@ -45,6 +45,8 @@ set(SOURCES
 	src/Managers/ActionManager.cpp
 	src/Managers/CommitManager.cpp
 	src/Managers/FileManager.cpp
+	src/Managers/TokenManager.cpp
+	src/Managers/UserManager.cpp
 	src/Syncers/Download.cpp
 	src/Syncers/Upload.cpp
 	src/Utilities/Conversions.cpp
@@ -53,10 +55,12 @@ set(HEADERS
 	src/Managers/ActionManager.h
 	src/Managers/CommitManager.h
 	src/Managers/FileManager.h
-	src/Models/Token.h
+	src/Managers/TokenManager.h
+	src/Managers/UserManager.h
 	src/Models/Flags.h
 	src/Models/IcarusAction.h
 	src/Models/Song.h
+	src/Models/Token.h
 	src/Models/UploadForm.h
 	src/Models/User.h
 	src/Syncers/Download.h

src/Managers/ActionManager.cpp

@@ -103,7 +103,6 @@ namespace Managers
 				flg = Flags{};
 				continue;
 			}
-			cout<<"\nprovided flag: "<<flag<<endl;
 			if (std::any_of(supportedFlags.begin(), supportedFlags.end(), 
 				[&](string val)
 				{
@@ -113,7 +112,6 @@ namespace Managers
 					return !val.compare(flag);
 				}))
 			{
-				cout<<"Flag : "<<flag<<" is valid"<<endl;
 				flg.flag = flag;
 			}
 			else

src/Managers/CommitManager.cpp

@@ -2,12 +2,20 @@
 
 #include<iostream>
 
+#include"Syncers/Upload.h"
+
+#include"TokenManager.h"
+#include"UserManager.h"
+
 using std::cout;
 using std::endl;
 using std::map;
 using std::string;
 
+using Managers::TokenManager;
+using Managers::UserManager;
 using Models::IcarusAction;
+using Syncers::Upload;
 
 namespace Managers
 {
@@ -50,14 +58,36 @@ namespace Managers
 	void CommitManager::uploadSong()
 	{
 		cout<<"Uploading song..."<<endl;
+		UserManager usrMgr{icaAction};
+		auto user = usrMgr.retrieveUser();
+
+		TokenManager tk{user};
+		auto token = tk.requestToken();
+
+		string songPath{};
+
+		for (auto arg : icaAction.flags)
+		{
+			auto flag = arg.flag;
+			auto value = arg.value;
+
+			if (flag.compare("-s") == 0)
+			{
+				songPath.assign(arg.value);
+			}
+		}
+
+		Upload upld{};
+		upld.uploadSong(token, songPath);
+
 		// TODO: Implement functionality for uploading
 		//
 		// Need to the following:
-		// 1. Parse the login credentials from the Flag model
-		// 2. Retrieve a token -- implement token management
-		// 3. Parse song path from the Flag model
-		// 4. Parse the HTTP API endpoint
-		// 5. Upload the song
+		// 1. Parse the login credentials from the Flag model x
+		// 2. Retrieve a token -- implement token management x
+		// 3. Parse song path from the Flag model x Make a parser class
+		// 4. Parse the HTTP API endpoint Make parser class
+		// 5. Upload the song x
 	}
 	#pragma Functions
 }

src/Managers/TokenManager.cpp

@@ -0,0 +1,47 @@
+#include"TokenManager.h"
+
+#include<iostream>
+
+#include<cpr/cpr.h>
+#include<nlohmann/json.hpp>
+
+using std::cout;
+using std::endl;
+
+using json = nlohmann::json;
+
+using Managers::TokenManager;
+using Models::Token;
+using Models::User;
+
+namespace Managers
+{
+	#pragma
+	TokenManager::TokenManager(const User user)
+	{
+		this->user = user;
+	}
+	#pragma Constructors
+
+
+	#pragma
+	Token TokenManager::requestToken()
+	{
+		Token token{};
+		json usrObj;
+
+		usrObj["username"] = user.username;
+		usrObj["password"] = user.password;
+
+		auto r = cpr::Post(cpr::Url{""},
+				cpr::Body{usrObj.dump()},
+		   cpr::Header{{"Content-Type", "application/json"}});
+
+		json res = json::parse(r.text);
+		token.accessToken = res["token"];
+		token.tokenType = res["token_type"];
+
+		return token;
+	}
+	#pragma Functions
+}

src/Managers/TokenManager.h

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

src/Managers/UserManager.cpp

@@ -0,0 +1,54 @@
+#include"UserManager.h"
+
+#include<iostream>
+#include<string>
+#include<vector>
+
+using std::string;
+using std::vector;
+
+using Models::IcarusAction;
+using Models::User;
+
+namespace Managers
+{
+	#pragma
+	UserManager::UserManager(User user)
+	{
+		this->user = user;
+		this->user = User{};
+	}
+	UserManager::UserManager(const IcarusAction icaAct)
+	{
+		this->icaAction = icaAct;
+		this->user = User{};
+		parseUserFromActions();
+	}
+	#pragma Constructors
+
+
+	#pragma
+	User UserManager::retrieveUser() const
+	{
+		return user;
+	}
+
+	void UserManager::parseUserFromActions()
+	{
+		auto args = icaAction.flags;
+
+		for (auto arg : args)
+		{
+			auto flag = arg.flag;
+			if (flag.compare("-u") == 0)
+			{
+				user.username = arg.value;
+			}
+			if (flag.compare("-p") == 0)
+			{
+				user.password = arg.value;
+			}
+		}
+	}
+	#pragma Functions
+}

src/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

src/Models/User.h

@@ -9,7 +9,7 @@ namespace Models
 	{
 		std::string username;
 		std::string password;
-	}
+	};
 }
 
 #endif

src/Syncers/Upload.cpp

@@ -1,4 +1,5 @@
 #include<iostream>
+#include<exception>
 #include<string>
 
 #include<cpr/cpr.h>
@@ -8,6 +9,7 @@
 
 using std::cout;
 using std::endl;
+using std::exception;
 using std::string;
 
 using json = nlohmann::json;
@@ -37,8 +39,8 @@ namespace Syncers
 		try
 		{
 			auto r = cpr::Post(cpr::Url{url},
-                   cpr::Multipart{{"key", "small value"},
-                                  {"file", cpr::File{songPath}}});
+                   		cpr::Multipart{{"key", "small value"},
+                                {"file", cpr::File{songPath}}});
 			cout << r.status_code<< std::endl;
 
 			cout<<"Success"<<endl;
@@ -50,6 +52,27 @@ namespace Syncers
 		cout<<"Finished"<<endl;
 
 	}
+	void Upload::uploadSong(const Models::Token token, const std::string songPath)
+	{
+		try
+		{
+			string auth{token.tokenType};
+			auth.append(" " + token.accessToken);
+			auto r = cpr::Post(cpr::Url{""},
+                   		cpr::Multipart{{"key", "small value"},
+                                {"file", cpr::File{songPath}}},
+		   		cpr::Header{{"authorization", auth}}
+				);
+
+			cout << r.status_code<< std::endl;
+		}
+		catch (exception e)
+		{
+			auto msg = e.what();
+			cout<<msg<<endl;
+		}
+		cout<<"Finished"<<endl;
+	}
 
 	void Upload::configureSongDemo()
 	{

src/Syncers/Upload.h

@@ -7,6 +7,7 @@
 
 #include"Managers/FileManager.h"
 #include"Models/Song.h"
+#include"Models/Token.h"
 #include"Models/UploadForm.h"
 
 
@@ -20,7 +21,7 @@ namespace Syncers
 			Upload(Models::UploadForm);
 
 			void uploadSong();
-
+			void uploadSong(const Models::Token, const std::string);
 		private:
 			Managers::FileManager fMgr;
 			Models::Song song;