Language Migration (#21)

* Blank slate

* Added gitignore

* Updated gitignore

* Added rust code

* Added modules

* Fixed build issues

* rustfmt

* Updated models

* Added parsers module

* Updated utilities module

* Updated main.rs

* Updated api_parser and song model

* Updated icarus_action model

* Updated structs in managers module

* Updated main.rs

* More changes

* Saving changes

* Added new struct and methods

* More changes. Not functional yet

* Changed name of the project

* Removed cmake workflow

* Adding rust workflow

* Adding code to the syncers module

* Cargo formatting

* Continuing work

* Adding code to the syncers module

* Added dependencies

* Adding more code to the syncers module

* Added more code to the syncers module

It's not 100 percent done yet, I'll work on other modules

* Added more code to the managers module

* Added code to request a token

* Cargo formatting

* Adding more code to multi target upload

* Adding more multi-target upload code and formatted code

* Added more multi-upload code

* cargo fmt

* Got uploading functional and cargo fmt-ing

* Uploading multi target works, but is buggy

Not all of the songs are being uploaded

* Added single target upload

* Single target upload is functional but need to revisit multi-target upload

Multi-target upload is broken now. Needs to be revisited

* Fixed multi target upload

* Can now retrieve songs

* Downloading functionality is working

* Delete functionality is operational

* Updated README

* More cleanup

* Added test

.github/workflows/rust.yml

@@ -0,0 +1,23 @@
+name: Rust
+
+on:
+  push:
+    branches: [ "rust-lg" ]
+  pull_request:
+    branches: [ "rust-lg" ]
+
+env:
+  CARGO_TERM_COLOR: always
+
+jobs:
+  build:
+
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v3
+    - name: Build
+      run: cargo build --verbose
+    - name: Run tests
+      run: cargo test --verbose
+

.gitignore

@@ -0,0 +1,10 @@
+/.vs/*
+/build
+/x64
+
+
+# Added by cargo
+
+/target
+.vscode/
+Cargo.lock

CMakeLists.txt

@@ -1,89 +0,0 @@
-cmake_minimum_required(VERSION 3.10)
-
-
-include("cmake/HunterGate.cmake")
-HunterGate(
-    URL "https://github.com/ruslo/hunter/archive/v0.23.184.tar.gz"
-    SHA1 "fe3fb05d51c21499c7eebbe7d0e102742a54a9cd"
-)
-
-project(IcarusDownloadManager)
-
-
-
-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++17 support.")
-    # Set C++17 support flags for various compilers
-    include(CheckCXXCompilerFlag)
-    check_cxx_compiler_flag("-std=c++17" COMPILER_SUPPORTS_CXX17)
-    check_cxx_compiler_flag("-std=c++0x" COMPILER_SUPPORTS_CXX0X)
-    if(COMPILER_SUPPORTS_CXX17)
-        message(STATUS "C++17 is supported.")
-        if(${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
-            set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++17 -stdlib=libc++")
-        else()
-            set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++17")
-        endif()
-    elseif(COMPILER_SUPPORTS_CXX0X)
-        message(STATUS "C++0x is supported.")
-        if(${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
-            set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++0x -stdlib=libc++")
-        else()
-            set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++0x")
-        endif()
-    else()
-        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/Managers/ActionManager.cpp
-    src/Managers/CommitManager.cpp
-    src/Managers/FileManager.cpp
-    src/Managers/TokenManager.cpp
-    src/Managers/UserManager.cpp
-    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
-    include/Managers/ActionManager.h
-    include/Managers/CommitManager.h
-    include/Managers/FileManager.h
-    include/Managers/TokenManager.h
-    include/Managers/UserManager.h
-    include/Models/API.h
-    include/Models/Flags.h
-    include/Models/IcarusAction.h
-    include/Models/Song.h
-    include/Models/Token.h
-    include/Models/UploadForm.h
-    include/Models/User.h
-    include/Parsers/APIParser.h
-    include/Syncers/Delete.h
-    include/Syncers/Download.h
-    include/Syncers/RetrieveRecords.h
-    include/Syncers/SyncerBase.h
-    include/Syncers/Upload.h
-    include/Utilities/Conversions.h
-)
-
-
-hunter_add_package(nlohmann_json)
-find_package(nlohmann_json CONFIG REQUIRED)
-
-hunter_add_package(cpr)
-find_package(cpr CONFIG REQUIRED)
-
-
-add_executable(icd ${SOURCES} ${HEADERS})
-target_link_libraries(icd PUBLIC nlohmann_json::nlohmann_json cpr::cpr)
-include_directories(include/)

Cargo.toml

@@ -0,0 +1,18 @@
+[package]
+name = "icarus-dm"
+version = "0.4.0"
+edition = "2021"
+
+
+
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+futures = { version = "0.3.30" }
+http = { version = "1.1.0" }
+reqwest = { version = "0.12.4", features = ["json", "blocking", "multipart", "stream"] }
+serde = { version = "1.0.197", features = ["derive"] }
+serde_json = "1.0.115"
+tokio = { version = "1.37", features = ["full"] }
+tokio-util = { version = "0.7.11", features = ["codec"] }

README.md

@@ -1,45 +1,68 @@
 # IcarusDownloadManager
 
-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. 
+IcarusDownloadManager is a CLI software client application that has the feature of uploading and downloading songs from the [Icarus](https://github.com/kdeng00/Icarus) Music Server. 
 
 
 ## Built With
 
-* C++
+* Rust
-* CMake
+* Cargo
-* GCC
+* futures
-* [Hunter](https://github.com/ruslo/hunter)
+* http
-* libCurl
+* reqwst
-* [json](https://github.com/nlohmann/json)
+* serde
-* [cpr](http://whoshuu.github.io/cpr/)
+* serde_json
+* tokio
+* tokio-util
 
 
 ### Getting Started
 
+Clone the repo
+
+```BASH
+git clone --recursive https://github.com/kdeng00/IcarusDownloadManager
+```
+
+
 Build the project:
 
-```
+```BASH
-export HUNTER_ROOT=/path/to/download/hunter/files/for/dependencies
+cd IcarusDownloadManager
-mkdir _build
+cargo 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.
+The program has been built and can be executed by the binary file *icarus-dm*. For information on how to use icarua-dm, 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
+```BASH
-``icd upload -u spacecadet -p stellar40 -h https://icarus.com -s /path/of/song.mp3``
+icarus-dm download -u spacecadet -p stellar40 -h https://icarus.com -b 15
+```
+
+### Uploading Song with metadata
+
+```BASH
+icarus-dm upload-meta -u spacecadet -p stellar40 -h https://icarus.com -s /path/of/song.mp3 -t 1 -m /path/to/metadata/config/collection.json -ca /path/to/cover/art/image.png
+```
+
+### Uploading Song with metadata from directory
+
+```BASH
+icarus-dm upload-meta -u spacecadet -p stellar40 -h https://icarus.com -smca /path/where/songs/and/metadata/exists/
+```
 
 ### Retrieving Song in json
-``icd retrieve -u spacecadet -p stellar40 -h https://icarus.com -rt songs``
+
+```Bash
+icarus-dm 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``
+
+```BASH
+icarus-dm delete -u spacecadet -p stellar40 -h https://icarus.com -D 15
+```
 
 
 ## Contributing
@@ -48,15 +71,14 @@ Please read [CONTRIBUTING.md](CONTRIBUTING.md) for details on the code of conduc
 
 ## Versioning
 
+[v0.4.0](https://github.com/kdeng00/IcarusDownloadManager/releases/tag/v0.4.0)  
+[v0.3.2](https://github.com/kdeng00/IcarusDownloadManager/releases/tag/v0.3.2)  
+[v0.3.0](https://github.com/kdeng00/IcarusDownloadManager/releases/tag/v0.3.0)  
+[v0.2.0](https://github.com/kdeng00/IcarusDownloadManager/releases/tag/v0.2.0)  
+[v0.1.2](https://github.com/kdeng00/IcarusDownloadManager/releases/tag/v0.1.2)  
 [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
-
-* **Kun Deng** - [amazing-username](https://github.com/amazing-username)
-
-See also the list of [contributors](https://github.com/amazing-username/Icarus/graphs/contributors) who participated in this project.
-
 ## License
 
 This project is licensed under the MIT License - see the [LICENSE.md](LICENSE.md) file for details

cmake/HunterGate.cmake

@@ -1,528 +0,0 @@
-# Copyright (c) 2013-2019, Ruslan Baratov
-# All rights reserved.
-#
-# Redistribution and use in source and binary forms, with or without
-# modification, are permitted provided that the following conditions are met:
-#
-# * Redistributions of source code must retain the above copyright notice, this
-#   list of conditions and the following disclaimer.
-#
-# * Redistributions in binary form must reproduce the above copyright notice,
-#   this list of conditions and the following disclaimer in the documentation
-#   and/or other materials provided with the distribution.
-#
-# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
-# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
-# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
-# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
-# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-# This is a gate file to Hunter package manager.
-# Include this file using `include` command and add package you need, example:
-#
-#     cmake_minimum_required(VERSION 3.2)
-#
-#     include("cmake/HunterGate.cmake")
-#     HunterGate(
-#         URL "https://github.com/path/to/hunter/archive.tar.gz"
-#         SHA1 "798501e983f14b28b10cda16afa4de69eee1da1d"
-#     )
-#
-#     project(MyProject)
-#
-#     hunter_add_package(Foo)
-#     hunter_add_package(Boo COMPONENTS Bar Baz)
-#
-# Projects:
-#     * https://github.com/hunter-packages/gate/
-#     * https://github.com/ruslo/hunter
-
-option(HUNTER_ENABLED "Enable Hunter package manager support" ON)
-
-if(HUNTER_ENABLED)
-  if(CMAKE_VERSION VERSION_LESS "3.2")
-    message(
-        FATAL_ERROR
-        "At least CMake version 3.2 required for Hunter dependency management."
-        " Update CMake or set HUNTER_ENABLED to OFF."
-    )
-  endif()
-endif()
-
-include(CMakeParseArguments) # cmake_parse_arguments
-
-option(HUNTER_STATUS_PRINT "Print working status" ON)
-option(HUNTER_STATUS_DEBUG "Print a lot info" OFF)
-option(HUNTER_TLS_VERIFY "Enable/disable TLS certificate checking on downloads" ON)
-
-set(HUNTER_ERROR_PAGE "https://docs.hunter.sh/en/latest/reference/errors")
-
-function(hunter_gate_status_print)
-  if(HUNTER_STATUS_PRINT OR HUNTER_STATUS_DEBUG)
-    foreach(print_message ${ARGV})
-      message(STATUS "[hunter] ${print_message}")
-    endforeach()
-  endif()
-endfunction()
-
-function(hunter_gate_status_debug)
-  if(HUNTER_STATUS_DEBUG)
-    foreach(print_message ${ARGV})
-      string(TIMESTAMP timestamp)
-      message(STATUS "[hunter *** DEBUG *** ${timestamp}] ${print_message}")
-    endforeach()
-  endif()
-endfunction()
-
-function(hunter_gate_error_page error_page)
-  message("------------------------------ ERROR ------------------------------")
-  message("    ${HUNTER_ERROR_PAGE}/${error_page}.html")
-  message("-------------------------------------------------------------------")
-  message("")
-  message(FATAL_ERROR "")
-endfunction()
-
-function(hunter_gate_internal_error)
-  message("")
-  foreach(print_message ${ARGV})
-    message("[hunter ** INTERNAL **] ${print_message}")
-  endforeach()
-  message("[hunter ** INTERNAL **] [Directory:${CMAKE_CURRENT_LIST_DIR}]")
-  message("")
-  hunter_gate_error_page("error.internal")
-endfunction()
-
-function(hunter_gate_fatal_error)
-  cmake_parse_arguments(hunter "" "ERROR_PAGE" "" "${ARGV}")
-  if("${hunter_ERROR_PAGE}" STREQUAL "")
-    hunter_gate_internal_error("Expected ERROR_PAGE")
-  endif()
-  message("")
-  foreach(x ${hunter_UNPARSED_ARGUMENTS})
-    message("[hunter ** FATAL ERROR **] ${x}")
-  endforeach()
-  message("[hunter ** FATAL ERROR **] [Directory:${CMAKE_CURRENT_LIST_DIR}]")
-  message("")
-  hunter_gate_error_page("${hunter_ERROR_PAGE}")
-endfunction()
-
-function(hunter_gate_user_error)
-  hunter_gate_fatal_error(${ARGV} ERROR_PAGE "error.incorrect.input.data")
-endfunction()
-
-function(hunter_gate_self root version sha1 result)
-  string(COMPARE EQUAL "${root}" "" is_bad)
-  if(is_bad)
-    hunter_gate_internal_error("root is empty")
-  endif()
-
-  string(COMPARE EQUAL "${version}" "" is_bad)
-  if(is_bad)
-    hunter_gate_internal_error("version is empty")
-  endif()
-
-  string(COMPARE EQUAL "${sha1}" "" is_bad)
-  if(is_bad)
-    hunter_gate_internal_error("sha1 is empty")
-  endif()
-
-  string(SUBSTRING "${sha1}" 0 7 archive_id)
-
-  set(
-      hunter_self
-      "${root}/_Base/Download/Hunter/${version}/${archive_id}/Unpacked"
-  )
-
-  set("${result}" "${hunter_self}" PARENT_SCOPE)
-endfunction()
-
-# Set HUNTER_GATE_ROOT cmake variable to suitable value.
-function(hunter_gate_detect_root)
-  # Check CMake variable
-  string(COMPARE NOTEQUAL "${HUNTER_ROOT}" "" not_empty)
-  if(not_empty)
-    set(HUNTER_GATE_ROOT "${HUNTER_ROOT}" PARENT_SCOPE)
-    hunter_gate_status_debug("HUNTER_ROOT detected by cmake variable")
-    return()
-  endif()
-
-  # Check environment variable
-  string(COMPARE NOTEQUAL "$ENV{HUNTER_ROOT}" "" not_empty)
-  if(not_empty)
-    set(HUNTER_GATE_ROOT "$ENV{HUNTER_ROOT}" PARENT_SCOPE)
-    hunter_gate_status_debug("HUNTER_ROOT detected by environment variable")
-    return()
-  endif()
-
-  # Check HOME environment variable
-  string(COMPARE NOTEQUAL "$ENV{HOME}" "" result)
-  if(result)
-    set(HUNTER_GATE_ROOT "$ENV{HOME}/.hunter" PARENT_SCOPE)
-    hunter_gate_status_debug("HUNTER_ROOT set using HOME environment variable")
-    return()
-  endif()
-
-  # Check SYSTEMDRIVE and USERPROFILE environment variable (windows only)
-  if(WIN32)
-    string(COMPARE NOTEQUAL "$ENV{SYSTEMDRIVE}" "" result)
-    if(result)
-      set(HUNTER_GATE_ROOT "$ENV{SYSTEMDRIVE}/.hunter" PARENT_SCOPE)
-      hunter_gate_status_debug(
-          "HUNTER_ROOT set using SYSTEMDRIVE environment variable"
-      )
-      return()
-    endif()
-
-    string(COMPARE NOTEQUAL "$ENV{USERPROFILE}" "" result)
-    if(result)
-      set(HUNTER_GATE_ROOT "$ENV{USERPROFILE}/.hunter" PARENT_SCOPE)
-      hunter_gate_status_debug(
-          "HUNTER_ROOT set using USERPROFILE environment variable"
-      )
-      return()
-    endif()
-  endif()
-
-  hunter_gate_fatal_error(
-      "Can't detect HUNTER_ROOT"
-      ERROR_PAGE "error.detect.hunter.root"
-  )
-endfunction()
-
-function(hunter_gate_download dir)
-  string(
-      COMPARE
-      NOTEQUAL
-      "$ENV{HUNTER_DISABLE_AUTOINSTALL}"
-      ""
-      disable_autoinstall
-  )
-  if(disable_autoinstall AND NOT HUNTER_RUN_INSTALL)
-    hunter_gate_fatal_error(
-        "Hunter not found in '${dir}'"
-        "Set HUNTER_RUN_INSTALL=ON to auto-install it from '${HUNTER_GATE_URL}'"
-        "Settings:"
-        "  HUNTER_ROOT: ${HUNTER_GATE_ROOT}"
-        "  HUNTER_SHA1: ${HUNTER_GATE_SHA1}"
-        ERROR_PAGE "error.run.install"
-    )
-  endif()
-  string(COMPARE EQUAL "${dir}" "" is_bad)
-  if(is_bad)
-    hunter_gate_internal_error("Empty 'dir' argument")
-  endif()
-
-  string(COMPARE EQUAL "${HUNTER_GATE_SHA1}" "" is_bad)
-  if(is_bad)
-    hunter_gate_internal_error("HUNTER_GATE_SHA1 empty")
-  endif()
-
-  string(COMPARE EQUAL "${HUNTER_GATE_URL}" "" is_bad)
-  if(is_bad)
-    hunter_gate_internal_error("HUNTER_GATE_URL empty")
-  endif()
-
-  set(done_location "${dir}/DONE")
-  set(sha1_location "${dir}/SHA1")
-
-  set(build_dir "${dir}/Build")
-  set(cmakelists "${dir}/CMakeLists.txt")
-
-  hunter_gate_status_debug("Locking directory: ${dir}")
-  file(LOCK "${dir}" DIRECTORY GUARD FUNCTION)
-  hunter_gate_status_debug("Lock done")
-
-  if(EXISTS "${done_location}")
-    # while waiting for lock other instance can do all the job
-    hunter_gate_status_debug("File '${done_location}' found, skip install")
-    return()
-  endif()
-
-  file(REMOVE_RECURSE "${build_dir}")
-  file(REMOVE_RECURSE "${cmakelists}")
-
-  file(MAKE_DIRECTORY "${build_dir}") # check directory permissions
-
-  # Disabling languages speeds up a little bit, reduces noise in the output
-  # and avoids path too long windows error
-  file(
-      WRITE
-      "${cmakelists}"
-      "cmake_minimum_required(VERSION 3.2)\n"
-      "project(HunterDownload LANGUAGES NONE)\n"
-      "include(ExternalProject)\n"
-      "ExternalProject_Add(\n"
-      "    Hunter\n"
-      "    URL\n"
-      "    \"${HUNTER_GATE_URL}\"\n"
-      "    URL_HASH\n"
-      "    SHA1=${HUNTER_GATE_SHA1}\n"
-      "    DOWNLOAD_DIR\n"
-      "    \"${dir}\"\n"
-      "    TLS_VERIFY\n"
-      "    ${HUNTER_TLS_VERIFY}\n"
-      "    SOURCE_DIR\n"
-      "    \"${dir}/Unpacked\"\n"
-      "    CONFIGURE_COMMAND\n"
-      "    \"\"\n"
-      "    BUILD_COMMAND\n"
-      "    \"\"\n"
-      "    INSTALL_COMMAND\n"
-      "    \"\"\n"
-      ")\n"
-  )
-
-  if(HUNTER_STATUS_DEBUG)
-    set(logging_params "")
-  else()
-    set(logging_params OUTPUT_QUIET)
-  endif()
-
-  hunter_gate_status_debug("Run generate")
-
-  # Need to add toolchain file too.
-  # Otherwise on Visual Studio + MDD this will fail with error:
-  # "Could not find an appropriate version of the Windows 10 SDK installed on this machine"
-  if(EXISTS "${CMAKE_TOOLCHAIN_FILE}")
-    get_filename_component(absolute_CMAKE_TOOLCHAIN_FILE "${CMAKE_TOOLCHAIN_FILE}" ABSOLUTE)
-    set(toolchain_arg "-DCMAKE_TOOLCHAIN_FILE=${absolute_CMAKE_TOOLCHAIN_FILE}")
-  else()
-    # 'toolchain_arg' can't be empty
-    set(toolchain_arg "-DCMAKE_TOOLCHAIN_FILE=")
-  endif()
-
-  string(COMPARE EQUAL "${CMAKE_MAKE_PROGRAM}" "" no_make)
-  if(no_make)
-    set(make_arg "")
-  else()
-    # Test case: remove Ninja from PATH but set it via CMAKE_MAKE_PROGRAM
-    set(make_arg "-DCMAKE_MAKE_PROGRAM=${CMAKE_MAKE_PROGRAM}")
-  endif()
-
-  execute_process(
-      COMMAND
-      "${CMAKE_COMMAND}"
-      "-H${dir}"
-      "-B${build_dir}"
-      "-G${CMAKE_GENERATOR}"
-      "${toolchain_arg}"
-      ${make_arg}
-      WORKING_DIRECTORY "${dir}"
-      RESULT_VARIABLE download_result
-      ${logging_params}
-  )
-
-  if(NOT download_result EQUAL 0)
-    hunter_gate_internal_error(
-        "Configure project failed."
-        "To reproduce the error run: ${CMAKE_COMMAND} -H${dir} -B${build_dir} -G${CMAKE_GENERATOR} ${toolchain_arg} ${make_arg}"
-        "In directory ${dir}"
-    )
-  endif()
-
-  hunter_gate_status_print(
-      "Initializing Hunter workspace (${HUNTER_GATE_SHA1})"
-      "  ${HUNTER_GATE_URL}"
-      "  -> ${dir}"
-  )
-  execute_process(
-      COMMAND "${CMAKE_COMMAND}" --build "${build_dir}"
-      WORKING_DIRECTORY "${dir}"
-      RESULT_VARIABLE download_result
-      ${logging_params}
-  )
-
-  if(NOT download_result EQUAL 0)
-    hunter_gate_internal_error("Build project failed")
-  endif()
-
-  file(REMOVE_RECURSE "${build_dir}")
-  file(REMOVE_RECURSE "${cmakelists}")
-
-  file(WRITE "${sha1_location}" "${HUNTER_GATE_SHA1}")
-  file(WRITE "${done_location}" "DONE")
-
-  hunter_gate_status_debug("Finished")
-endfunction()
-
-# Must be a macro so master file 'cmake/Hunter' can
-# apply all variables easily just by 'include' command
-# (otherwise PARENT_SCOPE magic needed)
-macro(HunterGate)
-  if(HUNTER_GATE_DONE)
-    # variable HUNTER_GATE_DONE set explicitly for external project
-    # (see `hunter_download`)
-    set_property(GLOBAL PROPERTY HUNTER_GATE_DONE YES)
-  endif()
-
-  # First HunterGate command will init Hunter, others will be ignored
-  get_property(_hunter_gate_done GLOBAL PROPERTY HUNTER_GATE_DONE SET)
-
-  if(NOT HUNTER_ENABLED)
-    # Empty function to avoid error "unknown function"
-    function(hunter_add_package)
-    endfunction()
-
-    set(
-        _hunter_gate_disabled_mode_dir
-        "${CMAKE_CURRENT_LIST_DIR}/cmake/Hunter/disabled-mode"
-    )
-    if(EXISTS "${_hunter_gate_disabled_mode_dir}")
-      hunter_gate_status_debug(
-          "Adding \"disabled-mode\" modules: ${_hunter_gate_disabled_mode_dir}"
-      )
-      list(APPEND CMAKE_PREFIX_PATH "${_hunter_gate_disabled_mode_dir}")
-    endif()
-  elseif(_hunter_gate_done)
-    hunter_gate_status_debug("Secondary HunterGate (use old settings)")
-    hunter_gate_self(
-        "${HUNTER_CACHED_ROOT}"
-        "${HUNTER_VERSION}"
-        "${HUNTER_SHA1}"
-        _hunter_self
-    )
-    include("${_hunter_self}/cmake/Hunter")
-  else()
-    set(HUNTER_GATE_LOCATION "${CMAKE_CURRENT_SOURCE_DIR}")
-
-    string(COMPARE NOTEQUAL "${PROJECT_NAME}" "" _have_project_name)
-    if(_have_project_name)
-      hunter_gate_fatal_error(
-          "Please set HunterGate *before* 'project' command. "
-          "Detected project: ${PROJECT_NAME}"
-          ERROR_PAGE "error.huntergate.before.project"
-      )
-    endif()
-
-    cmake_parse_arguments(
-        HUNTER_GATE "LOCAL" "URL;SHA1;GLOBAL;FILEPATH" "" ${ARGV}
-    )
-
-    string(COMPARE EQUAL "${HUNTER_GATE_SHA1}" "" _empty_sha1)
-    string(COMPARE EQUAL "${HUNTER_GATE_URL}" "" _empty_url)
-    string(
-        COMPARE
-        NOTEQUAL
-        "${HUNTER_GATE_UNPARSED_ARGUMENTS}"
-        ""
-        _have_unparsed
-    )
-    string(COMPARE NOTEQUAL "${HUNTER_GATE_GLOBAL}" "" _have_global)
-    string(COMPARE NOTEQUAL "${HUNTER_GATE_FILEPATH}" "" _have_filepath)
-
-    if(_have_unparsed)
-      hunter_gate_user_error(
-          "HunterGate unparsed arguments: ${HUNTER_GATE_UNPARSED_ARGUMENTS}"
-      )
-    endif()
-    if(_empty_sha1)
-      hunter_gate_user_error("SHA1 suboption of HunterGate is mandatory")
-    endif()
-    if(_empty_url)
-      hunter_gate_user_error("URL suboption of HunterGate is mandatory")
-    endif()
-    if(_have_global)
-      if(HUNTER_GATE_LOCAL)
-        hunter_gate_user_error("Unexpected LOCAL (already has GLOBAL)")
-      endif()
-      if(_have_filepath)
-        hunter_gate_user_error("Unexpected FILEPATH (already has GLOBAL)")
-      endif()
-    endif()
-    if(HUNTER_GATE_LOCAL)
-      if(_have_global)
-        hunter_gate_user_error("Unexpected GLOBAL (already has LOCAL)")
-      endif()
-      if(_have_filepath)
-        hunter_gate_user_error("Unexpected FILEPATH (already has LOCAL)")
-      endif()
-    endif()
-    if(_have_filepath)
-      if(_have_global)
-        hunter_gate_user_error("Unexpected GLOBAL (already has FILEPATH)")
-      endif()
-      if(HUNTER_GATE_LOCAL)
-        hunter_gate_user_error("Unexpected LOCAL (already has FILEPATH)")
-      endif()
-    endif()
-
-    hunter_gate_detect_root() # set HUNTER_GATE_ROOT
-
-    # Beautify path, fix probable problems with windows path slashes
-    get_filename_component(
-        HUNTER_GATE_ROOT "${HUNTER_GATE_ROOT}" ABSOLUTE
-    )
-    hunter_gate_status_debug("HUNTER_ROOT: ${HUNTER_GATE_ROOT}")
-    if(NOT HUNTER_ALLOW_SPACES_IN_PATH)
-      string(FIND "${HUNTER_GATE_ROOT}" " " _contain_spaces)
-      if(NOT _contain_spaces EQUAL -1)
-        hunter_gate_fatal_error(
-            "HUNTER_ROOT (${HUNTER_GATE_ROOT}) contains spaces."
-            "Set HUNTER_ALLOW_SPACES_IN_PATH=ON to skip this error"
-            "(Use at your own risk!)"
-            ERROR_PAGE "error.spaces.in.hunter.root"
-        )
-      endif()
-    endif()
-
-    string(
-        REGEX
-        MATCH
-        "[0-9]+\\.[0-9]+\\.[0-9]+[-_a-z0-9]*"
-        HUNTER_GATE_VERSION
-        "${HUNTER_GATE_URL}"
-    )
-    string(COMPARE EQUAL "${HUNTER_GATE_VERSION}" "" _is_empty)
-    if(_is_empty)
-      set(HUNTER_GATE_VERSION "unknown")
-    endif()
-
-    hunter_gate_self(
-        "${HUNTER_GATE_ROOT}"
-        "${HUNTER_GATE_VERSION}"
-        "${HUNTER_GATE_SHA1}"
-        _hunter_self
-    )
-
-    set(_master_location "${_hunter_self}/cmake/Hunter")
-    get_filename_component(_archive_id_location "${_hunter_self}/.." ABSOLUTE)
-    set(_done_location "${_archive_id_location}/DONE")
-    set(_sha1_location "${_archive_id_location}/SHA1")
-
-    # Check Hunter already downloaded by HunterGate
-    if(NOT EXISTS "${_done_location}")
-      hunter_gate_download("${_archive_id_location}")
-    endif()
-
-    if(NOT EXISTS "${_done_location}")
-      hunter_gate_internal_error("hunter_gate_download failed")
-    endif()
-
-    if(NOT EXISTS "${_sha1_location}")
-      hunter_gate_internal_error("${_sha1_location} not found")
-    endif()
-    file(READ "${_sha1_location}" _sha1_value)
-    string(COMPARE EQUAL "${_sha1_value}" "${HUNTER_GATE_SHA1}" _is_equal)
-    if(NOT _is_equal)
-      hunter_gate_internal_error(
-          "Short SHA1 collision:"
-          "  ${_sha1_value} (from ${_sha1_location})"
-          "  ${HUNTER_GATE_SHA1} (HunterGate)"
-      )
-    endif()
-    if(NOT EXISTS "${_master_location}")
-      hunter_gate_user_error(
-          "Master file not found:"
-          "  ${_master_location}"
-          "try to update Hunter/HunterGate"
-      )
-    endif()
-    include("${_master_location}")
-    set_property(GLOBAL PROPERTY HUNTER_GATE_DONE YES)
-  endif()
-endmacro()

include/Managers/ActionManager.h

@@ -1,43 +0,0 @@
-#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

@@ -1,49 +0,0 @@
-#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

@@ -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

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

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

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

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

include/Models/IcarusAction.h

@@ -1,18 +0,0 @@
-#ifndef ICARUSACTION_H_
-#define ICARUSACTION_H_
-
-#include<string>
-#include<vector>
-
-#include"Flags.h"
-
-namespace Models
-{
-    struct IcarusAction
-    {
-        std::string action;
-        std::vector<Flags> flags;
-    };
-}
-
-#endif

include/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;
-        int track;
-        std::string data;
-        std::string songPath;
-    };
-} 
-
-#endif

include/Models/Token.h

@@ -1,16 +0,0 @@
-#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

@@ -1,16 +0,0 @@
-#ifndef UPLOADFORM_H_
-#define UPLOADFORM_H_
-
-#include<string>
-
-
-namespace Models
-{
-    struct UploadForm
-    {
-        std::string url;
-        std::string filePath;
-    };
-} 
-
-#endif

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

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

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

include/Syncers/Download.h

@@ -1,31 +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(const Models::Token token, Models::Song);
-    private:
-        std::string retrieveUrl(Models::Song);
-
-        std::string downloadFilePath;
-        void saveSong(Models::Song&);
-    };
-}
-
-#endif

include/Syncers/RetrieveRecords.h

@@ -1,26 +0,0 @@
-#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

@@ -1,27 +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;
-
-        enum class Result 
-        {
-            OK = 200,
-            UNAUTHORIZED = 401,
-            NOTFOUND = 404
-        };
-    };
-}
-
-#endif

include/Syncers/Upload.h

@@ -1,48 +0,0 @@
-#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

@@ -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

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

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

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

scripts/bld.sh

@@ -1 +0,0 @@
-cmake -H. -B_builds -DHUNTER_STATUS_DEBUG=ON -DCMAKE_BUILD_TYPE=DEBUG

scripts/deb.sh

@@ -1 +0,0 @@
-cmake --build _builds --config Debug

scripts/rel.sh

@@ -1 +0,0 @@
-cmake --build _builds --config Release

src/Main.cpp

@@ -1,64 +0,0 @@
-#include<iostream>
-#include<string>
-
-#include"Managers/ActionManager.h"
-#include"Managers/CommitManager.h"
-
-using std::cin;
-using std::cout;
-using std::endl;
-using std::string;
-
-using Managers::ActionManager;
-using Managers::CommitManager;
-
-void printHelp()
-{
-    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)
-    {
-        printHelp();
-        return -1;
-    }
-
-    ActionManager actMgr(argv, argc);
-    auto chosenAction = actMgr.retrieveIcarusAction();
-
-    CommitManager commitMgr(chosenAction);
-    commitMgr.commitAction();
-
-    return 0;
-}

src/Managers/ActionManager.cpp

@@ -1,145 +0,0 @@
-#include"Managers/ActionManager.h"
-
-#include<algorithm>
-#include<iostream>
-#include<utility>
-#include<cstring>
-
-using std::cout;
-using std::endl;
-using std::string;
-using std::string_view;
-using std::vector;
-
-using Models::Flags;
-using Models::IcarusAction;
-
-namespace Managers
-{
-    #pragma
-    ActionManager::ActionManager(char **param, int paramCount) : 
-        params(std::move(param)), paramCount(paramCount)
-    {
-        initialize();
-    }
-    #pragma Constructors
-
-
-    #pragma
-    IcarusAction ActionManager::retrieveIcarusAction() const
-    {
-        IcarusAction icarusAction;
-        icarusAction.flags = flags;
-        icarusAction.action = action;
-
-        return icarusAction;
-    }
-
-
-    constexpr std::array<const char*, 12> ActionManager::supportedFlags() noexcept
-    {
-        constexpr std::array<const char*, 12> allFlags{"-u", "-p", "-t", "-h", "-s",
-                "-sd", "-sr", "-d", "-D", "-b", "-rt", "-nc"};
-
-        return allFlags;
-    }
-
-
-    bool ActionManager::isNumber(string_view val) noexcept
-    {
-        return !val.empty() && std::find_if(val.begin(), 
-            val.end(), [](char c)
-            {
-                return !std::isdigit(c);
-                }) == val.end();
-    }
-
-    void ActionManager::initialize()
-    {
-        validateFlags();
-
-        action = std::move(string{params[1]});
-        transform(action.begin(), action.end(),
-                action.begin(), ::tolower);
-    }
-    void ActionManager::validateFlags()
-    {
-        cout<<"Validating flags"<<endl;
-
-        auto flagVals = parsedFlags();
-
-        Flags flg{};
-
-        auto allSupportedFlags = supportedFlags();
-
-        for (auto flag : flagVals)
-        {
-            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;
-                flags.push_back(flg);
-                flg = Flags{};
-                continue;
-            }
-
-            if (std::any_of(allSupportedFlags.begin(), allSupportedFlags.end(), 
-                [&](const char *val)
-                {
-                    return !flag.compare(val);
-                }))
-            {
-                //cout<<"flag "<<flag<<endl;
-                flg.flag = flag;
-            }
-            else
-            {
-                cout<<"Flag is not valid"<<endl;
-                exit(1);
-            }
-        }
-    }
-
-    vector<string> ActionManager::parsedFlags()
-    {
-        auto parsed = vector<string>();
-        
-        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/CommitManager.cpp

@@ -1,229 +0,0 @@
-#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"Managers/TokenManager.h"
-#include"Managers/UserManager.h"
-
-using std::cout;
-using std::endl;
-using std::map;
-using std::string;
-
-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) : icaAction(std::move(icaAct))
-	{ }
-	#pragma Constructors
-
-
-	#pragma
-	void CommitManager::commitAction()
-	{
-		auto action = icaAction.action;
-		cout<<"Commiting "<<action<<" action"<<endl;
-		switch (mapActions()[action])
-		{
-            case ActionValues::deleteAct:
-				deleteSong();
-				break;
-            case ActionValues::downloadAct:
-				downloadSong();
-				break;
-            case ActionValues::retrieveAct:
-                retrieveObjects();
-				break;
-            case ActionValues::uploadAct:
-				uploadSong();
-				break;
-            default:
-                break;
-		}
-	}
-
-
-    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();
-
-		auto token = parseToken(api);
-
-		Song song{};
-
-		for (auto arg : icaAction.flags)
-		{
-			auto flag = arg.flag;
-			auto value = arg.value;
-
-			if (flag.compare("-D") == 0)
-			{
-				song.id = atoi(value.c_str());
-			}
-		}
-
-		Delete del{api};
-		cout<<"Deleting song..."<<endl;
-		del.deleteSong(token, song);
-	}
-	void CommitManager::downloadSong()
-	{
-		cout<<"Starting downloading process..."<<endl;
-
-		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("-d") == 0)
-			{
-				song.songPath.assign(arg.value);
-			}
-			if (flag.compare("-b") == 0)
-			{
-				song.id = atoi(value.c_str());
-			}
-		}
-
-		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()
-	{
-        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/FileManager.cpp

@@ -1,66 +0,0 @@
-#include<iostream>
-#include<fstream>
-
-#include"Managers/FileManager.h"
-
-using std::cout;
-using std::endl;
-using std::ifstream;
-using std::ofstream;
-using std::string;
-
-namespace Managers
-{
-    FileManager::FileManager() {}
-    FileManager::FileManager(string filePath)
-    {
-        this->filePath = filePath;
-        readFile();
-    }   
-
-
-    void FileManager::saveFile(string newFilePath)
-    {
-        if (!fileRead)
-            readFile();
-
-        ofstream of{newFilePath, ofstream::binary};
-        of.write(fileBuffer, fileBufferLength);
-        of.close();
-    }
-
-    void FileManager::readFile()
-    {
-        ifstream is{filePath, ifstream::binary};
-        if (is)
-        {
-            is.seekg (0, is.end);
-            fileBufferLength = is.tellg();
-            is.seekg (0, is.beg);
-
-            fileBuffer = new char [fileBufferLength];
-
-            cout<< "Reading "<<fileBufferLength<<" characters... "<<endl;;
-            is.read (fileBuffer,fileBufferLength);
-
-            if (is)
-                cout<<"all characters read successfully.";
-            else
-                cout<<"error: only "<<is.gcount()<<" could be read";
-            cout<<endl;
-            is.close();
-            fileRead = true;
-        }
-    }
-    void FileManager::modifyFilePath(string filePath)
-    {
-        this->filePath = filePath;
-    }
-
-    char* FileManager::retrieveFileBuffer() const
-    {
-        return fileBuffer;
-    }
-
-    int FileManager::retrieveFileBufferLength() const { return fileBufferLength; }
-}

src/Managers/TokenManager.cpp

@@ -1,60 +0,0 @@
-#include"Managers/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::API;
-using Models::Token;
-using Models::User;
-
-namespace Managers
-{
-    #pragma
-    TokenManager::TokenManager(const User& user)
-    {
-        this->user = user;
-    }
-    TokenManager::TokenManager(const User& user, API& api)
-    {
-        this->user = user;
-        this->api = api;
-        this->api.endpoint = "api/" + api.version 
-            + "/login";
-    }
-    #pragma Constructors
-
-
-    #pragma
-    Token TokenManager::requestToken()
-    {
-        Token token{};
-        json usrObj;
-
-        usrObj["username"] = user.username;
-        usrObj["password"] = user.password;
-
-        cout<<"Sending request for token"<<endl;
-        auto url = api.url + api.endpoint;
-        cout<<url<<endl;
-        auto r = cpr::Post(cpr::Url{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"];
-
-        cout<<"status code "<<r.status_code<<endl;
-
-        return token;
-    }
-    #pragma Functions
-}

src/Managers/UserManager.cpp

@@ -1,53 +0,0 @@
-#include"Managers/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;
-    }
-    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/Parsers/APIParser.cpp

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

src/Syncers/Delete.cpp

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

src/Syncers/Download.cpp

@@ -1,91 +0,0 @@
-#include"Syncers/Download.h"
-
-#include<exception>
-#include<iostream>
-#include<fstream>
-
-#include<cpr/cpr.h>
-
-using std::cout;
-using std::endl;
-using std::exception;
-using std::ofstream;
-using std::string;
-
-using Models::API;
-using Models::Song;
-using Models::Token;
-
-namespace Syncers
-{
-    #pragma
-    Download::Download() { }
-    Download::Download(API api)
-    {
-        this->api = api;
-        this->api.endpoint = "song/data";
-    }
-    Download::Download(string filePath)
-    {
-        downloadFilePath = filePath;
-    }
-    #pragma Constructors
-
-
-    #pragma
-    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{{"Content-type", "audio/mpeg"},
-                                {"Authorization", auth}});
-                
-
-            int statusCode = r.status_code;
-
-            if (statusCode == OK) {
-                song.data = r.text;
-                saveSong(song);
-            }
-
-
-            cout<<"finsihed with status code "<<statusCode<<endl;
-        }
-        catch (exception e)
-        {
-            auto msg = e.what();
-            cout<<msg<<endl;
-        }
-    }
-
-    string Download::retrieveUrl(Song song)
-    {
-        string url{api.url + "api/" + api.version + "/" + 
-            api.endpoint + "/"};
-
-        url.append(std::to_string(song.id));
-        cout<<"url "<<url<<endl;
-
-        return url;
-    }
-
-    void Download::saveSong(Song& song)
-    {
-        cout<<"\nSaving song to: "<<song.songPath<<endl;
-        int bufferLength = song.data.length();
-        const char *data = song.data.c_str();
-        cout<<"buff length  "<<bufferLength<<endl;
-
-        ofstream saveSong{song.songPath, std::ios::binary};
-        saveSong.write(data, bufferLength);
-        saveSong.close();
-    }
-    #pragma Functions
-}

src/Syncers/RetrieveRecords.cpp

@@ -1,62 +0,0 @@
-#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/Upload.cpp

@@ -1,216 +0,0 @@
-#include<iostream>
-#include<filesystem>
-#include<exception>
-
-#include<cpr/cpr.h>
-#include<nlohmann/json.hpp>
-
-#include"Syncers/Upload.h"
-
-using std::cout;
-using std::cin;
-using std::endl;
-using std::exception;
-using std::string;
-
-using json = nlohmann::json;
-
-using Managers::FileManager;
-using Models::API;
-using Models::Song;
-using Models::UploadForm;
-
-using namespace cpr;
-
-namespace Syncers
-{
-    Upload::Upload() { }
-    Upload::Upload(API api) : api(api)
-    {
-        this->api.endpoint = "song/data";
-    }
-
-
-    Song 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}}
-                );
-
-            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)
-        {
-            auto msg = e.what();
-            cout<<msg<<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()
-    {
-        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/UI/AboutWindow.cpp

@@ -1,47 +0,0 @@
-#include"UI/AboutWindow.h"
-
-using std::unique_ptr;
-
-namespace UI
-{
-    AboutWindow::AboutWindow(QWidget* parent): QDialog(parent)
-    {
-        setupWindow();
-    }
-
-
-    void AboutWindow::setupWindow()
-    {
-        windowWidth = 250;
-        windowHeight = 300;
-
-        mainLayoutQt = unique_ptr<QVBoxLayout>{new QVBoxLayout};
-
-        appName = unique_ptr<QLabel>{new QLabel(tr("IcarusDownloadManager"))};
-        actionButtonQt = unique_ptr<QPushButton>{new QPushButton(tr("Close"))};
-
-        mainLayoutQt->addWidget(appName.get());
-        mainLayoutQt->addWidget(actionButtonQt.get());
-
-
-        setFixedWidth(windowWidth);
-        setFixedHeight(windowHeight);
-
-        setLayout(mainLayoutQt.get());
-
-        setWindowTitle("About");
-
-        connections();
-    }
-    void AboutWindow::connections()
-    {
-        QObject::connect(actionButtonQt.get(), SIGNAL(clicked()), this, 
-                        SLOT(closeWindow()));
-    }
-
-
-    void AboutWindow::closeWindow()
-    {
-        this->hide();   
-    }
-}

src/UI/MainWindow.cpp

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

src/Utilities/Conversions.cpp

@@ -1,24 +0,0 @@
-#include"Utilities/Conversions.h"
-
-#include<iostream>
-
-using std::string;
-using std::unique_ptr;
-
-namespace Utilities
-{
-    Conversions::Conversions()
-    {
-        initializeValues();
-    }
-
-    void Conversions::initializeValues()
-    {
-    }
-    template <typename T>
-    void Conversions::printValue(T val)
-    {
-        std::cout<<"going to print value"<<std::endl;
-        std::cout<<val<<std::endl;
-    }
-}

src/constants/file_extensions.rs

@@ -0,0 +1,3 @@
+pub const WAV_FILE_EXTENSION: &str = ".wav";
+pub const _MP3_FILE_EXTENSION: &str = ".mp3";
+pub const JPG_FILE_EXTENSION: &str = ".jpg";

src/constants/mod.rs

@@ -0,0 +1 @@
+pub mod file_extensions;

src/main.rs

@@ -0,0 +1,81 @@
+mod constants;
+mod managers;
+mod models;
+mod parsers;
+mod syncers;
+mod utilities;
+
+use std::env;
+use std::process;
+
+fn exit_program(code: i32) {
+    process::exit(code);
+}
+
+fn print_help() {
+    let msg: String = String::from(
+        r#"icd [Action] [flag]
+
+        Actions
+            download
+            upload-meta
+            retrieve
+            delete
+
+        Flags
+        Required for all actions
+            -u username
+            -p password
+            -h host
+
+        Required for upload with metadata
+            -s path of song
+            -t track number
+            -m metadata filepath
+            -ca coverart filepath
+            -scma directory where songs, metadata, and cover art exists and will be uploaded (Optional)
+
+        Required for download
+            -b song id
+            -d path to download song (Optional)
+
+        Required for retrieving records
+            -rt retrieve type (songs is only accepted)
+
+        Required for deleting a song
+            -D song id"#,
+    );
+
+    println!("{}", msg);
+}
+
+fn main() {
+    let args: Vec<String> = env::args().collect();
+
+    if args.len() == 1 {
+        print_help();
+        exit_program(-1);
+    }
+
+    let args_len = args.len() as i32;
+
+    println!("Argument count: {}", args_len);
+
+    let mut act_mgr = managers::action_managers::ActionManager {
+        action: String::new(),
+        flags: Vec::new(),
+        params: args,
+        param_count: args_len,
+    };
+    act_mgr.initialize();
+
+    let chosen_act = act_mgr.retrieve_icarus_action();
+
+    chosen_act.print_action_and_flags();
+
+    let mut cmt_mgr = managers::commit_manager::CommitManager {
+        ica_action: chosen_act,
+    };
+
+    cmt_mgr.commit_action();
+}

src/managers/action_managers.rs

@@ -0,0 +1,221 @@
+use serde::{Deserialize, Serialize};
+
+use crate::models;
+
+#[derive(Debug, Deserialize, Serialize)]
+pub struct ActionManager {
+    pub action: String,
+    pub flags: Vec<models::flags::Flags>,
+    pub params: Vec<String>,
+    pub param_count: i32,
+}
+
+impl ActionManager {
+    pub fn retrieve_icarus_action(&self) -> models::icarus_action::IcarusAction {
+        return models::icarus_action::IcarusAction {
+            flags: self.flags.clone(),
+            action: String::from(&self.action),
+        };
+    }
+
+    fn supported_flags(&self) -> Vec<String> {
+        return vec![
+            String::from("-u"),
+            String::from("-p"),
+            String::from("-t"),
+            String::from("-h"),
+            String::from("-s"),
+            String::from("-sd"),
+            String::from("-sr"),
+            String::from("-d"),
+            String::from("-D"),
+            String::from("-b"),
+            String::from("-rt"),
+            String::from("-nc"),
+            String::from("-m"),
+            String::from("-ca"),
+            String::from("-smca"),
+            String::from("-t"),
+        ];
+    }
+
+    pub fn initialize(&mut self) {
+        self.validate_flags();
+        self.validate_action();
+        self.action = self.action.to_lowercase();
+    }
+
+    fn validate_flags(&mut self) {
+        println!("Validating flags");
+
+        let flag_vals = self.parsed_flags();
+
+        let mut i = 0;
+        println!("Flag count: {}", flag_vals.len());
+
+        while i < flag_vals.len() {
+            let flag = &flag_vals[i];
+            println!("Index: {} | Value: {}", i, flag);
+
+            let mut flg = models::flags::Flags::default();
+
+            if self.is_valid_flag(flag) && self.does_flag_have_value(flag) {
+                println!("Flag has value");
+                flg.flag = String::from(flag);
+                flg.value = String::from(&flag_vals[i + 1]);
+
+                i = i + 1;
+            } else if self.is_valid_flag(flag) {
+                println!("Flag does not have a value");
+                flg.flag = String::from(flag);
+            } else {
+                println!("Flag {} is not valid", flag);
+                std::process::exit(-1);
+            }
+
+            self.flags.push(flg);
+            println!("");
+            i += 1;
+        }
+    }
+
+    fn validate_action(&mut self) {
+        if self.params.len() >= 2 {
+            let act = &self.params[1];
+            self.action = String::from(act);
+        }
+    }
+
+    fn is_valid_flag(&self, flag: &String) -> bool {
+        let flags = self.supported_flags();
+        let mut found: bool = false;
+
+        for flg in &flags {
+            if flg == flag {
+                found = true;
+                break;
+            }
+        }
+
+        return found;
+    }
+
+    fn does_flag_have_value(&self, flag: &String) -> bool {
+        let flags_tmp = self.parsed_flags();
+
+        let mut i_found: i32 = -1;
+
+        for i in 0..flags_tmp.len() {
+            let flg = &flags_tmp[i];
+            if flg == flag {
+                i_found = i as i32;
+                break;
+            }
+        }
+
+        if i_found >= 0 {
+            if (i_found + 1) < flags_tmp.len().try_into().unwrap() {
+                return true;
+            } else {
+                return false;
+            }
+        } else {
+            return false;
+        }
+    }
+
+    fn _print_action(&self) {
+        if self.action.len() == 0 {
+            println!("Action is empty");
+        } else {
+            println!("Action is {}", self.action);
+        }
+    }
+
+    fn _print_flags(&self) {
+        println!("Printing flags...");
+        for flag in &self.flags {
+            println!("Flag {}", flag.flag);
+            println!("Value {}", flag.value);
+        }
+    }
+
+    fn parsed_flags(&self) -> Vec<String> {
+        let mut parsed: Vec<String> = Vec::new();
+
+        for i in 2..self.params.len() {
+            let flag = String::from(&self.params[i]);
+            parsed.push(flag);
+        }
+
+        return parsed;
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::managers::action_managers::ActionManager;
+
+    #[test]
+    fn minimum_action_and_args() {
+        let args: Vec<String> = vec![
+            "icarus-dm".to_string(),
+            "download".to_string(),
+            "-u".to_string(),
+            "jamborie".to_string(),
+            "-p".to_string(),
+            "somethingsecr3t!".to_string(),
+            "-h".to_string(),
+            "https://music-server.com".to_string(),
+        ];
+        let arg_count = args.len() as i32;
+        let minimum_arg_count = 8;
+        assert!(arg_count >= minimum_arg_count);
+
+        let mut act_mgr = ActionManager {
+            action: String::new(),
+            flags: Vec::new(),
+            params: args,
+            param_count: arg_count,
+        };
+        act_mgr.initialize();
+        let ica = act_mgr.retrieve_icarus_action();
+        let action = &ica.action;
+        let flags = &ica.flags;
+
+        assert!(action != "");
+        assert!(flags.len() > 2);
+        assert!(
+            !(action != "download"
+                && action != "upload"
+                && action != "retrieve"
+                && action != "upload-meta")
+        );
+
+        let mut all_flags_found = false;
+        let mut found_count = 0;
+        let mut flags_already_read = Vec::new();
+
+        for flag in flags {
+            if flags_already_read.contains(&flag.flag) {
+                continue;
+            }
+
+            if flag.flag == "-u" {
+                found_count += 1;
+                flags_already_read.push(flag.flag.clone());
+            } else if flag.flag == "-p" {
+                found_count += 1;
+                flags_already_read.push(flag.flag.clone());
+            } else if flag.flag == "-h" {
+                found_count += 1;
+                flags_already_read.push(flag.flag.clone());
+            }
+        }
+
+        all_flags_found = found_count == 3;
+
+        assert_eq!(found_count, 3, "Three flags are required: -u, -p, -h");
+        assert!(all_flags_found, "All flags have not been found");
+    }
+}

src/managers/commit_manager.rs

@@ -0,0 +1,745 @@
+use std::collections::HashMap;
+use std::default::Default;
+use std::fs::read_dir;
+use std::io::{Result, Write};
+use std::str::FromStr;
+
+use serde::{Deserialize, Serialize};
+use tokio::runtime::Runtime;
+
+use crate::managers;
+use crate::models::song::Album;
+use crate::models::{self};
+use crate::syncers;
+use crate::utilities;
+use crate::{constants, parsers};
+
+#[derive(Debug, Deserialize, Serialize)]
+pub struct CommitManager {
+    pub ica_action: models::icarus_action::IcarusAction,
+}
+
+#[derive(Clone, Debug)]
+enum ActionValues {
+    DeleteAct,
+    DownloadAct,
+    RetrieveAct,
+    UploadAct,
+    UploadSongWithMetadata,
+    None,
+}
+
+enum _RetrieveTypes {
+    Songs,
+}
+
+#[derive(Clone, Debug)]
+enum En {
+    ImageFile,
+    SongFile,
+    MetadataFile,
+    Other,
+}
+
+impl Album {
+    pub fn _print_info(&self) {
+        println!("Album: {}", self.title);
+        println!("Album Artist: {}", self.album_artist);
+        println!("Genre: {}", self.genre);
+        println!("Year: {}", self.year);
+        println!("Track Count: {}", self.track_count);
+        println!("Disc Count: {}\n", self.disc_count);
+    }
+
+    pub fn retrieve_song(&self, track: i32, disc: i32) -> Result<models::song::Song> {
+        let mut found = false;
+        let mut song = models::song::Song::default();
+
+        for song_i in &self.songs {
+            if song_i.track.unwrap() == track && song_i.disc.unwrap() == disc {
+                song = song_i.clone();
+                found = true;
+            }
+        }
+
+        if found {
+            return Ok(song);
+        }
+
+        return Err(std::io::Error::new(
+            std::io::ErrorKind::NotFound,
+            "Song not found",
+        ));
+    }
+}
+
+impl CommitManager {
+    pub fn commit_action(&mut self) {
+        let action = &self.ica_action.action;
+        println!("Committing {} action", action);
+
+        let mapped_actions = &self.map_actions();
+        let mapped_action = self.find_mapped_action(&mapped_actions, action);
+
+        println!("{:?}", mapped_action);
+
+        match mapped_action {
+            ActionValues::DeleteAct => self.delete_song(),
+            ActionValues::DownloadAct => self.download_song(),
+            ActionValues::RetrieveAct => self.retrieve_object(),
+            ActionValues::UploadAct => self.upload_song(),
+            ActionValues::UploadSongWithMetadata => self.upload_song_with_metadata(),
+            _ => {
+                println!("Nothing good here");
+            }
+        }
+    }
+
+    fn find_mapped_action(
+        &self,
+        actions: &HashMap<String, ActionValues>,
+        action: &String,
+    ) -> ActionValues {
+        for (key, act) in actions {
+            if key == action {
+                return act.clone();
+            }
+        }
+
+        return ActionValues::None;
+    }
+
+    fn map_actions(&self) -> HashMap<String, ActionValues> {
+        let mut actions: HashMap<String, ActionValues> = HashMap::new();
+        actions.insert("download".to_string(), ActionValues::DownloadAct);
+        actions.insert("upload".to_string(), ActionValues::UploadAct);
+        actions.insert(
+            "upload-meta".to_string(),
+            ActionValues::UploadSongWithMetadata,
+        );
+        actions.insert("retrieve".to_string(), ActionValues::RetrieveAct);
+        actions.insert("delete".to_string(), ActionValues::DeleteAct);
+
+        return actions;
+    }
+
+    fn delete_song(&self) {
+        let mut prsr = parsers::api_parser::APIParser {
+            ica_act: self.ica_action.clone(),
+            api: models::api::API::default(),
+        };
+        prsr.parse_api();
+        let api = prsr.retrieve_api();
+
+        let token = self.parse_token(&api);
+
+        println!("Deleting song");
+
+        let mut song = models::song::Song::default();
+
+        for arg in &self.ica_action.flags {
+            let flag = &arg.flag;
+            let value = &arg.value;
+
+            if flag == "-D" {
+                song.id = Some(value.parse::<i32>().unwrap());
+            }
+        }
+
+        let mut del = syncers::delete::Delete { api: api.clone() };
+
+        println!("Deleting song..");
+
+        let res_fut = del.delete_song(&token, &song);
+        let result = Runtime::new().unwrap().block_on(res_fut);
+        match result {
+            Ok(o) => {
+                println!("Song (Id {:?}) has been successfully deleted", o.id);
+            }
+            Err(er) => {
+                println!("Error {:?}", er);
+            }
+        }
+    }
+
+    fn download_song(&self) {
+        println!("Deleting song");
+        let dwn = self.ica_action.retrieve_flag_value(&String::from("-b"));
+        let num: i32 = dwn.parse::<i32>().unwrap();
+
+        let mut prsr = parsers::api_parser::APIParser {
+            api: models::api::API::default(),
+            ica_act: self.ica_action.clone(),
+        };
+        prsr.parse_api();
+
+        let api = prsr.retrieve_api();
+        let token = self.parse_token(&api);
+
+        let mut dwn_loader = syncers::download::Download { api: api.clone() };
+        let mut song = models::song::Song::default();
+        song.id = Some(num);
+        let result_fut = dwn_loader.download_song(&token, &song);
+        let result = Runtime::new().unwrap().block_on(result_fut);
+        match result {
+            Ok(o) => {
+                println!("Success");
+                let mut filename = String::from("audio");
+                filename += constants::file_extensions::WAV_FILE_EXTENSION;
+                let data = o.as_bytes();
+                let mut file = std::fs::File::create(filename).expect("Failed to save");
+                file.write_all(&data).expect("ff");
+            }
+            Err(er) => {
+                println!("Error {:?}", er);
+            }
+        }
+    }
+
+    fn retrieve_object(&self) {
+        println!("Deleting song");
+        let rt = self.ica_action.retrieve_flag_value(&String::from("-rt"));
+
+        if rt != "songs" {
+            panic!("Unsupported -rt: {}", rt);
+        }
+
+        let mut prsr = parsers::api_parser::APIParser {
+            api: models::api::API::default(),
+            ica_act: self.ica_action.clone(),
+        };
+        prsr.parse_api();
+
+        let api = prsr.retrieve_api();
+        let token = self.parse_token(&api);
+        let mut repo = syncers::retrieve_records::RetrieveRecords { api: api.clone() };
+        let result_fut = repo.get_all_songs(&token);
+
+        let result = Runtime::new().unwrap().block_on(result_fut);
+        match result {
+            Ok(o) => {
+                for son in o {
+                    son.print_info();
+                }
+            }
+            Err(er) => {
+                println!("Error: {:?}", er);
+            }
+        }
+    }
+
+    fn upload_song(&self) {
+        println!("Deleting song");
+        panic!("Not supported");
+    }
+
+    fn parse_token(&self, api: &models::api::API) -> models::token::Token {
+        println!("Fetching token");
+
+        let mut usr_mgr: managers::user_manager::UserManager =
+            managers::user_manager::UserManager {
+                user: models::user::User {
+                    username: String::new(),
+                    password: String::new(),
+                },
+                ica_action: self.ica_action.clone(),
+            };
+        usr_mgr.parse_user_from_actions();
+
+        let usr = usr_mgr.retrieve_user();
+        let mut tok_mgr = managers::token_manager::TokenManager {
+            user: usr,
+            api: api.clone(),
+        };
+        tok_mgr.init();
+
+        let token = Runtime::new().unwrap().block_on(tok_mgr.request_token());
+
+        return token.unwrap();
+    }
+
+    fn upload_song_with_metadata(&mut self) {
+        println!("Uplodaring song with metadara");
+
+        let songpath = self.ica_action.retrieve_flag_value(&String::from("-s"));
+        let metadata_path = self.ica_action.retrieve_flag_value(&String::from("-m"));
+        let coverpath = self.ica_action.retrieve_flag_value(&String::from("-ca"));
+        let track_id = self.ica_action.retrieve_flag_value(&String::from("-t"));
+
+        let single_target = songpath.len() > 0
+            && metadata_path.len() > 0
+            && coverpath.len() > 0
+            && track_id.len() > 0;
+
+        let uni = self.ica_action.retrieve_flag_value(&String::from("-smca"));
+        let multitarget = uni.len() > 0;
+
+        if single_target && multitarget {
+            println!("Cannot upload from source and directory");
+            panic!("What??");
+        }
+
+        if single_target {
+            println!("Song path: {}", songpath);
+            println!("Track ID: {}", track_id);
+            println!("metadata path: {}", metadata_path);
+            println!("cover art path: {}", coverpath);
+
+            let _ = self.sing_target_upload(&songpath, &track_id, &metadata_path, &coverpath);
+        } else if multitarget {
+            let _ = self.multi_target_upload(&uni);
+        } else {
+            println!("Single or Multi target has not been chosen");
+        }
+    }
+
+    fn sing_target_upload(
+        &mut self,
+        songpath: &String,
+        track_id: &String,
+        meta_path: &String,
+        cover_path: &String,
+    ) -> Result<()> {
+        let mut prsr = parsers::api_parser::APIParser {
+            api: models::api::API::default(),
+            ica_act: self.ica_action.clone(),
+        };
+        prsr.parse_api();
+
+        let api = prsr.retrieve_api();
+        let token = self.parse_token(&api);
+
+        let song_file = std::path::Path::new(&songpath);
+
+        if !song_file.exists() {
+            println!("Song file does not exist");
+            panic!("Error");
+        }
+
+        let mut cover_art = models::song::CoverArt::default();
+        let mut song = models::song::Song::default();
+        let mut filenames = Vec::new();
+        let mut fp = String::new();
+        let mut dir = String::new();
+
+        let entry = &song_file;
+
+        let file_name = std::ffi::OsString::from(entry.file_name().unwrap());
+
+        println!("file name: {:?}", file_name);
+
+        match self.find_file_extension(&file_name) {
+            En::ImageFile => {}
+            En::MetadataFile => {}
+            En::SongFile => {
+                let fname = self.o_to_string(&file_name);
+
+                match fname {
+                    Ok(s) => {
+                        filenames.push(s.clone());
+                        fp = s.clone();
+                        dir = song_file.parent().unwrap().display().to_string();
+                        song.filepath = Some(s.clone());
+                        song.directory = Some(dir.clone());
+                        self.initialize_disc_and_track(&mut song);
+                    }
+                    Err(er) => println!("Error: {:?}", er),
+                }
+            }
+            _ => {}
+        }
+
+        cover_art.path = Some(cover_path.clone());
+
+        let album = self.retrieve_metadata(&meta_path);
+        let trck = i32::from_str(track_id).unwrap();
+        let mut s = album.retrieve_song(trck, 1).unwrap();
+        s.filepath = Some(fp);
+        s.directory = Some(dir);
+        s.genre = Some(album.genre.clone());
+        s.year = Some(album.year.clone());
+        s.album = Some(album.title.clone());
+        s.data = Some(s.to_data().unwrap());
+
+        cover_art.data = Some(cover_art.to_data().unwrap());
+
+        let mut up = syncers::upload::Upload::default();
+        let host = self.ica_action.retrieve_flag_value(&String::from("-h"));
+        up.set_api(&host);
+
+        let res = up.upload_song_with_metadata(&token, &s, &cover_art, &album);
+        let tken = Runtime::new().unwrap().block_on(res);
+
+        match &tken {
+            Ok(o) => {
+                println!("Successfully sent {:?}", o);
+            }
+            Err(er) => {
+                println!("Some error {:?}", er);
+            }
+        }
+
+        Ok(())
+    }
+
+    fn multi_target_upload(&mut self, sourcepath: &String) -> std::io::Result<()> {
+        let mut prsr = parsers::api_parser::APIParser {
+            api: models::api::API::default(),
+            ica_act: self.ica_action.clone(),
+        };
+        prsr.parse_api();
+        let api = prsr.retrieve_api();
+        let token = self.parse_token(&api);
+
+        let directory_path = std::path::Path::new(&sourcepath);
+
+        if !directory_path.exists() {
+            panic!("Directory does not exist");
+        }
+
+        let mut cover_art = models::song::CoverArt::default();
+        let mut songs: Vec<models::song::Song> = Vec::new();
+        let mut filenames: Vec<String> = Vec::new();
+        let mut metadatapath: String = String::new();
+
+        // iterate files in metadatapath
+        let path = std::path::Path::new(directory_path);
+
+        for entry in read_dir(path)? {
+            let entry = entry?;
+
+            let file_type = entry.file_type();
+            let file_name = entry.file_name();
+
+            println!("file type: {:?}", file_type);
+            println!("file name: {:?}", file_name);
+
+            match self.find_file_extension(&file_name) {
+                En::ImageFile => {
+                    let directory_part = sourcepath.clone();
+                    let fname = self.o_to_string(&file_name);
+                    let fullpath = directory_part + "/" + &fname.unwrap();
+                    cover_art.path = Some(fullpath);
+                }
+                En::MetadataFile => {
+                    let directory_part = sourcepath.clone();
+                    let fname = self.o_to_string(&file_name);
+                    metadatapath = directory_part + "/" + &fname.unwrap();
+                }
+                En::SongFile => {
+                    let mut song = models::song::Song::default();
+                    let fname = self.o_to_string(&file_name);
+
+                    match fname {
+                        Ok(s) => {
+                            filenames.push(s.clone());
+                            song.filepath = Some(s.clone());
+                            song.directory = Some(sourcepath.clone());
+                            song.data = Some(song.to_data().unwrap());
+                            self.initialize_disc_and_track(&mut song);
+                        }
+                        Err(er) => println!("Error: {:?}", er),
+                    }
+
+                    songs.push(song)
+                }
+                _ => {}
+            }
+        }
+
+        filenames.sort();
+
+        let mut album = self.retrieve_metadata(&metadatapath);
+
+        self.song_parsing(&mut album, &sourcepath, &filenames);
+
+        let mut up = syncers::upload::Upload::default();
+        let host = self.ica_action.retrieve_flag_value(&String::from("-h"));
+        up.set_api(&host);
+
+        cover_art.data = Some(cover_art.to_data().unwrap());
+
+        println!("");
+
+        for sng in &mut album.songs {
+            match sng.data {
+                Some(_) => {}
+                None => {
+                    sng.data = Some(sng.to_data().unwrap());
+                }
+            };
+        }
+
+        for song in &album.songs {
+            // Upload each song
+            println!("Sending song...");
+            let res = up.upload_song_with_metadata(&token, &song, &cover_art, &album);
+            let tken = Runtime::new().unwrap().block_on(res);
+
+            match &tken {
+                Ok(o) => {
+                    println!("Successfully sent {:?}", o);
+                }
+                Err(er) => {
+                    println!("Some error {:?}", er);
+                }
+            }
+
+            println!("");
+        }
+
+        Ok(())
+    }
+
+    // Makes sure the elements in album.songs is populated
+    fn song_parsing(
+        &self,
+        album: &mut models::song::Album,
+        directory: &String,
+        filenames: &Vec<String>,
+    ) {
+        // Apply directory
+        for song in &mut album.songs {
+            let dir = &song.directory;
+            match dir {
+                Some(s) => println!("{}", s),
+                None => {
+                    song.directory = Some(directory.clone());
+                }
+            }
+        }
+
+        // Apply filename
+        let mut index = 0;
+        for song in &mut album.songs {
+            let filename = filenames[index].clone();
+            song.filepath = Some(filename);
+            index += 1;
+        }
+
+        for song in &mut album.songs {
+            match &mut song.album {
+                Some(_) => {}
+                None => {
+                    song.album = Some(album.title.clone());
+                }
+            }
+
+            match &mut song.genre {
+                Some(_) => {}
+                None => {
+                    song.genre = Some(album.genre.clone());
+                }
+            }
+
+            match &mut song.year {
+                Some(_) => {}
+                None => {
+                    song.year = Some(album.year.clone());
+                }
+            }
+        }
+    }
+
+    fn find_file_extension(&self, file_name: &std::ffi::OsString) -> En {
+        let file_name_str = Some(file_name.clone().into_string());
+
+        match file_name_str {
+            Some(string) => {
+                let a = string.unwrap();
+                let split = a.split(".");
+                let mut last_index = 0;
+
+                for _ in split.clone() {
+                    last_index += 1;
+                }
+
+                let mut extension = String::new();
+                let mut index = 1;
+
+                for word in split {
+                    if index == last_index {
+                        extension = word.to_string();
+                        break;
+                    }
+
+                    index += 1;
+                }
+
+                if extension == "wav" || extension == "flac" {
+                    return En::SongFile;
+                } else if extension == "json" {
+                    return En::MetadataFile;
+                } else if extension == "jpg" || extension == "jpeg" || extension == "png" {
+                    return En::ImageFile;
+                }
+            }
+            _ => {
+                return En::Other;
+            }
+        }
+
+        return En::Other;
+    }
+
+    fn o_to_string(&self, val: &std::ffi::OsString) -> Result<std::string::String> {
+        let res = val.clone().into_string();
+        return match res {
+            Ok(sss) => Ok(sss),
+            Err(_) => Ok(String::from("Error")),
+        };
+    }
+
+    // Standards
+    // * track01.cdda.wav - Disc 1, Track 1
+    // * track02d02.cdda.wav - Disc 2, Track 2
+    fn initialize_disc_and_track(&mut self, song: &mut models::song::Song) {
+        let mut disc = 1;
+        let mut track = 1;
+        let mut mode = 0;
+        let filename =
+            &<std::option::Option<std::string::String> as Clone>::clone(&song.filepath).unwrap();
+
+        let trd = filename.contains("trackd");
+        let tr = filename.contains("track");
+
+        if tr {
+            mode = 1;
+        }
+
+        if trd {
+            mode = 2;
+        }
+
+        let dl = |a: &char, b: &char| -> bool {
+            return a == b;
+        };
+        let d = utilities::checks::Checks::index_of_item_in_container(&filename, &'d', dl);
+        let k = utilities::checks::Checks::index_of_item_in_container(&filename, &'k', dl);
+        let dot = utilities::checks::Checks::index_of_item_in_container(&filename, &'.', dl);
+        let end = filename.len() as i32;
+
+        match mode {
+            1 => {
+                if k != end && dot != end {
+                    let st = k + 1;
+                    let ed = dot - 1;
+                    let mut t: String = String::new();
+                    let mut index = 0;
+                    for a in filename.chars() {
+                        if index >= st && index <= ed {
+                            t.push(a);
+                        }
+
+                        index += 1;
+                    }
+
+                    if utilities::checks::Checks::is_numeric(&t) {
+                        track = t.parse::<i32>().unwrap();
+                    }
+                    disc = 1
+                }
+            }
+            2 => {
+                if k != end && dot != end && d != end {
+                    let st = k + 1;
+                    let ed = dot - 1;
+                    let mut t: String = String::new();
+                    let mut index = 0;
+                    for a in filename.chars() {
+                        if index <= ed {
+                            t.push(a);
+                        } else if index >= st {
+                            t.push(a);
+                        }
+
+                        index += 1;
+                    }
+
+                    if utilities::checks::Checks::is_numeric(&t) {
+                        track = t.parse::<i32>().unwrap();
+                    }
+
+                    let sst = d + 1;
+                    let eed = dot;
+                    let mut d_s = String::new();
+                    index = 0;
+                    for a in filename.chars() {
+                        if index <= eed {
+                            d_s.push(a);
+                        } else if index >= sst {
+                            d_s.push(a);
+                        }
+
+                        index += 1;
+                    }
+
+                    if utilities::checks::Checks::is_numeric(&d_s) {
+                        track = d_s.parse::<i32>().unwrap();
+                    }
+                }
+            }
+            _ => println!(""),
+        }
+
+        song.disc = Some(disc);
+        song.track = Some(track);
+    }
+
+    fn _parse_disc_and_track(&self, song: &mut models::song::Song, track_id: &String) {
+        let sep = |_a: &char, _b: &char| -> bool {
+            return false;
+        };
+
+        let index = utilities::checks::Checks::index_of_item_in_container(track_id, &':', sep);
+
+        if index == -1 {
+            let mut d_str: String = String::new();
+            let t_str = String::new();
+
+            for c in track_id.chars().skip(0).take(index as usize) {
+                d_str.push(c);
+            }
+
+            let start = index + 1;
+            let end = track_id.len() - 1;
+
+            for c in track_id.chars().skip(start as usize).take(end as usize) {
+                d_str.push(c);
+            }
+
+            song.disc = Some(d_str.parse::<i32>().unwrap());
+            song.track = Some(t_str.parse::<i32>().unwrap());
+        } else {
+            if utilities::checks::Checks::is_numeric(track_id) {
+                song.track = Some(track_id.parse::<i32>().unwrap());
+            }
+        }
+    }
+
+    fn _check_for_no_confirm(&self) -> bool {
+        for flag in self.ica_action.flags.iter() {
+            if flag.flag == "-nc" {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    fn retrieve_metadata(&self, path: &String) -> Album {
+        let content = self.retrieve_file_content(&path);
+        let val = content.unwrap();
+
+        let converted = serde_json::from_str(&val);
+
+        match &converted {
+            Ok(_) => println!("Good!"),
+            Err(er) => println!("Error {:?}", er),
+        }
+        return converted.unwrap();
+    }
+
+    fn retrieve_file_content(&self, path: &String) -> Result<String> {
+        return std::fs::read_to_string(path);
+    }
+}

src/managers/file_manager.rs

@@ -0,0 +1,64 @@
+use std::default::Default;
+
+
+pub struct FileManager {
+    pub filepath: String,
+    pub filebuffer: String,
+    pub file_read: bool,
+    pub file_buffer_length: i32,
+}
+
+impl Default for FileManager {
+    fn default() -> Self {
+        FileManager {
+            filepath: String::new(),
+            filebuffer: String::new(),
+            file_read: false,
+            file_buffer_length: -1
+        }
+    }
+}
+
+
+impl FileManager {
+    // TODO: Implement
+    pub fn init(&mut self) {
+        self.read_file()
+    }
+
+    pub fn save_file(&mut self, filepath: &String) {
+        if !self.file_read {
+            self.read_file();
+        }
+
+        let mut file = File::open(filepath)?;
+        let mut buffer = Vec::new();
+        file.read_to_end(&mut buffer)?;
+        self.file_buffer_length = buffer.len();
+        self.filebuffer = String::from_utf8(buffer); // Assuming UTF-8 encoding
+    }
+
+    pub fn modify_file_path(&mut self, file: &String) {
+        self.filepath = file;
+    }
+
+    pub fn retrieve_file_buffer(&self) -> String {
+        self.filebuffer;
+    }
+
+    pub fn retrieve_file_length(&self) -> i32 {
+        self.file_buffer_length;
+    }
+
+    fn read_file(&mut self) -> Vec<u8> {
+        let mut file = File::open(self.filepath)?;
+        let mut buffer = Vec::new();
+        file.read_to_end(&mut buffer)?;
+        self.file_buffer_length = buffer.len();
+        self.filebuffer = String::from_utf8(buffer); // Assuming UTF-8 encoding
+        self.file_read = true;
+
+        return buffer;
+    }
+}
+

src/managers/mod.rs

@@ -0,0 +1,4 @@
+pub mod action_managers;
+pub mod commit_manager;
+pub mod token_manager;
+pub mod user_manager;

src/managers/token_manager.rs

@@ -0,0 +1,73 @@
+use std::default::Default;
+
+use crate::models;
+
+pub struct TokenManager {
+    pub user: models::user::User,
+    pub api: models::api::API,
+}
+
+impl Default for TokenManager {
+    fn default() -> Self {
+        let mut token = TokenManager {
+            user: models::user::User::default(),
+            api: models::api::API::default(),
+        };
+
+        token.init();
+
+        return token;
+    }
+}
+
+impl TokenManager {
+    pub async fn request_token(&self) -> Result<models::token::Token, std::io::Error> {
+        println!("Sending request for a token");
+
+        let url = self.retrieve_url();
+
+        println!("URL: {}", url);
+
+        let mut token = models::token::Token::default();
+
+        let client = reqwest::Client::new();
+        let response = client.post(&url).json(&self.user).send().await.unwrap();
+
+        match response.status() {
+            reqwest::StatusCode::OK => {
+                // on success, parse our JSON to an APIResponse
+                let s = response.json::<models::token::Token>().await;
+                match s {
+                    //
+                    Ok(parsed) => {
+                        token = parsed;
+                    }
+                    Err(_) => println!("Hm, the response didn't match the shape we expected."),
+                };
+            }
+            reqwest::StatusCode::UNAUTHORIZED => {
+                println!("Need to grab a new token");
+            }
+            other => {
+                panic!("Uh oh! Something unexpected happened: {:?}", other);
+            }
+        }
+
+        return Ok(token);
+    }
+
+    pub fn init(&mut self) {
+        let api = &mut self.api;
+        api.version = String::from("v1");
+        api.endpoint = String::from(format!("api/{}/login", api.version));
+    }
+
+    pub fn retrieve_url(&self) -> String {
+        let api = &self.api;
+        let mut url = String::from(&api.url);
+        url += &String::from(&api.endpoint);
+        url += &String::from("/");
+
+        return url;
+    }
+}

src/managers/user_manager.rs

@@ -0,0 +1,42 @@
+use std::default::Default;
+
+use serde::{Deserialize, Serialize};
+
+use crate::models::{self};
+
+#[derive(Debug, Deserialize, Serialize)]
+pub struct UserManager {
+    pub user: models::user::User,
+    pub ica_action: models::icarus_action::IcarusAction,
+}
+
+impl Default for UserManager {
+    fn default() -> Self {
+        UserManager {
+            user: models::user::User::default(),
+            ica_action: models::icarus_action::IcarusAction::default(),
+        }
+    }
+}
+
+impl UserManager {
+    pub fn retrieve_user(&self) -> models::user::User {
+        return self.user.clone();
+    }
+
+    pub fn parse_user_from_actions(&mut self) {
+        let args = &self.ica_action.flags;
+
+        for arg in args {
+            let flag = &arg.flag;
+
+            if flag == "-u" {
+                self.user.username = String::from(&arg.value);
+            }
+
+            if flag == "-p" {
+                self.user.password = String::from(&arg.value);
+            }
+        }
+    }
+}

src/models/api.rs

@@ -0,0 +1,20 @@
+use std::default::Default;
+
+use serde::{Deserialize, Serialize};
+
+#[derive(Clone, Debug, Deserialize, Serialize)]
+pub struct API {
+    pub url: String,
+    pub endpoint: String,
+    pub version: String,
+}
+
+impl Default for API {
+    fn default() -> Self {
+        API {
+            url: String::new(),
+            endpoint: String::new(),
+            version: String::new(),
+        }
+    }
+}

src/models/flags.rs

@@ -0,0 +1,18 @@
+use std::default::Default;
+
+use serde::{Deserialize, Serialize};
+
+#[derive(Clone, Debug, Deserialize, Serialize)]
+pub struct Flags {
+    pub flag: String,
+    pub value: String,
+}
+
+impl Default for Flags {
+    fn default() -> Self {
+        Flags {
+            flag: String::new(),
+            value: String::new(),
+        }
+    }
+}

src/models/icarus_action.rs

@@ -0,0 +1,44 @@
+use std::default::Default;
+
+use serde::{Deserialize, Serialize};
+
+use crate::models;
+
+#[derive(Clone, Debug, Deserialize, Serialize)]
+pub struct IcarusAction {
+    pub action: String,
+    pub flags: Vec<models::flags::Flags>,
+}
+
+impl Default for IcarusAction {
+    fn default() -> Self {
+        IcarusAction {
+            action: String::new(),
+            flags: Vec::new(),
+        }
+    }
+}
+
+impl IcarusAction {
+    pub fn retrieve_flag_value(&self, flag: &String) -> String {
+        let mut val: String = String::new();
+
+        for f in self.flags.iter() {
+            if f.flag == *flag {
+                val = f.value.clone();
+                break;
+            }
+        }
+
+        return val;
+    }
+
+    pub fn print_action_and_flags(&self) {
+        println!("Action: {}", self.action);
+        println!("Flag count: {}", self.flags.len());
+
+        for flag in self.flags.iter() {
+            println!("flag {} value {}", flag.flag, flag.value);
+        }
+    }
+}

src/models/mod.rs

@@ -0,0 +1,7 @@
+pub mod api;
+pub mod flags;
+pub mod icarus_action;
+pub mod song;
+pub mod token;
+pub mod upload_form;
+pub mod user;

src/models/song.rs

@@ -0,0 +1,171 @@
+use std::default::Default;
+use std::io::Read;
+
+use serde::{Deserialize, Serialize};
+
+use crate::constants;
+
+#[derive(Clone, Debug, Deserialize, Serialize)]
+pub struct Song {
+    #[serde(alias = "song_id")]
+    pub id: Option<i32>,
+    pub title: Option<String>,
+    pub artist: Option<String>,
+    pub album: Option<String>,
+    pub genre: Option<String>,
+    pub year: Option<i32>,
+    pub duration: Option<f64>,
+    pub track: Option<i32>,
+    pub disc: Option<i32>,
+    pub data: Option<Vec<u8>>,
+    pub filepath: Option<String>,
+    pub directory: Option<String>,
+}
+
+#[derive(Debug, Deserialize, Serialize)]
+pub struct Album {
+    #[serde(alias = "album")]
+    pub title: String,
+    pub album_artist: String,
+    pub genre: String,
+    pub year: i32,
+    pub track_count: i32,
+    pub disc_count: i32,
+    #[serde(alias = "tracks")]
+    pub songs: Vec<Song>,
+}
+
+impl Default for Album {
+    fn default() -> Self {
+        Album {
+            title: String::new(),
+            album_artist: String::new(),
+            genre: String::new(),
+            year: 0,
+            track_count: 0,
+            disc_count: 0,
+            songs: Vec::new(),
+        }
+    }
+}
+
+impl Default for Song {
+    fn default() -> Self {
+        Song {
+            id: None,
+            title: None,
+            artist: None,
+            album: None,
+            genre: None,
+            year: None,
+            duration: None,
+            track: None,
+            disc: None,
+            data: None,
+            filepath: None,
+            directory: None,
+        }
+    }
+}
+
+impl Song {
+    pub fn print_info(&self) {
+        println!("Title: {:?}", self.title);
+        println!("Artist: {:?}", self.artist);
+    }
+
+    pub fn song_path(&self) -> String {
+        let directory =
+            &<std::option::Option<std::string::String> as Clone>::clone(&self.directory).unwrap();
+
+        let mut buffer: String = directory.to_string();
+        let count = buffer.len();
+
+        if buffer.chars().nth(count - 1) != Some('/') {
+            buffer += "/";
+        }
+
+        let filename =
+            &<std::option::Option<std::string::String> as Clone>::clone(&self.filepath).unwrap();
+        buffer += filename;
+
+        return buffer;
+    }
+
+    pub fn to_data(&self) -> Result<Vec<u8>, std::io::Error> {
+        let path = self.song_path();
+        println!("Converting song to data");
+        println!("Path: {:?}", path);
+
+        let mut file = std::fs::File::open(path)?;
+        let mut buffer = Vec::new();
+        file.read_to_end(&mut buffer)?;
+        if buffer.len() == 0 {
+            println!("Why is it empty?");
+        }
+
+        Ok(buffer)
+    }
+
+    // if 1 - wav, if 0 - mp3, anything else defaults to wav
+    pub fn _generate_filename_from_track(&mut self, i_type: i32) -> i32 {
+        let mut filename: String = String::new();
+        if self.track.unwrap() < 10 {
+            filename += "0";
+        }
+
+        filename += &self.track.unwrap().to_string();
+
+        if i_type == 0 {
+            filename += constants::file_extensions::_MP3_FILE_EXTENSION;
+        } else {
+            filename += constants::file_extensions::WAV_FILE_EXTENSION;
+        }
+
+        self.filepath = Some(filename);
+
+        return 0;
+    }
+
+    pub fn _to_metadata_json(&self) -> Result<String, serde_json::Error> {
+        return serde_json::to_string_pretty(&self);
+    }
+}
+
+#[derive(Debug, Deserialize, Serialize)]
+pub struct CoverArt {
+    pub id: Option<i32>,
+    pub title: Option<String>,
+    pub path: Option<String>,
+    pub data: Option<Vec<u8>>,
+}
+
+impl Default for CoverArt {
+    fn default() -> Self {
+        CoverArt {
+            id: None,
+            title: None,
+            path: None,
+            data: None,
+        }
+    }
+}
+
+impl CoverArt {
+    pub fn to_data(&self) -> Result<Vec<u8>, std::io::Error> {
+        let mut path: String = String::new();
+        match &self.path {
+            Some(val) => {
+                path = String::from(val);
+            }
+            None => {
+                ();
+            }
+        }
+
+        let mut file = std::fs::File::open(path)?;
+        let mut buffer = Vec::new();
+        file.read_to_end(&mut buffer)?;
+        Ok(buffer)
+    }
+}

src/models/token.rs

@@ -0,0 +1,47 @@
+use std::default::Default;
+
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Deserialize, Serialize)]
+pub struct Token {
+    #[serde(alias = "user_id")]
+    pub user_id: i32,
+    #[serde(alias = "username")]
+    pub username: Option<String>,
+    #[serde(alias = "token")]
+    pub access_token: Option<String>,
+    #[serde(alias = "token_type")]
+    pub token_type: Option<String>,
+    #[serde(alias = "expiration")]
+    pub expiration: Option<i32>,
+    #[serde(alias = "message")]
+    pub message: Option<String>,
+}
+
+impl Default for Token {
+    fn default() -> Self {
+        Token {
+            user_id: -1,
+            username: None,
+            access_token: None,
+            token_type: None,
+            expiration: None,
+            message: None,
+        }
+    }
+}
+
+impl Token {
+    pub fn bearer_token(&self) -> String {
+        let mut token: String = String::from("Bearer ");
+
+        match &self.access_token {
+            Some(tok) => {
+                token += tok;
+            }
+            None => {}
+        }
+
+        return token;
+    }
+}

src/models/upload_form.rs

@@ -0,0 +1,18 @@
+use std::default::Default;
+
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Deserialize, Serialize)]
+pub struct UploadForm {
+    pub url: Option<String>,
+    pub filepath: Option<String>,
+}
+
+impl Default for UploadForm {
+    fn default() -> Self {
+        UploadForm {
+            url: None,
+            filepath: None,
+        }
+    }
+}

src/models/user.rs

@@ -0,0 +1,24 @@
+use std::default::Default;
+
+use serde::{Deserialize, Serialize};
+
+#[derive(Clone, Debug, Deserialize, Serialize)]
+pub struct User {
+    pub username: String,
+    pub password: String,
+}
+
+impl Default for User {
+    fn default() -> Self {
+        User {
+            username: String::new(),
+            password: String::new(),
+        }
+    }
+}
+
+impl User {
+    pub fn _to_json(&self) -> Result<String, serde_json::Error> {
+        return serde_json::to_string_pretty(&self);
+    }
+}

src/parsers/api_parser.rs

@@ -0,0 +1,34 @@
+use crate::models;
+
+#[derive(Clone, Debug)]
+pub struct APIParser {
+    pub api: models::api::API,
+    pub ica_act: models::icarus_action::IcarusAction,
+}
+
+impl APIParser {
+    pub fn retrieve_api(&self) -> models::api::API {
+        return self.api.clone();
+    }
+
+    pub fn parse_api(&mut self) {
+        let flags = self.ica_act.flags.clone();
+        println!("Parsing api");
+
+        for elem in flags {
+            let arg = elem.flag;
+            let value = elem.value;
+
+            if arg == "-h" {
+                if value.chars().nth(value.len() - 1) == Some('/') {
+                    self.api.url = value;
+                } else {
+                    self.api.url = value + "/";
+                }
+                break;
+            }
+        }
+
+        self.api.version = "v1".to_string();
+    }
+}

src/parsers/mod.rs

@@ -0,0 +1 @@
+pub mod api_parser;

src/syncers/delete.rs

@@ -0,0 +1,72 @@
+use std::default::Default;
+
+use reqwest;
+
+use crate::models;
+
+#[derive(Clone, Debug)]
+pub struct Delete {
+    pub api: models::api::API,
+}
+
+impl Default for Delete {
+    fn default() -> Self {
+        Delete {
+            api: models::api::API::default(),
+        }
+    }
+}
+
+impl Delete {
+    pub async fn delete_song(
+        &mut self,
+        token: &models::token::Token,
+        song: &models::song::Song,
+    ) -> Result<models::song::Song, std::io::Error> {
+        self.api.endpoint = "song/data/delete".to_owned();
+        let url = self.retrieve_url(&song);
+        let client = reqwest::Client::builder().build().unwrap();
+        let access_token = token.bearer_token();
+        let response = client
+            .delete(&url)
+            .header(reqwest::header::AUTHORIZATION, access_token)
+            .send()
+            .await
+            .unwrap();
+        let mut sng = models::song::Song::default();
+
+        match response.status() {
+            reqwest::StatusCode::OK => {
+                println!("Success!");
+                let s = response.json::<models::song::Song>().await;
+                match s {
+                    //
+                    Ok(parsed) => {
+                        sng = parsed;
+                    }
+                    Err(er) => {
+                        println!("Error {:?}", er);
+                    }
+                };
+            }
+            other => {
+                panic!("Issue occurred: {:?}", other);
+            }
+        }
+
+        return Ok(sng);
+    }
+
+    fn retrieve_url(&self, song: &models::song::Song) -> String {
+        let api = &self.api;
+        let mut url: String = String::from(&api.url);
+        url += &String::from("api/");
+        url += &String::from(&api.version);
+        url += &String::from("/");
+        url += &String::from(&api.endpoint);
+        url += &String::from("/");
+        url += &song.id.unwrap().to_string();
+
+        return url;
+    }
+}

src/syncers/download.rs

@@ -0,0 +1,82 @@
+use std::default::Default;
+
+use crate::models;
+
+pub struct Download {
+    pub api: models::api::API,
+}
+
+impl Default for Download {
+    fn default() -> Self {
+        Download {
+            api: models::api::API::default(),
+        }
+    }
+}
+
+#[derive(Debug)]
+pub enum MyError {
+    _Request(reqwest::Error),
+    Other(String),
+}
+
+impl Download {
+    pub async fn download_song(
+        &mut self,
+        token: &models::token::Token,
+        song: &models::song::Song,
+    ) -> Result<String, MyError> {
+        self.api.endpoint = String::from("song/data/download");
+        let url = self.retrieve_url(&song);
+        let access_token = token.bearer_token();
+
+        let mut headers = reqwest::header::HeaderMap::new();
+        headers.insert(
+            reqwest::header::AUTHORIZATION,
+            http::header::HeaderValue::from_str(&access_token.clone()).unwrap(),
+        );
+
+        let client = reqwest::Client::builder().build().unwrap();
+        let response = client
+            .get(&url)
+            .header(reqwest::header::AUTHORIZATION, &access_token)
+            .send()
+            .await
+            .unwrap();
+
+        match response.status() {
+            reqwest::StatusCode::OK => {
+                let data = response.text();
+                match data.await {
+                    Ok(e) => {
+                        return Ok(e);
+                    }
+                    Err(er) => {
+                        println!("Error {:?}", er);
+                    }
+                }
+            }
+            reqwest::StatusCode::UNAUTHORIZED => {
+                println!("Need to grab a new token");
+            }
+            other => {
+                panic!("Uh oh! Something unexpected happened: {:?}", other);
+            }
+        }
+
+        return Err(MyError::Other(String::from("Error downloading")));
+    }
+
+    fn retrieve_url(&self, song: &models::song::Song) -> String {
+        let api = &self.api;
+        let mut url: String = String::from(&api.url);
+        url += &String::from("api/");
+        url += &String::from(&api.version);
+        url += &String::from("/");
+        url += &String::from(&api.endpoint);
+        url += &String::from("/");
+        url += &song.id.unwrap().to_string();
+
+        return url;
+    }
+}

src/syncers/mod.rs

@@ -0,0 +1,4 @@
+pub mod delete;
+pub mod download;
+pub mod retrieve_records;
+pub mod upload;

src/syncers/retrieve_records.rs

@@ -0,0 +1,80 @@
+use std::default::Default;
+use std::io::Error;
+
+use crate::models;
+
+pub struct RetrieveRecords {
+    pub api: models::api::API,
+}
+
+impl Default for RetrieveRecords {
+    fn default() -> Self {
+        RetrieveRecords {
+            api: models::api::API::default(),
+        }
+    }
+}
+
+impl RetrieveRecords {
+    pub async fn get_all_songs(
+        &mut self,
+        token: &models::token::Token,
+    ) -> Result<Vec<models::song::Song>, Error> {
+        self.api.endpoint = String::from("song");
+        let mut songs: Vec<models::song::Song> = Vec::new();
+        let url = self.retrieve_url();
+        let access_token = token.bearer_token();
+
+        let mut headers = reqwest::header::HeaderMap::new();
+        headers.insert(
+            reqwest::header::AUTHORIZATION,
+            http::header::HeaderValue::from_str(&access_token.clone()).unwrap(),
+        );
+        headers.insert(
+            reqwest::header::CONTENT_TYPE,
+            http::header::HeaderValue::from_static("application/json"),
+        );
+
+        let client = reqwest::Client::builder().build().unwrap();
+        let response = client
+            .get(&url)
+            .header(reqwest::header::AUTHORIZATION, access_token)
+            .send()
+            .await
+            .unwrap();
+
+        match response.status() {
+            reqwest::StatusCode::OK => {
+                // on success, parse our JSON to an APIResponse
+                let s = response.json::<Vec<models::song::Song>>().await;
+                match s {
+                    //
+                    Ok(parsed) => {
+                        songs = parsed;
+                    }
+                    Err(_) => println!("Hm, the response didn't match the shape we expected."),
+                };
+            }
+            reqwest::StatusCode::UNAUTHORIZED => {
+                println!("Need to grab a new token");
+            }
+            other => {
+                panic!("Uh oh! Something unexpected happened: {:?}", other);
+            }
+        }
+
+        return Ok(songs);
+    }
+
+    fn retrieve_url(&self) -> String {
+        let api = &self.api;
+        let mut url: String = String::from(&api.url);
+        url += &String::from("api/");
+        url += &String::from(&api.version);
+        url += &String::from("/");
+        url += &String::from(&api.endpoint);
+        url += &String::from("/");
+
+        return url;
+    }
+}

src/syncers/upload.rs

@@ -0,0 +1,195 @@
+use std::default::Default;
+
+use http::HeaderMap;
+use http::HeaderValue;
+use reqwest;
+use reqwest::multipart::Form;
+use serde::{Deserialize, Serialize};
+
+use crate::constants;
+use crate::models;
+
+pub struct Upload {
+    pub api: models::api::API,
+}
+
+#[derive(Debug, Deserialize, Serialize)]
+struct Song {
+    title: String,
+    album: String,
+    artist: String,
+    album_artist: String,
+    year: i32,
+    genre: String,
+    duration: i32,
+    track: i32,
+    track_count: i32,
+    disc: i32,
+    disc_count: i32,
+    #[serde(skip_serializing)]
+    songpath: String,
+}
+
+impl Song {
+    pub fn to_metadata_json(&self) -> Result<String, serde_json::Error> {
+        return serde_json::to_string_pretty(&self);
+    }
+}
+
+impl Default for Upload {
+    fn default() -> Self {
+        Upload {
+            api: models::api::API::default(),
+        }
+    }
+}
+
+impl Upload {
+    pub async fn upload_song_with_metadata(
+        &mut self,
+        token: &models::token::Token,
+        song: &models::song::Song,
+        cover: &models::song::CoverArt,
+        album: &models::song::Album,
+    ) -> Result<reqwest::Response, std::io::Error> {
+        self.api.endpoint = String::from("song/data/upload/with/data");
+        let url = self.retrieve_url();
+        let mut new_song = self.initialize_song(&song, &album);
+        new_song.songpath = song.song_path();
+        let access_token = token.bearer_token();
+
+        if url.is_empty() {
+            println!("Url is empty");
+        }
+
+        println!("Url: {}", url);
+        println!("Token: {}", access_token);
+
+        let mut headers = reqwest::header::HeaderMap::new();
+        headers.insert(
+            reqwest::header::AUTHORIZATION,
+            HeaderValue::from_str(&access_token.clone()).unwrap(),
+        );
+        headers.insert(reqwest::header::ACCEPT, HeaderValue::from_static("*/*"));
+
+        let form = self.init_form(&new_song, &cover);
+        let client = reqwest::Client::builder().build().unwrap();
+        let response = client
+            .post(url)
+            .headers(headers)
+            .multipart(form)
+            .send()
+            .await;
+        let response_text = response.unwrap();
+
+        println!("Something was sent");
+        println!("{:?}", response_text);
+
+        return Ok(response_text);
+    }
+
+    fn _initialize_form(
+        &self,
+        song_raw_data: Vec<u8>,
+        cover_raw_data: Vec<u8>,
+        song_detail: String,
+    ) -> Form {
+        let mut headers = HeaderMap::new();
+        headers.insert(
+            http::header::CONTENT_TYPE,
+            http::HeaderValue::from_static("application/octet-stream"),
+        );
+
+        let file = reqwest::multipart::Part::bytes(song_raw_data).headers(headers);
+        let mut headers_i = HeaderMap::new();
+        headers_i.insert(
+            http::header::CONTENT_TYPE,
+            http::HeaderValue::from_static("image/jpeg"),
+        );
+
+        let cover = reqwest::multipart::Part::bytes(cover_raw_data).headers(headers_i);
+
+        let mut song_filename = String::from("audio");
+        song_filename += constants::file_extensions::WAV_FILE_EXTENSION;
+        let mut cover_filename = String::from("cover");
+        cover_filename += constants::file_extensions::JPG_FILE_EXTENSION;
+
+        return reqwest::multipart::Form::new()
+            .part("cover", cover.file_name(cover_filename))
+            .text("metadata", song_detail)
+            .part("file", file.file_name(song_filename));
+    }
+
+    fn init_form(&self, song: &Song, cover: &models::song::CoverArt) -> reqwest::multipart::Form {
+        let songpath = song.songpath.clone();
+        let coverpath = cover.path.clone().unwrap();
+        let song_detail = song.to_metadata_json().unwrap();
+
+        println!("\n{}\n", song_detail);
+
+        let mut song_filename = String::from("audio");
+        song_filename += constants::file_extensions::WAV_FILE_EXTENSION;
+        let mut cover_filename = String::from("cover");
+        cover_filename += constants::file_extensions::JPG_FILE_EXTENSION;
+
+        let form = reqwest::multipart::Form::new()
+            .part(
+                "file",
+                reqwest::multipart::Part::bytes(std::fs::read(songpath).unwrap())
+                    .file_name(song_filename),
+            )
+            .part(
+                "cover",
+                reqwest::multipart::Part::bytes(std::fs::read(coverpath).unwrap())
+                    .file_name(cover_filename),
+            )
+            .text("metadata", song_detail);
+
+        return form;
+    }
+
+    pub fn set_api(&mut self, host: &String) {
+        let mut api = models::api::API::default();
+        api.url = host.clone();
+        api.version = String::from("v1");
+        self.api = api;
+    }
+
+    fn retrieve_url(&self) -> String {
+        let api = &self.api;
+        let mut buffer = api.url.clone();
+        let count = buffer.len();
+
+        if buffer.chars().nth(count - 1) != Some('/') {
+            buffer += "/";
+        }
+
+        let mut url: String = String::from(&buffer);
+        url += &String::from("api/");
+        url += &String::from(&api.version);
+        url += &String::from("/");
+        url += &String::from(&api.endpoint);
+
+        return url;
+    }
+
+    fn initialize_song(&self, song: &models::song::Song, album: &models::song::Album) -> Song {
+        let dur = song.duration.clone().unwrap();
+        println!("Duration: {}", dur);
+
+        return Song {
+            title: String::from(&song.title.clone().unwrap()),
+            album: album.title.clone(),
+            artist: String::from(&song.artist.clone().unwrap().clone()),
+            album_artist: album.album_artist.clone(),
+            year: album.year.clone(),
+            genre: album.genre.clone(),
+            duration: f64::round(dur) as i32,
+            track: (song.track.clone().unwrap()),
+            track_count: album.track_count.clone(),
+            disc: song.disc.clone().unwrap(),
+            disc_count: album.disc_count.clone(),
+            songpath: String::new(),
+        };
+    }
+}

src/utilities/checks.rs

@@ -0,0 +1,28 @@
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Deserialize, Serialize)]
+pub struct Checks {}
+
+impl Checks {
+    pub fn is_numeric(text: &String) -> bool {
+        text.parse::<f64>().is_ok()
+    }
+
+    pub fn index_of_item_in_container<F>(container: &String, item: &char, func: F) -> i32
+    where
+        F: Fn(&char, &char) -> bool,
+    {
+        let mut index = -1;
+
+        for c in container.chars() {
+            if func(&c, item) {
+                index += 1;
+                break;
+            }
+
+            index += 1;
+        }
+
+        return index;
+    }
+}

src/utilities/mod.rs

@@ -0,0 +1 @@
+pub mod checks;