Trying

This reverts commit 7a209eeb5e.

.dockerignore.yaml

@@ -0,0 +1,21 @@
+# Ignore build artifacts
+target/
+pkg/
+
+# Ignore git directory
+.git/
+
+.github/
+
+# Ignore environment files (configure via docker-compose instead)
+.env*
+
+# Ignore IDE/editor specific files
+.idea/
+.vscode/
+
+# Ignore OS specific files
+*.DS_Store
+
+# Add any other files/directories you don't need in the image
+# e.g., logs/, tmp/

.env.docker.sample

@@ -0,0 +1,29 @@
+APP_ENV=development
+BACKEND_PORT=8000
+FRONTEND_URL=http://localhost:4200
+RUST_LOG=debug
+ALLOWED_ORIGINS=https://soaricarus.com,https://www.soaricarus.com
+SECRET_MAIN_KEY=refero34o8rfhfjn983thf39fhc943rf923n3h
+ROOT_DIRECTORY=/home/soaricarus/mydata
+POSTGRES_MAIN_USER=soaricarus
+POSTGRES_MAIN_PASSWORD=password
+POSTGRES_MAIN_DB=soaricarus_db
+POSTGRES_MAIN_HOST=main_db
+POSTGRES_MAIN_PORT=5432
+DATABASE_URL=postgres://${POSTGRES_MAIN_USER}:${POSTGRES_MAIN_PASSWORD}@${POSTGRES_MAIN_HOST}:${POSTGRES_MAIN_PORT}/${POSTGRES_MAIN_DB}
+
+GARAGE_RPC_SECRET=c2bde5c3f9c04116a7563e25ea5ba6fab25319daa2fe8a952ad57d0b8159b590
+GARAGE_METADATA_DIR=/var/lib/garage/meta
+GARAGE_DATA_DIR=/var/lib/garage/data
+GARAGE_DB_ENGINE=sqlite
+GARAGE_REPLICATION_FACTOR=1
+GARAGE_RPC_BIND_ADDR=[::]:3901
+GARAGE_S3_API_BIND_ADDR=[::]:3900
+GARAGE_S3_WEB_BIND_ADDR=[::]:3902
+GARAGE_S3_REGION=maze
+GARAGE_ROOT_DOMAIN=.localhost
+AWS_DEFAULT_REGION=maze
+AWS_SECRET_ACCESS_KEY=3o4n7yfo34985yrfcq9238765ry3928475rcy349857ty394578cy
+AWS_ACCESS_KEY_ID=2q39fnoy59q2347yfdrc327894ryfc0q2834rcyq023897
+
+S3_BUCKET_NAME=soaricarus-storage

.env.local.sample

@@ -0,0 +1,13 @@
+APP_ENV=development
+BACKEND_PORT=8000
+FRONTEND_URL=http://localhost:4200
+RUST_LOG=debug
+ALLOWED_ORIGINS=https://soaricarus.com,https://www.soaricarus.com
+SECRET_MAIN_KEY=refero34o8rfhfjn983thf39fhc943rf923n3h
+ROOT_DIRECTORY=/home/soaricarus/mydata
+POSTGRES_MAIN_USER=soaricarus
+POSTGRES_MAIN_PASSWORD=password
+POSTGRES_MAIN_DB=soaricarus_db
+POSTGRES_MAIN_HOST=main_db
+POSTGRES_MAIN_PORT=5432
+DATABASE_URL=postgres://${POSTGRES_MAIN_USER}:${POSTGRES_MAIN_PASSWORD}@${POSTGRES_MAIN_HOST}:${POSTGRES_MAIN_PORT}/${POSTGRES_MAIN_DB}

.gitattributes

@@ -0,0 +1,9 @@
+# Override specific file types
+*.cs linguist-language=Rust
+*.sln linguist-documentation
+*.csproj linguist-documentation
+
+# Or vendor all non-Rust files
+*.cs linguist-vendored
+*.js linguist-vendored
+*.py linguist-vendored

.github/workflows/release.yml

@@ -0,0 +1,50 @@
+name: Release Tagging
+
+on:
+  push:
+    branches: [ "v0.2" ]
+
+jobs:
+  release:
+    runs-on: ubuntu-24.04
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v6
+        with:
+          fetch-depth: 0 # Important for git describe --tags
+
+      - name: Install Rust
+        uses: actions-rs/toolchain@v1
+        with:
+          toolchain: 1.97
+          components: cargo
+
+      - name: Extract Version from Cargo.toml
+        id: version
+        run: |
+          VERSION=$(grep '^version = "' Cargo.toml | sed -E 's/version = "([^"]+)"/\1/')
+          PROJECT_COMMIT_HASH=$(git rev-parse HEAD | cut -c 1-10)
+          BRANCH_REF="${GITHUB_REF}"
+          BRANCH_NAME=$(echo "$BRANCH_REF" | cut -d '/' -f 3)
+          PROJECT_TAG_RELEASE="v$VERSION-$BRANCH_NAME-$PROJECT_COMMIT_HASH"
+          echo "::set-output name=project_tag_release::$PROJECT_TAG_RELEASE-961"
+          echo "Version: $VERSION"
+          echo "Hash: $PROJECT_COMMIT_HASH"
+          echo "Branch: $BRANCH_NAME"
+          echo "Tag Release: $PROJECT_TAG_RELEASE"
+
+      - name: Print version
+        id: print_version
+        run: |
+          echo "Printing version"
+          echo "Version: ${{ steps.version.outputs.project_tag_release }}"
+
+      - name: Create GitHub Release
+        uses: actions/create-release@v1
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          tag_name: ${{ steps.version.outputs.project_tag_release }}
+          release_name: Release ${{ steps.version.outputs.project_tag_release }}
+          body: |
+           Release of version ${{ steps.version.outputs.project_tag_release }}

.github/workflows/workflow.yml

@@ -0,0 +1,144 @@
+name: soaricarus_api CI
+
+on:
+  push:
+    branches: [ "main" ]
+  pull_request:
+    branches: [ "main" ]
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+
+jobs:
+  check:
+    name: Check
+    runs-on: ubuntu-24.04
+    steps:
+      - uses: actions/checkout@v6
+      - uses: actions-rust-lang/setup-rust-toolchain@v1
+        with:
+          toolchain: 1.97
+      - uses: Swatinem/rust-cache@v2
+      - run: |
+          mkdir -p ~/.ssh
+          echo "${{ secrets.MYREPO_TOKEN }}" > ~/.ssh/soaricarus_models_deploy_key
+          chmod 600 ~/.ssh/soaricarus_models_deploy_key
+          ssh-keyscan ${{ secrets.MYHOST }} >> ~/.ssh/known_hosts
+
+          eval $(ssh-agent -s)
+          ssh-add -v ~/.ssh/soaricarus_models_deploy_key
+
+          cargo check
+
+  test:
+    name: Test Suite
+    runs-on: ubuntu-24.04
+    services:
+      postgres:
+        image: postgres:18.4-alpine
+        env:
+          POSTGRES_USER: ${{ secrets.DB_TEST_USER || 'testuser' }}
+          POSTGRES_PASSWORD: ${{ secrets.DB_TEST_PASSWORD || 'testpassword' }}
+          POSTGRES_DB: ${{ secrets.DB_TEST_NAME || 'testdb' }}
+        options: >-
+          --health-cmd pg_isready
+          --health-interval 10s
+          --health-timeout 5s
+          --health-retries 5
+
+    steps:
+      - uses: actions/checkout@v6
+      - uses: actions-rust-lang/setup-rust-toolchain@v1
+        with:
+          toolchain: 1.97
+      - uses: Swatinem/rust-cache@v2
+      - name: Verify Docker Environment
+        run: |
+          echo "Runner User Info:"
+          id
+          echo "Checking Docker Version:"
+          docker --version
+          echo "Checking Docker Daemon Status (info):"
+          docker info
+          echo "Checking Docker Daemon Status (ps):"
+          docker ps -a
+          echo "Docker environment check complete."
+      - name: Run tests
+        env:
+          # Define DATABASE_URL for tests to use
+          DATABASE_URL: postgresql://${{ secrets.DB_TEST_USER || 'testuser' }}:${{ secrets.DB_TEST_PASSWORD || 'testpassword' }}@postgres:5432/${{ secrets.DB_TEST_NAME || 'testdb' }}
+          RUST_LOG: info # Optional: configure test log level
+          SECRET_MAIN_KEY: ${{ secrets.TOKEN_SECRET_KEY }}
+          SSH_AUTH_SOCK: ${{ env.SSH_AUTH_SOCK }}
+          ROOT_DIRECTORY: "/tmp"
+        run: |
+          mkdir -p ~/.ssh
+          echo "${{ secrets.MYREPO_TOKEN }}" > ~/.ssh/soaricarus_models_deploy_key
+          chmod 600 ~/.ssh/soaricarus_models_deploy_key
+          ssh-keyscan ${{ secrets.MYHOST }} >> ~/.ssh/known_hosts
+
+          eval $(ssh-agent -s)
+          ssh-add -v ~/.ssh/soaricarus_models_deploy_key
+
+          cargo test
+
+  fmt:
+    name: Rustfmt
+    runs-on: ubuntu-24.04
+    steps:
+      - uses: actions/checkout@v6
+      - uses: actions-rust-lang/setup-rust-toolchain@v1
+        with:
+          toolchain: 1.97
+      - uses: Swatinem/rust-cache@v2
+      - run: rustup component add rustfmt
+      - run: |
+          mkdir -p ~/.ssh
+          echo "${{ secrets.MYREPO_TOKEN }}" > ~/.ssh/soaricarus_models_deploy_key
+          chmod 600 ~/.ssh/soaricarus_models_deploy_key
+          ssh-keyscan ${{ secrets.MYHOST }} >> ~/.ssh/known_hosts
+
+          eval $(ssh-agent -s)
+          ssh-add -v ~/.ssh/soaricarus_models_deploy_key
+          cargo fmt --all -- --check
+
+  clippy:
+    name: Clippy
+    runs-on: ubuntu-24.04
+    steps:
+      - uses: actions/checkout@v6
+      - uses: actions-rust-lang/setup-rust-toolchain@v1
+        with:
+          toolchain: 1.97
+      - uses: Swatinem/rust-cache@v2
+      - run: rustup component add clippy
+      - run: |
+          mkdir -p ~/.ssh
+          echo "${{ secrets.MYREPO_TOKEN }}" > ~/.ssh/soaricarus_models_deploy_key
+          chmod 600 ~/.ssh/soaricarus_models_deploy_key
+          ssh-keyscan ${{ secrets.MYHOST }} >> ~/.ssh/known_hosts
+
+          eval $(ssh-agent -s)
+          ssh-add -v ~/.ssh/soaricarus_models_deploy_key
+          cargo clippy -- -D warnings
+
+  build:
+    name: build
+    runs-on: ubuntu-24.04
+    steps:
+      - uses: actions/checkout@v6
+      - uses: actions-rust-lang/setup-rust-toolchain@v1
+        with:
+          toolchain: 1.97
+      - uses: Swatinem/rust-cache@v2
+      - run: |
+          mkdir -p ~/.ssh
+          echo "${{ secrets.MYREPO_TOKEN }}" > ~/.ssh/soaricarus_models_deploy_key
+          chmod 600 ~/.ssh/soaricarus_models_deploy_key
+          ssh-keyscan ${{ secrets.MYHOST }} >> ~/.ssh/known_hosts
+
+          eval $(ssh-agent -s)
+          ssh-add -v ~/.ssh/soaricarus_models_deploy_key
+          cargo build --release

.gitignore

@@ -1,8 +1,13 @@
-################################################################################
+# Added by cargo
-# This .gitignore file was automatically created by Microsoft(R) Visual Studio.
-################################################################################
 
-/.vs/Icarus
+/target
-/bin/Debug/netcoreapp2.2
+.env
-/Migrations
+.env.docker
-/obj
+.env.local
+
+.DS_STORE
+Storage/
+
+*.sln
+*.cs
+*.csproj

.gitmodules

@@ -1,21 +0,0 @@
-[submodule "Libs/cpr"]
-	path = 3rdparty/cpr
-	url = https://github.com/whoshuu/cpr.git
-[submodule "3rdparty/taglib"]
-	path = 3rdparty/taglib
-	url = https://github.com/taglib/taglib
-[submodule "3rdparty/oatpp"]
-	path = 3rdparty/oatpp
-	url = https://github.com/oatpp/oatpp
-[submodule "build/3rdparty/jwt-cpp"]
-	path = build/3rdparty/jwt-cpp
-	url = https://github.com/Thalhammer/jwt-cpp
-[submodule "3rdparty/jwt-cpp"]
-	path = 3rdparty/jwt-cpp
-	url = https://github.com/Thalhammer/jwt-cpp
-[submodule "3rdparty/ormpp"]
-	path = 3rdparty/ormpp
-	url = https://github.com/qicosmos/ormpp
-[submodule "3rdparty/libbcrypt"]
-	path = 3rdparty/libbcrypt
-	url = https://github.com/rg3/libbcrypt

.sqlxconfig

@@ -0,0 +1,8 @@
+{
+  "dev": {
+    "migrations": "./migrations"
+  },
+  "test": {
+    "migrations": "./test_migrations"
+  }
+}

CMakeLists.txt

@@ -1,149 +0,0 @@
-cmake_minimum_required(VERSION 3.10)
-
-project(icarus)
-
-set(CMAKE_CXX_STANDARD_REQUIRED ON)
-set(CMAKE_CXX_STANDARD 17)
-
-set(SOURCES
-    src/callback/StreamCallback.cpp
-    src/database/AlbumRepository.cpp
-    src/database/ArtistRepository.cpp
-    src/database/BaseRepository.cpp
-    src/database/CoverArtRepository.cpp
-    src/database/GenreRepository.cpp
-    src/database/SongRepository.cpp
-    src/database/UserRepository.cpp
-    src/database/YearRepository.cpp
-    src/dto/conversion/DtoConversions.cpp
-    src/Main.cpp
-    src/manager/AlbumManager.cpp
-    src/manager/ArtistManager.cpp
-    src/manager/CoverArtManager.cpp
-    src/manager/DirectoryManager.cpp
-    src/manager/GenreManager.cpp
-    src/manager/SongManager.cpp
-    src/manager/TokenManager.cpp
-    src/manager/UserManager.cpp
-    src/manager/YearManager.cpp
-    src/utility/ImageFile.cpp
-    src/utility/MetadataRetriever.cpp
-    src/utility/PasswordEncryption.cpp
-    src/verify/Initialization.cpp
-)
-set(HEADERS
-    include/callback/StreamCallback.h
-    include/component/AppComponent.hpp
-    include/controller/AlbumController.hpp
-    include/controller/ArtistController.hpp
-    include/controller/CoverArtController.hpp
-    include/controller/GenreController.hpp
-    include/controller/LoginController.hpp
-    include/controller/RegisterController.hpp
-    include/controller/SongController.hpp
-    include/controller/YearController.hpp
-    include/database/AlbumRepository.h
-    include/database/ArtistRepository.h
-    include/database/BaseRepository.h
-    include/database/CoverArtRepository.h
-    include/database/GenreRepository.h
-    include/database/SongRepository.h
-    include/database/UserRepository.h
-    include/database/YearRepository.h
-    include/dto/AlbumDto.hpp
-    include/dto/ArtistDto.hpp
-    include/dto/CoverArtDto.hpp
-    include/dto/GenreDto.hpp
-    include/dto/LoginResultDto.hpp
-    include/dto/SongDto.hpp
-    include/dto/YearDto.hpp
-    include/dto/conversion/DtoConversions.h
-    include/manager/AlbumManager.h
-    include/manager/ArtistManager.h
-    include/manager/CoverArtManager.h
-    include/manager/DirectoryManager.h
-    include/manager/GenreManager.h
-    include/manager/SongManager.h
-    include/manager/TokenManager.h    
-    include/manager/UserManager.h
-    include/manager/YearManager.h
-    include/model/Models.h
-    include/utility/ImageFile.h
-    include/utility/MetadataRetriever.h
-    include/utility/PasswordEncryption.h
-    include/type/AlbumFilter.h
-    include/type/ArtistFilter.h
-    include/type/CoverFilter.h
-    include/type/GenreFilter.h
-    include/type/PathType.h
-    include/type/SaltFilter.h
-    include/type/Scopes.h
-    include/type/SongChanged.h
-    include/type/SongFilter.h
-    include/type/UserFilter.h
-    include/type/YearFilter.h
-    include/verify/Initialization.h
-)
-
-set (TAGLIB
-    ${CMAKE_CURRENT_SOURCE_DIR}/3rdparty/taglib/3rdparty
-)
-
-set (BCRYPTLIB
-    ${CMAKE_SOURCE_DIR}/3rdparty/libbcrypt
-)
-
-set(TAGLIB_HEADERS
-    "${CMAKE_SOURCE_DIR}/build/3rdparty/taglib" 
-    "${CMAKE_SOURCE_DIR}/3rdparty/taglib" 
-    "${CMAKE_SOURCE_DIR}/3rdparty/taglib/taglib" 
-    "${CMAKE_SOURCE_DIR}/3rdparty/taglib/taglib/ape" 
-    "${CMAKE_SOURCE_DIR}/3rdparty/taglib/taglib/asf" 
-    "${CMAKE_SOURCE_DIR}/3rdparty/taglib/taglib/dsdiff" 
-    "${CMAKE_SOURCE_DIR}/3rdparty/taglib/taglib/dsf" 
-    "${CMAKE_SOURCE_DIR}/3rdparty/taglib/taglib/flac" 
-    "${CMAKE_SOURCE_DIR}/3rdparty/taglib/taglib/it" 
-    "${CMAKE_SOURCE_DIR}/3rdparty/taglib/taglib/mod" 
-    "${CMAKE_SOURCE_DIR}/3rdparty/taglib/taglib/mp4" 
-    "${CMAKE_SOURCE_DIR}/3rdparty/taglib/taglib/mpc" 
-    "${CMAKE_SOURCE_DIR}/3rdparty/taglib/taglib/mpeg" 
-    "${CMAKE_SOURCE_DIR}/3rdparty/taglib/taglib/mpeg/id3v2" 
-    "${CMAKE_SOURCE_DIR}/3rdparty/taglib/taglib/mpeg/id3v2/frames" 
-    "${CMAKE_SOURCE_DIR}/3rdparty/taglib/taglib/ogg" 
-    "${CMAKE_SOURCE_DIR}/3rdparty/taglib/taglib/riff" 
-    "${CMAKE_SOURCE_DIR}/3rdparty/taglib/taglib/s3m" 
-    "${CMAKE_SOURCE_DIR}/3rdparty/taglib/taglib/toolkit" 
-    "${CMAKE_SOURCE_DIR}/3rdparty/taglib/taglib/trueaudio" 
-    "${CMAKE_SOURCE_DIR}/3rdparty/taglib/taglib/wavpack" 
-    "${CMAKE_SOURCE_DIR}/3rdparty/taglib/taglib/xm" 
-)
-
-set(JWT_CPP_INCLUDE
-    ${CMAKE_CURRENT_SOURCE_DIR}/3rdparty/jwt-cpp/include
-)
-
-set (ORM_DIR
-    ${CMAKE_CURRENT_SOURCE_DIR}/3rdparty/ormpp
-)
-
-include(${CMAKE_BINARY_DIR}/conanbuildinfo.cmake)
-conan_basic_setup()
-
-find_library(BCRYPT bcrypt ${BCRYPTLIB})
-
-include_directories(include ${CPR_INCLUDE_DIRS} ${TAGLIB} ${TAGLIB_HEADERS} ${BCRYPTLIB}/)
-
-add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/3rdparty/cpr)
-add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/3rdparty/taglib)
-add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/3rdparty/oatpp)
-#add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/3rdparty/libbcrypt)
-
-configure_file(${CMAKE_CURRENT_SOURCE_DIR}/appsettings.json ${CMAKE_BINARY_DIR}/bin/appsettings.json COPYONLY)
-configure_file(${CMAKE_CURRENT_SOURCE_DIR}/authcredentials.json ${CMAKE_BINARY_DIR}/bin/authcredentials.json COPYONLY)
-configure_file(${CMAKE_CURRENT_SOURCE_DIR}/database.json ${CMAKE_BINARY_DIR}/bin/database.json COPYONLY)
-configure_file(${CMAKE_CURRENT_SOURCE_DIR}/paths.json ${CMAKE_BINARY_DIR}/bin/paths.json COPYONLY)
-configure_file(${CMAKE_CURRENT_SOURCE_DIR}/Images/Stock/CoverArt.png ${CMAKE_BINARY_DIR}/bin/CoverArt.png COPYONLY)
-
-add_executable(icarus ${SOURCES} ${HEADERS})
-target_include_directories(icarus PUBLIC ${JWT_CPP_INCLUDE})
-target_link_libraries(icarus "-lstdc++fs" tag oatpp mysqlclient ${CONAN_LIBS} ${CPR_LIBRARIES} ${BCRYPT})

CONTRIBUTING.md

@@ -1,67 +0,0 @@
-# Contributing
-
-When contributing to this repository, please first discuss the change you wish to make via issue,
-email, or any other method with the owners of this repository before making a change. 
-
-Please note the project has a code of conduct, please follow it in all your interactions with the project.
-
-## Code of Conduct
-
-### Pledge
-
-In the interest of fostering an open and welcoming environment, I as
-aintainers pledge to making participation in this project and
-this community a harassment-free experience for everyone, regardless of age, body
-size, disability, ethnicity, gender identity and expression, level of experience,
-nationality, personal appearance, race, religion, or sexual identity and
-orientation.
-
-### Standards
-
-Examples of behavior that contributes to creating a positive environment
-include:
-
-* Using welcoming and inclusive language
-* Being respectful of differing viewpoints and experiences
-* Gracefully accepting constructive criticism
-* Focusing on what is best for the community
-* Showing empathy towards other community members
-
-Examples of unacceptable behavior by participants include:
-
-* The use of sexualized language or imagery and unwelcome sexual attention or
-advances
-* Trolling, insulting/derogatory comments, and personal or political attacks
-* Public or private harassment
-* Publishing others' private information, such as a physical or electronic
-  address, without explicit permission
-* Other conduct which could reasonably be considered inappropriate in a
-  professional setting
-
-### Maintainers Responsibilities
-
-Project maintainers are responsible for clarifying the standards of acceptable
-behavior and are expected to take appropriate and fair corrective action in
-response to any instances of unacceptable behavior.
-
-Project maintainers have the right and responsibility to remove, edit, or
-reject comments, commits, code, wiki edits, issues, and other contributions
-that are not aligned to this Code of Conduct, or to ban temporarily or
-permanently any contributor for other behaviors that they deem inappropriate,
-threatening, offensive, or harmful.
-
-## How You Can Contribute
-
-The project is always looking for people to help in anyway they can. The following would be greatly appreciated:
-
-* Developers
-* Graphic Designers
-* Documenters
-
-### Attribution
-
-This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4,
-available at [http://contributor-covenant.org/version/1/4][version]
-
-[homepage]: http://contributor-covenant.org
-[version]: http://contributor-covenant.org/version/1/4/

Cargo.toml

@@ -0,0 +1,36 @@
+[package]
+name = "soaricarus_api"
+version = "0.5.2"
+edition = "2024"
+rust-version = "1.95"
+license = "MIT"
+description = "Core API for interacting with soaricarus"
+
+[dependencies]
+axum = { version = "0.8.9", features = ["multipart"] }
+axum-extra = { version = "0.12.6", features = ["cookie"] }
+openssl = { version = "0.10.81", features = ["vendored"] }
+serde = { version = "1.0.228", features = ["derive"] }
+serde_json = { version = "1.0.150" }
+tokio = { version = "1.52.3", features = ["full"] }
+tokio-util = { version = "0.7.18", features = ["io"] }
+tower = { version = "0.5.3", features = ["full"] }
+tower-http = { version = "0.7.0", features = ["cors", "timeout"] }
+tracing-subscriber = "0.3.23"
+futures = { version = "0.3.32" }
+mime_guess = { version = "2.0.5" }
+uuid = { version = "1.23.5", features = ["v4", "serde"] }
+sqlx = { version = "0.9.0", features = ["postgres", "runtime-tokio", "tls-native-tls", "time", "uuid"] }
+time = { version = "0.3.53", features = ["formatting", "macros", "parsing", "serde"]  }
+jsonwebtoken = { version = "10.3.0", features = ["rust_crypto"] }
+josekit = { version = "0.10.3" }
+utoipa = { version = "5.5.0", features = ["axum_extras"] }
+utoipa-swagger-ui = { version = "9.0.2", features = ["axum"] }
+simeta = { git = "ssh://git@git.kundeng.us/phoenix/simeta.git", tag = "v0.6.1-main-b690995806-680" }
+simodels = { git = "ssh://git@git.kundeng.us/phoenix/simodels.git", tag = "v0.11.3-main-fe9d101bd0-111" }
+sienvy = { git = "ssh://git@git.kundeng.us/phoenix/sienvy.git", tag = "v0.8.0-main-d06c8fdf49-006" }
+
+[dev-dependencies]
+common-multipart-rfc7578 = { version = "0.7.0" }
+url = { version = "2.5.8" }
+tempfile = { version = "3.27.0" }

Dockerfile

@@ -0,0 +1,56 @@
+FROM rust:1.97 as builder
+
+# Set the working directory inside the container
+WORKDIR /usr/src/app
+
+# Install build dependencies if needed (e.g., git for cloning)
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    pkg-config libssl3 \
+    ca-certificates \
+    openssh-client git \
+    && rm -rf /var/lib/apt/lists/*
+
+# Create .ssh/ directory for internal dependencies
+RUN mkdir -p -m 0700 ~/.ssh && \
+    echo "Host git.kundeng.us" >> ~/.ssh/config && \
+    echo "    User git" >> ~/.ssh/config && \
+    chmod 600 ~/.ssh/config
+
+RUN ssh-keyscan git.kundeng.us >> ~/.ssh/known_hosts
+
+# Copy Cargo manifests
+COPY Cargo.toml Cargo.lock ./
+
+RUN --mount=type=ssh mkdir src && \
+    echo "fn main() {println!(\"if you see this, the build broke\")}" > src/main.rs && \
+    cargo build --release --quiet && \
+    rm -rf src target/release/deps/soaricarus_api*
+
+# Copy the actual source code
+COPY src ./src
+COPY .env ./.env
+COPY migrations ./migrations
+COPY scripts/init-garage.sh /scripts/init-garage.sh
+
+# Make it executable
+RUN chmod +x /scripts/init-garage.sh
+
+RUN --mount=type=ssh \
+    cargo build --release --quiet
+
+FROM debian:trixie-slim
+
+# Install runtime dependencies if needed (e.g., SSL certificates)
+RUN apt-get update && apt-get install -y ca-certificates libssl-dev libssl3 && rm -rf /var/lib/apt/lists/*
+
+# Set the working directory
+WORKDIR /usr/local/bin
+
+COPY --from=builder /usr/src/app/target/release/soaricarus_api .
+
+COPY --from=builder /usr/src/app/.env .
+COPY --from=builder /usr/src/app/migrations ./migrations
+
+EXPOSE 8000
+
+CMD ["./soaricarus_api"]

LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2019 Kun Deng
+Copyright (c) 2025 Kun Deng
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

README.md

@@ -1,182 +1,33 @@
-# Icarus
+# soaricarus_api
-
+Core web API for the soaricarus project.
-Icarus is a music streaming API Server, allowing access to stream your personal music collection
-
-### Interfacing With Icarus
-
-One can interface with Icarus the music server either by:
-
-* [Mear](https://github.com/amazing-username/mear) - Partially implemented (under development)
-* [IcarusDownloadManager](https://github.com/amazing-username/IcarusDownloadManager)
-* Create your own client to interact with the API
 
 
+### Requires
+`soaricarus_auth` v0.8.x  
+`songparser` v0.6.x
 
-## Built With
+### Compatible with
+`sidm` v0.10.x  
 
 
-* C++ >= C++17
+## Getting Started
-* GCC >= 8.0
+Quickest way to get started is with docker. Make sure `soaricarus_auth` and `songparser` repositories 
-* [json](https://www.github.com/nlohmann/json)
+are located in the root of the parent directory. Check the respective repositories to ensure they
-* [cpr](https://www.github.com/whoshuu/cpr)
+are setup correctly before configuring `soaricarus_api`.
-* [TagLib](https://github.com/taglib/taglib)
-* [jwt-cpp](https://github.com/Thalhammer/jwt-cpp)
-* [libbcrypt](https://github.com/rg3/libbcrypt)
-* [oatpp](https://github.com/oatpp/oatpp)
 
-![image](https://user-images.githubusercontent.com/14333136/56252069-28532d00-6084-11e9-896d-1a3c378014ef.png)
+Copy the `.env.docker.sample` file to `.env`. Ensure that the `ROOT_DIRECTORY` variable is populated
+and exists on the docker image's filesystem. The credentials for the database doesn't need to be
+changed for development, but if deploying it, it should be modified.
 
-## Getting started
+Build containers
-There are several things that need to be completed to properly setup and secure the API.
+```
-1. Auth0 API configuration
+docker compose build --ssh default
-2. API filesystem paths
-3. Database connection string
-4. Migrations
-
-### Auth0 API configuration
-
-Securing Icarus is required, preventing the API from being publicly accessible. To do so, create an Auth0 account (it's free), for the sake of this section of the documentation, I will not go over how to create an Auth0 account. Once created, create a tentant and proceed to create an API
-<h1 align=center>
-    <img src="Images/Configuration/create_api.png" width=100%>
-</h1>
-
-Create the API and enter an approrpiate name and identified. For the identified, append **api** like in the example
-<h1 align="center">
-    <img src="Images/Configuration/enter_api_info.png" width=100%>
-</h1>
-Replace [domain] with the domain name of the created tenant. This can be found in the Default App from the Application menu. Replace [identifier] with the identifer root name in the appsettings environment file. Not the friendly name but the root name of the identifier, omitting the http protocol and the *api* path.
-
-```Json
-  "domain": "[domain].auth0.com", 
-  "api_identifier": "https://[identifier]/api",
-  "client_id": "iamunique",
-  "client_secret": "Icankeepasecret"
 ```
 
-For the sake of this section, I will not go over configuring the API to accept the signing algorithm since it has already been configured in the [Startip](Startup.cs).cs file. Click on permissions to create the permissions for the API.
+Bring it up
-<h1 align "center">
+```
-    <img src="Images/Configuration/configure_api.png" width=100%>
+docker compose up -d --force-recreate
-</h1>
-
-The permissions ensure that a validated user can interact with the API with a token that has not expired. Ensure that the permissions match, the description can change but the permission identifier must match.
-<h1 align="center">
-    <img src="Images/Configuration/permissions.png" width=100%>
-</h1>
-
-On the left side, click on Application and create a new Application. Choose the Machine to Machine Application
-<h1 align="center">
-    <img src="Images/Configuration/create_m2m.png" width=100%>
-</h1>
-
-With the grant permissions you created from the API, enable all the permissions. This is important because if they are not enabled then even with a valid token the request will return 403 (unauthorized)
-<h1 align="center">
-    <img src="Images/Configuration/authorize_app.png" width=100%>
-</h1>
-
-From the Application page, copy the client id and client secret. These values will be used for the API to interact with API.
-<h1 align="center">
-    <img src="Images/Configuration/api_cred.png" width=100%>
-</h1>
-Enter the information in the corresponding ``authcredentials.json`` file  
-```Json
-{
-  "domain": "somedomain.auth0.com",
-  "api_identifier": "https://squawk/api"
-  "client_id": "clientidhere",
-  "client_secret": "illkeepyoumydirtylittlesecret"
-}
 ```
 
-### API filesystem paths
+To view the OpenAPI spec, run the project and access `/swagger-ui`. If running through docker,
-
+the url would be something like `http://localhost:8000/swagger-ui`.
-For the purposes of properly uploading, downloading, updating, deleting, and streaming songs the API filesystem paths must be configured. For that purpose you have to open the ``paths.json`` file. What is meant by this is that the `root_music_path` directory where all music will be stored must exist. The `cover_root_path`, `archive_root_path`, and `temp_root_path` paths must exist and be accessible. An example on a Linux system:
-```Json
-{
-  "root_music_path": "/dev/null/music/",
-  "temp_root_path": "/dev/null/music/temp/",
-  "cover_root_path": "/dev/null/music/coverArt/",
-  "archive_root_path": "/dev/null/music/archive/"
-}
-```
-* `root_music_path` - Where music will be stored in the following convention: *`Artist/Album/Songs`*
-* `temp_music_path` - Where music will be stored when uploding songs to the server until the metadata has been fully parsed and entered into the database. Upon completion the files will be deleted and moved to the appropriate path in the `root_music_path`
-* `cover_root_path` - Where cover art of music will be saved to.
-* `archive_root_path` - When downloading compressed songs this is the path where songs will be compressed prior to dataa being read into memory, deleting the compressed file, and sending the compressed file from memory to the client
-
-
-**Note**: The `temp_root_path`, `cover_root_path`, or `archive_root_path` does not have to be located in the same parent directory as `root_music_path`. Ensure that the permissions are properly set for all of the paths.
-
-### Database connection string
-
-In order for Database functionality to be operable, there must be a valid connection string and MySQL credentials with appropriate permissions. **At the moment there is only support for MySQL**. Edit the database.json file accordingly. An example of the fields to change are below:
-```Json
-{
-
-  "server": "localhost", 
-  "database": "my_db",
-  "username": "admin",
-  "password": "toughpassword"
- 
-}
-```
-* server - The address or domain name of the MySQL server
-* database - The database name
-* username - Username
-* password - Self-explanatory
-
-The only requirement of the User is that the user should have full permissions to the database as well as permissions to create a database. Other than that, that is all that is required.
-
-### Database
-
-Prior to starting the API, the database must be created. The following tables are required:
-* User
-* Song
-* Album
-* Artist
-* Year
-* Genre
-* CoverArt
-
-There is a MySQL script to create these tables, it can be found in the [Scripts/MySQL/](https://github.com/amazing-username/Icarus/blob/master/Scripts/MySQL/create_database.sql) directory. Just merely execute:
-```shell
-mysql -u dblikedecibel -p < Scripts/MySQL/create_database.sql
-```
-
-From this point the database has been successfully created. Metadata and song filesystem locations can be saved.
-
-
-## Building and Running
-```
-git clone --recursive https://github.com/kdeng00/icarus
-cd 3rdparty/libbcrypt/
-make
-cp bcrypt.a libbcrypt.a
-cp bcrypt.o libbcrypt.o
-cd ../..
-mkdir build
-cd build
-conan install ..
-cmake ..
-make
-bin/icarus
-```
-Runs the server on localhost port 5002
-
-## Contributing
-
-Please read [CONTRIBUTING.md](CONTRIBUTING.md) for details on the code of conduct, and the process for submitting pull requests to the project.
-
-## Versioning
-
-* [v0.1](https://github.com/amazing-username/Icarus/releases/tag/v0.1)
-
-## 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](LICENSE) file for details
-

Scripts/Migrations/Linux/AddUpdate.sh

@@ -1,26 +0,0 @@
-echo "Adding migrations..."
-echo "Adding User migration"
-dotnet ef migrations add User --context UserContext
-echo "Adding Song migration"
-dotnet ef migrations add Song --context SongContext
-echo "Adding Album migration"
-dotnet ef migrations add Album --context AlbumContext
-echo "Adding Artist migration"
-dotnet ef migrations add Artist --context ArtistContext
-echo "Adding Genre migration"
-dotnet ef migrations add Genre --context GenreContext
-echo "Adding Year migration"
-dotnet ef migrations add Year --context YearContext
-echo "Adding Cover art migration"
-dotnet ef migrations add CoverArt --context CoverArtContext
-
-echo "Updating migrations.."
-echo "Updating User migration"
-dotnet ef database update --context UserContext
-echo "Updating Song migration"
-echo "Updating Album migration"
-echo "Updating Artist migration"
-echo "Updating Genre migration"
-echo "Updating Year migration"
-echo "Updating Cover art migration"
-dotnet ef database update --context SongContext

Scripts/MySQL/create_database.sql

@@ -1,86 +0,0 @@
-CREATE DATABASE Icarus;
-
-USE Icarus;
-
-CREATE TABLE CoverArt (
-    CoverArtId INT NOT NULL AUTO_INCREMENT,
-    SongTitle TEXT NOT NULL,
-    ImagePath TEXT NOT NULL,
-
-    PRIMARY KEY (CoverArtId)
-);
-
-CREATE TABLE Album (
-    AlbumId INT NOT NULL AUTO_INCREMENT,
-    Title TEXT NOT NULL,
-    Year INT NOT NULL,
-
-    PRIMARY KEY (AlbumId)
-);
-
-CREATE TABLE Artist (
-    ArtistId INT NOT NULL AUTO_INCREMENT,
-    Artist TEXT NOT NULL,
-
-    PRIMARY KEY (ArtistId)
-);
-
-CREATE TABLE Genre (
-    GenreId INT NOT NULL AUTO_INCREMENT,
-    Category TEXT NOT NULL,
-
-    PRIMARY KEY (GenreId)
-);
-
-CREATE TABLE Year (
-    YearId INT NOT NULL AUTO_INCREMENT,
-    Year INT NOT NULL,
-
-    PRIMARY KEY (YearId)
-);
-
-CREATE TABLE Song (
-    SongId INT NOT NULL AUTO_INCREMENT,
-    Title TEXT NOT NULL,
-    Artist TEXT NOT NULL,
-    Album TEXT NOT NULL,
-    Genre TEXT NOT NULL,
-    Year INT NOT NULL,
-    Duration INT NOT NULL,
-    Track INT NOT NULL,
-    Disc INT NOT NULL,
-    SongPath TEXT NOT NULL,
-    CoverArtId INT NOT NULL,
-    ArtistId INT NOT NULL,
-    AlbumId INT NOT NULL,
-    GenreId INT NOT NULL,
-    YearId INT NOT NULL,
-
-    PRIMARY KEY (SongId),
-    CONSTRAINT FK_CoverArtId FOREIGN KEY (CoverArtId) REFERENCES CoverArt (CoverArtId),
-    CONSTRAINT FK_ArtistId FOREIGN KEY (ArtistId) REFERENCES Artist (ArtistId),
-    CONSTRAINT FK_AlbumId FOREIGN KEY (AlbumId) REFERENCES Album (AlbumId),
-    CONSTRAINT FK_GenreId FOREIGN KEY (GenreId) REFERENCES Genre (GenreId),
-    CONSTRAINT FK_YearId FOREIGN KEY (YearId) REFERENCES Year (YearId)
-);
-
-CREATE TABLE User (
-    UserId INT NOT NULL AUTO_INCREMENT,
-    Firstname TEXT NOT NULL,
-    Lastname TEXT NOT NULL,
-    Email TEXT NOT NULL,
-    Phone TEXT NOT NULL,
-    Username TEXT NOT NULL,
-    Password TEXT NOT NULL,
-
-    PRIMARY KEY (UserId)
-);
-
-CREATE TABLE Salt (
-    SaltId INT NOT NULL AUTO_INCREMENT,
-    Salt TEXT NOT NULL,
-    UserId INT NOT NULL,
-
-    PRIMARY KEY (SaltId),
-    CONSTRAINT FK_UserId FOREIGN KEY (UserId) REFERENCES User (UserId)
-);

Scripts/MySQL/delete_all.sql

@@ -1,6 +0,0 @@
-delete from Song;
-delete from Album;
-delete from Artist;
-delete from Genre;
-delete from Year;
-delete from CoverArt;

Scripts/MySQL/display_songs.sql

@@ -1 +0,0 @@
-select * from Song;

appsettings.json

@@ -1,22 +0,0 @@
-{
-  "Logging": {
-    "LogLevel": {
-      "Default": "Trace",
-      "Microsoft": "Information"
-    }
-  },
-  "AllowedHosts": "*",
-  "Auth0": {
-	  "Domain": "[domain].auth0.com",
-	  "ApiIdentifier": "https://[identifier]/api",
-	  "ClientId": "",
-	  "ClientSecret": ""
-  },
-  "ConnectionStrings": {
-	  "DefaultConnection": "Server=;Database=;Uid=;Pwd=;"
-  },
-  "RootMusicPath": "/music/path/",
-  "TemporaryMusicPath": "/music/temp/path/",
-  "ArchivePath": "/archive/path/",
-  "CoverArtPath": "/cover/art/path/"
-}

authcredentials.json

@@ -1,6 +0,0 @@
-{
-  "domain": "[domain].auth0.com",
-  "api_identifier": "https://[identifier]/api",
-  "client_id": "dfdfdfdf",
-  "client_secret": "dfdfdfdf"
-}

conanfile.txt

@@ -1,5 +0,0 @@
-[requires]
-jsonformoderncpp/3.7.0@vthiery/stable
-
-[generators]
-cmake

database.json

@@ -1,7 +0,0 @@
-
-{
-  "server": "localhost",
-  "database": "Icarus",
-  "username": "icarus-admin",
-  "password": "dreamofpeace"
-}

docker-compose.yaml

@@ -0,0 +1,163 @@
+version: '3.8' # Use a recent version
+
+services:
+  # --- Web API ---
+  api:
+    build:
+      context: .
+      ssh: ["default"]
+    container_name: soaricarus
+    ports:
+      - "8000:8000"
+    env_file:
+      - .env
+    volumes:
+      - shared_credentials:/shared:ro  # Mount as read-only 
+    depends_on:
+      main_db:
+        condition: service_healthy
+    networks:
+      - soaricarus-network
+    restart: unless-stopped
+
+  # --- Web API auth ---
+  auth_api:
+    build:
+      context: ../soaricarus_auth # IMPORTANT: Relative path to the local checkout of your web API repo (containing the Dockerfile)
+      ssh: ["default"]
+      dockerfile: Dockerfile # Optional: Specify if your Dockerfile has a non-standard name
+    container_name: auth_api
+    restart: unless-stopped
+    ports:
+      - "8001:8001"
+    env_file:
+     - ../soaricarus_auth/.env
+    depends_on:
+      auth_db:
+        condition: service_healthy
+    networks:
+      - soaricarus-network
+    # Optional: Mount local code for development (live reload)
+    # volumes:
+    #  - ./path/to/your/web-api-repo:/app
+
+  # --- songparser service ---
+  songparser:
+    build:
+      context: ../songparser
+      ssh: ["default"]
+      dockerfile: Dockerfile
+    container_name: songparser
+    restart: unless-stopped
+    env_file:
+      - ../songparser/.env
+    depends_on:
+      - api
+      - main_db
+      - auth_api
+      - auth_db
+    networks:
+      - soaricarus-network
+  # --- storage service ---
+  maze:
+    build:
+      context: ./garage
+      dockerfile: Dockerfile
+    container_name: maze
+    restart: unless-stopped
+    ports:
+      - "3900:3900"  # S3 API
+      - "3901:3901"  # RPC for cluster communication
+      - "3902:3902"  # S3 web interface
+      - "3903:3903"  # Admin API
+    volumes:
+      - ./garage.toml:/etc/garage.toml:ro
+      - ./garage/entrypoint.sh:/entrypoint.sh:ro
+      - shared_credentials:/shared
+      - object_data:/var/lib/garage
+      # - ./scripts:/scripts:ro  # ← ADD THIS - mount the scripts directory
+    env_file:
+      - .env
+    environment:
+      - AWS_ACCESS_KEY_ID=${AWS_ACCESS_KEY_ID}
+      - AWS_SECRET_ACCESS_KEY=${AWS_SECRET_ACCESS_KEY}
+      - GARAGE_RPC_SECRET=${GARAGE_RPC_SECRET}
+      - BUCKET_NAME=${S3_BUCKET_NAME}
+    # entrypoint: ["/entrypoint.sh"]
+    # command: []
+    healthcheck:
+      test: ["CMD-SHELL", "curl -f http://localhost:3901/v0/status || exit 1"]
+      # test: ["CMD-SHELL", "echo 'What is to be done?'"]
+      # test: ["CMD-SHELL", "nc -z localhost 3900 || exit 1"]
+      # test: ["CMD-SHELL", "/garage status | grep -q 'Health: ok' || exit 1"]
+      interval: 10s
+      timeout: 5s
+      retries: 5
+      start_period: 30s
+    networks:
+      - soaricarus-network
+
+
+  # PostgreSQL Database Service
+  main_db:
+    image: postgres:18.4-alpine
+    container_name: soaricarus_db
+    environment:
+      # These MUST match the user, password, and database name in the DATABASE_URL above
+      POSTGRES_USER: ${POSTGRES_MAIN_USER:-soaricarus}
+      POSTGRES_PASSWORD: ${POSTGRES_MAIN_PASSWORD:-password}
+      POSTGRES_DB: ${POSTGRES_MAIN_DB:-soaricarus_db}
+    volumes:
+      # Persist database data using a named volume
+      - postgres_data:/var/lib/postgresql
+    ports:
+      - "5432:5432"
+    healthcheck:
+        # Checks if Postgres is ready to accept connections
+        test: ["CMD-SHELL", "pg_isready -U $$POSTGRES_USER -d $$POSTGRES_DB"]
+        interval: 10s
+        timeout: 5s
+        retries: 5
+        start_period: 10s
+    restart: always
+    networks:
+      - soaricarus-network
+
+  # --- soaricarus web auth api db ---
+  auth_db:
+    image: postgres:18.4-alpine
+    container_name: soaricarus_auth_db
+    environment:
+      # These MUST match the user, password, and database name in the DATABASE_URL above
+      POSTGRES_USER: ${POSTGRES_AUTH_USER:-soaricarus_op}
+      POSTGRES_PASSWORD: ${POSTGRES_AUTH_PASSWORD:-password}
+      POSTGRES_DB: ${POSTGRES_AUTH_DB:-soaricarus_auth_db}
+    volumes:
+      # Persist database data using a named volume
+      - postgres_data_auth:/var/lib/postgresql
+    ports: 
+      - "5433:5432"
+    healthcheck:
+        # Checks if Postgres is ready to accept connections
+        test: ["CMD-SHELL", "pg_isready -U $$POSTGRES_USER -d $$POSTGRES_DB"]
+        interval: 10s
+        timeout: 5s
+        retries: 5
+        start_period: 10s
+    restart: always
+    networks:
+      - soaricarus-network
+
+volumes:
+  postgres_data:
+    driver: local # Use the default local driver
+  postgres_data_auth:
+    driver: local # Use the default local driver
+  object_data:
+    driver: local # Use the default local driver
+  shared_credentials:  # New shared volume
+    driver: local
+
+networks:
+  soaricarus-network:
+    driver: bridge

garage.toml

@@ -0,0 +1,16 @@
+metadata_dir = "/var/lib/garage/meta"
+data_dir = "/var/lib/garage/data"
+db_engine = "sqlite"
+replication_factor = 1
+
+rpc_bind_addr = "[::]:3901"
+rpc_secret = "${GARAGE_RPC_SECRET}"
+
+[s3_api]
+s3_region = "maze"
+api_bind_addr = "[::]:3900"
+root_domain = ".localhost"
+
+[s3_web]
+bind_addr = "[::]:3902"
+root_domain = ".localhost"

garage/Dockerfile

@@ -0,0 +1,18 @@
+# Use a base image with a shell (Alpine)
+FROM alpine:latest
+
+# Install necessary tools
+RUN apk add --no-cache curl
+
+# Copy the Garage binary from the official image
+COPY --from=dxflrs/garage:v2.3.0 /garage /usr/local/bin/garage
+
+# Copy the entrypoint script
+COPY entrypoint.sh /entrypoint.sh
+RUN chmod +x /entrypoint.sh
+
+# Set the entrypoint
+ENTRYPOINT ["/entrypoint.sh"]
+
+# Pass through any arguments to Garage
+CMD []

garage/entrypoint.sh

@@ -0,0 +1,103 @@
+#!/bin/sh
+set -e
+
+BUCKET_NAME="${BUCKET_NAME:-soaricarus-storage}"
+CREDENTIALS_FILE="/shared/garage-credentials.env"
+SETUP_DONE="/shared/setup.done"
+GARAGE_BIN="/usr/local/bin/garage"
+
+# Function to write credentials
+write_credentials() {
+    local access_key="$1"
+    local secret_key="$2"
+    mkdir -p "$(dirname "$CREDENTIALS_FILE")"
+    cat > "$CREDENTIALS_FILE" << EOF
+GARAGE_ACCESS_KEY_ID=$access_key
+GARAGE_SECRET_ACCESS_KEY=$secret_key
+GARAGE_BUCKET_NAME=$BUCKET_NAME
+GARAGE_ENDPOINT=http://localhost:3900
+EOF
+    touch "$SETUP_DONE"
+    echo "✅ Credentials saved to $CREDENTIALS_FILE"
+}
+
+# Check if setup already completed
+if [ -f "$SETUP_DONE" ]; then
+    echo "ℹ️  Setup already completed. Starting Garage..."
+    exec $GARAGE_BIN "$@"
+fi
+
+echo "🔧 First-time setup - initializing Garage..."
+
+# Start Garage in background for setup (just the binary, no daemon subcommand)
+echo "⏳ Starting Garage in background..."
+$GARAGE_BIN "$@" &
+GARAGE_PID=$!
+
+# Wait for Garage to be ready
+echo "⏳ Waiting for Garage API..."
+until curl -s -f "http://localhost:3901/v0/status" > /dev/null 2>&1; do
+    echo "   Not ready yet, sleeping 2s..."
+    sleep 2
+done
+echo "✅ Garage API is responding!"
+
+# Apply cluster layout
+if ! $GARAGE_BIN layout show 2>/dev/null | grep -q "Current cluster layout"; then
+    echo "📦 Applying cluster layout..."
+    NODE_ID=$($GARAGE_BIN node id | head -n1)
+    $GARAGE_BIN layout assign --version 1 "$NODE_ID"
+    $GARAGE_BIN layout apply --version 1
+    echo "   ✅ Layout applied"
+    sleep 2
+else
+    echo "ℹ️  Layout already applied"
+fi
+
+# Create bucket
+if ! $GARAGE_BIN bucket info "$BUCKET_NAME" 2>/dev/null; then
+    echo "📦 Creating bucket: $BUCKET_NAME"
+    $GARAGE_BIN bucket create "$BUCKET_NAME"
+else
+    echo "ℹ️  Bucket $BUCKET_NAME already exists"
+fi
+
+# Handle key
+if [ -n "$AWS_ACCESS_KEY_ID" ] && [ -n "$AWS_SECRET_ACCESS_KEY" ]; then
+    echo "🔑 Using pre-defined credentials from .env"
+    if ! $GARAGE_BIN key info "$AWS_ACCESS_KEY_ID" 2>/dev/null; then
+        $GARAGE_BIN key import "$AWS_ACCESS_KEY_ID" "$AWS_SECRET_ACCESS_KEY" "app-key"
+        echo "   ✅ Key imported: $AWS_ACCESS_KEY_ID"
+    else
+        echo "   ℹ️  Key already exists: $AWS_ACCESS_KEY_ID"
+    fi
+    ACCESS_KEY="$AWS_ACCESS_KEY_ID"
+    SECRET_KEY="$AWS_SECRET_ACCESS_KEY"
+else
+    echo "🔑 Generating new key..."
+    KEY_OUTPUT=$($GARAGE_BIN key create --name "app-key")
+    echo "$KEY_OUTPUT"
+    ACCESS_KEY=$(echo "$KEY_OUTPUT" | grep 'Key ID:' | awk '{print $3}')
+    SECRET_KEY=$(echo "$KEY_OUTPUT" | grep 'Secret key:' | awk '{print $3}')
+    echo "   ✅ Key generated: $ACCESS_KEY"
+fi
+
+# Grant permissions
+$GARAGE_BIN bucket allow --read --write --owner "$BUCKET_NAME" --key "$ACCESS_KEY"
+echo "   ✅ Permissions granted"
+
+# Save credentials
+write_credentials "$ACCESS_KEY" "$SECRET_KEY"
+
+echo "🎉 Setup complete!"
+echo "   Bucket: $BUCKET_NAME"
+echo "   Access Key: $ACCESS_KEY"
+
+# Stop background Garage
+echo "⏹️  Stopping background Garage..."
+kill "$GARAGE_PID"
+wait "$GARAGE_PID" 2>/dev/null || true
+
+# Start Garage in foreground
+echo "🚀 Starting Garage in foreground..."
+exec $GARAGE_BIN "$@"

garage/full-init-garage.sh

@@ -0,0 +1,109 @@
+#!/bin/sh
+set -e
+
+BUCKET_NAME="${BUCKET_NAME:-soaricarus-storage}"
+CREDENTIALS_FILE="/shared/garage-credentials.env"
+SETUP_DONE="/shared/setup.done"
+
+# Function to write credentials to shared volume
+write_credentials() {
+    local access_key="$1"
+    local secret_key="$2"
+    mkdir -p "$(dirname "$CREDENTIALS_FILE")"
+    cat > "$CREDENTIALS_FILE" << EOF
+GARAGE_ACCESS_KEY_ID=$access_key
+GARAGE_SECRET_ACCESS_KEY=$secret_key
+GARAGE_BUCKET_NAME=$BUCKET_NAME
+GARAGE_ENDPOINT=http://maze:3900
+EOF
+    touch "$SETUP_DONE"
+    echo "✅ Credentials saved to $CREDENTIALS_FILE"
+}
+
+# Check if setup already done
+if [ -f "$SETUP_DONE" ]; then
+    echo "ℹ️  Setup already completed. Starting Garage..."
+    # Source credentials if needed for the main Garage process
+    # shellcheck source=/dev/null
+    [ -f "$CREDENTIALS_FILE" ] && . "$CREDENTIALS_FILE"
+    exec /usr/local/bin/garage "$@"
+fi
+
+echo "🔧 Running initial setup..."
+
+# Start Garage in background for setup
+echo "⏳ Starting Garage in background..."
+/usr/local/bin/garage "$@" &
+GARAGE_PID=$!
+
+# Wait for Garage API to be ready
+echo "⏳ Waiting for Garage API..."
+# until curl -s -f "http://localhost:3900/v0/status" > /dev/null 2>&1; do
+#    echo "   Not ready yet, sleeping 2s..."
+#    sleep 2
+#done
+echo "✅ Garage API is responding!"
+
+# Apply layout if not already applied
+if ! /usr/local/bin/garage layout show 2>/dev/null | grep -q "Current cluster layout"; then
+    echo "📦 Applying cluster layout..."
+    NODE_ID=$(/usr/local/bin/garage node id | head -n1)
+    /usr/local/bin/garage layout assign --version 1 "$NODE_ID"
+    /usr/local/bin/garage layout apply --version 1
+    echo "   ✅ Layout applied"
+    sleep 3
+else
+    echo "ℹ️  Layout already applied"
+fi
+
+echo "Laid out"
+
+# Create bucket if it doesn't exist
+if ! /usr/local/bin/garage bucket info "$BUCKET_NAME" 2>/dev/null; then
+    echo "📦 Creating bucket: $BUCKET_NAME"
+    /usr/local/bin/garage bucket create "$BUCKET_NAME"
+else
+    echo "ℹ️  Bucket $BUCKET_NAME already exists"
+fi
+
+# Create or import key
+# We'll use the credentials from .env if provided, otherwise generate new ones
+if [ -n "$AWS_ACCESS_KEY_ID" ] && [ -n "$AWS_SECRET_ACCESS_KEY" ]; then
+    echo "🔑 Using pre-defined AWS credentials from .env"
+    if ! /usr/local/bin/garage key info "$AWS_ACCESS_KEY_ID" 2>/dev/null; then
+        # Key doesn't exist, import it
+        /usr/local/bin/garage key import "$AWS_ACCESS_KEY_ID" "$AWS_SECRET_ACCESS_KEY" "app-key"
+        echo "   ✅ Key imported: $AWS_ACCESS_KEY_ID"
+    else
+        echo "   ℹ️  Key already exists: $AWS_ACCESS_KEY_ID"
+    fi
+    ACCESS_KEY="$AWS_ACCESS_KEY_ID"
+    SECRET_KEY="$AWS_SECRET_ACCESS_KEY"
+else
+    echo "🔑 Generating new key..."
+    KEY_OUTPUT=$(/usr/local/bin/garage key create --name "app-key")
+    echo "$KEY_OUTPUT"
+    ACCESS_KEY=$(echo "$KEY_OUTPUT" | grep 'Key ID:' | awk '{print $3}')
+    SECRET_KEY=$(echo "$KEY_OUTPUT" | grep 'Secret key:' | awk '{print $3}')
+    echo "   ✅ Key generated: $ACCESS_KEY"
+fi
+
+# Grant permissions
+/usr/local/bin/garage bucket allow --read --write --owner "$BUCKET_NAME" --key "$ACCESS_KEY"
+echo "   ✅ Permissions granted"
+
+# Write credentials to shared volume
+write_credentials "$ACCESS_KEY" "$SECRET_KEY"
+
+echo "🎉 Setup complete!"
+echo "   Bucket: $BUCKET_NAME"
+echo "   Access Key: $ACCESS_KEY"
+
+# Stop the background Garage process
+echo "⏹️  Stopping background Garage process..."
+kill "$GARAGE_PID"
+wait "$GARAGE_PID" 2>/dev/null || true
+
+echo "🚀 Starting Garage in foreground..."
+exec /usr/local/bin/garage "$@"
+

garage/init-garage.sh

@@ -0,0 +1,36 @@
+#!/bin/sh
+set -e
+
+BUCKET_NAME="${BUCKET_NAME:-soaricarus-storage}"
+CREDENTIALS_FILE="/shared/garage-credentials.env"
+SETUP_DONE="/shared/setup.done"
+
+echo "🔧 Running initial setup..."
+
+# Start Garage in background for setup
+echo "⏳ Starting Garage in background..."
+/usr/local/bin/garage "$@" &
+GARAGE_PID=$!
+
+# Wait for Garage API to be ready
+echo "⏳ Waiting for Garage API..."
+# until curl -s -f "http://localhost:3900/v0/status" > /dev/null 2>&1; do
+#    echo "   Not ready yet, sleeping 2s..."
+#    sleep 2
+#done
+echo "✅ Garage API is responding!"
+
+# Apply layout if not already applied
+#if ! /usr/local/bin/garage layout show 2>/dev/null | grep -q "Current cluster layout"; then
+#    echo "📦 Applying cluster layout..."
+#    NODE_ID=$(/usr/local/bin/garage node id | head -n1)
+#    echo $NODE_ID
+    # /usr/local/bin/garage layout assign --version 1 "$NODE_ID"
+    # /usr/local/bin/garage layout apply --version 1
+#    echo "   ✅ Layout applied"
+#    sleep 3
+#else
+    # echo "ℹ️  Layout already applied"
+# fi
+
+echo "Laid out"

include/callback/StreamCallback.h

@@ -1,26 +0,0 @@
-#ifndef STREAMCALLBACK_H_
-#define STREAMCALLBACK_H_
-
-#include <string>
-
-#include "oatpp/core/data/stream/FileStream.hpp"
-#include "oatpp/web/protocol/http/outgoing/ChunkedBody.hpp"
-
-namespace callback {
-class StreamCallback : public oatpp::data::stream::ReadCallback
-{
-public:
-    StreamCallback();
-    StreamCallback(const std::string&);
-
-    oatpp::data::v_io_size read(void*, oatpp::data::v_io_size);
-private:
-    std::string m_songPath;
-
-    long m_bytesRead;
-    long m_counter;
-    long m_fileSize;
-};
-}
-
-#endif

include/component/AppComponent.hpp

@@ -1,37 +0,0 @@
-#ifndef APPCOMPONENT_H_
-#define APPCOMPONENT_H_
-
-#include <memory>
-
-#include "oatpp/core/macro/component.hpp"
-#include "oatpp/network/server/SimpleTCPConnectionProvider.hpp"
-#include "oatpp/parser/json/mapping/ObjectMapper.hpp"
-#include "oatpp/web/server/HttpConnectionHandler.hpp"
-
-namespace component {
-
-class AppComponent 
-{
-public:
-    OATPP_CREATE_COMPONENT(std::shared_ptr<oatpp::network::ServerConnectionProvider>, serverConnectionProvider)([] {
-        return oatpp::network::server::SimpleTCPConnectionProvider::createShared(5002);
-    }());
-
-    OATPP_CREATE_COMPONENT(std::shared_ptr<oatpp::web::server::HttpRouter>, httpRouter)([] {
-        return oatpp::web::server::HttpRouter::createShared();
-    }());
-
-    OATPP_CREATE_COMPONENT(std::shared_ptr<oatpp::network::server::ConnectionHandler>, serverConnectionHandler)([] {
-        OATPP_COMPONENT(std::shared_ptr<oatpp::web::server::HttpRouter>, router);
-
-        return oatpp::web::server::HttpConnectionHandler::createShared(router);
-    }());
-
-    OATPP_CREATE_COMPONENT(std::shared_ptr<oatpp::data::mapping::ObjectMapper>, apiObjectMapper)([] {
-        return oatpp::parser::json::mapping::ObjectMapper::createShared();
-    }());
-private:
-};
-}
-
-#endif

include/controller/AlbumController.hpp

@@ -1,102 +0,0 @@
-#ifndef ALBUMCONTROLLER_H_
-#define ALBUMCONTROLLER_H_
-
-#include <filesystem>
-#include <iostream>
-#include <fstream>
-#include <limits>
-#include <string>
-#include <memory>
-#include <vector>
-
-#include "oatpp/core/data/stream/ChunkedBuffer.hpp"
-#include "oatpp/core/data/stream/FileStream.hpp"
-#include "oatpp/core/macro/codegen.hpp"
-#include "oatpp/core/macro/component.hpp"
-#include "oatpp/web/mime/multipart/InMemoryPartReader.hpp"
-#include "oatpp/web/mime/multipart/Reader.hpp"
-#include "oatpp/web/server/api/ApiController.hpp"
-
-#include "database/AlbumRepository.h"
-#include "dto/AlbumDto.hpp"
-#include "manager/AlbumManager.h"
-#include "manager/TokenManager.h"
-#include "model/Models.h"
-#include "type/Scopes.h"
-#include "type/AlbumFilter.h"
-
-namespace fs = std::filesystem;
-
-namespace controller {
-class AlbumController : public oatpp::web::server::api::ApiController
-{
-public:
-    AlbumController(std::string p, OATPP_COMPONENT(std::shared_ptr<ObjectMapper>, objectMapper))
-        : oatpp::web::server::api::ApiController(objectMapper), m_exe_path(p)
-    { }
-
-    AlbumController(const model::BinaryPath& bConf, OATPP_COMPONENT(std::shared_ptr<ObjectMapper>, objectMapper))
-        : oatpp::web::server::api::ApiController(objectMapper), m_bConf(bConf)
-    { }
-
-    #include OATPP_CODEGEN_BEGIN(ApiController)
-
-    // endpoint for retrieving all album records in json format
-    ENDPOINT("GET", "/api/v1/album", albumRecords, 
-        REQUEST(std::shared_ptr<IncomingRequest>, request))
-    {
-        auto authHeader = request->getHeader("Authorization");
-        OATPP_ASSERT_HTTP(authHeader, Status::CODE_403, "Nope");
-        auto auth = authHeader->std_str();
-        manager::TokenManager tok;
-        OATPP_ASSERT_HTTP(tok.isTokenValid(auth, type::Scope::retrieveAlbum), Status::CODE_403, "Not allowed");
-
-        std::cout << "starting process of retrieving album" << std::endl;
-        database::AlbumRepository albRepo(m_bConf);
-        auto albsDb = albRepo.retrieveRecords();
-        auto albums = oatpp::data::mapping::type::List<dto::AlbumDto::ObjectWrapper>::createShared();
-
-        for (auto& albDb : albsDb) {
-            auto alb = dto::AlbumDto::createShared();
-            alb->id = albDb.id;
-            alb->title = albDb.title.c_str();
-            alb->year = albDb.year;
-
-            albums->pushBack(alb);
-        }
-
-        return createDtoResponse(Status::CODE_200, albums);
-    }
-
-    // endpoint for retrieving single album record by the album id in json format
-    ENDPOINT("GET", "/api/v1/album/{id}", albumRecord, 
-        REQUEST(std::shared_ptr<IncomingRequest>, request), PATH(Int32, id)) {
-        auto authHeader = request->getHeader("Authorization");
-        OATPP_ASSERT_HTTP(authHeader, Status::CODE_403, "Nope");
-        auto auth = authHeader->std_str();
-        manager::TokenManager tok;
-        OATPP_ASSERT_HTTP(tok.isTokenValid(auth, type::Scope::retrieveAlbum), Status::CODE_403, "Not allowed");
-
-        database::AlbumRepository albRepo(m_bConf);
-        model::Album albDb(id);
-
-        OATPP_ASSERT_HTTP(albRepo.doesAlbumExists(albDb, type::AlbumFilter::id) , Status::CODE_403, "album does not exist");
-
-        std::cout << "album exists" << std::endl;
-        albDb = albRepo.retrieveRecord(albDb, type::AlbumFilter::id);
-
-        auto album = dto::AlbumDto::createShared();
-        album->id = albDb.id;
-        album->title = albDb.title.c_str();
-        album->year = albDb.year;
-
-        return createDtoResponse(Status::CODE_200, album);
-    }
-
-    #include OATPP_CODEGEN_END(ApiController)
-private:
-    std::string m_exe_path;
-    model::BinaryPath m_bConf;
-};
-}
-#endif

include/controller/ArtistController.hpp

@@ -1,100 +0,0 @@
-#ifndef ARTISTCONTROLLER_H_
-#define ARTISTCONTROLLER_H_
-
-#include <filesystem>
-#include <iostream>
-#include <fstream>
-#include <limits>
-#include <string>
-#include <memory>
-#include <vector>
-
-#include "oatpp/core/data/stream/ChunkedBuffer.hpp"
-#include "oatpp/core/data/stream/FileStream.hpp"
-#include "oatpp/core/macro/codegen.hpp"
-#include "oatpp/core/macro/component.hpp"
-#include "oatpp/web/mime/multipart/InMemoryPartReader.hpp"
-#include "oatpp/web/mime/multipart/Reader.hpp"
-#include "oatpp/web/server/api/ApiController.hpp"
-
-#include "database/ArtistRepository.h"
-#include "dto/ArtistDto.hpp"
-#include "manager/ArtistManager.h"
-#include "manager/TokenManager.h"
-#include "model/Models.h"
-#include "type/Scopes.h"
-#include "type/ArtistFilter.h"
-
-namespace fs = std::filesystem;
-
-namespace controller {
-class ArtistController : public oatpp::web::server::api::ApiController
-{
-public:
-    ArtistController(std::string p, OATPP_COMPONENT(std::shared_ptr<ObjectMapper>, objectMapper))
-        : oatpp::web::server::api::ApiController(objectMapper), m_exe_path(p)
-    { }
-
-    ArtistController(const model::BinaryPath& bConf, OATPP_COMPONENT(std::shared_ptr<ObjectMapper>, objectMapper))
-        : oatpp::web::server::api::ApiController(objectMapper), m_bConf(bConf)
-    { }
-
-    #include OATPP_CODEGEN_BEGIN(ApiController)
-
-    // endpoint for retrieving all artist records in json format
-    ENDPOINT("GET", "/api/v1/artist", artistRecords, 
-        REQUEST(std::shared_ptr<IncomingRequest>, request))
-    {
-        auto authHeader = request->getHeader("Authorization");
-        OATPP_ASSERT_HTTP(authHeader, Status::CODE_403, "Nope");
-        auto auth = authHeader->std_str();
-        manager::TokenManager tok;
-        OATPP_ASSERT_HTTP(tok.isTokenValid(auth, type::Scope::retrieveArtist), Status::CODE_403, "Not allowed");
-
-        std::cout << "starting process of retrieving artist" << std::endl;
-        database::ArtistRepository artRepo(m_bConf);
-        auto artsDb = artRepo.retrieveRecords();
-        auto artists = oatpp::data::mapping::type::List<dto::ArtistDto::ObjectWrapper>::createShared();
-
-        for (auto& artDb : artsDb) {
-            auto art = dto::ArtistDto::createShared();
-            art->id = artDb.id;
-            art->artist = artDb.artist.c_str();
-
-            artists->pushBack(art);
-        }
-
-        return createDtoResponse(Status::CODE_200, artists);
-    }
-
-    // endpoint for retrieving single artist record by the artist id in json format
-    ENDPOINT("GET", "/api/v1/artist/{id}", artistRecord, 
-        REQUEST(std::shared_ptr<IncomingRequest>, request), PATH(Int32, id)) {
-        auto authHeader = request->getHeader("Authorization");
-        OATPP_ASSERT_HTTP(authHeader, Status::CODE_403, "Nope");
-        auto auth = authHeader->std_str();
-        manager::TokenManager tok;
-        OATPP_ASSERT_HTTP(tok.isTokenValid(auth, type::Scope::retrieveArtist), Status::CODE_403, "Not allowed");
-
-        database::ArtistRepository artRepo(m_bConf);
-        model::Artist artDb(id);
-
-        OATPP_ASSERT_HTTP(artRepo.doesArtistExist(artDb, type::ArtistFilter::id) , Status::CODE_403, "artist does not exist");
-
-        std::cout << "artist exist" << std::endl;
-        artDb = artRepo.retrieveRecord(artDb, type::ArtistFilter::id);
-
-        auto artist = dto::ArtistDto::createShared();
-        artist->id = artDb.id;
-        artist->artist = artDb.artist.c_str();
-
-        return createDtoResponse(Status::CODE_200, artist);
-    }
-
-    #include OATPP_CODEGEN_END(ApiController)
-private:
-    std::string m_exe_path;
-    model::BinaryPath m_bConf;
-};
-}
-#endif

include/controller/CoverArtController.hpp

@@ -1,121 +0,0 @@
-#ifndef COVERARTCONTROLLER_H_
-#define COVERARTCONTROLLER_H_
-
-#include <filesystem>
-#include <iostream>
-#include <fstream>
-#include <limits>
-#include <string>
-#include <memory>
-#include <vector>
-
-#include "oatpp/core/data/stream/ChunkedBuffer.hpp"
-#include "oatpp/core/data/stream/FileStream.hpp"
-#include "oatpp/core/macro/codegen.hpp"
-#include "oatpp/core/macro/component.hpp"
-#include "oatpp/web/mime/multipart/InMemoryPartReader.hpp"
-#include "oatpp/web/mime/multipart/Reader.hpp"
-#include "oatpp/web/server/api/ApiController.hpp"
-
-#include "database/CoverArtRepository.h"
-#include "dto/CoverArtDto.hpp"
-#include "manager/CoverArtManager.h"
-#include "model/Models.h"
-#include "type/Scopes.h"
-#include "type/CoverFilter.h"
-
-namespace fs = std::filesystem;
-
-namespace controller {
-class CoverArtController : public oatpp::web::server::api::ApiController
-{
-public:
-    CoverArtController(std::string p, OATPP_COMPONENT(std::shared_ptr<ObjectMapper>, objectMapper))
-        : oatpp::web::server::api::ApiController(objectMapper), m_exe_path(p)
-    { }
-
-    CoverArtController(const model::BinaryPath& bConf, OATPP_COMPONENT(std::shared_ptr<ObjectMapper>, objectMapper))
-        : oatpp::web::server::api::ApiController(objectMapper), m_bConf(bConf)
-    { }
-
-    #include OATPP_CODEGEN_BEGIN(ApiController)
-
-    // endpoint for retrieving all cover art records in json format
-    ENDPOINT("GET", "/api/v1/coverart", coverArtRecords, 
-        REQUEST(std::shared_ptr<IncomingRequest>, request))
-    {
-        auto authHeader = request->getHeader("Authorization");
-        OATPP_ASSERT_HTTP(authHeader, Status::CODE_403, "Nope");
-        auto auth = authHeader->std_str();
-        manager::TokenManager tok;
-        OATPP_ASSERT_HTTP(tok.isTokenValid(auth, type::Scope::downloadCoverArt), Status::CODE_403, "Not allowed");
-
-        std::cout << "starting process of retrieving cover art" << std::endl;
-        database::CoverArtRepository covRepo(m_bConf);
-        auto covsDb = covRepo.retrieveRecords();
-        auto coverArts = oatpp::data::mapping::type::List<dto::CoverArtDto::ObjectWrapper>::createShared();
-
-        for (auto& covDb : covsDb) {
-            auto cov = dto::CoverArtDto::createShared();
-            cov->id = covDb.id;
-            cov->songTitle = covDb.songTitle.c_str();
-
-            coverArts->pushBack(cov);
-        }
-
-        return createDtoResponse(Status::CODE_200, coverArts);
-    }
-
-    // endpoint for retrieving single cover art record by the cover art id in json format
-    ENDPOINT("GET", "/api/v1/coverart/{id}", coverArtRecord, 
-        REQUEST(std::shared_ptr<IncomingRequest>, request), PATH(Int32, id)) {
-        auto authHeader = request->getHeader("Authorization");
-        OATPP_ASSERT_HTTP(authHeader, Status::CODE_403, "Nope");
-        auto auth = authHeader->std_str();
-        manager::TokenManager tok;
-        OATPP_ASSERT_HTTP(tok.isTokenValid(auth, type::Scope::downloadCoverArt), Status::CODE_403, "Not allowed");
-
-        database::CoverArtRepository covRepo(m_bConf);
-        model::Cover covDb;
-        covDb.id = id;
-
-        OATPP_ASSERT_HTTP(covRepo.doesCoverArtExist(covDb, type::CoverFilter::id) , Status::CODE_403, "song does not exist");
-
-        std::cout << "cover art exists" << std::endl;
-        covDb = covRepo.retrieveRecord(covDb, type::CoverFilter::id);
-
-        auto coverArt = dto::CoverArtDto::createShared();
-        coverArt->id = covDb.id;
-        coverArt->songTitle = covDb.songTitle.c_str();
-
-        return createDtoResponse(Status::CODE_200, coverArt);
-    }
-
-    ENDPOINT("GET", "/api/v1/coverart/download/{id}", downloadCoverArt, 
-        REQUEST(std::shared_ptr<IncomingRequest>, request), PATH(Int32, id)) {
-        auto authHeader = request->getHeader("Authorization");
-        OATPP_ASSERT_HTTP(authHeader, Status::CODE_403, "Nope");
-        auto auth = authHeader->std_str();
-        manager::TokenManager tok;
-        OATPP_ASSERT_HTTP(tok.isTokenValid(auth, type::Scope::downloadCoverArt), Status::CODE_403, "Not allowed");
-
-        database::CoverArtRepository covRepo(m_bConf);
-        model::Cover covDb;
-        covDb.id = id;
-        covDb = covRepo.retrieveRecord(covDb, type::CoverFilter::id);
-
-        auto rawCover = oatpp::base::StrBuffer::loadFromFile(covDb.imagePath.c_str());
-        auto response = createResponse(Status::CODE_200, rawCover);
-            
-        response->putHeader(Header::CONTENT_TYPE, "image/*");
-
-        return response;
-    }
-
-    #include OATPP_CODEGEN_END(ApiController)
-private:
-    std::string m_exe_path;
-    model::BinaryPath m_bConf;
-};
-}
-#endif

include/controller/GenreController.hpp

@@ -1,100 +0,0 @@
-#ifndef GENRECONTROLLER_H_
-#define GENRECONTROLLER_H_
-
-#include <filesystem>
-#include <iostream>
-#include <fstream>
-#include <limits>
-#include <string>
-#include <memory>
-#include <vector>
-
-#include "oatpp/core/data/stream/ChunkedBuffer.hpp"
-#include "oatpp/core/data/stream/FileStream.hpp"
-#include "oatpp/core/macro/codegen.hpp"
-#include "oatpp/core/macro/component.hpp"
-#include "oatpp/web/mime/multipart/InMemoryPartReader.hpp"
-#include "oatpp/web/mime/multipart/Reader.hpp"
-#include "oatpp/web/server/api/ApiController.hpp"
-
-#include "database/GenreRepository.h"
-#include "dto/GenreDto.hpp"
-#include "manager/GenreManager.h"
-#include "manager/YearManager.h"
-#include "model/Models.h"
-#include "type/Scopes.h"
-#include "type/GenreFilter.h"
-
-namespace fs = std::filesystem;
-
-namespace controller {
-class GenreController : public oatpp::web::server::api::ApiController
-{
-public:
-    GenreController(std::string p, OATPP_COMPONENT(std::shared_ptr<ObjectMapper>, objectMapper))
-        : oatpp::web::server::api::ApiController(objectMapper), m_exe_path(p)
-    { }
-
-    GenreController(const model::BinaryPath& bConf, OATPP_COMPONENT(std::shared_ptr<ObjectMapper>, objectMapper))
-        : oatpp::web::server::api::ApiController(objectMapper), m_bConf(bConf)
-    { }
-
-    #include OATPP_CODEGEN_BEGIN(ApiController)
-
-    // endpoint for retrieving all genre records in json format
-    ENDPOINT("GET", "/api/v1/genre", genreRecords, 
-        REQUEST(std::shared_ptr<IncomingRequest>, request))
-    {
-        auto authHeader = request->getHeader("Authorization");
-        OATPP_ASSERT_HTTP(authHeader, Status::CODE_403, "Nope");
-        auto auth = authHeader->std_str();
-        manager::TokenManager tok;
-        OATPP_ASSERT_HTTP(tok.isTokenValid(auth, type::Scope::retrieveGenre), Status::CODE_403, "Not allowed");
-
-        std::cout << "starting process of retrieving genre" << std::endl;
-        database::GenreRepository gnrRepo(m_bConf);
-        auto gnrsDb = gnrRepo.retrieveRecords();
-        auto genres = oatpp::data::mapping::type::List<dto::GenreDto::ObjectWrapper>::createShared();
-
-        for (auto& gnrDb : gnrsDb) {
-            auto gnr = dto::GenreDto::createShared();
-            gnr->id = gnrDb.id;
-            gnr->category = gnrDb.category.c_str();
-
-            genres->pushBack(gnr);
-        }
-
-        return createDtoResponse(Status::CODE_200, genres);
-    }
-
-    // endpoint for retrieving single genre record by the genre id in json format
-    ENDPOINT("GET", "/api/v1/genre/{id}", genreRecord, 
-        REQUEST(std::shared_ptr<IncomingRequest>, request), PATH(Int32, id)) {
-        auto authHeader = request->getHeader("Authorization");
-        OATPP_ASSERT_HTTP(authHeader, Status::CODE_403, "Nope");
-        auto auth = authHeader->std_str();
-        manager::TokenManager tok;
-        OATPP_ASSERT_HTTP(tok.isTokenValid(auth, type::Scope::retrieveGenre), Status::CODE_403, "Not allowed");
-
-        database::GenreRepository gnrRepo(m_bConf);
-        model::Genre gnrDb(id);
-
-        OATPP_ASSERT_HTTP(gnrRepo.doesGenreExist(gnrDb, type::GenreFilter::id) , Status::CODE_403, "genre does not exist");
-
-        std::cout << "genre exist" << std::endl;
-        gnrDb = gnrRepo.retrieveRecord(gnrDb, type::GenreFilter::id);
-
-        auto genre = dto::GenreDto::createShared();
-        genre->id = gnrDb.id;
-        genre->category= gnrDb.category.c_str();
-
-        return createDtoResponse(Status::CODE_200, genre);
-    }
-
-    #include OATPP_CODEGEN_END(ApiController)
-private:
-    std::string m_exe_path;
-    model::BinaryPath m_bConf;
-};
-}
-#endif

include/controller/LoginController.hpp

@@ -1,61 +0,0 @@
-#ifndef LOGINCONTROLLER_H_
-#define LOGINCONTROLLER_H_
-
-#include <iostream>
-#include <string>
-#include <memory>
-
-#include "oatpp/core/macro/codegen.hpp"
-#include "oatpp/core/macro/component.hpp"
-#include "oatpp/web/server/api/ApiController.hpp"
-
-#include "dto/LoginResultDto.hpp"
-#include "dto/conversion/DtoConversions.h"
-#include "manager/TokenManager.h"
-#include "manager/UserManager.h"
-#include "model/Models.h"
-
-namespace controller {
-class LoginController : public oatpp::web::server::api::ApiController {
-public:
-    LoginController(std::string p, OATPP_COMPONENT(std::shared_ptr<ObjectMapper>, objectMapper))
-        : oatpp::web::server::api::ApiController(objectMapper), exe_path(p)
-    { }
-    LoginController(const model::BinaryPath& bConf, OATPP_COMPONENT(std::shared_ptr<ObjectMapper>, objectMapper))
-        :oatpp::web::server::api::ApiController(objectMapper), m_bConf(bConf)
-    { }
-
-
-    #include OATPP_CODEGEN_BEGIN(ApiController)
-    
-    ENDPOINT("POST", "/api/v1/login", data, BODY_DTO(dto::UserDto::ObjectWrapper, usr)) {
-        OATPP_LOGI("icarus", "logging in");
-
-        manager::UserManager usrMgr(m_bConf);
-        auto user = dto::conversion::DtoConversions::toUser(usr);
-
-        if (!usrMgr.doesUserExist(user) || !usrMgr.validatePassword(user)) {
-            auto logRes = dto::LoginResultDto::createShared();
-            logRes->message = "invalid credentials";
-            std::cout << "user does not exist" << std::endl;
-            return createDtoResponse(Status::CODE_401, logRes);
-        }
-
-        std::cout << "user exists" << std::endl;
-
-        manager::TokenManager tok;
-        auto token = tok.retrieveToken(m_bConf);
-
-        auto logRes = dto::conversion::DtoConversions::toLoginResultDto(user, token);
-        logRes->message = "Successful";
-
-        return createDtoResponse(Status::CODE_200, logRes);
-    }
-
-    #include OATPP_CODEGEN_END(ApiController)
-private:
-    std::string exe_path;
-    model::BinaryPath m_bConf;
-};
-}
-#endif

include/controller/RegisterController.hpp

@@ -1,41 +0,0 @@
-#ifndef REGISTERCONTROLLER_H_
-#define REGISTERCONTROLLER_H_
-
-#include <iostream>
-#include <memory>
-
-#include "oatpp/core/macro/codegen.hpp"
-#include "oatpp/core/macro/component.hpp"
-#include "oatpp/web/server/api/ApiController.hpp"
-
-#include "dto/LoginResultDto.hpp"
-#include "dto/conversion/DtoConversions.h"
-#include "manager/UserManager.h"
-#include "model/Models.h"
-
-namespace controller {
-    class RegisterController : public oatpp::web::server::api::ApiController {
-    public:
-        RegisterController(const model::BinaryPath& bConf, 
-            OATPP_COMPONENT(std::shared_ptr<ObjectMapper>, objectMapper)) :
-            oatpp::web::server::api::ApiController(objectMapper), m_bConf(bConf) { }
-
-        #include OATPP_CODEGEN_BEGIN(ApiController)
-
-        ENDPOINT("POST", "api/v1/register", registerUser, 
-            BODY_DTO(dto::UserDto::ObjectWrapper, usr)) {
-            manager::UserManager usrMgr(m_bConf);
-            auto user = dto::conversion::DtoConversions::toUser(usr);
-
-            auto res = usrMgr.registerUser(user);
-            auto registerResult = dto::conversion::DtoConversions::toRegisterResultDto(res);
-
-            return createDtoResponse(Status::CODE_200, registerResult);
-        }
-        #include OATPP_CODEGEN_END(ApiController)
-    private:
-        model::BinaryPath m_bConf;
-    };
-}
-
-#endif

include/controller/SongController.hpp

@@ -1,235 +0,0 @@
-#ifndef SONGCONTROLLER_H_
-#define SONGCONTROLLER_H_
-
-#include <filesystem>
-#include <iostream>
-#include <fstream>
-#include <limits>
-#include <string>
-#include <memory>
-#include <vector>
-
-#include "oatpp/core/data/stream/ChunkedBuffer.hpp"
-#include "oatpp/core/data/stream/FileStream.hpp"
-#include "oatpp/core/macro/codegen.hpp"
-#include "oatpp/core/macro/component.hpp"
-#include "oatpp/web/mime/multipart/InMemoryPartReader.hpp"
-#include "oatpp/web/mime/multipart/Reader.hpp"
-#include "oatpp/web/protocol/http/outgoing/ChunkedBody.hpp"
-#include "oatpp/web/server/api/ApiController.hpp"
-
-#include "callback/StreamCallback.h"
-#include "database/SongRepository.h"
-#include "dto/SongDto.hpp"
-#include "manager/SongManager.h"
-#include "manager/TokenManager.h"
-#include "model/Models.h"
-#include "type/Scopes.h"
-#include "type/SongFilter.h"
-
-namespace fs = std::filesystem;
-
-namespace controller {
-class SongController : public oatpp::web::server::api::ApiController {
-public:
-    SongController(std::string p, OATPP_COMPONENT(std::shared_ptr<ObjectMapper>, objectMapper))
-        : oatpp::web::server::api::ApiController(objectMapper), m_exe_path(p)
-    { }
-
-    SongController(const model::BinaryPath& bConf, OATPP_COMPONENT(std::shared_ptr<ObjectMapper>, objectMapper))
-        : oatpp::web::server::api::ApiController(objectMapper), m_bConf(bConf)
-    { }
-
-    #include OATPP_CODEGEN_BEGIN(ApiController)
-
-    // endpoint for uploading a song
-    ENDPOINT("POST", "/api/v1/song/data", songUpload, 
-        REQUEST(std::shared_ptr<IncomingRequest>, request))
-    {
-        auto authHeader = request->getHeader("Authorization");
-        OATPP_ASSERT_HTTP(authHeader, Status::CODE_403, "Nope");
-        auto auth = authHeader->std_str();
-        manager::TokenManager tok;
-        OATPP_ASSERT_HTTP(tok.isTokenValid(auth, type::Scope::upload), Status::CODE_403, "Not allowed");
-
-        auto mp = std::make_shared<oatpp::web::mime::multipart::Multipart>(request->getHeaders());
-
-        oatpp::web::mime::multipart::Reader mp_reader(mp.get());
-
-        mp_reader.setPartReader("file", oatpp::web::mime::multipart::createInMemoryPartReader(m_dataSize));
-
-        request->transferBody(&mp_reader);
-
-        auto file = mp->getNamedPart("file");
-
-        OATPP_ASSERT_HTTP(file, Status::CODE_400, "file is null");
-
-        auto buff = std::unique_ptr<char>(new char[file->getKnownSize()]);
-        auto buffSize = file->getInputStream()->read(buff.get(), file->getKnownSize());
-
-        std::vector<unsigned char> data(buff.get(), buff.get() + buffSize);
-
-        model::Song sng;
-        sng.data = std::move(data);
-    
-        manager::SongManager songMgr(m_bConf);
-        songMgr.saveSong(sng);
-
-        return createResponse(Status::CODE_200, "OK");
-    }
-
-    // endpoint for retrieving all song records in json format
-    ENDPOINT("GET", "/api/v1/song", songRecords, 
-        REQUEST(std::shared_ptr<IncomingRequest>, request))
-    {
-        auto authHeader = request->getHeader("Authorization");
-        OATPP_ASSERT_HTTP(authHeader, Status::CODE_403, "Nope");
-        auto auth = authHeader->std_str();
-        manager::TokenManager tok;
-        OATPP_ASSERT_HTTP(tok.isTokenValid(auth, type::Scope::retrieveSong), Status::CODE_403, "Not allowed");
-
-        std::cout << "starting process of retrieving songs" << std::endl;
-        database::SongRepository songRepo(m_bConf);
-        auto songsDb = songRepo.retrieveRecords();
-        auto songs = oatpp::data::mapping::type::List<dto::SongDto::ObjectWrapper>::createShared();
-
-        std::cout << "creating object to send" << std::endl;
-        for (auto& songDb : songsDb) {
-            auto song = dto::SongDto::createShared();
-            song->id = songDb.id;
-            song->title = songDb.title.c_str();
-            song->artist = songDb.artist.c_str();
-            song->album = songDb.album.c_str();
-            song->genre = songDb.genre.c_str();
-            song->year = songDb.year;
-            song->duration = songDb.duration;
-            song->track = songDb.track;
-            song->disc = songDb.disc;
-
-            songs->pushBack(song);
-        }
-
-        return createDtoResponse(Status::CODE_200, songs);
-    }
-
-        // endpoint for retrieving song record by the song id in json format
-    ENDPOINT("GET", "/api/v1/song/{id}", songRecord,
-        REQUEST(std::shared_ptr<IncomingRequest>, request), PATH(Int32, id)) {
-        auto authHeader = request->getHeader("Authorization");
-        OATPP_ASSERT_HTTP(authHeader, Status::CODE_403, "Nope");
-        auto auth = authHeader->std_str();
-        manager::TokenManager tok;
-        OATPP_ASSERT_HTTP(tok.isTokenValid(auth, type::Scope::retrieveSong), Status::CODE_403, "Not allowed");
-
-        database::SongRepository songRepo(m_bConf);
-        model::Song songDb(id);
-
-        OATPP_ASSERT_HTTP(songRepo.doesSongExist(songDb, type::SongFilter::id) , Status::CODE_403, 
-            "song does not exist");
-
-        std::cout << "song exists" << std::endl;
-        songDb = songRepo.retrieveRecord(songDb, type::SongFilter::id);
-
-        auto song = dto::SongDto::createShared();
-        song->id = songDb.id;
-        song->title = songDb.title.c_str();
-        song->artist = songDb.artist.c_str();
-        song->album = songDb.album.c_str();
-        song->genre = songDb.genre.c_str();
-        song->year = songDb.year;
-        song->duration = songDb.duration;
-        song->track = songDb.track;
-        song->disc = songDb.disc;
-
-        return createDtoResponse(Status::CODE_200, song);
-    }
-
-    ENDPOINT("GET", "/api/v1/song/data/{id}", downloadSong, 
-        REQUEST(std::shared_ptr<IncomingRequest>, request), PATH(Int32, id)) {
-        auto authHeader = request->getHeader("Authorization");
-        OATPP_ASSERT_HTTP(authHeader, Status::CODE_403, "Nope");
-        auto auth = authHeader->std_str();
-        manager::TokenManager tok;
-        OATPP_ASSERT_HTTP(tok.isTokenValid(auth, type::Scope::download), Status::CODE_403, "Not allowed");
-
-        database::SongRepository songRepo(m_bConf);
-        model::Song songDb(id);
-        songDb = songRepo.retrieveRecord(songDb, type::SongFilter::id);
-
-        auto rawSong = oatpp::base::StrBuffer::loadFromFile(songDb.songPath.c_str());
-        
-        auto response = createResponse(Status::CODE_200, rawSong);
-        response->putHeader(Header::CONTENT_TYPE, "audio/mpeg");
-
-        return response;
-    }
-
-    ENDPOINT("UPDATE", "/api/v1/song/{id}", songUpdate,
-        REQUEST(std::shared_ptr<IncomingRequest>, request),
-        BODY_DTO(dto::SongDto::ObjectWrapper, songDto), PATH(Int32, id)) {
-        songDto->id = id;
-        auto authHeader = request->getHeader("Authorization");
-        OATPP_ASSERT_HTTP(authHeader, Status::CODE_403, "Nope");
-        auto auth = authHeader->std_str();
-        manager::TokenManager tok;
-        OATPP_ASSERT_HTTP(tok.isTokenValid(auth, type::Scope::updateSong), Status::CODE_403, "Not allowed");
-            
-        auto updatedSong = manager::SongManager::songDtoConv(songDto);
-        manager::SongManager songMgr(m_bConf);
-        songMgr.updateSong(updatedSong);
-
-        return createResponse(Status::CODE_200, "OK");
-    }
-
-    // endpoint to delete a song
-    ENDPOINT("DELETE", "api/v1/song/data/{id}", songDelete, 
-        REQUEST(std::shared_ptr<IncomingRequest>, request),   PATH(Int32, id)) {
-        auto authHeader = request->getHeader("Authorization");
-        OATPP_ASSERT_HTTP(authHeader, Status::CODE_403, "Nope");
-        auto auth = authHeader->std_str();
-        manager::TokenManager tok;
-        OATPP_ASSERT_HTTP(tok.isTokenValid(auth, type::Scope::deleteSong), Status::CODE_403, "Not allowed");
-
-        model::Song song(id);
-
-        manager::SongManager sngMgr(m_bConf);
-        sngMgr.deleteSong(song);
-
-        return createResponse(Status::CODE_200, "OK");
-    }
-
-    // endpoint for streaming a song
-    ENDPOINT("GET", "/api/v1/song/stream/{id}", streamSong,
-        REQUEST(std::shared_ptr<IncomingRequest>, request), PATH(Int32, id)) {
-        auto authHeader = request->getHeader("Authorization");
-        OATPP_ASSERT_HTTP(authHeader, Status::CODE_403, "Nope");
-        auto auth = authHeader->std_str();
-        manager::TokenManager tok;
-        OATPP_ASSERT_HTTP(tok.isTokenValid(auth, type::Scope::stream), Status::CODE_403, "Not allowed");
-
-        database::SongRepository songRepo(m_bConf);
-        model::Song songDb(id);
-        songDb = songRepo.retrieveRecord(songDb, type::SongFilter::id);
-
-        oatpp::data::v_io_size dSize = 1024;
-
-        auto db = std::make_shared<oatpp::web::protocol::http::outgoing::ChunkedBody>(
-            std::make_shared<callback::StreamCallback>(songDb.songPath), nullptr, dSize);
-
-        auto response = OutgoingResponse::createShared(Status::CODE_200, db);
-        response->putHeader(Header::CONNECTION, Header::Value::CONNECTION_KEEP_ALIVE);
-        response->putHeader(Header::CONTENT_TYPE, "audio/mpeg");
-
-        return response;
-    }
-
-    #include OATPP_CODEGEN_END(ApiController)
-private:
-    std::string m_exe_path;
-
-    model::BinaryPath m_bConf;
-
-    const long m_dataSize = std::numeric_limits<long long int>::max();
-};
-}
-#endif

include/controller/YearController.hpp

@@ -1,99 +0,0 @@
-#ifndef YEARCONTROLLER_H_
-#define YEARCONTROLLER_H_
-
-#include <filesystem>
-#include <iostream>
-#include <fstream>
-#include <limits>
-#include <string>
-#include <memory>
-#include <vector>
-
-#include "oatpp/core/data/stream/ChunkedBuffer.hpp"
-#include "oatpp/core/data/stream/FileStream.hpp"
-#include "oatpp/core/macro/codegen.hpp"
-#include "oatpp/core/macro/component.hpp"
-#include "oatpp/web/mime/multipart/InMemoryPartReader.hpp"
-#include "oatpp/web/mime/multipart/Reader.hpp"
-#include "oatpp/web/server/api/ApiController.hpp"
-
-#include "database/YearRepository.h"
-#include "dto/YearDto.hpp"
-#include "manager/YearManager.h"
-#include "model/Models.h"
-#include "type/Scopes.h"
-#include "type/YearFilter.h"
-
-namespace fs = std::filesystem;
-
-namespace controller {
-class YearController : public oatpp::web::server::api::ApiController
-{
-public:
-    YearController(std::string p, OATPP_COMPONENT(std::shared_ptr<ObjectMapper>, objectMapper))
-        : oatpp::web::server::api::ApiController(objectMapper), m_exe_path(p)
-    { }
-
-    YearController(const model::BinaryPath& bConf, OATPP_COMPONENT(std::shared_ptr<ObjectMapper>, objectMapper))
-        : oatpp::web::server::api::ApiController(objectMapper), m_bConf(bConf)
-    { }
-
-    #include OATPP_CODEGEN_BEGIN(ApiController)
-
-    // endpoint for retrieving all year records in json format
-    ENDPOINT("GET", "/api/v1/year", yearRecords, 
-        REQUEST(std::shared_ptr<IncomingRequest>, request))
-    {
-        auto authHeader = request->getHeader("Authorization");
-        OATPP_ASSERT_HTTP(authHeader, Status::CODE_403, "Nope");
-        auto auth = authHeader->std_str();
-        manager::TokenManager tok;
-        OATPP_ASSERT_HTTP(tok.isTokenValid(auth, type::Scope::retrieveYear), Status::CODE_403, "Not allowed");
-
-        std::cout << "starting process of retrieving year" << std::endl;
-        database::YearRepository yrRepo(m_bConf);
-        auto yrsDb = yrRepo.retrieveRecords();
-        auto yearRecs = oatpp::data::mapping::type::List<dto::YearDto::ObjectWrapper>::createShared();
-
-        for (auto& yrDb : yrsDb) {
-            auto yr = dto::YearDto::createShared();
-            yr->id = yrDb.id;
-            yr->year = yrDb.year;
-
-            yearRecs->pushBack(yr);
-        }
-
-        return createDtoResponse(Status::CODE_200, yearRecs);
-    }
-
-    // endpoint for retrieving single year record by the year id in json format
-    ENDPOINT("GET", "/api/v1/year/{id}", yearRecord, 
-        REQUEST(std::shared_ptr<IncomingRequest>, request), PATH(Int32, id)) {
-        auto authHeader = request->getHeader("Authorization");
-        OATPP_ASSERT_HTTP(authHeader, Status::CODE_403, "Nope");
-        auto auth = authHeader->std_str();
-        manager::TokenManager tok;
-        OATPP_ASSERT_HTTP(tok.isTokenValid(auth, type::Scope::retrieveYear), Status::CODE_403, "Not allowed");
-
-        database::YearRepository yrRepo(m_bConf);
-        model::Year yrDb(id);
-
-        OATPP_ASSERT_HTTP(yrRepo.doesYearExist(yrDb, type::YearFilter::id) , Status::CODE_403, "year does not exist");
-
-        std::cout << "year exist" << std::endl;
-        yrDb = yrRepo.retrieveRecord(yrDb, type::YearFilter::id);
-
-        auto year = dto::YearDto::createShared();
-        year->id = yrDb.id;
-        year->year= yrDb.year;
-
-        return createDtoResponse(Status::CODE_200, year);
-    }
-
-    #include OATPP_CODEGEN_END(ApiController)
-private:
-    std::string m_exe_path;
-    model::BinaryPath m_bConf;
-};
-}
-#endif

include/database/AlbumRepository.h

@@ -1,40 +0,0 @@
-#ifndef ALBUMREPOSITORY_H_
-#define ALBUMREPOSITORY_H_
-
-#include <utility>
-#include <vector>
-
-#include "database/BaseRepository.h"
-#include "model/Models.h"
-#include "type/AlbumFilter.h"
-
-namespace database
-{
-    class AlbumRepository : public BaseRepository
-    {
-    public:
-        AlbumRepository(const model::BinaryPath&);
-
-        std::vector<model::Album> retrieveRecords();
-
-        std::pair<model::Album, int> retrieveRecordWithSongCount(model::Album&, type::AlbumFilter);
-
-        model::Album retrieveRecord(model::Album&, type::AlbumFilter);
-
-        bool doesAlbumExists(const model::Album&, type::AlbumFilter);
-
-        void saveAlbum(const model::Album&);
-        void deleteAlbum(const model::Album&, type::AlbumFilter);
-    private:
-        std::vector<model::Album> parseRecords(MYSQL_STMT*);
-
-        std::pair<model::Album, int> parseRecordWithSongCount(MYSQL_STMT*);
-
-        // TODO: after parseRecord(MYSQL_STMT*) is implemented remove
-        // parseRecord(MYSQL_RES*)
-        model::Album parseRecord(MYSQL_RES*);
-        model::Album parseRecord(MYSQL_STMT*);
-    };
-}
-
-#endif

include/database/ArtistRepository.h

@@ -1,40 +0,0 @@
-#ifndef ARTISTREPOSITORY_H_
-#define ARTISTREPOSITORY_H_
-
-#include <utility>
-#include <vector>
-
-#include "database/BaseRepository.h"
-#include "model/Models.h"
-#include "type/ArtistFilter.h"
-
-namespace database
-{
-    class ArtistRepository : public BaseRepository
-    {
-    public:
-        ArtistRepository(const model::BinaryPath&);
-
-        std::vector<model::Artist> retrieveRecords();
-
-        std::pair<model::Artist, int> retrieveRecordWithSongCount(model::Artist&, type::ArtistFilter);
-
-        model::Artist retrieveRecord(model::Artist&, type::ArtistFilter);
-
-        bool doesArtistExist(const model::Artist&, type::ArtistFilter);
-
-        void saveRecord(const model::Artist&);
-        void deleteArtist(const model::Artist&, type::ArtistFilter);
-    private:
-        std::vector<model::Artist> parseRecords(MYSQL_STMT*);
-
-        std::pair<model::Artist, int> parseRecordWithSongCount(MYSQL_STMT*);
-
-        // TODO: After parseRecord(MYSQL_STMT*) is implemented
-        // remove parseRecord(MYSQL_RES*)
-        model::Artist parseRecord(MYSQL_RES*);
-        model::Artist parseRecord(MYSQL_STMT*);
-    };
-}
-
-#endif

include/database/BaseRepository.h

@@ -1,36 +0,0 @@
-#ifndef BASE_REPOSITORY_H_
-#define BASE_REPOSITORY_H_
-
-#include <string>
-
-#include <mysql/mysql.h>
-
-#include "model/Models.h"
-
-namespace database
-{
-    class BaseRepository
-    {
-    public:
-        BaseRepository();
-        BaseRepository(const std::string&);
-        BaseRepository(const model::BinaryPath&);
-
-        bool testConnection();
-    protected:
-        MYSQL* setupMysqlConnection();
-        MYSQL* setupMysqlConnection(model::DatabaseConnection);
-
-        MYSQL_RES* performMysqlQuery(MYSQL*, const std::string&);
-
-        model::DatabaseConnection details;
-    private:
-        void intitalizeDetails();
-        void initializeDetails(const model::BinaryPath&);
-
-        std::string path;
-        model::BinaryPath m_binConf;
-    };
-}
-
-#endif

include/database/CoverArtRepository.h

@@ -1,39 +0,0 @@
-#ifndef COVERARTREPOSITORY_H_
-#define COVERARTREPOSITORY_H_
-
-#include <vector>
-
-#include <mysql/mysql.h>
-
-#include "database/BaseRepository.h"
-#include "model/Models.h"
-#include "type/CoverFilter.h"
-
-namespace database
-{
-    class CoverArtRepository : public BaseRepository
-    {
-    public:
-        CoverArtRepository(const std::string&);
-        CoverArtRepository(const model::BinaryPath&);
-
-        std::vector<model::Cover> retrieveRecords();
-
-        model::Cover retrieveRecord(model::Cover&, type::CoverFilter);
-        
-        bool doesCoverArtExist(const model::Cover&, type::CoverFilter);
-
-        void deleteRecord(const model::Cover&);
-        void saveRecord(const model::Cover&);
-        void updateRecord(const model::Cover&);
-    private:
-        std::vector<model::Cover> parseRecords(MYSQL_STMT*);
-
-        // TODO: After parseRecord(MYSQL_STMT*) is implemented
-        // remove parseRecord(MYSQL_RES*)
-        model::Cover parseRecord(MYSQL_RES*);
-        model::Cover parseRecord(MYSQL_STMT*);
-    };
-}
-
-#endif

include/database/GenreRepository.h

@@ -1,40 +0,0 @@
-#ifndef GENREREPOSITORY_H_
-#define GENREREPOSITORY_H_
-
-#include <utility>
-#include <vector>
-
-#include "database/BaseRepository.h"
-#include "model/Models.h"
-#include "type/GenreFilter.h"
-
-namespace database
-{
-    class GenreRepository : public BaseRepository
-    {
-    public:
-        GenreRepository(const model::BinaryPath&);
-
-        std::vector<model::Genre> retrieveRecords();
-
-        std::pair<model::Genre, int> retrieveRecordWithSongCount(model::Genre&, type::GenreFilter);
-
-        model::Genre retrieveRecord(model::Genre&, type::GenreFilter);
-
-        bool doesGenreExist(const model::Genre&, type::GenreFilter);
-
-        void saveRecord(const model::Genre&);
-        void deleteRecord(const model::Genre&, type::GenreFilter);
-    private:
-        std::vector<model::Genre> parseRecords(MYSQL_STMT*);
-
-        std::pair<model::Genre, int> parseRecordWithSongCount(MYSQL_STMT*);
-
-        // TODO: After parseRecord(MYSQL_STMT*) is implemented
-        // remove parseRecord(MYSQL_RES*)
-        model::Genre parseRecord(MYSQL_RES*);
-        model::Genre parseRecord(MYSQL_STMT*);
-    };
-}
-
-#endif

include/database/SongRepository.h

@@ -1,39 +0,0 @@
-#ifndef SONGREPOSITORY_H_
-#define SONGREPOSITORY_H_
-
-#include <memory>
-#include <vector>
-
-#include <mysql/mysql.h>
-
-#include "database/BaseRepository.h"
-#include "model/Models.h"
-#include "type/SongFilter.h"
-
-namespace database
-{
-    class SongRepository : public BaseRepository
-    {
-    public:
-        SongRepository(const std::string&);
-        SongRepository(const model::BinaryPath&);
-
-        std::vector<model::Song> retrieveRecords();
-
-        model::Song retrieveRecord(model::Song&, type::SongFilter);
-
-        bool doesSongExist(const model::Song&, type::SongFilter);
-        bool deleteRecord(const model::Song&);
-
-        void saveRecord(const model::Song&);
-        void updateRecord(const model::Song&);
-    private:
-        std::vector<model::Song> parseRecords(MYSQL_RES*); // TODO: to be removed
-        std::vector<model::Song> parseRecords(MYSQL_STMT*);
-
-        model::Song parseRecord(MYSQL_RES*); // TODO: to be removed
-        model::Song parseRecord(MYSQL_STMT*);
-    };
-}
-
-#endif

include/database/UserRepository.h

@@ -1,58 +0,0 @@
-#ifndef USERREPOSITORY_H_
-#define USERREPOSITORY_H_
-
-#include <iostream>
-#include <memory>
-#include <tuple>
-
-#include "database/BaseRepository.h"
-#include "model/Models.h"
-#include "type/SaltFilter.h"
-#include "type/UserFilter.h"
-
-namespace database {
-class UserRepository : BaseRepository {
-public:
-    UserRepository(const model::BinaryPath&);
-
-    model::User retrieveUserRecord(model::User&, type::UserFilter);
-    model::PassSec retrieverUserSaltRecord(model::PassSec&, type::SaltFilter);
-
-    bool doesUserRecordExist(const model::User&, type::UserFilter);
-
-    void saveUserRecord(const model::User&);
-    void saveUserSalt(const model::PassSec&);
-private:
-    struct UserLengths;
-    struct SaltLengths;
-
-    struct UserLengths
-    {
-        unsigned long firstnameLength;
-        unsigned long lastnameLength;
-        unsigned long phoneLength;
-        unsigned long emailLength;
-        unsigned long usernameLength;
-        unsigned long passwordLength;
-    };
-    struct SaltLengths
-    {
-        unsigned long saltLength;
-    };
-
-    std::shared_ptr<MYSQL_BIND> insertUserValues(const model::User&, std::shared_ptr<UserLengths>);
-    std::shared_ptr<MYSQL_BIND> insertSaltValues(const model::PassSec&, std::shared_ptr<SaltLengths>);
-    std::shared_ptr<MYSQL_BIND> valueBind(model::User&, std::tuple<char*, char*, char*, char*, char*, char*>&);
-    std::shared_ptr<MYSQL_BIND> saltValueBind(model::PassSec&, char*);
-    std::shared_ptr<UserLengths> fetchUserLengths(const model::User&);
-    std::shared_ptr<SaltLengths> fetchSaltLengths(const model::PassSec&);
-
-    std::tuple<char*, char*, char*, char*, char*, char*> fetchUV();
-
-    model::User parseRecord(MYSQL_STMT*);
-    model::PassSec parseSaltRecord(MYSQL_STMT*);
-};
-}
-
-
-#endif

include/database/YearRepository.h

@@ -1,40 +0,0 @@
-#ifndef YEARREPOSITORY_H_
-#define YEARREPOSITORY_H_
-
-#include <utility>
-#include <vector>
-
-#include "database/BaseRepository.h"
-#include "model/Models.h"
-#include "type/YearFilter.h"
-
-namespace database
-{
-    class YearRepository : public BaseRepository
-    {
-    public:
-        YearRepository(const model::BinaryPath&);
-
-        std::vector<model::Year> retrieveRecords();
-
-        std::pair<model::Year, int> retrieveRecordWithSongCount(model::Year&, type::YearFilter);
-
-        model::Year retrieveRecord(model::Year&, type::YearFilter);
-
-        bool doesYearExist(const model::Year&, type::YearFilter);
-
-        void saveRecord(const model::Year&);
-        void deleteYear(const model::Year&, type::YearFilter);
-    private:
-        std::vector<model::Year> parseRecords(MYSQL_STMT*);
-
-        std::pair<model::Year, int> parseRecordWithSongCount(MYSQL_STMT*);
-
-        // TODO: After parseRecord(MYSQL_STMT*) is implemented
-        // remove parseRecord(MYSQL_RES*)
-        model::Year parseRecord(MYSQL_RES*);
-        model::Year parseRecord(MYSQL_STMT*);
-    };
-}
-
-#endif

include/dto/AlbumDto.hpp

@@ -1,23 +0,0 @@
-#ifndef ALBUMDTO_H_
-#define ALBUMDTO_H_
-
-#include "oatpp/core/data/mapping/type/Object.hpp"
-#include "oatpp/core/macro/codegen.hpp"
-
-namespace dto
-{
-    #include OATPP_CODEGEN_BEGIN(DTO)
-
-    class AlbumDto : public oatpp::data::mapping::type::Object
-    {
-        DTO_INIT(AlbumDto, Object)
-
-        DTO_FIELD(Int32, id);
-        DTO_FIELD(String, title);
-        DTO_FIELD(Int32, year);
-    };
-
-    #include OATPP_CODEGEN_END(DTO)
-}
-
-#endif

include/dto/ArtistDto.hpp

@@ -1,22 +0,0 @@
-#ifndef ARTISTDTO_H_
-#define ARTISTDTO_H_
-
-#include "oatpp/core/data/mapping/type/Object.hpp"
-#include "oatpp/core/macro/codegen.hpp"
-
-namespace dto
-{
-    #include OATPP_CODEGEN_BEGIN(DTO)
-
-    class ArtistDto : public oatpp::data::mapping::type::Object
-    {
-        DTO_INIT(ArtistDto, Object)
-
-        DTO_FIELD(Int32, id);
-        DTO_FIELD(String, artist);
-    };
-
-    #include OATPP_CODEGEN_END(DTO)
-}
-
-#endif

include/dto/CoverArtDto.hpp

@@ -1,22 +0,0 @@
-#ifndef COVERARTDTO_H_
-#define COVERARTDTO_H_
-
-#include "oatpp/core/data/mapping/type/Object.hpp"
-#include "oatpp/core/macro/codegen.hpp"
-
-namespace dto
-{
-    #include OATPP_CODEGEN_BEGIN(DTO)
-
-    class CoverArtDto : public oatpp::data::mapping::type::Object
-    {
-        DTO_INIT(CoverArtDto, Object)
-
-        DTO_FIELD(Int32, id);
-        DTO_FIELD(String, songTitle);
-    };
-
-    #include OATPP_CODEGEN_END(DTO)
-}
-
-#endif

include/dto/GenreDto.hpp

@@ -1,22 +0,0 @@
-#ifndef GENREDTO_H_
-#define GENREDTO_H_
-
-#include "oatpp/core/data/mapping/type/Object.hpp"
-#include "oatpp/core/macro/codegen.hpp"
-
-namespace dto
-{
-    #include OATPP_CODEGEN_BEGIN(DTO)
-
-    class GenreDto : public oatpp::data::mapping::type::Object
-    {
-        DTO_INIT(GenreDto, Object)
-
-        DTO_FIELD(Int32, id);
-        DTO_FIELD(String, category);
-    };
-
-    #include OATPP_CODEGEN_END(DTO)
-}
-
-#endif

include/dto/LoginResultDto.hpp

@@ -1,47 +0,0 @@
-#ifndef LOGINRESULTDTO_H_
-#define LOGINRESULTDTO_H_
-
-#include "oatpp/core/data/mapping/type/Object.hpp"
-#include "oatpp/core/macro/codegen.hpp"
-
-#include "model/Models.h"
-
-namespace dto {
-    #include OATPP_CODEGEN_BEGIN(DTO)
-
-    class LoginResultDto : public oatpp::data::mapping::type::Object {
-        DTO_INIT(LoginResultDto, Object)
-
-        DTO_FIELD(Int32, id);
-        DTO_FIELD(String, username);
-        DTO_FIELD(String, token);
-        DTO_FIELD(String, token_type);
-        DTO_FIELD(Int32, expiration);
-        DTO_FIELD(String, message);
-    };
-
-    class RegisterResultDto : public oatpp::data::mapping::type::Object {
-        DTO_INIT(RegisterResultDto, Object)
-
-        DTO_FIELD(String, username);
-        DTO_FIELD(Boolean, registered);
-        DTO_FIELD(String, message);
-    };
-
-    class UserDto : public oatpp::data::mapping::type::Object {
-        DTO_INIT(UserDto, Object)
-
-        DTO_FIELD(Int32, userId);
-        DTO_FIELD(String, firstname);
-        DTO_FIELD(String, lastname);
-        DTO_FIELD(String, phone);
-        DTO_FIELD(String, email);
-        DTO_FIELD(String, username);
-        DTO_FIELD(String, password);
-    };
-
-    #include OATPP_CODEGEN_END(DTO)
-
-}
-
-#endif

include/dto/SongDto.hpp

@@ -1,33 +0,0 @@
-#ifndef SONGDTO_H_
-#define SONGDTO_H_
-
-#include "oatpp/core/data/mapping/type/Object.hpp"
-#include "oatpp/core/macro/codegen.hpp"
-
-#include "model/Models.h"
-
-namespace dto
-{
-    #include OATPP_CODEGEN_BEGIN(DTO)
-
-    class SongDto : public oatpp::data::mapping::type::Object
-    {
-        DTO_INIT(SongDto, Object)
-
-        DTO_FIELD(Int32, id);
-        DTO_FIELD(String, title);
-        DTO_FIELD(String, artist);
-        DTO_FIELD(String, album);
-        DTO_FIELD(String, genre);
-        DTO_FIELD(Int32, track);
-        DTO_FIELD(Int32, disc);
-        DTO_FIELD(Int32, year);
-        DTO_FIELD(Int32, duration);
-    };
-
-    #include OATPP_CODEGEN_END(DTO)
-
-
-}
-
-#endif

include/dto/YearDto.hpp

@@ -1,22 +0,0 @@
-#ifndef YEARDTO_H_
-#define YEARDTO_H_
-
-#include "oatpp/core/data/mapping/type/Object.hpp"
-#include "oatpp/core/macro/codegen.hpp"
-
-namespace dto
-{
-    #include OATPP_CODEGEN_BEGIN(DTO)
-
-    class YearDto : public oatpp::data::mapping::type::Object
-    {
-        DTO_INIT(YearDto, Object)
-
-        DTO_FIELD(Int32, id);
-        DTO_FIELD(Int32, year);
-    };
-
-    #include OATPP_CODEGEN_END(DTO)
-}
-
-#endif

include/dto/conversion/DtoConversions.h

@@ -1,22 +0,0 @@
-#ifndef DTOCONVERSIONS_H_
-#define DTOCONVERSIONS_H_
-
-#include "dto/LoginResultDto.hpp"
-#include "dto/SongDto.hpp"
-#include "model/Models.h"
-
-namespace dto { namespace conversion {
-    class DtoConversions {
-    public:
-        static dto::LoginResultDto::ObjectWrapper toLoginResultDto(const model::User&, const model::Token&);
-
-        static dto::RegisterResultDto::ObjectWrapper toRegisterResultDto(
-            const model::RegisterResult&);
-
-        static model::Song toSong(dto::SongDto::ObjectWrapper&);
-
-        static model::User toUser(dto::UserDto::ObjectWrapper&);
-    };
-}}
-
-#endif

include/manager/AlbumManager.h

@@ -1,25 +0,0 @@
-#ifndef ALBUMMANAGER_H_
-#define ALBUMMANAGER_H_
-
-#include "model/Models.h"
-
-namespace manager
-{
-    class AlbumManager
-    {
-    public:
-        AlbumManager(const model::BinaryPath&);
-
-        model::Album retrieveAlbum(model::Album&);
-        model::Album saveAlbum(const model::Song&);
-
-        void deleteAlbum(const model::Song&);
-        void updateAlbum(model::Song&, const model::Song&);
-
-        static void printAlbum(const model::Album&);
-    private:
-        model::BinaryPath m_bConf;
-    };
-}
-
-#endif

include/manager/ArtistManager.h

@@ -1,25 +0,0 @@
-#ifndef ARTISTMANAGER_H_
-#define ARTISTMANAGER_H_
-
-#include "model/Models.h"
-
-namespace manager
-{
-    class ArtistManager
-    {
-    public:
-        ArtistManager(const model::BinaryPath&);
-
-        model::Artist retrieveArtist(model::Artist&);
-        model::Artist saveArtist(const model::Song&);
-
-        void deleteArtist(const model::Song&);
-        void updateArtist(model::Song&, const model::Song&);
-
-        static void printArtist(const model::Artist&);
-    private:
-        model::BinaryPath m_bConf;
-    };
-}
-
-#endif

include/manager/CoverArtManager.h

@@ -1,32 +0,0 @@
-#ifndef COVERARTMANAGER_H_
-#define COVERARTMANAGER_H_
-
-#include <string>
-#include <utility>
-
-#include "model/Models.h"
-
-namespace manager
-{
-    class CoverArtManager
-    {
-    public:
-        CoverArtManager(const std::string&);
-        CoverArtManager(const model::BinaryPath& bConf);
-
-        model::Cover saveCover(const model::Song&);
-
-        std::pair<bool, std::string> defaultCover(const model::Cover&);
-        
-        void deleteCover(const model::Song&);
-        void updateCover(const model::Song&, const model::Song&);
-        void updateCoverRecord(const model::Song&);
-    private:
-        std::string createImagePath(const model::Song&);
-
-        model::BinaryPath m_bConf;
-        std::string path;
-    };
-}
-
-#endif

include/manager/DirectoryManager.h

@@ -1,37 +0,0 @@
-#ifndef DIRECTORY_MANAGER_H_
-#define DIRECTORY_MANAGER_H_
-
-#include <string>
-#include <string_view>
-
-#include <nlohmann/json.hpp>
-
-#include "model/Models.h"
-#include "type/PathType.h"
-
-namespace manager
-{
-    class DirectoryManager
-    {
-    public:
-        static std::string createDirectoryProcess(model::Song, const std::string&);
-        static std::string createDirectoryProcess(const model::Song&, const model::BinaryPath&, type::PathType);
-        static std::string configPath(std::string_view);
-        static std::string configPath(const model::BinaryPath&);
-        static std::string contentOfPath(const std::string&);
-        static std::string retrievePathType(type::PathType);
-
-        static nlohmann::json credentialConfigContent(const model::BinaryPath&);
-        static nlohmann::json databaseConfigContent(const model::BinaryPath&);
-        static nlohmann::json pathConfigContent(const model::BinaryPath&);
-
-        static void deleteDirectories(model::Song, const std::string&);
-
-        void deleteCoverArtFile(const std::string&, const std::string&);
-
-    private:
-        void deleteSong(const model::Song);
-    };
-}
-
-#endif

include/manager/GenreManager.h

@@ -1,25 +0,0 @@
-#ifndef GENREMANAGER_H_
-#define GENREMANAGER_H_
-
-#include "model/Models.h"
-
-namespace manager
-{
-    class GenreManager
-    {
-    public:
-        GenreManager(const model::BinaryPath&);
-
-        model::Genre retrieveGenre(model::Genre&);
-        model::Genre saveGenre(const model::Song&);
-
-        void deleteGenre(const model::Song&);
-        void updateGenre(model::Song&, const model::Song&);
-
-        static void printGenre(const model::Genre&);
-    private:
-        model::BinaryPath m_bConf;
-    };
-}
-
-#endif

include/manager/SongManager.h

@@ -1,54 +0,0 @@
-#ifndef SONGMANAGER_H_
-#define SONGMANAGER_H_
-
-#include <iostream>
-#include <map>
-#include <string>
-
-#include <nlohmann/json.hpp>
-
-#include "dto/SongDto.hpp"
-#include "model/Models.h"
-#include "type/SongChanged.h"
-
-namespace manager
-{
-    class SongManager
-    {
-    public:
-        SongManager(std::string&);
-        SongManager(const model::BinaryPath&);
-
-
-        bool didSongChange(const model::Song&, const model::Song&);
-        bool requiresFilesystemChange(const model::Song&, const model::Song&);
-
-        void saveSong(model::Song&);
-        void deleteSong(model::Song&);
-        void updateSong(model::Song&);
-
-        static model::Song songDtoConv(dto::SongDto::ObjectWrapper&);
-
-        static void printSong(const model::Song&);
-    private:
-        std::map<type::SongChanged, bool> changesInSong(const model::Song&, const model::Song&);
-
-        std::string createSongPath(const model::Song&);
-
-        void assignMiscId(model::Song&, const model::Song&);
-        void assignMiscFields(std::map<type::SongChanged, bool>&, model::Song&, 
-            const model::Song&);
-        void saveSongTemp(model::Song&);
-        void saveMisc(model::Song&);
-        void deleteMisc(const model::Song&);
-        void deleteMiscExceptCoverArt(const model::Song&);
-        void updateMisc(const std::map<type::SongChanged, bool>&, 
-            model::Song&, const model::Song&);
-        void modifySongOnFilesystem(model::Song&, const model::Song&);
-
-        model::BinaryPath m_bConf;
-        std::string exe_path;
-    };
-}
-
-#endif

include/manager/TokenManager.h

@@ -1,40 +0,0 @@
-#ifndef TOKEN_MANAGER_H_
-#define TOKEN_MANAGER_H_
-
-#include <string>
-#include <string_view>
-#include <utility>
-#include <vector>
-
-#include <cpr/cpr.h>
-#include <jwt-cpp/jwt.h>
-#include <nlohmann/json.hpp>
-
-#include "model/Models.h"
-#include "type/Scopes.h"
-
-namespace manager {
-class TokenManager {
-public:
-    TokenManager();
-
-    model::Token retrieveToken(const model::BinaryPath&);
-
-    bool isTokenValid(std::string&, type::Scope);
-    bool testAuth(const model::BinaryPath&);
-private:
-    cpr::Response sendRequest(std::string_view, nlohmann::json&);
-
-    nlohmann::json createTokenBody(const model::AuthCredentials&);
-
-    model::AuthCredentials parseAuthCredentials(std::string_view);
-    model::AuthCredentials parseAuthCredentials(const model::BinaryPath&);
-
-    std::vector<std::string> extractScopes(const jwt::decoded_jwt&&);
-    std::pair<bool, std::vector<std::string>> fetchAuthHeader(const std::string&);
-
-    bool tokenSupportsScope(const std::vector<std::string>&, const std::string&&);
-};
-}
-
-#endif

include/manager/UserManager.h

@@ -1,25 +0,0 @@
-#ifndef USERMANAGER_H_
-#define USERMANAGER_H_
-
-#include <iostream>
-
-#include "dto/LoginResultDto.hpp"
-#include "model/Models.h"
-
-namespace manager {
-class UserManager {
-public:
-    UserManager(const model::BinaryPath&);
-
-    model::RegisterResult registerUser(model::User&);
-
-    bool doesUserExist(const model::User&);
-    bool validatePassword(const model::User&);
-
-    void printUser(const model::User&);
-private:
-    model::BinaryPath m_bConf;
-};
-}
-
-#endif

include/manager/YearManager.h

@@ -1,25 +0,0 @@
-#ifndef YEARMANAGER_H_
-#define YEARMANAGER_H_
-
-#include "model/Models.h"
-
-namespace manager
-{
-    class YearManager
-    {
-    public:
-        YearManager(const model::BinaryPath&);
-
-        model::Year retrieveYear(model::Year&);
-        model::Year saveYear(const model::Song&);
-
-        void deleteYear(const model::Song&);
-        void updateYear(model::Song&, const model::Song&);
-
-        static void printYear(const model::Year&);
-    private:
-        model::BinaryPath m_bConf;
-    };
-}
-
-#endif

include/model/Models.h

@@ -1,176 +0,0 @@
-#ifndef MODELS_H_
-#define MODELS_H_
-
-#include <string>
-#include <vector>
-
-namespace model {
-struct Song {
-    Song() = default;
-    Song(const int id) : id(id) { }
-
-    int id; 
-    std::string title;
-    std::string artist;
-    std::string album;
-    std::string genre;
-    int year;
-    int duration;
-    int track;
-    int disc;
-    std::string songPath;
-    std::vector<unsigned char> data;
-    int coverArtId;
-    int artistId;
-    int albumId;
-    int genreId;
-    int yearId;
-};
-
-struct Artist {
-    Artist() = default;
-    Artist(const Song& song)
-    {
-        id = song.artistId;
-        artist = song.artist;
-    }
-    Artist(const int id) : id(id) { }
-
-    int id;
-    std::string artist;
-};
-
-struct Album {
-    Album() = default;
-    Album(const Song& song)
-    {
-        id = song.albumId;
-        title = song.album;
-        year = song.year;
-    }
-    Album(const int id) : id(id) { }
-
-    int id;
-    std::string title;
-    int year;
-    std::vector<Song> songs;
-};
-
-struct Genre {
-    Genre() = default;
-    Genre(const Song& song)
-    {
-        id = song.genreId;
-        category = song.genre;
-    }
-    Genre(const int id) : id(id) { }
-
-    int id;
-    std::string category;
-
-};
-
-struct Year {
-    Year() = default;
-    Year(const Song& song)
-    {
-        id = song.yearId;
-        year = song.year;
-    }
-    Year(const int id) : id(id) { }
-
-    int id;
-    int year;
-};
-
-struct Cover {
-    Cover() = default;
-    Cover(const Song& song)
-    {
-        id = song.coverArtId;
-        songTitle = song.title;
-    }
-    Cover(const int id) : id(id) { }
-
-    int id;
-    std::string songTitle;
-    std::string imagePath;
-    // Not being used but it should be
-    std::vector<unsigned char> data;
-};
-
-class Token {
-public:
-    Token() = default;
-    Token(const std::string& accessToken) :
-        accessToken(accessToken) { }
-    Token(const std::string& accessToken, const std::string& tokenType, 
-        const int expiration) :
-        accessToken(accessToken), tokenType(tokenType), 
-        expiration(expiration) { }
-
-    std::string accessToken;
-    int expiration;
-    std::string tokenType;
-};
-
-struct LoginResult {
-    int userId;
-    std::string username;
-    std::string accessToken;
-    std::string tokenType;
-    std::string message;
-    int expiration;
-};
-
-class RegisterResult {
-public:
-    std::string username;
-    bool registered;
-    std::string message;
-};
-
-struct User {
-    int id;
-    std::string firstname;
-    std::string lastname;
-    std::string email;
-    std::string phone;
-    std::string username;
-    std::string password;
-};
-
-struct PassSec {
-    int id;
-    std::string hashPassword;
-    std::string salt;
-    int userId;
-};
-
-struct AuthCredentials {
-    std::string domain;
-    std::string apiIdentifier;
-    std::string clientId;
-    std::string clientSecret;
-    std::string uri;
-    std::string endpoint;
-};
-
-struct DatabaseConnection {
-    std::string server;
-    std::string username;
-    std::string password;
-    std::string database;
-};
-
-struct BinaryPath {
-    BinaryPath() = default;
-    BinaryPath(const char *p) : path(std::move(p)) { }
-    BinaryPath(std::string& p) : path(p) { }
-    BinaryPath(const std::string& p) : path(p) { }
-
-    std::string path;
-};
-}
-
-#endif

include/type/AlbumFilter.h

@@ -1,14 +0,0 @@
-#ifndef ALBUMFILTER_H_
-#define ALBUMFILTER_H_
-
-namespace type
-{
-    enum class AlbumFilter
-    {
-        id = 0,
-        title,
-        year
-    };
-}
-
-#endif

include/type/ArtistFilter.h

@@ -1,13 +0,0 @@
-#ifndef ARTISTFILTER_H_
-#define ARTISTFILTER_H_
-
-namespace type
-{
-    enum class ArtistFilter
-    {
-        id = 0,
-        artist
-    };
-}
-
-#endif

include/type/CoverFilter.h

@@ -1,14 +0,0 @@
-#ifndef COVERFILTER_H_
-#define COVERFILTER_H_
-
-namespace type
-{
-    enum class CoverFilter
-    {
-        id = 0,
-        songTitle,
-        imagePath
-    };
-}
-
-#endif

include/type/GenreFilter.h

@@ -1,13 +0,0 @@
-#ifndef GENREFILTER_H_
-#define GENREFILTER_H_
-
-namespace type
-{
-    enum class GenreFilter
-    {
-        id = 0,
-        category
-    };
-}
-
-#endif

include/type/PathType.h

@@ -1,15 +0,0 @@
-#ifndef PATHTYPE_H_
-#define PATHTYPE_H_
-
-namespace type
-{
-    enum PathType
-    {
-        music = 0,
-        archive,
-        temp,
-        coverArt
-    };
-}
-
-#endif

include/type/SaltFilter.h

@@ -1,13 +0,0 @@
-#ifndef SALTFILTER_H_
-#define SALTFILTER_H_
-
-namespace type {
-    enum class SaltFilter
-    {
-        id = 0,
-        salt,
-        userId
-    };
-}
-
-#endif

include/type/Scopes.h

@@ -1,23 +0,0 @@
-#ifndef SCOPES_H_
-#define SCOPES_H_
-
-namespace type
-{
-    enum class Scope
-    {
-        upload = 0,
-        download,
-        stream,
-        retrieveSong,
-        updateSong,
-        deleteSong,
-        retrieveAlbum,
-        retrieveArtist,
-        retrieveGenre,
-        retrieveYear,
-        downloadCoverArt
-
-    };
-}
-
-#endif

include/type/SongChanged.h

@@ -1,16 +0,0 @@
-#ifndef SONGCHANGED_H_
-#define SONGCHANGED_H_
-
-namespace type
-{
-    enum SongChanged
-    {
-        title = 0,
-        artist,
-        album,
-        genre,
-        year
-    };
-}
-
-#endif

include/type/SongFilter.h

@@ -1,17 +0,0 @@
-#ifndef SONGFILTER_H_
-#define SONGFILTER_H_
-
-namespace type
-{
-    enum class SongFilter
-    {
-        id = 0,
-        title,
-        album,
-        artist,
-        genre,
-        year
-    };
-}
-
-#endif

include/type/UserFilter.h

@@ -1,12 +0,0 @@
-#ifndef USERFILTER_H_
-#define USERFILTER_H_
-
-namespace type {
-    enum class UserFilter
-    {
-        id = 0,
-        username
-    };
-}
-
-#endif

include/type/YearFilter.h

@@ -1,13 +0,0 @@
-#ifndef YEARFILTER_H_
-#define YEARFILTER_H_
-
-namespace type
-{
-    enum class YearFilter
-    {
-        id = 0,
-        year
-    };
-}
-
-#endif

include/utility/ImageFile.h

@@ -1,32 +0,0 @@
-#ifndef IMAGEFILE_H_
-#define IMAGEFILE_H_
-
-#include <iostream>
-
-#include <attachedpictureframe.h>
-#include <tag.h>
-#include <tfile.h>
-#include <tfilestream.h>
-#include <fileref.h>
-#include <tbytevector.h>
-#include <tbytevectorstream.h>
-#include <tpropertymap.h>
-#include <id3v2tag.h>
-
-namespace utility
-{
-    class ImageFile : public TagLib::File
-    {
-    public:
-        ImageFile(const char *file);
-
-        TagLib::ByteVector data();
-
-    private:
-        virtual TagLib::Tag *tag() const { return 0; }
-        virtual TagLib::AudioProperties *audioProperties() const { return 0; }
-        virtual bool save() { return false; }
-    };
-}
-
-#endif

include/utility/MetadataRetriever.h

@@ -1,26 +0,0 @@
-#ifndef METADATA_RETRIEVER_H_
-#define METADATA_RETRIEVER_H_
-
-#include <iostream>
-#include <string>
-
-#include "model/Models.h"
-
-namespace utility {
-class MetadataRetriever
-{
-public:
-    model::Song retrieveMetadata(std::string&);
-
-    model::Cover updateCoverArt(const model::Song&, model::Cover&, const std::string&);
-    model::Cover applyStockCoverArt(const model::Song&, model::Cover&, const std::string&);
-    model::Cover applyCoverArt(const model::Song&, model::Cover&);
-
-    bool songContainsCoverArt(const model::Song&);
-
-    void updateMetadata(model::Song&, const model::Song&);
-private:
-};
-}
-
-#endif

include/utility/PasswordEncryption.h

@@ -1,19 +0,0 @@
-#ifndef PASSWORDENCRYPTION_H_
-#define PASSWORDENCRYPTION_H_
-
-#include <string>
-
-#include "model/Models.h"
-
-namespace utility {
-class PasswordEncryption {
-public:
-    model::PassSec hashPassword(const model::User&);
-
-    bool isPasswordValid(const model::User&, const model::PassSec&);
-private:
-    int saltSize();
-};
-}
-
-#endif

include/verify/Initialization.h

@@ -1,25 +0,0 @@
-#ifndef INITIALIZATION_H_
-#define INITIALIZATION_H_
-
-#include <string>
-
-#include "model/Models.h"
-
-namespace verify
-{
-    class Initialization
-    {
-    public:
-        static bool skipVerification(const std::string&);
-
-        static void checkIcarus(const model::BinaryPath&);
-    private:
-        static bool confirmConfigAuth(const model::BinaryPath&);
-        static bool confirmConfigDatabase(const model::BinaryPath&);
-        static bool confirmConfigPaths(const model::BinaryPath&);
-
-        static void failedConfirmation();
-    };
-}
-
-#endif

migrations/20250420185217_init_migration.sql

@@ -0,0 +1,63 @@
+-- Add migration script here
+CREATE EXTENSION IF NOT EXISTS pgcrypto;
+
+-- Table to store queued songs to process
+CREATE TABLE IF NOT EXISTS "songQueue" (
+    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+    filename TEXT NOT NULL,
+    status TEXT CHECK (status IN ('pending', 'ready', 'processing', 'done')),
+    data BYTEA NULL,
+    user_id UUID NULL
+);
+
+-- Table to store queued metadata
+CREATE TABLE IF NOT EXISTS "metadataQueue" (
+    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+    metadata jsonb NOT NULL,
+    created_at timestamptz DEFAULT now(),
+    song_queue_id UUID NOT NULL
+);
+
+-- Table to store queued coverart
+CREATE TABLE IF NOT EXISTS "coverartQueue" (
+    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+    data BYTEA NULL,
+    file_type TEXT NOT NULL,
+    song_queue_id UUID NULL
+);
+
+-- Create an index for better query performance
+CREATE INDEX metadata_queue_data_metadata ON "metadataQueue" USING gin (metadata);
+
+-- Table to store a song's info
+CREATE TABLE IF NOT EXISTS "song" (
+    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+    title TEXT NOT NULL,
+    artist TEXT NOT NULL,
+    album_artist TEXT NOT NULL,
+    album TEXT NOT NULL,
+    genre TEXT NOT NULL,
+    -- TODO: Address discrepancy of date and year at some point
+    -- date TEXT NOT NULL,
+    year INT NOT NULL,
+    track INT NOT NULL,
+    disc INT NOT NULL,
+    track_count INT NOT NULL,
+    disc_count INT NOT NULL,
+    duration INT NOT NULL,
+    audio_type TEXT NOT NULL,
+    date_created timestamptz DEFAULT now(),
+    filename TEXT NOT NULL,
+    directory TEXT NOT NULL,
+    user_id UUID NULL
+    -- TODO: Add coverart id later. This will allow multiple songs to be linked to a single cover art
+);
+
+CREATE TABLE IF NOT EXISTS "coverart" (
+    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+    title TEXT NOT NULL,
+    directory TEXT NOT NULL,
+    filename TEXT NOT NULL,
+    file_type TEXT NOT NULL,
+    song_id UUID NOT NULL
+);

paths.json

@@ -1,6 +0,0 @@
-{
-    "root_music_path": "/icarus/music/",
-    "temp_root_path": "/icarus/temp/",
-    "cover_root_path": "/icarus/cover/",
-    "archive_root_path": "icarus/archive/"
-}

scripts/init-garage.sh

@@ -0,0 +1,84 @@
+#!/bin/sh
+set -e
+
+BUCKET_NAME="soaricarus-storage"
+
+echo "⏳ Waiting for Garage to be ready..."
+# until docker exec maze curl -s -f "http://localhost:3901/v0/status" > /dev/null 2>&1; do
+until docker exec maze nc -z "localhost 3900" > /dev/null 2>&1; do
+  echo "   Garage not ready yet, retrying in 2s..."
+  sleep 2
+done
+echo "✅ Garage API is responding!"
+
+sleep 3
+
+# Check if layout is already applied
+if docker exec maze garage layout show 2>/dev/null | grep -q "Current cluster layout"; then
+  echo "ℹ️  Layout already applied, checking bucket..."
+else
+  echo "📦 Applying cluster layout..."
+  
+  # Get node ID
+  MAX_RETRIES=10
+  RETRY_COUNT=0
+  NODE_ID=""
+  while [ $RETRY_COUNT -lt $MAX_RETRIES ]; do
+    NODE_ID=$(docker exec maze garage node id 2>/dev/null | head -n1)
+    if [ -n "$NODE_ID" ]; then
+      break
+    fi
+    RETRY_COUNT=$((RETRY_COUNT + 1))
+    echo "   Waiting for node ID (attempt $RETRY_COUNT/$MAX_RETRIES)..."
+    sleep 2
+  done
+  
+  if [ -z "$NODE_ID" ]; then
+    echo "❌ Failed to get node ID after $MAX_RETRIES attempts"
+    exit 1
+  fi
+  
+  echo "   Node ID: $NODE_ID"
+  docker exec maze garage layout assign --version 1 "$NODE_ID"
+  docker exec maze garage layout apply --version 1
+  echo "   ✅ Layout applied"
+  
+  sleep 3
+fi
+
+# Check if bucket exists
+if docker exec maze garage bucket info "${BUCKET_NAME}" 2>/dev/null; then
+  echo "ℹ️  Bucket '${BUCKET_NAME}' already exists. Skipping setup."
+  exit 0
+fi
+
+echo "📦 Creating bucket and configuring permissions..."
+
+# Create the bucket
+docker exec maze garage bucket create "${BUCKET_NAME}"
+echo "   ✅ Bucket created: ${BUCKET_NAME}"
+
+# Check if key exists
+if docker exec maze garage key info "${AWS_ACCESS_KEY_ID}" 2>/dev/null; then
+  echo "   ℹ️  Key already exists: ${AWS_ACCESS_KEY_ID}"
+else
+  docker exec maze garage key create \
+    --name "app-key" \
+    "${AWS_ACCESS_KEY_ID}" \
+    "${AWS_SECRET_ACCESS_KEY}"
+  echo "   ✅ Key created: ${AWS_ACCESS_KEY_ID}"
+fi
+
+# Grant permissions
+docker exec maze garage bucket allow \
+  --read \
+  --write \
+  --owner \
+  "${BUCKET_NAME}" \
+  --key "${AWS_ACCESS_KEY_ID}"
+echo "   ✅ Permissions granted"
+
+echo "🎉 Setup complete!"
+echo "   Bucket: ${BUCKET_NAME}"
+echo "   Access Key: ${AWS_ACCESS_KEY_ID}"
+echo "   Endpoint: http://maze:3900"

src/Main.cpp

@@ -1,82 +0,0 @@
-#include <exception>
-#include <iostream>
-#include <filesystem>
-#include <memory>
-#include <string>
-
-#include <mysql/mysql.h>
-#include <oatpp/network/server/Server.hpp>
-#include "oatpp/network/server/SimpleTCPConnectionProvider.hpp"
-#include "oatpp/web/server/HttpConnectionHandler.hpp"
-
-#include "component/AppComponent.hpp"
-#include "controller/ArtistController.hpp"
-#include "controller/AlbumController.hpp"
-#include "controller/CoverArtController.hpp"
-#include "controller/GenreController.hpp"
-#include "controller/LoginController.hpp"
-#include "controller/RegisterController.hpp"
-#include "controller/SongController.hpp"
-#include "controller/YearController.hpp"
-#include "model/Models.h"
-#include "verify/Initialization.h"
-
-namespace fs = std::filesystem;
-
-void run(const model::BinaryPath& bConf)
-{
-    component::AppComponent component;
-
-    OATPP_COMPONENT(std::shared_ptr<oatpp::web::server::HttpRouter>, router);
-
-    auto albumController = std::make_shared<controller::AlbumController>(bConf);
-    auto artistController = std::make_shared<controller::ArtistController>(bConf);
-    auto coverArtController = std::make_shared<controller::CoverArtController>(bConf);
-    auto gnrController = std::make_shared<controller::GenreController>(bConf);
-    auto logController = std::make_shared<controller::LoginController>(bConf);
-    auto regController = std::make_shared<controller::RegisterController>(bConf);
-    auto sngController = std::make_shared<controller::SongController>(bConf);
-    auto yearController = std::make_shared<controller::YearController>(bConf);
-
-    albumController->addEndpointsToRouter(router);
-    artistController->addEndpointsToRouter(router);
-    coverArtController->addEndpointsToRouter(router);
-    gnrController->addEndpointsToRouter(router);
-    logController->addEndpointsToRouter(router);
-    regController->addEndpointsToRouter(router);
-    sngController->addEndpointsToRouter(router);
-    yearController->addEndpointsToRouter(router);
-
-    OATPP_COMPONENT(std::shared_ptr<oatpp::network::server::ConnectionHandler>, connectionHandler);
-
-    OATPP_COMPONENT(std::shared_ptr<oatpp::network::ServerConnectionProvider>, connectionProvider);
-
-    oatpp::network::server::Server server(connectionProvider, connectionHandler);
-
-    OATPP_LOGI("icarus", "Server running on port %s", connectionProvider->getProperty("port").getData());
-
-    server.run();
-}
-
-int main(int argc, char **argv)
-{
-    oatpp::base::Environment::init();
-    
-    model::BinaryPath bConf(std::move(argv[0]));
-
-    if (argc > 1) {
-        if (!verify::Initialization::skipVerification(argv[1])) {
-            verify::Initialization::checkIcarus(bConf);
-        } else {
-            std::cout << "skiping verifyication" << std::endl;
-        }
-    } else {
-        verify::Initialization::checkIcarus(bConf);
-    }
-
-    run(bConf);
-
-    oatpp::base::Environment::destroy();
-
-    return 0;
-}

src/auth/mod.rs

@@ -0,0 +1,59 @@
+use axum::{
+    Json,
+    http::{Request, StatusCode},
+    middleware::Next,
+    response::IntoResponse,
+};
+use axum_extra::extract::cookie::CookieJar;
+use jsonwebtoken::{DecodingKey, Validation, decode};
+
+#[derive(Debug, serde::Serialize)]
+pub struct ErrorResponse {
+    pub status: &'static str,
+    pub message: String,
+}
+
+pub async fn auth<B>(
+    cookie_jar: CookieJar,
+    req: Request<axum::body::Body>,
+    next: Next,
+) -> Result<impl IntoResponse, (StatusCode, Json<ErrorResponse>)> {
+    let token = cookie_jar
+        .get("token")
+        .map(|cookie| cookie.value().to_string())
+        .or_else(|| {
+            req.headers()
+                .get(axum::http::header::AUTHORIZATION)
+                .and_then(|auth_header| auth_header.to_str().ok())
+                .and_then(|auth_value| auth_value.strip_prefix("Bearer ").map(String::from))
+        });
+
+    let token = token.ok_or_else(|| {
+        let json_error = ErrorResponse {
+            status: "fail",
+            message: "You are not logged in, please provide token".to_string(),
+        };
+        (StatusCode::UNAUTHORIZED, Json(json_error))
+    })?;
+
+    let secret_key = sienvy::environment::get_secret_main_key().value;
+
+    let mut validation = Validation::new(jsonwebtoken::Algorithm::HS256);
+    validation.set_audience(&["soaricarus"]);
+    let _claims = decode::<simodels::token::UserClaims>(
+        &token,
+        &DecodingKey::from_secret(secret_key.as_ref()),
+        &validation,
+    )
+    .map_err(|err| {
+        eprintln!("Error: {err:?}");
+        let json_error = ErrorResponse {
+            status: "fail",
+            message: "Invalid token - Error decoding claims".to_string(),
+        };
+        (StatusCode::UNAUTHORIZED, Json(json_error))
+    })?
+    .claims;
+
+    Ok(next.run(req).await)
+}

src/callback/StreamCallback.cpp

@@ -1,44 +0,0 @@
-#include "callback/StreamCallback.h"
-
-#include <iostream>
-#include <fstream>
-#include <memory>
-
-namespace callback {
-StreamCallback::StreamCallback() : 
-    m_counter(0) { }
-
-StreamCallback::StreamCallback(const std::string& songPath) : 
-    m_songPath(songPath),
-    m_counter(0),
-    m_bytesRead(0) 
-{ 
-    // getting file size
-    std::ifstream song(m_songPath.c_str(), std::ios::binary | std::ios::in | std::ios::ate);
-    m_fileSize = song.tellg();
-    std::cout << "file size is " << m_fileSize << " bytes" << std::endl;
-}
-
-
-oatpp::data::v_io_size StreamCallback::read(void *buff, oatpp::data::v_io_size count) 
-{
-    if (m_counter >= m_fileSize) {
-        std::cout << "done streaming song" << std::endl;
-        return 0;
-    }
-
-    std::fstream song(m_songPath.c_str(), std::ios::binary | std::ios::in);
-    song.seekg(m_counter);
-
-    std::unique_ptr<char[]> data(new char[count]);
-
-    song.read(data.get(), count);
-    std::memcpy(buff, data.get(), count);
-
-    m_counter += count;
-
-    song.close();
-
-    return count;
-}
-}