fixed readme

.github/ISSUE_TEMPLATE/1-bug.yml

@@ -6,7 +6,7 @@ body:
   - type: markdown
     attributes:
       value: |
-        Thanks for taking the time to improve cleanuperr!
+        Thanks for taking the time to improve Cleanuparr!
   - type: checkboxes
     id: init
     attributes:
@@ -14,7 +14,7 @@ body:
       options:
         - label: Reviewed the documentation.
           required: true
-        - label: Ensured I am using ghcr.io/flmorg/cleanuperr docker repository.
+        - label: Ensured I am using ghcr.io/Cleanuparr/Cleanuparr docker repository.
           required: true
         - label: Ensured I am using the latest version.
           required: true

.github/ISSUE_TEMPLATE/2-feature.yml

@@ -6,7 +6,7 @@ body:
   - type: markdown
     attributes:
       value: |
-        Thanks for taking the time to improve cleanuperr!
+        Thanks for taking the time to improve Cleanuparr!
   - type: textarea
     id: description
     attributes:

.github/ISSUE_TEMPLATE/3-help.yml

@@ -14,7 +14,7 @@ body:
       options:
         - label: Reviewed the documentation.
           required: true
-        - label: Ensured I am using ghcr.io/flmorg/cleanuperr docker repository.
+        - label: Ensured I am using ghcr.io/Cleanuparr/Cleanuparr docker repository.
           required: true
         - label: Ensured I am using the latest version.
           required: true

.github/workflows/build-docker.yml

@@ -0,0 +1,125 @@
+name: Build Docker Images
+
+on:
+  push:
+    tags:
+      - "v*.*.*"
+  pull_request:
+    paths:
+      - 'code/**'
+  workflow_dispatch:
+  workflow_call:
+
+jobs:
+  build_app:
+    runs-on: ubuntu-latest
+    steps:
+
+      - name: Set github context
+        timeout-minutes: 1
+        run: |
+          echo 'githubRepository=${{ github.repository }}' >> $GITHUB_ENV
+          echo 'githubSha=${{ github.sha }}' >> $GITHUB_ENV
+          echo 'githubRef=${{ github.ref }}' >> $GITHUB_ENV
+          echo 'githubHeadRef=${{ github.head_ref }}' >> $GITHUB_ENV
+
+      - name: Initialize build info
+        timeout-minutes: 1
+        run: |
+          githubHeadRef=${{ env.githubHeadRef }}
+          latestDockerTag=""
+          versionDockerTag=""
+          version="0.0.1"
+
+          if [[ "$githubRef" =~ ^"refs/tags/" ]]; then
+            branch=${githubRef##*/}
+            latestDockerTag="latest"
+            versionDockerTag=${branch#v}
+            version=${branch#v}
+          else
+            # Determine if this run is for the main branch or another branch
+            if [[ -z "$githubHeadRef" ]]; then
+              # Main branch
+              githubRef=${{ env.githubRef }}
+              branch=${githubRef##*/}
+              versionDockerTag="$branch"
+            else
+              # Pull request
+              branch=$githubHeadRef
+              versionDockerTag="$branch"
+            fi
+          fi
+
+          githubTags=""
+
+          if [ -n "$latestDockerTag" ]; then
+            githubTags="$githubTags,ghcr.io/cleanuparr:$latestDockerTag"
+          fi
+
+          if [ -n "$versionDockerTag" ]; then
+            githubTags="$githubTags,ghcr.io/cleanuparr:$versionDockerTag"
+          fi
+
+          # set env vars
+          echo "branch=$branch" >> $GITHUB_ENV
+          echo "githubTags=$githubTags" >> $GITHUB_ENV
+          echo "versionDockerTag=$versionDockerTag" >> $GITHUB_ENV
+          echo "version=$version" >> $GITHUB_ENV
+
+      - name: Get vault secrets
+        uses: hashicorp/vault-action@v2
+        with:
+          url: ${{ secrets.VAULT_HOST }}
+          method: approle
+          roleId: ${{ secrets.VAULT_ROLE_ID }}
+          secretId: ${{ secrets.VAULT_SECRET_ID }}
+          secrets:
+            secrets/data/docker username | DOCKER_USERNAME;
+            secrets/data/docker password | DOCKER_PASSWORD;
+            secrets/data/github repo_readonly_pat | REPO_READONLY_PAT;
+            secrets/data/github packages_pat | PACKAGES_PAT
+
+      - name: Checkout target repository
+        uses: actions/checkout@v4
+        timeout-minutes: 1
+        with:
+          repository: ${{ env.githubRepository }}
+          ref: ${{ env.branch }}
+          token: ${{ env.REPO_READONLY_PAT }}
+
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3
+        timeout-minutes: 5
+
+      - name: Set up QEMU
+        uses: docker/setup-qemu-action@v3
+
+      - name: Login to GitHub Container Registry
+        uses: docker/login-action@v3
+        with:
+          registry: ghcr.io
+          username: ${{ github.repository_owner }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Build and push docker image
+        timeout-minutes: 15
+        uses: docker/build-push-action@v6
+        with:
+          context: ${{ github.workspace }}/code
+          file: ${{ github.workspace }}/code/Dockerfile
+          provenance: false
+          labels: |
+            commit=sha-${{ env.githubSha }}
+            version=${{ env.versionDockerTag }}
+          build-args: |
+            VERSION=${{ env.version }}
+            PACKAGES_USERNAME=${{ env.PACKAGES_USERNAME }}
+            PACKAGES_PAT=${{ env.PACKAGES_PAT }}
+          outputs: |
+            type=image
+          platforms: |
+            linux/amd64
+            linux/arm64
+          push: true
+          tags: |
+            ${{ env.githubTags }}

.github/workflows/build-executable.yml

@@ -0,0 +1,177 @@
+name: Build Executables
+
+on:
+  push:
+    tags:
+      - "v*.*.*"
+  workflow_dispatch:
+  workflow_call:
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+
+      - name: Gate
+        if: ${{ !startsWith(github.ref, 'refs/tags/') && github.event_name != 'workflow_dispatch' }}
+        run: |
+          echo "This workflow only runs on tag events or manual dispatch. Pipeline finished."
+          exit 0
+
+      - name: Set variables
+        run: |
+          repoFullName=${{ github.repository }}
+          ref=${{ github.ref }}
+          
+          # Handle both tag events and manual dispatch
+          if [[ "$ref" =~ ^refs/tags/ ]]; then
+            releaseVersion=${ref##refs/tags/}
+            appVersion=${releaseVersion#v}
+          else
+            # For manual dispatch, use a default version
+            releaseVersion="dev-$(date +%Y%m%d-%H%M%S)"
+            appVersion="0.0.1-dev"
+          fi
+
+          echo "githubRepository=${{ github.repository }}" >> $GITHUB_ENV
+          echo "githubRepositoryName=${repoFullName#*/}" >> $GITHUB_ENV
+          echo "releaseVersion=$releaseVersion" >> $GITHUB_ENV
+          echo "appVersion=$appVersion" >> $GITHUB_ENV
+          echo "executableName=Cleanuparr.Api" >> $GITHUB_ENV
+
+      - name: Get vault secrets
+        uses: hashicorp/vault-action@v2
+        with:
+          url: ${{ secrets.VAULT_HOST }}
+          method: approle
+          roleId: ${{ secrets.VAULT_ROLE_ID }}
+          secretId: ${{ secrets.VAULT_SECRET_ID }}
+          secrets:
+            secrets/data/github repo_readonly_pat | REPO_READONLY_PAT;
+            secrets/data/github packages_pat | PACKAGES_PAT
+
+      - name: Checkout target repository
+        uses: actions/checkout@v4
+        timeout-minutes: 1
+        with:
+          repository: ${{ env.githubRepository }}
+          ref: ${{ github.ref_name }}
+          token: ${{ env.REPO_READONLY_PAT }}
+
+      - name: Setup Node.js for frontend build
+        uses: actions/setup-node@v4
+        with:
+          node-version: '18'
+          cache: 'npm'
+          cache-dependency-path: code/frontend/package-lock.json
+
+      - name: Build frontend
+        run: |
+          cd code/frontend
+          npm ci
+          npm run build
+
+      - name: Setup dotnet
+        uses: actions/setup-dotnet@v4
+        with:
+          dotnet-version: 9.0.x
+      
+      - name: Install dependencies and restore
+        run: |
+          dotnet nuget add source --username ${{ github.repository_owner }} --password ${{ secrets.PACKAGES_PAT }} --store-password-in-clear-text --name Cleanuparr https://nuget.pkg.github.com/Cleanuparr/index.json
+          dotnet restore code/backend/${{ env.executableName }}/${{ env.executableName }}.csproj
+
+      - name: Copy frontend to backend wwwroot
+        run: |
+          mkdir -p code/backend/${{ env.executableName }}/wwwroot
+          cp -r code/frontend/dist/ui/browser/* code/backend/${{ env.executableName }}/wwwroot/
+
+      - name: Build win-x64
+        run: dotnet publish code/backend/${{ env.executableName }}/${{ env.executableName }}.csproj -c Release --runtime win-x64 --self-contained -o artifacts/${{ env.githubRepositoryName }}-${{ env.appVersion }}-win-amd64 /p:PublishSingleFile=true /p:Version=${{ env.appVersion }} /p:DebugSymbols=false
+
+      - name: Build linux-x64
+        run: dotnet publish code/backend/${{ env.executableName }}/${{ env.executableName }}.csproj -c Release --runtime linux-x64 --self-contained -o artifacts/${{ env.githubRepositoryName }}-${{ env.appVersion }}-linux-amd64 /p:PublishSingleFile=true /p:Version=${{ env.appVersion }} /p:DebugSymbols=false
+
+      - name: Build linux-arm64
+        run: dotnet publish code/backend/${{ env.executableName }}/${{ env.executableName }}.csproj -c Release --runtime linux-arm64 --self-contained -o artifacts/${{ env.githubRepositoryName }}-${{ env.appVersion }}-linux-arm64 /p:PublishSingleFile=true /p:Version=${{ env.appVersion }} /p:DebugSymbols=false
+        
+      - name: Build osx-x64
+        run: dotnet publish code/backend/${{ env.executableName }}/${{ env.executableName }}.csproj -c Release --runtime osx-x64 --self-contained -o artifacts/${{ env.githubRepositoryName }}-${{ env.appVersion }}-osx-amd64 /p:PublishSingleFile=true /p:Version=${{ env.appVersion }} /p:DebugSymbols=false
+
+      - name: Build osx-arm64
+        run: dotnet publish code/backend/${{ env.executableName }}/${{ env.executableName }}.csproj -c Release --runtime osx-arm64 --self-contained -o artifacts/${{ env.githubRepositoryName }}-${{ env.appVersion }}-osx-arm64 /p:PublishSingleFile=true /p:Version=${{ env.appVersion }} /p:DebugSymbols=false
+
+      - name: Create sample configuration files
+        run: |
+          # Create a sample appsettings.json for each platform
+          cat > sample-config.json << 'EOF'
+          {
+            "Logging": {
+              "LogLevel": {
+                "Default": "Information",
+                "Microsoft.AspNetCore": "Warning"
+              }
+            },
+            "AllowedHosts": "*"
+          }
+          EOF
+          
+          # Copy to each build directory
+          cp sample-config.json artifacts/${{ env.githubRepositoryName }}-${{ env.appVersion }}-win-amd64/appsettings.json
+          cp sample-config.json artifacts/${{ env.githubRepositoryName }}-${{ env.appVersion }}-linux-amd64/appsettings.json
+          cp sample-config.json artifacts/${{ env.githubRepositoryName }}-${{ env.appVersion }}-linux-arm64/appsettings.json
+          cp sample-config.json artifacts/${{ env.githubRepositoryName }}-${{ env.appVersion }}-osx-amd64/appsettings.json
+          cp sample-config.json artifacts/${{ env.githubRepositoryName }}-${{ env.appVersion }}-osx-arm64/appsettings.json
+
+      - name: Zip win-x64
+        run: |
+          cd ./artifacts
+          zip -r ./${{ env.githubRepositoryName }}-${{ env.appVersion }}-win-amd64.zip ./${{ env.githubRepositoryName }}-${{ env.appVersion }}-win-amd64/
+
+      - name: Zip linux-x64
+        run: |
+          cd ./artifacts
+          zip -r ./${{ env.githubRepositoryName }}-${{ env.appVersion }}-linux-amd64.zip ./${{ env.githubRepositoryName }}-${{ env.appVersion }}-linux-amd64/
+
+      - name: Zip linux-arm64
+        run: |
+          cd ./artifacts
+          zip -r ./${{ env.githubRepositoryName }}-${{ env.appVersion }}-linux-arm64.zip ./${{ env.githubRepositoryName }}-${{ env.appVersion }}-linux-arm64/
+
+      - name: Zip osx-x64
+        run: |
+          cd ./artifacts
+          zip -r ./${{ env.githubRepositoryName }}-${{ env.appVersion }}-osx-amd64.zip ./${{ env.githubRepositoryName }}-${{ env.appVersion }}-osx-amd64/
+
+      - name: Zip osx-arm64
+        run: |
+          cd ./artifacts
+          zip -r ./${{ env.githubRepositoryName }}-${{ env.appVersion }}-osx-arm64.zip ./${{ env.githubRepositoryName }}-${{ env.appVersion }}-osx-arm64/
+
+      - name: Upload artifacts
+        uses: actions/upload-artifact@v4
+        with:
+          name: cleanuparr-executables
+          path: |
+            ./artifacts/*.zip
+          retention-days: 30
+
+      - name: Release
+        if: startsWith(github.ref, 'refs/tags/')
+        id: release
+        uses: softprops/action-gh-release@v2
+        with:
+          name: ${{ env.releaseVersion }}
+          tag_name: ${{ env.releaseVersion }}
+          repository: ${{ env.githubRepository }}
+          token: ${{ env.REPO_READONLY_PAT }}
+          make_latest: true
+          fail_on_unmatched_files: true
+          target_commitish: main
+          generate_release_notes: true
+          files: |
+            ./artifacts/${{ env.githubRepositoryName }}-${{ env.appVersion }}-win-amd64.zip
+            ./artifacts/${{ env.githubRepositoryName }}-${{ env.appVersion }}-linux-amd64.zip
+            ./artifacts/${{ env.githubRepositoryName }}-${{ env.appVersion }}-linux-arm64.zip
+            ./artifacts/${{ env.githubRepositoryName }}-${{ env.appVersion }}-osx-amd64.zip
+            ./artifacts/${{ env.githubRepositoryName }}-${{ env.appVersion }}-osx-arm64.zip

.github/workflows/build-macos-arm-installer.yml

@@ -0,0 +1,376 @@
+name: Build macOS ARM Installer
+
+permissions:
+  contents: write
+
+on:
+  push:
+    tags:
+      - "v*.*.*"
+  workflow_dispatch:
+  workflow_call:
+
+jobs:
+  build-macos-arm-installer:
+    name: Build macOS ARM Installer
+    runs-on: macos-14  # ARM runner for Apple Silicon
+    
+    steps:
+      - name: Set variables
+        run: |
+          repoFullName=${{ github.repository }}
+          ref=${{ github.ref }}
+          
+          # Handle both tag events and manual dispatch
+          if [[ "$ref" =~ ^refs/tags/ ]]; then
+            releaseVersion=${ref##refs/tags/}
+            appVersion=${releaseVersion#v}
+          else
+            # For manual dispatch, use a default version
+            releaseVersion="dev-$(date +%Y%m%d-%H%M%S)"
+            appVersion="0.0.1-dev"
+          fi
+          
+          repositoryName=${repoFullName#*/}
+          
+          echo "githubRepository=${{ github.repository }}" >> $GITHUB_ENV
+          echo "githubRepositoryName=$repositoryName" >> $GITHUB_ENV
+          echo "releaseVersion=$releaseVersion" >> $GITHUB_ENV
+          echo "appVersion=$appVersion" >> $GITHUB_ENV
+          echo "executableName=Cleanuparr.Api" >> $GITHUB_ENV
+
+      - name: Get vault secrets
+        uses: hashicorp/vault-action@v2
+        with:
+          url: ${{ secrets.VAULT_HOST }}
+          method: approle
+          roleId: ${{ secrets.VAULT_ROLE_ID }}
+          secretId: ${{ secrets.VAULT_SECRET_ID }}
+          secrets:
+            secrets/data/github repo_readonly_pat | REPO_READONLY_PAT;
+            secrets/data/github packages_pat | PACKAGES_PAT
+
+      - name: Checkout repository
+        uses: actions/checkout@v4
+        with:
+          repository: ${{ env.githubRepository }}
+          ref: ${{ github.ref_name }}
+          token: ${{ env.REPO_READONLY_PAT }}
+          fetch-depth: 0
+
+      - name: Setup Node.js for frontend build
+        uses: actions/setup-node@v4
+        with:
+          node-version: '18'
+          cache: 'npm'
+          cache-dependency-path: code/frontend/package-lock.json
+
+      - name: Build frontend
+        run: |
+          cd code/frontend
+          npm ci
+          npm run build
+
+      - name: Setup .NET
+        uses: actions/setup-dotnet@v4
+        with:
+          dotnet-version: 9.0.x
+
+      - name: Restore .NET dependencies
+        run: |
+          dotnet nuget add source --username ${{ github.repository_owner }} --password ${{ env.PACKAGES_PAT }} --store-password-in-clear-text --name Cleanuparr https://nuget.pkg.github.com/Cleanuparr/index.json
+          dotnet restore code/backend/${{ env.executableName }}/${{ env.executableName }}.csproj
+
+      - name: Build macOS ARM executable
+        run: |
+          # Clean any existing output directory
+          rm -rf dist
+          mkdir -p dist/temp
+          
+          # Build to a temporary location
+          dotnet publish code/backend/${{ env.executableName }}/${{ env.executableName }}.csproj \
+            -c Release \
+            --runtime osx-arm64 \
+            --self-contained true \
+            -o dist/temp \
+            /p:PublishSingleFile=true \
+            /p:Version=${{ env.appVersion }} \
+            /p:DebugType=None \
+            /p:DebugSymbols=false \
+            /p:UseAppHost=true \
+            /p:EnableMacOSCodeSign=false \
+            /p:CodeSignOnCopy=false \
+            /p:_CodeSignDuringBuild=false \
+            /p:PublishTrimmed=false \
+            /p:TrimMode=link
+          
+          # Create proper app bundle structure
+          mkdir -p dist/Cleanuparr.app/Contents/MacOS
+          
+          # Copy the built executable (note: AssemblyName is "Cleanuparr" not "Cleanuparr.Api")
+          cp dist/temp/Cleanuparr dist/Cleanuparr.app/Contents/MacOS/Cleanuparr
+          
+          # Copy frontend directly to where it belongs in the app bundle
+          mkdir -p dist/Cleanuparr.app/Contents/MacOS/wwwroot
+          cp -r code/frontend/dist/ui/browser/* dist/Cleanuparr.app/Contents/MacOS/wwwroot/
+          
+          # Copy any additional runtime files if they exist
+          if [ -d "dist/temp" ]; then
+            find dist/temp -name "*.dylib" -exec cp {} dist/Cleanuparr.app/Contents/MacOS/ \; 2>/dev/null || true
+            find dist/temp -name "createdump" -exec cp {} dist/Cleanuparr.app/Contents/MacOS/ \; 2>/dev/null || true
+          fi
+
+      - name: Post-build setup
+        run: |
+          # Make sure the executable is actually executable
+          chmod +x dist/Cleanuparr.app/Contents/MacOS/Cleanuparr
+          
+          # Remove any .pdb files that might have been created
+          find dist/Cleanuparr.app/Contents/MacOS -name "*.pdb" -delete 2>/dev/null || true
+          
+          echo "Checking architecture of built binary:"
+          file dist/Cleanuparr.app/Contents/MacOS/Cleanuparr
+          if command -v lipo >/dev/null 2>&1; then
+            lipo -info dist/Cleanuparr.app/Contents/MacOS/Cleanuparr
+          fi
+          
+          echo "Files in MacOS directory:"
+          ls -la dist/Cleanuparr.app/Contents/MacOS/
+
+      - name: Create macOS app bundle structure
+        run: |
+          # Create proper app bundle structure
+          mkdir -p dist/Cleanuparr.app/Contents/{MacOS,Resources,Frameworks}
+          
+          # Convert ICO to ICNS for macOS app bundle
+          if command -v iconutil >/dev/null 2>&1; then
+            # Create iconset directory structure
+            mkdir -p Cleanuparr.iconset
+            
+            # Use existing PNG files from Logo directory for different sizes
+            cp Logo/16.png Cleanuparr.iconset/icon_16x16.png
+            cp Logo/32.png Cleanuparr.iconset/icon_16x16@2x.png
+            cp Logo/32.png Cleanuparr.iconset/icon_32x32.png
+            cp Logo/64.png Cleanuparr.iconset/icon_32x32@2x.png
+            cp Logo/128.png Cleanuparr.iconset/icon_128x128.png
+            cp Logo/256.png Cleanuparr.iconset/icon_128x128@2x.png
+            cp Logo/256.png Cleanuparr.iconset/icon_256x256.png
+            cp Logo/512.png Cleanuparr.iconset/icon_256x256@2x.png
+            cp Logo/512.png Cleanuparr.iconset/icon_512x512.png
+            cp Logo/1024.png Cleanuparr.iconset/icon_512x512@2x.png
+            
+            # Create ICNS file
+            iconutil -c icns Cleanuparr.iconset -o dist/Cleanuparr.app/Contents/Resources/Cleanuparr.icns
+            
+            # Clean up iconset directory
+            rm -rf Cleanuparr.iconset
+          fi
+          
+          # Create Launch Daemon plist
+          cat > dist/Cleanuparr.app/Contents/Resources/com.cleanuparr.daemon.plist << EOF
+          <?xml version="1.0" encoding="UTF-8"?>
+          <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+          <plist version="1.0">
+          <dict>
+              <key>Label</key>
+              <string>com.cleanuparr.daemon</string>
+              <key>ProgramArguments</key>
+              <array>
+                  <string>/Applications/Cleanuparr.app/Contents/MacOS/Cleanuparr</string>
+              </array>
+              <key>RunAtLoad</key>
+              <true/>
+              <key>KeepAlive</key>
+              <true/>
+              <key>StandardOutPath</key>
+              <string>/var/log/cleanuparr.log</string>
+              <key>StandardErrorPath</key>
+              <string>/var/log/cleanuparr.error.log</string>
+              <key>WorkingDirectory</key>
+              <string>/Applications/Cleanuparr.app/Contents/MacOS</string>
+              <key>EnvironmentVariables</key>
+              <dict>
+                  <key>HTTP_PORTS</key>
+                  <string>11011</string>
+              </dict>
+          </dict>
+          </plist>
+          EOF
+          
+          # Create Info.plist with proper configuration
+          cat > dist/Cleanuparr.app/Contents/Info.plist << EOF
+          <?xml version="1.0" encoding="UTF-8"?>
+          <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+          <plist version="1.0">
+          <dict>
+              <key>CFBundleExecutable</key>
+              <string>Cleanuparr</string>
+              <key>CFBundleIdentifier</key>
+              <string>com.Cleanuparr</string>
+              <key>CFBundleName</key>
+              <string>Cleanuparr</string>
+              <key>CFBundleDisplayName</key>
+              <string>Cleanuparr</string>
+              <key>CFBundleVersion</key>
+              <string>${{ env.appVersion }}</string>
+              <key>CFBundleShortVersionString</key>
+              <string>${{ env.appVersion }}</string>
+              <key>CFBundleInfoDictionaryVersion</key>
+              <string>6.0</string>
+              <key>CFBundlePackageType</key>
+              <string>APPL</string>
+              <key>CFBundleSignature</key>
+              <string>CLNR</string>
+              <key>CFBundleIconFile</key>
+              <string>Cleanuparr</string>
+              <key>NSHighResolutionCapable</key>
+              <true/>
+              <key>NSRequiresAquaSystemAppearance</key>
+              <false/>
+              <key>LSMinimumSystemVersion</key>
+              <string>11.0</string>
+              <key>LSApplicationCategoryType</key>
+              <string>public.app-category.productivity</string>
+              <key>NSSupportsAutomaticTermination</key>
+              <false/>
+              <key>NSSupportsSuddenTermination</key>
+              <false/>
+              <key>LSBackgroundOnly</key>
+              <false/>
+              <key>NSAppTransportSecurity</key>
+              <dict>
+                  <key>NSAllowsArbitraryLoads</key>
+                  <true/>
+              </dict>
+          </dict>
+          </plist>
+          EOF
+          
+          # Clean up temp directory
+          rm -rf dist/temp
+
+      - name: Create PKG installer
+        run: |
+          # Create preinstall script to handle existing installations
+          mkdir -p scripts
+          cat > scripts/preinstall << 'EOF'
+          #!/bin/bash
+          
+          # Stop and unload existing launch daemon if it exists
+          if launchctl list | grep -q "com.cleanuparr.daemon"; then
+            launchctl stop com.cleanuparr.daemon 2>/dev/null || true
+            launchctl unload /Library/LaunchDaemons/com.cleanuparr.daemon.plist 2>/dev/null || true
+          fi
+          
+          # Stop any running instances of Cleanuparr
+          pkill -f "Cleanuparr" || true
+          sleep 2
+          
+          # Remove old installation if it exists
+          if [[ -d "/Applications/Cleanuparr.app" ]]; then
+            rm -rf "/Applications/Cleanuparr.app"
+          fi
+          
+          # Remove old launch daemon plist if it exists
+          if [[ -f "/Library/LaunchDaemons/com.cleanuparr.daemon.plist" ]]; then
+            rm -f "/Library/LaunchDaemons/com.cleanuparr.daemon.plist"
+          fi
+          
+          exit 0
+          EOF
+          
+          chmod +x scripts/preinstall
+          
+          # Create postinstall script
+          cat > scripts/postinstall << 'EOF'
+          #!/bin/bash
+          
+          # Set proper permissions for the app bundle
+          chmod -R 755 /Applications/Cleanuparr.app
+          chmod +x /Applications/Cleanuparr.app/Contents/MacOS/Cleanuparr
+          
+          # Install the launch daemon
+          cp /Applications/Cleanuparr.app/Contents/Resources/com.cleanuparr.daemon.plist /Library/LaunchDaemons/
+          chown root:wheel /Library/LaunchDaemons/com.cleanuparr.daemon.plist
+          chmod 644 /Library/LaunchDaemons/com.cleanuparr.daemon.plist
+          
+          # Load and start the service
+          launchctl load /Library/LaunchDaemons/com.cleanuparr.daemon.plist
+          launchctl start com.cleanuparr.daemon
+          
+          # Wait a moment for service to start
+          sleep 3
+          
+          # Display as system notification
+          osascript -e 'display notification "Cleanuparr service started! Visit http://localhost:11011 in your browser." with title "Installation Complete"' 2>/dev/null || true
+          
+          exit 0
+          EOF
+          
+          chmod +x scripts/postinstall
+          
+          # Create uninstall script (optional, for user reference)
+          cat > scripts/uninstall_cleanuparr.sh << 'EOF'
+          #!/bin/bash
+          # Cleanuparr Uninstall Script
+          # Run this script with sudo to completely remove Cleanuparr
+          
+          echo "Stopping Cleanuparr service..."
+          launchctl stop com.cleanuparr.daemon 2>/dev/null || true
+          launchctl unload /Library/LaunchDaemons/com.cleanuparr.daemon.plist 2>/dev/null || true
+          
+          echo "Removing service files..."
+          rm -f /Library/LaunchDaemons/com.cleanuparr.daemon.plist
+          
+          echo "Removing application..."
+          rm -rf /Applications/Cleanuparr.app
+          
+          echo "Removing logs..."
+          rm -f /var/log/cleanuparr.log
+          rm -f /var/log/cleanuparr.error.log
+          
+          echo "Cleanuparr has been completely removed."
+          echo "Note: Configuration files in /Applications/Cleanuparr.app/Contents/MacOS/config/ have been removed with the app."
+          EOF
+          
+          chmod +x scripts/uninstall_cleanuparr.sh
+          
+          # Copy uninstall script to app bundle for user access
+          cp scripts/uninstall_cleanuparr.sh dist/Cleanuparr.app/Contents/Resources/
+          
+          # Determine package name
+          if [[ "${{ github.ref }}" =~ ^refs/tags/ ]]; then
+            pkg_name="Cleanuparr-${{ env.appVersion }}-macos-arm64.pkg"
+          else
+            pkg_name="Cleanuparr-${{ env.appVersion }}-macos-arm64-dev.pkg"
+          fi
+          
+          # Create PKG installer with better metadata
+          pkgbuild --root dist/ \
+                  --scripts scripts/ \
+                  --identifier com.Cleanuparr \
+                  --version ${{ env.appVersion }} \
+                  --install-location /Applications \
+                  --ownership preserve \
+                  ${pkg_name}
+          
+          echo "pkgName=${pkg_name}" >> $GITHUB_ENV
+
+      - name: Upload installer as artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: Cleanuparr-macos-arm64-installer
+          path: '${{ env.pkgName }}'
+          retention-days: 30
+
+      - name: Release
+        if: startsWith(github.ref, 'refs/tags/')
+        uses: softprops/action-gh-release@v2
+        with:
+          name: ${{ env.releaseVersion }}
+          tag_name: ${{ env.releaseVersion }}
+          repository: ${{ env.githubRepository }}
+          token: ${{ env.REPO_READONLY_PAT }}
+          make_latest: true
+          files: |
+            ${{ env.pkgName }} 

.github/workflows/build-macos-intel-installer.yml

@@ -0,0 +1,376 @@
+name: Build macOS Intel Installer
+
+permissions:
+  contents: write
+
+on:
+  push:
+    tags:
+      - "v*.*.*"
+  workflow_dispatch:
+  workflow_call:
+
+jobs:
+  build-macos-intel-installer:
+    name: Build macOS Intel Installer
+    runs-on: macos-13  # Intel runner
+    
+    steps:
+      - name: Set variables
+        run: |
+          repoFullName=${{ github.repository }}
+          ref=${{ github.ref }}
+          
+          # Handle both tag events and manual dispatch
+          if [[ "$ref" =~ ^refs/tags/ ]]; then
+            releaseVersion=${ref##refs/tags/}
+            appVersion=${releaseVersion#v}
+          else
+            # For manual dispatch, use a default version
+            releaseVersion="dev-$(date +%Y%m%d-%H%M%S)"
+            appVersion="0.0.1-dev"
+          fi
+          
+          repositoryName=${repoFullName#*/}
+          
+          echo "githubRepository=${{ github.repository }}" >> $GITHUB_ENV
+          echo "githubRepositoryName=$repositoryName" >> $GITHUB_ENV
+          echo "releaseVersion=$releaseVersion" >> $GITHUB_ENV
+          echo "appVersion=$appVersion" >> $GITHUB_ENV
+          echo "executableName=Cleanuparr.Api" >> $GITHUB_ENV
+
+      - name: Get vault secrets
+        uses: hashicorp/vault-action@v2
+        with:
+          url: ${{ secrets.VAULT_HOST }}
+          method: approle
+          roleId: ${{ secrets.VAULT_ROLE_ID }}
+          secretId: ${{ secrets.VAULT_SECRET_ID }}
+          secrets:
+            secrets/data/github repo_readonly_pat | REPO_READONLY_PAT;
+            secrets/data/github packages_pat | PACKAGES_PAT
+
+      - name: Checkout repository
+        uses: actions/checkout@v4
+        with:
+          repository: ${{ env.githubRepository }}
+          ref: ${{ github.ref_name }}
+          token: ${{ env.REPO_READONLY_PAT }}
+          fetch-depth: 0
+
+      - name: Setup Node.js for frontend build
+        uses: actions/setup-node@v4
+        with:
+          node-version: '18'
+          cache: 'npm'
+          cache-dependency-path: code/frontend/package-lock.json
+
+      - name: Build frontend
+        run: |
+          cd code/frontend
+          npm ci
+          npm run build
+
+      - name: Setup .NET
+        uses: actions/setup-dotnet@v4
+        with:
+          dotnet-version: 9.0.x
+
+      - name: Restore .NET dependencies
+        run: |
+          dotnet nuget add source --username ${{ github.repository_owner }} --password ${{ env.PACKAGES_PAT }} --store-password-in-clear-text --name Cleanuparr https://nuget.pkg.github.com/Cleanuparr/index.json
+          dotnet restore code/backend/${{ env.executableName }}/${{ env.executableName }}.csproj
+
+      - name: Build macOS Intel executable
+        run: |
+          # Clean any existing output directory
+          rm -rf dist
+          mkdir -p dist/temp
+          
+          # Build to a temporary location
+          dotnet publish code/backend/${{ env.executableName }}/${{ env.executableName }}.csproj \
+            -c Release \
+            --runtime osx-x64 \
+            --self-contained true \
+            -o dist/temp \
+            /p:PublishSingleFile=true \
+            /p:Version=${{ env.appVersion }} \
+            /p:DebugType=None \
+            /p:DebugSymbols=false \
+            /p:UseAppHost=true \
+            /p:EnableMacOSCodeSign=false \
+            /p:CodeSignOnCopy=false \
+            /p:_CodeSignDuringBuild=false \
+            /p:PublishTrimmed=false \
+            /p:TrimMode=link
+          
+          # Create proper app bundle structure
+          mkdir -p dist/Cleanuparr.app/Contents/MacOS
+          
+          # Copy the built executable (note: AssemblyName is "Cleanuparr" not "Cleanuparr.Api")
+          cp dist/temp/Cleanuparr dist/Cleanuparr.app/Contents/MacOS/Cleanuparr
+          
+          # Copy frontend directly to where it belongs in the app bundle
+          mkdir -p dist/Cleanuparr.app/Contents/MacOS/wwwroot
+          cp -r code/frontend/dist/ui/browser/* dist/Cleanuparr.app/Contents/MacOS/wwwroot/
+          
+          # Copy any additional runtime files if they exist
+          if [ -d "dist/temp" ]; then
+            find dist/temp -name "*.dylib" -exec cp {} dist/Cleanuparr.app/Contents/MacOS/ \; 2>/dev/null || true
+            find dist/temp -name "createdump" -exec cp {} dist/Cleanuparr.app/Contents/MacOS/ \; 2>/dev/null || true
+          fi
+
+      - name: Post-build setup
+        run: |
+          # Make sure the executable is actually executable
+          chmod +x dist/Cleanuparr.app/Contents/MacOS/Cleanuparr
+          
+          # Remove any .pdb files that might have been created
+          find dist/Cleanuparr.app/Contents/MacOS -name "*.pdb" -delete 2>/dev/null || true
+          
+          echo "Checking architecture of built binary:"
+          file dist/Cleanuparr.app/Contents/MacOS/Cleanuparr
+          if command -v lipo >/dev/null 2>&1; then
+            lipo -info dist/Cleanuparr.app/Contents/MacOS/Cleanuparr
+          fi
+          
+          echo "Files in MacOS directory:"
+          ls -la dist/Cleanuparr.app/Contents/MacOS/
+
+      - name: Create macOS app bundle structure
+        run: |
+          # Create proper app bundle structure
+          mkdir -p dist/Cleanuparr.app/Contents/{MacOS,Resources,Frameworks}
+          
+          # Convert ICO to ICNS for macOS app bundle
+          if command -v iconutil >/dev/null 2>&1; then
+            # Create iconset directory structure
+            mkdir -p Cleanuparr.iconset
+            
+            # Use existing PNG files from Logo directory for different sizes
+            cp Logo/16.png Cleanuparr.iconset/icon_16x16.png
+            cp Logo/32.png Cleanuparr.iconset/icon_16x16@2x.png
+            cp Logo/32.png Cleanuparr.iconset/icon_32x32.png
+            cp Logo/64.png Cleanuparr.iconset/icon_32x32@2x.png
+            cp Logo/128.png Cleanuparr.iconset/icon_128x128.png
+            cp Logo/256.png Cleanuparr.iconset/icon_128x128@2x.png
+            cp Logo/256.png Cleanuparr.iconset/icon_256x256.png
+            cp Logo/512.png Cleanuparr.iconset/icon_256x256@2x.png
+            cp Logo/512.png Cleanuparr.iconset/icon_512x512.png
+            cp Logo/1024.png Cleanuparr.iconset/icon_512x512@2x.png
+            
+            # Create ICNS file
+            iconutil -c icns Cleanuparr.iconset -o dist/Cleanuparr.app/Contents/Resources/Cleanuparr.icns
+            
+            # Clean up iconset directory
+            rm -rf Cleanuparr.iconset
+          fi
+          
+          # Create Launch Daemon plist
+          cat > dist/Cleanuparr.app/Contents/Resources/com.cleanuparr.daemon.plist << EOF
+          <?xml version="1.0" encoding="UTF-8"?>
+          <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+          <plist version="1.0">
+          <dict>
+              <key>Label</key>
+              <string>com.cleanuparr.daemon</string>
+              <key>ProgramArguments</key>
+              <array>
+                  <string>/Applications/Cleanuparr.app/Contents/MacOS/Cleanuparr</string>
+              </array>
+              <key>RunAtLoad</key>
+              <true/>
+              <key>KeepAlive</key>
+              <true/>
+              <key>StandardOutPath</key>
+              <string>/var/log/cleanuparr.log</string>
+              <key>StandardErrorPath</key>
+              <string>/var/log/cleanuparr.error.log</string>
+              <key>WorkingDirectory</key>
+              <string>/Applications/Cleanuparr.app/Contents/MacOS</string>
+              <key>EnvironmentVariables</key>
+              <dict>
+                  <key>HTTP_PORTS</key>
+                  <string>11011</string>
+              </dict>
+          </dict>
+          </plist>
+          EOF
+          
+          # Create Info.plist with proper configuration
+          cat > dist/Cleanuparr.app/Contents/Info.plist << EOF
+          <?xml version="1.0" encoding="UTF-8"?>
+          <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+          <plist version="1.0">
+          <dict>
+              <key>CFBundleExecutable</key>
+              <string>Cleanuparr</string>
+              <key>CFBundleIdentifier</key>
+              <string>com.Cleanuparr</string>
+              <key>CFBundleName</key>
+              <string>Cleanuparr</string>
+              <key>CFBundleDisplayName</key>
+              <string>Cleanuparr</string>
+              <key>CFBundleVersion</key>
+              <string>${{ env.appVersion }}</string>
+              <key>CFBundleShortVersionString</key>
+              <string>${{ env.appVersion }}</string>
+              <key>CFBundleInfoDictionaryVersion</key>
+              <string>6.0</string>
+              <key>CFBundlePackageType</key>
+              <string>APPL</string>
+              <key>CFBundleSignature</key>
+              <string>CLNR</string>
+              <key>CFBundleIconFile</key>
+              <string>Cleanuparr</string>
+              <key>NSHighResolutionCapable</key>
+              <true/>
+              <key>NSRequiresAquaSystemAppearance</key>
+              <false/>
+              <key>LSMinimumSystemVersion</key>
+              <string>10.15</string>
+              <key>LSApplicationCategoryType</key>
+              <string>public.app-category.productivity</string>
+              <key>NSSupportsAutomaticTermination</key>
+              <false/>
+              <key>NSSupportsSuddenTermination</key>
+              <false/>
+              <key>LSBackgroundOnly</key>
+              <false/>
+              <key>NSAppTransportSecurity</key>
+              <dict>
+                  <key>NSAllowsArbitraryLoads</key>
+                  <true/>
+              </dict>
+          </dict>
+          </plist>
+          EOF
+          
+          # Clean up temp directory
+          rm -rf dist/temp
+
+      - name: Create PKG installer
+        run: |
+          # Create preinstall script to handle existing installations
+          mkdir -p scripts
+          cat > scripts/preinstall << 'EOF'
+          #!/bin/bash
+          
+          # Stop and unload existing launch daemon if it exists
+          if launchctl list | grep -q "com.cleanuparr.daemon"; then
+            launchctl stop com.cleanuparr.daemon 2>/dev/null || true
+            launchctl unload /Library/LaunchDaemons/com.cleanuparr.daemon.plist 2>/dev/null || true
+          fi
+          
+          # Stop any running instances of Cleanuparr
+          pkill -f "Cleanuparr" || true
+          sleep 2
+          
+          # Remove old installation if it exists
+          if [[ -d "/Applications/Cleanuparr.app" ]]; then
+            rm -rf "/Applications/Cleanuparr.app"
+          fi
+          
+          # Remove old launch daemon plist if it exists
+          if [[ -f "/Library/LaunchDaemons/com.cleanuparr.daemon.plist" ]]; then
+            rm -f "/Library/LaunchDaemons/com.cleanuparr.daemon.plist"
+          fi
+          
+          exit 0
+          EOF
+          
+          chmod +x scripts/preinstall
+          
+          # Create postinstall script
+          cat > scripts/postinstall << 'EOF'
+          #!/bin/bash
+          
+          # Set proper permissions for the app bundle
+          chmod -R 755 /Applications/Cleanuparr.app
+          chmod +x /Applications/Cleanuparr.app/Contents/MacOS/Cleanuparr
+          
+          # Install the launch daemon
+          cp /Applications/Cleanuparr.app/Contents/Resources/com.cleanuparr.daemon.plist /Library/LaunchDaemons/
+          chown root:wheel /Library/LaunchDaemons/com.cleanuparr.daemon.plist
+          chmod 644 /Library/LaunchDaemons/com.cleanuparr.daemon.plist
+          
+          # Load and start the service
+          launchctl load /Library/LaunchDaemons/com.cleanuparr.daemon.plist
+          launchctl start com.cleanuparr.daemon
+          
+          # Wait a moment for service to start
+          sleep 3
+          
+          # Display as system notification
+          osascript -e 'display notification "Cleanuparr service started! Visit http://localhost:11011 in your browser." with title "Installation Complete"' 2>/dev/null || true
+          
+          exit 0
+          EOF
+          
+          chmod +x scripts/postinstall
+          
+          # Create uninstall script (optional, for user reference)
+          cat > scripts/uninstall_cleanuparr.sh << 'EOF'
+          #!/bin/bash
+          # Cleanuparr Uninstall Script
+          # Run this script with sudo to completely remove Cleanuparr
+          
+          echo "Stopping Cleanuparr service..."
+          launchctl stop com.cleanuparr.daemon 2>/dev/null || true
+          launchctl unload /Library/LaunchDaemons/com.cleanuparr.daemon.plist 2>/dev/null || true
+          
+          echo "Removing service files..."
+          rm -f /Library/LaunchDaemons/com.cleanuparr.daemon.plist
+          
+          echo "Removing application..."
+          rm -rf /Applications/Cleanuparr.app
+          
+          echo "Removing logs..."
+          rm -f /var/log/cleanuparr.log
+          rm -f /var/log/cleanuparr.error.log
+          
+          echo "Cleanuparr has been completely removed."
+          echo "Note: Configuration files in /Applications/Cleanuparr.app/Contents/MacOS/config/ have been removed with the app."
+          EOF
+          
+          chmod +x scripts/uninstall_cleanuparr.sh
+          
+          # Copy uninstall script to app bundle for user access
+          cp scripts/uninstall_cleanuparr.sh dist/Cleanuparr.app/Contents/Resources/
+          
+          # Determine package name
+          if [[ "${{ github.ref }}" =~ ^refs/tags/ ]]; then
+            pkg_name="Cleanuparr-${{ env.appVersion }}-macos-intel.pkg"
+          else
+            pkg_name="Cleanuparr-${{ env.appVersion }}-macos-intel-dev.pkg"
+          fi
+          
+          # Create PKG installer with better metadata
+          pkgbuild --root dist/ \
+                  --scripts scripts/ \
+                  --identifier com.Cleanuparr \
+                  --version ${{ env.appVersion }} \
+                  --install-location /Applications \
+                  --ownership preserve \
+                  ${pkg_name}
+          
+          echo "pkgName=${pkg_name}" >> $GITHUB_ENV
+
+      - name: Upload installer as artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: Cleanuparr-macos-intel-installer
+          path: '${{ env.pkgName }}'
+          retention-days: 30
+
+      - name: Release
+        if: startsWith(github.ref, 'refs/tags/')
+        uses: softprops/action-gh-release@v2
+        with:
+          name: ${{ env.releaseVersion }}
+          tag_name: ${{ env.releaseVersion }}
+          repository: ${{ env.githubRepository }}
+          token: ${{ env.REPO_READONLY_PAT }}
+          make_latest: true
+          files: |
+            ${{ env.pkgName }} 

.github/workflows/build-windows-installer.yml

@@ -0,0 +1,171 @@
+name: Build Windows Installer
+
+on:
+  push:
+    tags:
+      - "v*.*.*"
+  workflow_dispatch:
+  workflow_call:
+
+jobs:
+  build-windows-installer:
+    runs-on: windows-latest
+    
+    steps:
+      - name: Set variables
+        shell: pwsh
+        run: |
+          $repoFullName = "${{ github.repository }}"
+          $ref = "${{ github.ref }}"
+          
+          # Handle both tag events and manual dispatch
+          if ($ref -match "^refs/tags/") {
+            $releaseVersion = $ref -replace "refs/tags/", ""
+            $appVersion = $releaseVersion -replace "^v", ""
+          } else {
+            # For manual dispatch, use a default version
+            $releaseVersion = "dev-$(Get-Date -Format 'yyyyMMdd-HHmmss')"
+            $appVersion = "0.0.1-dev"
+          }
+          
+          $repositoryName = $repoFullName.Split("/")[1]
+          
+          echo "githubRepository=${{ github.repository }}" >> $env:GITHUB_ENV
+          echo "githubRepositoryName=$repositoryName" >> $env:GITHUB_ENV
+          echo "releaseVersion=$releaseVersion" >> $env:GITHUB_ENV
+          echo "appVersion=$appVersion" >> $env:GITHUB_ENV
+          echo "executableName=Cleanuparr.Api" >> $env:GITHUB_ENV
+          echo "APP_VERSION=$appVersion" >> $env:GITHUB_ENV
+
+      - name: Get vault secrets
+        uses: hashicorp/vault-action@v2
+        with:
+          url: ${{ secrets.VAULT_HOST }}
+          method: approle
+          roleId: ${{ secrets.VAULT_ROLE_ID }}
+          secretId: ${{ secrets.VAULT_SECRET_ID }}
+          secrets:
+            secrets/data/github repo_readonly_pat | REPO_READONLY_PAT;
+            secrets/data/github packages_pat | PACKAGES_PAT
+
+      - name: Checkout repository
+        uses: actions/checkout@v4
+        with:
+          repository: ${{ env.githubRepository }}
+          ref: ${{ github.ref_name }}
+          token: ${{ env.REPO_READONLY_PAT }}
+
+      - name: Setup Node.js for frontend build
+        uses: actions/setup-node@v4
+        with:
+          node-version: '18'
+          cache: 'npm'
+          cache-dependency-path: code/frontend/package-lock.json
+
+      - name: Build frontend
+        run: |
+          cd code/frontend
+          npm ci
+          npm run build
+
+      - name: Setup .NET
+        uses: actions/setup-dotnet@v4
+        with:
+          dotnet-version: 9.0.x
+
+      - name: Restore .NET dependencies
+        run: |
+          dotnet nuget add source --username ${{ github.repository_owner }} --password ${{ env.PACKAGES_PAT }} --store-password-in-clear-text --name Cleanuparr https://nuget.pkg.github.com/Cleanuparr/index.json
+          dotnet restore code/backend/${{ env.executableName }}/${{ env.executableName }}.csproj
+
+      - name: Copy frontend to backend wwwroot
+        shell: pwsh
+        run: |
+          New-Item -ItemType Directory -Force -Path "code/backend/${{ env.executableName }}/wwwroot"
+          Copy-Item -Path "code/frontend/dist/ui/browser/*" -Destination "code/backend/${{ env.executableName }}/wwwroot/" -Recurse -Force
+
+      - name: Build Windows executable
+        run: |
+          dotnet publish code/backend/${{ env.executableName }}/${{ env.executableName }}.csproj -c Release --runtime win-x64 --self-contained -o dist /p:PublishSingleFile=true /p:Version=${{ env.appVersion }} /p:DebugType=None /p:DebugSymbols=false
+
+      - name: Create sample configuration
+        shell: pwsh
+        run: |
+          # Create config directory
+          New-Item -ItemType Directory -Force -Path "config"
+          
+          $config = @{
+            "HTTP_PORTS" = 11011
+            "BASE_PATH" = "/"
+          }
+          
+          $config | ConvertTo-Json | Out-File -FilePath "config/cleanuparr.json" -Encoding UTF8
+
+      - name: Setup Inno Setup
+        shell: pwsh
+        run: |
+          # Download and install Inno Setup
+          $url = "https://jrsoftware.org/download.php/is.exe"
+          $output = "innosetup-installer.exe"
+          
+          Invoke-WebRequest -Uri $url -OutFile $output
+          Start-Process -FilePath $output -ArgumentList "/VERYSILENT", "/SUPPRESSMSGBOXES", "/NORESTART" -Wait
+          
+          # Add Inno Setup to PATH
+          $innoPath = "C:\Program Files (x86)\Inno Setup 6"
+          echo "$innoPath" >> $env:GITHUB_PATH
+
+      - name: Verify LICENSE file exists
+        shell: pwsh
+        run: |
+          if (-not (Test-Path "LICENSE")) {
+            Write-Error "LICENSE file not found in repository root"
+            exit 1
+          }
+          Write-Host "LICENSE file found successfully"
+
+      - name: Build Windows installer
+        shell: pwsh
+        run: |
+          # Copy installer script to root
+          Copy-Item "installers/windows/cleanuparr-installer.iss" -Destination "cleanuparr-installer.iss"
+          
+          # The installer script has been pre-updated with proper icon and config paths
+          # No dynamic modifications needed as the base script now includes correct references
+          
+          # Run Inno Setup compiler
+          & "C:\Program Files (x86)\Inno Setup 6\ISCC.exe" "cleanuparr-installer.iss"
+          
+          # Check if installer was created
+          if (Test-Path "installer/Cleanuparr_Setup.exe") {
+            Write-Host "Installer created successfully"
+          } else {
+            Write-Error "Installer creation failed"
+            exit 1
+          }
+
+      - name: Rename installer with version
+        shell: pwsh
+        run: |
+          $installerName = "Cleanuparr-${{ env.appVersion }}-Setup.exe"
+          Move-Item "installer/Cleanuparr_Setup.exe" "installer/$installerName"
+          echo "installerName=$installerName" >> $env:GITHUB_ENV
+
+      - name: Upload installer artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: Cleanuparr-windows-installer
+          path: installer/${{ env.installerName }}
+          retention-days: 30
+
+      - name: Release
+        if: startsWith(github.ref, 'refs/tags/')
+        uses: softprops/action-gh-release@v2
+        with:
+          name: ${{ env.releaseVersion }}
+          tag_name: ${{ env.releaseVersion }}
+          repository: ${{ env.githubRepository }}
+          token: ${{ env.REPO_READONLY_PAT }}
+          make_latest: true
+          files: |
+            installer/${{ env.installerName }} 

.github/workflows/build.yml

@@ -1,12 +0,0 @@
-on:
-  workflow_dispatch:
-  workflow_call:
-
-jobs:
-  build:
-    uses: flmorg/universal-workflows/.github/workflows/dotnet.build.app.yml@main
-    with:
-      dockerRepository: flaminel/cleanuperr
-      githubContext: ${{ toJSON(github) }}
-      outputName: cleanuperr
-    secrets: inherit

.github/workflows/deploy.yml

@@ -1,19 +0,0 @@
-on:
-  workflow_call:
-  workflow_dispatch:
-  push:
-    paths:
-      - 'chart/**'
-    branches: [ main ]
-
-jobs:
-  deploy:
-    uses: flmorg/universal-workflows/.github/workflows/chart.install.yml@main
-    with:
-      githubContext: ${{ toJSON(github) }}
-      chartRepo: oci://ghcr.io/flmorg
-      chartName: universal-chart
-      version: ^1.0.0
-      valuesPath: chart/values.yaml
-      releaseName: main
-    secrets: inherit

.github/workflows/pipeline.yml

@@ -1,20 +0,0 @@
-on:
-  push:
-    tags:
-      - "v*.*.*"
-    # paths:
-    #   - 'code/**'
-    # branches: [ main ]
-  pull_request:
-    paths:
-      - 'code/**'
-
-jobs:
-  build:
-    uses: flmorg/cleanuperr/.github/workflows/build.yml@main
-    secrets: inherit
-
-  # deploy:
-  #   needs: [ build ]
-  #   uses: flmorg/cleanuperr/.github/workflows/deploy.yml@main
-  #   secrets: inherit

.github/workflows/release.yml

@@ -1,11 +1,164 @@
+name: Release Build
+
 on:
   push:
     tags:
       - "v*.*.*"
+  workflow_dispatch:
+    inputs:
+      version:
+        description: 'Version to release (e.g., 1.0.0)'
+        required: false
+        default: ''
 
 jobs:
-  release:
-    uses: flmorg/universal-workflows/.github/workflows/dotnet.release.yml@main
-    with:
-      githubContext: ${{ toJSON(github) }}
-    secrets: inherit
+  # Validate release
+  validate:
+    runs-on: ubuntu-latest
+    outputs:
+      app_version: ${{ steps.version.outputs.app_version }}
+      release_version: ${{ steps.version.outputs.release_version }}
+      is_tag: ${{ steps.version.outputs.is_tag }}
+      
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Get version info
+        id: version
+        run: |
+          if [[ "${{ github.ref }}" =~ ^refs/tags/ ]]; then
+            # Tag event
+            release_version=${GITHUB_REF##refs/tags/}
+            app_version=${release_version#v}
+            is_tag=true
+          elif [[ -n "${{ github.event.inputs.version }}" ]]; then
+            # Manual workflow with version
+            app_version="${{ github.event.inputs.version }}"
+            release_version="v$app_version"
+            is_tag=false
+          else
+            # Manual workflow without version
+            app_version="0.0.1-dev-$(date +%Y%m%d-%H%M%S)"
+            release_version="v$app_version"
+            is_tag=false
+          fi
+          
+          echo "app_version=$app_version" >> $GITHUB_OUTPUT
+          echo "release_version=$release_version" >> $GITHUB_OUTPUT
+          echo "is_tag=$is_tag" >> $GITHUB_OUTPUT
+          
+          echo "🏷️ Release Version: $release_version"
+          echo "📱 App Version: $app_version"
+          echo "🔖 Is Tag: $is_tag"
+
+  # Build portable executables
+  build-executables:
+    needs: validate
+    uses: ./.github/workflows/build_executable.yml
+    secrets: inherit
+
+  # Build Windows installer
+  build-windows-installer:
+    needs: validate
+    uses: ./.github/workflows/build-windows-installer.yml
+    secrets: inherit
+
+  # Build macOS Intel installer
+  build-macos-intel:
+    needs: validate
+    uses: ./.github/workflows/build-macos-intel-installer.yml
+    secrets: inherit
+
+  # Build macOS ARM installer
+  build-macos-arm:
+    needs: validate
+    uses: ./.github/workflows/build-macos-arm-installer.yml
+    secrets: inherit
+
+  # Create GitHub release
+  create-release:
+    needs: [validate, build-executables, build-windows-installer, build-macos-intel, build-macos-arm]
+    runs-on: ubuntu-latest
+    if: github.event_name == 'push' && startsWith(github.ref, 'refs/tags/')
+    
+    steps:
+      - name: Get vault secrets
+        uses: hashicorp/vault-action@v2
+        with:
+          url: ${{ secrets.VAULT_HOST }}
+          method: approle
+          roleId: ${{ secrets.VAULT_ROLE_ID }}
+          secretId: ${{ secrets.VAULT_SECRET_ID }}
+          secrets:
+            secrets/data/github repo_readonly_pat | REPO_READONLY_PAT
+
+      - name: Download all artifacts
+        uses: actions/download-artifact@v4
+        with:
+          path: ./artifacts
+
+      - name: List downloaded artifacts
+        run: |
+          echo "📦 Downloaded artifacts:"
+          find ./artifacts -type f -name "*.zip" -o -name "*.pkg" -o -name "*.exe" | sort
+
+      - name: Create release
+        uses: softprops/action-gh-release@v2
+        with:
+          name: Cleanuparr ${{ needs.validate.outputs.release_version }}
+          tag_name: ${{ needs.validate.outputs.release_version }}
+          token: ${{ env.REPO_READONLY_PAT }}
+          make_latest: true
+          generate_release_notes: true
+          prerelease: ${{ contains(needs.validate.outputs.app_version, '-') }}
+          files: |
+            ./artifacts/**/*.zip
+            ./artifacts/**/*.pkg
+            ./artifacts/**/*.exe
+
+  # Summary job
+  summary:
+    needs: [validate, build-executables, build-windows-installer, build-macos-intel, build-macos-arm]
+    runs-on: ubuntu-latest
+    if: always()
+    
+    steps:
+      - name: Build Summary
+        run: |
+          echo "## 🏗️ Cleanuparr Build Summary" >> $GITHUB_STEP_SUMMARY
+          echo "" >> $GITHUB_STEP_SUMMARY
+          echo "**Version**: ${{ needs.validate.outputs.release_version }}" >> $GITHUB_STEP_SUMMARY
+          echo "**App Version**: ${{ needs.validate.outputs.app_version }}" >> $GITHUB_STEP_SUMMARY
+          echo "**Is Tag**: ${{ needs.validate.outputs.is_tag }}" >> $GITHUB_STEP_SUMMARY
+          echo "" >> $GITHUB_STEP_SUMMARY
+          echo "### Build Results" >> $GITHUB_STEP_SUMMARY
+          echo "" >> $GITHUB_STEP_SUMMARY
+          
+          # Check job results
+          if [[ "${{ needs.build-executables.result }}" == "success" ]]; then
+            echo "✅ **Portable Executables**: Success" >> $GITHUB_STEP_SUMMARY
+          else
+            echo "❌ **Portable Executables**: ${{ needs.build-executables.result }}" >> $GITHUB_STEP_SUMMARY
+          fi
+          
+          if [[ "${{ needs.build-windows-installer.result }}" == "success" ]]; then
+            echo "✅ **Windows Installer**: Success" >> $GITHUB_STEP_SUMMARY
+          else
+            echo "❌ **Windows Installer**: ${{ needs.build-windows-installer.result }}" >> $GITHUB_STEP_SUMMARY
+          fi
+          
+          if [[ "${{ needs.build-macos-intel.result }}" == "success" ]]; then
+            echo "✅ **macOS Intel Installer**: Success" >> $GITHUB_STEP_SUMMARY
+          else
+            echo "❌ **macOS Intel Installer**: ${{ needs.build-macos-intel.result }}" >> $GITHUB_STEP_SUMMARY
+          fi
+          
+          if [[ "${{ needs.build-macos-arm.result }}" == "success" ]]; then
+            echo "✅ **macOS ARM Installer**: Success" >> $GITHUB_STEP_SUMMARY
+          else
+            echo "❌ **macOS ARM Installer**: ${{ needs.build-macos-arm.result }}" >> $GITHUB_STEP_SUMMARY
+          fi
+          
+          echo "" >> $GITHUB_STEP_SUMMARY
+          echo "🎉 **Build completed!**" >> $GITHUB_STEP_SUMMARY 

README.md

@@ -1,30 +1,53 @@
 _Love this project? Give it a ⭐️ and let others know!_
 
-# <img width="24px" src="./Logo/256.png" alt="cleanuperr"></img> Cleanuperr
+# <img width="24px" src="./Logo/256.png" alt="Cleanuparr"></img> Cleanuparr
 
-[![Discord](https://img.shields.io/discord/1306721212587573389?color=7289DA&label=Discord&style=for-the-badge&logo=discord)](https://discord.gg/sWggpnmGNY)
+[![Discord](https://img.shields.io/discord/1306721212587573389?color=7289DA&label=Discord&style=for-the-badge&logo=discord)](https://discord.gg/SCtMCgtsc4)
 
-Cleanuperr is a tool for automating the cleanup of unwanted or blocked files in Sonarr, Radarr, and supported download clients like qBittorrent. It removes incomplete or blocked downloads, updates queues, and enforces blacklists or whitelists to manage file selection. After removing blocked content, Cleanuperr can also trigger a search to replace the deleted shows/movies.
+Cleanuparr is a tool for automating the cleanup of unwanted or blocked files in Sonarr, Radarr, and supported download clients like qBittorrent. It removes incomplete or blocked downloads, updates queues, and enforces blacklists or whitelists to manage file selection. After removing blocked content, Cleanuparr can also trigger a search to replace the deleted shows/movies.
 
-Cleanuperr was created primarily to address malicious files, such as `*.lnk` or `*.zipx`, that were getting stuck in Sonarr/Radarr and required manual intervention. Some of the reddit posts that made Cleanuperr come to life can be found [here](https://www.reddit.com/r/sonarr/comments/1gqnx16/psa_sonarr_downloaded_a_virus/), [here](https://www.reddit.com/r/sonarr/comments/1gqwklr/sonar_downloaded_a_mkv_file_which_looked_like_a/), [here](https://www.reddit.com/r/sonarr/comments/1gpw2wa/downloaded_waiting_to_import/) and [here](https://www.reddit.com/r/sonarr/comments/1gpi344/downloads_not_importing_no_files_found/).
+Cleanuparr was created primarily to address malicious files, such as `*.lnk` or `*.zipx`, that were getting stuck in Sonarr/Radarr and required manual intervention. Some of the reddit posts that made Cleanuparr come to life can be found [here](https://www.reddit.com/r/sonarr/comments/1gqnx16/psa_sonarr_downloaded_a_virus/), [here](https://www.reddit.com/r/sonarr/comments/1gqwklr/sonar_downloaded_a_mkv_file_which_looked_like_a/), [here](https://www.reddit.com/r/sonarr/comments/1gpw2wa/downloaded_waiting_to_import/) and [here](https://www.reddit.com/r/sonarr/comments/1gpi344/downloads_not_importing_no_files_found/).
 
 > [!IMPORTANT]
 > **Features:**
-> - Strike system to mark stalled or downloads stuck in metadata downloading.
+> - Strike system to mark bad downloads.
 > - Remove and block downloads that reached a maximum number of strikes.
-> - Remove and block downloads that have a low download speed or high estimated completion time.
-> - Remove downloads blocked by qBittorrent or by Cleanuperr's **content blocker**.
-> - Trigger a search for downloads removed from the *arrs.
-> - Remove downloads that have been seeding for a certain amount of time.
-> - Remove downloads that have no hardlinks (have been upgraded by the *arrs).
-> - Notify on strike or download removal.
-> - Ignore certain torrent hashes, categories, tags or trackers from being processed by Cleanuperr.
+> - Remove and block downloads that are **failing to be imported** by the arrs. [configuration](https://cleanuparr.github.io/cleanuparr/docs/configuration/queue-cleaner/import-failed)
+> - Remove and block downloads that are **stalled** or in **metadata downloading** state. [configuration](https://cleanuparr.github.io/cleanuparr/docs/configuration/queue-cleaner/stalled)
+> - Remove and block downloads that have a **low download speed** or **high estimated completion time**. [configuration](https://cleanuparr.github.io/cleanuparr/docs/configuration/queue-cleaner/slow)
+> - Remove and block downloads blocked by qBittorrent or by Cleanuparr's **Content Blocker**. [configuration](https://cleanuparr.github.io/cleanuparr/docs/configuration/content-blocker/general)
+> - Automatically trigger a search for downloads removed from the arrs.
+> - Clean up downloads that have been **seeding** for a certain amount of time. [configuration](https://cleanuparr.github.io/cleanuparr/docs/configuration/download-cleaner/seeding)
+> - Remove downloads that are **orphaned**/have no **hardlinks**/are not referenced by the arrs anymore (with [cross-seed](https://www.cross-seed.org/) support). [configuration](https://cleanuparr.github.io/cleanuparr/docs/configuration/download-cleaner/hardlinks)
+> - Notify on strike or download removal. [configuration](https://cleanuparr.github.io/cleanuparr/docs/category/notifications)
+> - Ignore certain torrent hashes, categories, tags or trackers from being processed by Cleanuparr.
 
-Cleanuperr supports both qBittorrent's built-in exclusion features and its own blocklist-based system. Binaries for all platforms are provided, along with Docker images for easy deployment.
+Cleanuparr supports both qBittorrent's built-in exclusion features and its own blocklist-based system. Binaries for all platforms are provided, along with Docker images for easy deployment.
+
+## Quick Start
+
+> [!NOTE]
+>
+> 1. **Docker (Recommended)**  
+> Pull the Docker image from `ghcr.io/Cleanuparr/Cleanuparr:latest`.
+>
+> 2. **Unraid (for Unraid users)**  
+> Use the Unraid Community App.
+>
+> 3. **Manual Installation (if you're not using Docker)**  
+> Go to [Windows](#windows), [Linux](#linux) or [MacOS](#macos).
 
 # Docs
 
-Docs can be found [here](https://flmorg.github.io/cleanuperr/).
+Docs can be found [here](https://Cleanuparr.github.io/Cleanuparr/).
+
+# <img style="vertical-align: middle;" width="24px" src="./Logo/256.png" alt="Cleanuparr"> <span style="vertical-align: middle;">Cleanuparr</span> <img src="https://raw.githubusercontent.com/FortAwesome/Font-Awesome/6.x/svgs/solid/x.svg" height="24px" width="30px" style="vertical-align: middle;"> <span style="vertical-align: middle;">Huntarr</span> <img style="vertical-align: middle;" width="24px" src="https://github.com/plexguide/Huntarr.io/blob/main/frontend/static/logo/512.png?raw=true" alt Huntarr></img>
+
+Think of **Cleanuparr** as the janitor of your server; it keeps your download queue spotless, removes clutter, and blocks malicious files. Now imagine combining that with **Huntarr**, the compulsive librarian who finds missing and upgradable media to complete your collection
+
+While **Huntarr** fills in the blanks and improves what you already have, **Cleanuparr** makes sure that only clean downloads get through. If you're aiming for a reliable and self-sufficient setup, **Cleanuparr** and **Huntarr** will take your automated media stack to another level.
+
+<span style="font-size:24px"> ➡️ [**Huntarr**](https://github.com/plexguide/Huntarr.io) <span style="vertical-align: middle">![Huntarr](https://img.shields.io/github/stars/plexguide/Huntarr.io?style=social)</span></span> 
 
 # Credits
 Special thanks for inspiration go to:

blacklist

@@ -1,5 +1,6 @@
 *(sample).*
 *.0xe
+*.001
 *.73k
 *.73p
 *.7z

blacklist_permissive

@@ -1,3 +1,4 @@
+*.001
 *.apk
 *.arj
 *.bat

chart/values.yaml

@@ -1,162 +0,0 @@
-deployment:
-  replicas: 1
-  strategy:
-    type: RollingUpdate
-    maxSurge: 1
-    maxUnavailable: 0
-  containers:
-    - name: qbit
-      image:
-        repository: ghcr.io/flmorg/cleanuperr
-        tag: latest
-      env:
-        - name: DRY_RUN
-          value: "false"
-
-        - name: LOGGING__LOGLEVEL
-          value: Verbose
-        - name: LOGGING__FILE__ENABLED
-          value: "true"
-        - name: LOGGING__FILE__PATH
-          value: /var/logs
-        - name: LOGGING__ENHANCED
-          value: "true"
-
-        - name: TRIGGERS__QUEUECLEANER
-          value: 0 0/5 * * * ?
-        - name: TRIGGERS__CONTENTBLOCKER
-          value: 0 0/5 * * * ?
-
-        - name: QUEUECLEANER__ENABLED
-          value: "true"
-        - name: QUEUECLEANER__RUNSEQUENTIALLY
-          value: "true"
-        - name: QUEUECLEANER__IMPORT_FAILED_MAX_STRIKES
-          value: "3"
-        - name: QUEUECLEANER__IMPORT_FAILED_IGNORE_PRIVATE
-          value: "false"
-        - name: QUEUECLEANER__IMPORT_FAILED_DELETE_PRIVATE
-          value: "false"
-        - name: QUEUECLEANER__STALLED_MAX_STRIKES
-          value: "3"
-        - name: QUEUECLEANER__STALLED_IGNORE_PRIVATE
-          value: "false"
-        - name: QUEUECLEANER__STALLED_DELETE_PRIVATE
-          value: "false"
-
-        - name: CONTENTBLOCKER__ENABLED
-          value: "true"
-        - name: CONTENTBLOCKER__IGNORE_PRIVATE
-          value: "true"
-        - name: CONTENTBLOCKER__DELETE_PRIVATE
-          value: "false"
-
-        - name: DOWNLOADCLEANER__ENABLED
-          value: "false"
-
-        - name: DOWNLOAD_CLIENT
-          value: qbittorrent
-        - name: QBITTORRENT__URL
-          value: http://service.qbittorrent-videos.svc.cluster.local
-
-        - name: SONARR__ENABLED
-          value: "true"
-        - name: SONARR__SEARCHTYPE
-          value: Episode
-        - name: SONARR__BLOCK__TYPE
-          value: blacklist
-        - name: SONARR__BLOCK__PATH
-          value: https://raw.githubusercontent.com/flmorg/cleanuperr/refs/heads/main/blacklist
-        - name: SONARR__INSTANCES__0__URL
-          value: http://service.sonarr-low-res.svc.cluster.local
-        - name: SONARR__INSTANCES__1__URL
-          value: http://service.sonarr-high-res.svc.cluster.local
-
-        - name: RADARR__ENABLED
-          value: "true"
-        - name: RADARR__BLOCK__TYPE
-          value: blacklist
-        - name: RADARR__BLOCK__PATH
-          value: https://raw.githubusercontent.com/flmorg/cleanuperr/refs/heads/main/blacklist
-        - name: RADARR__INSTANCES__0__URL
-          value: http://service.radarr-low-res.svc.cluster.local
-        - name: RADARR__INSTANCES__1__URL
-          value: http://service.radarr-high-res.svc.cluster.local
-
-        - name: NOTIFIARR__ON_IMPORT_FAILED_STRIKE
-          value: "true"
-        - name: NOTIFIARR__ON_STALLED_STRIKE
-          value: "true"
-        - name: NOTIFIARR__ON_QUEUE_ITEM_DELETED
-          value: "true"
-        - name: NOTIFIARR__ON_DOWNLOAD_CLEANED
-          value: "true"
-        - name: NOTIFIARR__CHANNEL_ID
-          value: "1340708411259748413"
-      envFromSecret:
-        - secretName: qbit-auth
-          envs:
-            - name: QBITTORRENT__USERNAME
-              key: QBIT_USER
-            - name: QBITTORRENT__PASSWORD
-              key: QBIT_PASS
-        - secretName: sonarr-auth
-          envs:
-            - name: SONARR__INSTANCES__0__APIKEY
-              key: SNRL_API_KEY
-            - name: SONARR__INSTANCES__1__APIKEY
-              key: SNRH_API_KEY
-        - secretName: radarr-auth
-          envs:
-            - name: RADARR__INSTANCES__0__APIKEY
-              key: RDRL_API_KEY
-            - name: RADARR__INSTANCES__1__APIKEY
-              key: RDRH_API_KEY
-        - secretName: notifiarr-auth
-          envs:
-            - name: NOTIFIARR__API_KEY
-              key: API_KEY
-      resources:
-        requests:
-          cpu: 0m
-          memory: 0Mi
-        limits:
-          cpu: 1000m
-          memory: 1000Mi
-      volumeMounts:
-        - name: storage
-          mountPath: /var/logs
-          subPath: cleanuperr/logs
-  volumes:
-    - name: storage
-      type: pvc
-      typeName: storage-pvc
-
-pvcs:
-  - name: storage-pvc
-    storageClassName: local-path-persistent
-    accessModes:
-      - ReadWriteOnce
-    size: 1Gi
-    volumeMode: Filesystem
-
-vaultSecrets:
-  - name: qbit-auth
-    path: secrets/qbittorrent
-    templates:
-      QBIT_USER: "{% .Secrets.username %}"
-      QBIT_PASS: "{% .Secrets.password %}"
-  - name: radarr-auth
-    path: secrets/radarr
-    templates:
-      RDRL_API_KEY: "{% .Secrets.low_api_key %}"
-      RDRH_API_KEY: "{% .Secrets.high_api_key %}"
-  - name: sonarr-auth
-    path: secrets/sonarr
-    templates:
-      SNRL_API_KEY: "{% .Secrets.low_api_key %}"
-      SNRH_API_KEY: "{% .Secrets.high_api_key %}"
-  - name: notifiarr-auth
-    path: secrets/notifiarr
-    templates:
-      API_KEY: "{% .Secrets.passthrough_api_key %}"

code/.dockerignore

@@ -0,0 +1,41 @@
+# Documentation
+*.md
+docs/
+
+# Version control
+.git/
+.gitignore
+
+# IDE files
+.vscode/
+.idea/
+*.swp
+*.swo
+
+# OS files
+.DS_Store
+Thumbs.db
+
+# Node.js
+frontend/node_modules/
+frontend/dist/
+frontend/.angular/
+
+# .NET
+backend/bin/
+backend/obj/
+backend/*/bin/
+backend/*/obj/
+backend/.vs/
+
+# Build artifacts
+artifacts/
+dist/
+
+# Test files
+backend/**/*Tests/
+backend/**/Tests/
+
+# Development files
+docker-compose*.yml
+test/ 

code/Common/Attributes/DryRunSafeguardAttribute.cs

@@ -1,6 +0,0 @@
-namespace Common.Attributes;
-
-[AttributeUsage(AttributeTargets.Method, Inherited = true)]
-public class DryRunSafeguardAttribute : Attribute
-{
-}

code/Common/Configuration/Arr/ArrConfig.cs

@@ -1,19 +0,0 @@
-using Common.Configuration.ContentBlocker;
-
-namespace Common.Configuration.Arr;
-
-public abstract record ArrConfig
-{
-    public required bool Enabled { get; init; }
-
-    public Block Block { get; init; } = new();
-    
-    public required List<ArrInstance> Instances { get; init; }
-}
-
-public readonly record struct Block
-{
-    public BlocklistType Type { get; init; }
-    
-    public string? Path { get; init; }
-}

code/Common/Configuration/Arr/ArrInstance.cs

@@ -1,8 +0,0 @@
-namespace Common.Configuration.Arr;
-
-public sealed class ArrInstance
-{
-    public required Uri Url { get; set; }
-    
-    public required string ApiKey { get; set; }
-}

code/Common/Configuration/Arr/LidarrConfig.cs

@@ -1,6 +0,0 @@
-namespace Common.Configuration.Arr;
-
-public sealed record LidarrConfig : ArrConfig
-{
-    public const string SectionName = "Lidarr";
-}

code/Common/Configuration/Arr/RadarrConfig.cs

@@ -1,6 +0,0 @@
-namespace Common.Configuration.Arr;
-
-public sealed record RadarrConfig : ArrConfig
-{
-    public const string SectionName = "Radarr";
-}

code/Common/Configuration/Arr/SonarrConfig.cs

@@ -1,8 +0,0 @@
-namespace Common.Configuration.Arr;
-
-public sealed record SonarrConfig : ArrConfig
-{
-    public const string SectionName = "Sonarr";
-    
-    public SonarrSearchType SearchType { get; init; }
-}

code/Common/Configuration/ContentBlocker/ContentBlockerConfig.cs

@@ -1,23 +0,0 @@
-using Microsoft.Extensions.Configuration;
-
-namespace Common.Configuration.ContentBlocker;
-
-public sealed record ContentBlockerConfig : IJobConfig, IIgnoredDownloadsConfig
-{
-    public const string SectionName = "ContentBlocker";
-    
-    public required bool Enabled { get; init; }
-    
-    [ConfigurationKeyName("IGNORE_PRIVATE")]
-    public bool IgnorePrivate { get; init; }
-    
-    [ConfigurationKeyName("DELETE_PRIVATE")]
-    public bool DeletePrivate { get; init; }
-
-    [ConfigurationKeyName("IGNORED_DOWNLOADS_PATH")]
-    public string? IgnoredDownloadsPath { get; init; }
-    
-    public void Validate()
-    {
-    }
-}

code/Common/Configuration/DownloadCleaner/CleanCategory.cs

@@ -1,45 +0,0 @@
-using Common.Exceptions;
-using Microsoft.Extensions.Configuration;
-
-namespace Common.Configuration.DownloadCleaner;
-
-public sealed record CleanCategory : IConfig
-{
-    public required string Name { get; init; }
-
-    /// <summary>
-    /// Max ratio before removing a download.
-    /// </summary>
-    [ConfigurationKeyName("MAX_RATIO")]
-    public required double MaxRatio { get; init; } = -1;
-
-    /// <summary>
-    /// Min number of hours to seed before removing a download, if the ratio has been met.
-    /// </summary>
-    [ConfigurationKeyName("MIN_SEED_TIME")]
-    public required double MinSeedTime { get; init; } = 0;
-
-    /// <summary>
-    /// Number of hours to seed before removing a download.
-    /// </summary>
-    [ConfigurationKeyName("MAX_SEED_TIME")]
-    public required double MaxSeedTime { get; init; } = -1;
-
-    public void Validate()
-    {
-        if (string.IsNullOrWhiteSpace(Name))
-        {
-            throw new ValidationException($"{nameof(Name)} can not be empty");
-        }
-
-        if (MaxRatio < 0 && MaxSeedTime < 0)
-        {
-            throw new ValidationException($"both {nameof(MaxRatio)} and {nameof(MaxSeedTime)} are disabled");
-        }
-
-        if (MinSeedTime < 0)
-        {
-            throw new ValidationException($"{nameof(MinSeedTime)} can not be negative");
-        }
-    }
-}

code/Common/Configuration/DownloadCleaner/DownloadCleanerConfig.cs

@@ -1,73 +0,0 @@
-using Common.Exceptions;
-using Microsoft.Extensions.Configuration;
-
-namespace Common.Configuration.DownloadCleaner;
-
-public sealed record DownloadCleanerConfig : IJobConfig, IIgnoredDownloadsConfig
-{
-    public const string SectionName = "DownloadCleaner";
-    
-    public bool Enabled { get; init; }
-
-    public List<CleanCategory>? Categories { get; init; }
-
-    [ConfigurationKeyName("DELETE_PRIVATE")]
-    public bool DeletePrivate { get; init; }
-    
-    [ConfigurationKeyName("IGNORED_DOWNLOADS_PATH")]
-    public string? IgnoredDownloadsPath { get; init; }
-
-    [ConfigurationKeyName("UNLINKED_TARGET_CATEGORY")]
-    public string UnlinkedTargetCategory { get; init; } = "cleanuperr-unlinked";
-
-    [ConfigurationKeyName("UNLINKED_IGNORED_ROOT_DIR")]
-    public string UnlinkedIgnoredRootDir { get; init; } = string.Empty;
-    
-    [ConfigurationKeyName("UNLINKED_CATEGORIES")]
-    public List<string>? UnlinkedCategories { get; init; }
-
-    public void Validate()
-    {
-        if (!Enabled)
-        {
-            return;
-        }
-        
-        if (Categories?.Count is null or 0)
-        {
-            throw new ValidationException("no categories configured");
-        }
-
-        if (Categories?.GroupBy(x => x.Name).Any(x => x.Count() > 1) is true)
-        {
-            throw new ValidationException("duplicated clean categories found");
-        }
-        
-        Categories?.ForEach(x => x.Validate());
-        
-        if (string.IsNullOrEmpty(UnlinkedTargetCategory))
-        {
-            return;
-        }
-
-        if (UnlinkedCategories?.Count is null or 0)
-        {
-            throw new ValidationException("no unlinked categories configured");
-        }
-
-        if (UnlinkedCategories.Contains(UnlinkedTargetCategory))
-        {
-            throw new ValidationException($"{SectionName.ToUpperInvariant()}__UNLINKED_TARGET_CATEGORY should not be present in {SectionName.ToUpperInvariant()}__UNLINKED_CATEGORIES");
-        }
-
-        if (UnlinkedCategories.Any(string.IsNullOrEmpty))
-        {
-            throw new ValidationException("empty unlinked category filter found");
-        }
-
-        if (!string.IsNullOrEmpty(UnlinkedIgnoredRootDir) && !Directory.Exists(UnlinkedIgnoredRootDir))
-        {
-            throw new ValidationException($"{UnlinkedIgnoredRootDir} root directory does not exist");
-        }
-    }
-}

code/Common/Configuration/DownloadClient/DelugeConfig.cs

@@ -1,24 +0,0 @@
-using Common.Exceptions;
-using Microsoft.Extensions.Configuration;
-
-namespace Common.Configuration.DownloadClient;
-
-public sealed record DelugeConfig : IConfig
-{
-    public const string SectionName = "Deluge";
-    
-    public Uri? Url { get; init; }
-    
-    [ConfigurationKeyName("URL_BASE")]
-    public string UrlBase { get; init; } = string.Empty;
-    
-    public string? Password { get; init; }
-    
-    public void Validate()
-    {
-        if (Url is null)
-        {
-            throw new ValidationException($"{nameof(Url)} is empty");
-        }
-    }
-}

code/Common/Configuration/DownloadClient/DownloadClientConfig.cs

@@ -1,9 +0,0 @@
-using Microsoft.Extensions.Configuration;
-
-namespace Common.Configuration.DownloadClient;
-
-public sealed record DownloadClientConfig
-{
-    [ConfigurationKeyName("DOWNLOAD_CLIENT")]
-    public Enums.DownloadClient DownloadClient { get; init; } = Enums.DownloadClient.None;
-}

code/Common/Configuration/DownloadClient/QBitConfig.cs

@@ -1,26 +0,0 @@
-using Common.Exceptions;
-using Microsoft.Extensions.Configuration;
-
-namespace Common.Configuration.DownloadClient;
-
-public sealed class QBitConfig : IConfig
-{
-    public const string SectionName = "qBittorrent";
-    
-    public Uri? Url { get; init; }
-    
-    [ConfigurationKeyName("URL_BASE")]
-    public string UrlBase { get; init; } = string.Empty;
-    
-    public string? Username { get; init; }
-    
-    public string? Password { get; init; }
-    
-    public void Validate()
-    {
-        if (Url is null)
-        {
-            throw new ValidationException($"{nameof(Url)} is empty");
-        }
-    }
-}

code/Common/Configuration/DownloadClient/TransmissionConfig.cs

@@ -1,26 +0,0 @@
-using Common.Exceptions;
-using Microsoft.Extensions.Configuration;
-
-namespace Common.Configuration.DownloadClient;
-
-public record TransmissionConfig : IConfig
-{
-    public const string SectionName = "Transmission";
-    
-    public Uri? Url { get; init; }
-    
-    [ConfigurationKeyName("URL_BASE")]
-    public string UrlBase { get; init; } = "transmission";
-    
-    public string? Username { get; init; }
-    
-    public string? Password { get; init; }
-    
-    public void Validate()
-    {
-        if (Url is null)
-        {
-            throw new ValidationException($"{nameof(Url)} is empty");
-        }
-    }
-}

code/Common/Configuration/General/DryRunConfig.cs

@@ -1,9 +0,0 @@
-using Microsoft.Extensions.Configuration;
-
-namespace Common.Configuration.General;
-
-public sealed record DryRunConfig
-{
-    [ConfigurationKeyName("DRY_RUN")]
-    public bool IsDryRun { get; init; }
-}

code/Common/Configuration/General/HttpConfig.cs

@@ -1,21 +0,0 @@
-using Common.Exceptions;
-using Microsoft.Extensions.Configuration;
-
-namespace Common.Configuration.General;
-
-public sealed record HttpConfig : IConfig
-{
-    [ConfigurationKeyName("HTTP_MAX_RETRIES")]
-    public ushort MaxRetries { get; init; }
-    
-    [ConfigurationKeyName("HTTP_TIMEOUT")]
-    public ushort Timeout { get; init; } = 100;
-
-    public void Validate()
-    {
-        if (Timeout is 0)
-        {
-            throw new ValidationException("HTTP_TIMEOUT must be greater than 0");
-        }
-    }
-}

code/Common/Configuration/General/TriggersConfig.cs

@@ -1,12 +0,0 @@
-namespace Common.Configuration.General;
-
-public sealed class TriggersConfig
-{
-    public const string SectionName = "Triggers";
-    
-    public required string QueueCleaner { get; init; }
-    
-    public required string ContentBlocker { get; init; }
-    
-    public required string DownloadCleaner { get; init; }
-}

code/Common/Configuration/IConfig.cs

@@ -1,6 +0,0 @@
-namespace Common.Configuration;
-
-public interface IConfig
-{
-    void Validate();
-}

code/Common/Configuration/IIgnoredDownloadsConfig.cs

@@ -1,6 +0,0 @@
-namespace Common.Configuration;
-
-public interface IIgnoredDownloadsConfig
-{
-    string? IgnoredDownloadsPath { get; }
-}

code/Common/Configuration/IJobConfig.cs

@@ -1,6 +0,0 @@
-namespace Common.Configuration;
-
-public interface IJobConfig : IConfig
-{
-    bool Enabled { get; init; }
-}

code/Common/Configuration/Logging/FileLogConfig.cs

@@ -1,12 +0,0 @@
-namespace Common.Configuration.Logging;
-
-public class FileLogConfig : IConfig
-{
-    public bool Enabled { get; set; }
-    
-    public string Path { get; set; } = string.Empty;
-    
-    public void Validate()
-    {
-    }
-}

code/Common/Configuration/Logging/LoggingConfig.cs

@@ -1,18 +0,0 @@
-using Serilog.Events;
-
-namespace Common.Configuration.Logging;
-
-public class LoggingConfig : IConfig
-{
-    public const string SectionName = "Logging";
-    
-    public LogEventLevel LogLevel { get; set; }
-    
-    public bool Enhanced { get; set; }
-    
-    public FileLogConfig? File { get; set; }
-    
-    public void Validate()
-    {
-    }
-}

code/Common/Configuration/QueueCleaner/QueueCleanerConfig.cs

@@ -1,119 +0,0 @@
-using Common.CustomDataTypes;
-using Common.Exceptions;
-using Microsoft.Extensions.Configuration;
-
-namespace Common.Configuration.QueueCleaner;
-
-public sealed record QueueCleanerConfig : IJobConfig, IIgnoredDownloadsConfig
-{
-    public const string SectionName = "QueueCleaner";
-    
-    public required bool Enabled { get; init; }
-    
-    public required bool RunSequentially { get; init; }
-    
-    [ConfigurationKeyName("IGNORED_DOWNLOADS_PATH")]
-    public string? IgnoredDownloadsPath { get; init; }
-    
-    [ConfigurationKeyName("IMPORT_FAILED_MAX_STRIKES")]
-    public ushort ImportFailedMaxStrikes { get; init; }
-    
-    [ConfigurationKeyName("IMPORT_FAILED_IGNORE_PRIVATE")]
-    public bool ImportFailedIgnorePrivate { get; init; }
-    
-    [ConfigurationKeyName("IMPORT_FAILED_DELETE_PRIVATE")]
-    public bool ImportFailedDeletePrivate { get; init; }
-    
-    [ConfigurationKeyName("IMPORT_FAILED_IGNORE_PATTERNS")]
-    public IReadOnlyList<string>? ImportFailedIgnorePatterns { get; init; }
-    
-    [ConfigurationKeyName("STALLED_MAX_STRIKES")]
-    public ushort StalledMaxStrikes { get; init; }
-    
-    [ConfigurationKeyName("STALLED_RESET_STRIKES_ON_PROGRESS")]
-    public bool StalledResetStrikesOnProgress { get; init; }
-    
-    [ConfigurationKeyName("STALLED_IGNORE_PRIVATE")]
-    public bool StalledIgnorePrivate { get; init; }
-    
-    [ConfigurationKeyName("STALLED_DELETE_PRIVATE")]
-    public bool StalledDeletePrivate { get; init; }
-    
-    [ConfigurationKeyName("DOWNLOADING_METADATA_MAX_STRIKES")]
-    public ushort DownloadingMetadataMaxStrikes { get; init; }
-    
-    [ConfigurationKeyName("SLOW_MAX_STRIKES")]
-    public ushort SlowMaxStrikes { get; init; }
-    
-    [ConfigurationKeyName("SLOW_RESET_STRIKES_ON_PROGRESS")]
-    public bool SlowResetStrikesOnProgress { get; init; }
-
-    [ConfigurationKeyName("SLOW_IGNORE_PRIVATE")]
-    public bool SlowIgnorePrivate { get; init; }
-    
-    [ConfigurationKeyName("SLOW_DELETE_PRIVATE")]
-    public bool SlowDeletePrivate { get; init; }
-
-    [ConfigurationKeyName("SLOW_MIN_SPEED")]
-    public string SlowMinSpeed { get; init; } = string.Empty;
-    
-    public ByteSize SlowMinSpeedByteSize => string.IsNullOrEmpty(SlowMinSpeed) ? new ByteSize(0) : ByteSize.Parse(SlowMinSpeed);
-    
-    [ConfigurationKeyName("SLOW_MAX_TIME")]
-    public double SlowMaxTime { get; init; }
-    
-    [ConfigurationKeyName("SLOW_IGNORE_ABOVE_SIZE")]
-    public string SlowIgnoreAboveSize { get; init; } = string.Empty;
-    
-    public ByteSize? SlowIgnoreAboveSizeByteSize => string.IsNullOrEmpty(SlowIgnoreAboveSize) ? null : ByteSize.Parse(SlowIgnoreAboveSize);
-    
-    public void Validate()
-    {
-        if (ImportFailedMaxStrikes is > 0 and < 3)
-        {
-            throw new ValidationException($"the minimum value for {SectionName.ToUpperInvariant()}__IMPORT_FAILED_MAX_STRIKES must be 3");
-        }
-
-        if (StalledMaxStrikes is > 0 and < 3)
-        {
-            throw new ValidationException($"the minimum value for {SectionName.ToUpperInvariant()}__STALLED_MAX_STRIKES must be 3");
-        }
-        
-        if (DownloadingMetadataMaxStrikes is > 0 and < 3)
-        {
-            throw new ValidationException($"the minimum value for {SectionName.ToUpperInvariant()}__DOWNLOADING_METADATA_MAX_STRIKES must be 3");
-        }
-        
-        if (SlowMaxStrikes is > 0 and < 3)
-        {
-            throw new ValidationException($"the minimum value for {SectionName.ToUpperInvariant()}__SLOW_MAX_STRIKES must be 3");
-        }
-
-        if (SlowMaxStrikes > 0)
-        {
-            bool isSlowSpeedSet = !string.IsNullOrEmpty(SlowMinSpeed);
-
-            if (isSlowSpeedSet && ByteSize.TryParse(SlowMinSpeed, out _) is false)
-            {
-                throw new ValidationException($"invalid value for {SectionName.ToUpperInvariant()}__SLOW_MIN_SPEED");
-            }
-
-            if (SlowMaxTime < 0)
-            {
-                throw new ValidationException($"invalid value for {SectionName.ToUpperInvariant()}__SLOW_MAX_TIME");
-            }
-
-            if (!isSlowSpeedSet && SlowMaxTime is 0)
-            {
-                throw new ValidationException($"either {SectionName.ToUpperInvariant()}__SLOW_MIN_SPEED or {SectionName.ToUpperInvariant()}__SLOW_MAX_STRIKES must be set");
-            }
-        
-            bool isSlowIgnoreAboveSizeSet = !string.IsNullOrEmpty(SlowIgnoreAboveSize);
-        
-            if (isSlowIgnoreAboveSizeSet && ByteSize.TryParse(SlowIgnoreAboveSize, out _) is false)
-            {
-                throw new ValidationException($"invalid value for {SectionName.ToUpperInvariant()}__SLOW_IGNORE_ABOVE_SIZE");
-            }
-        }
-    }
-}

code/Common/Enums/DownloadClient.cs

@@ -1,10 +0,0 @@
-namespace Common.Enums;
-
-public enum DownloadClient
-{
-    QBittorrent,
-    Deluge,
-    Transmission,
-    None,
-    Disabled
-}

code/Dockerfile

@@ -0,0 +1,72 @@
+# Build Angular frontend
+FROM --platform=$BUILDPLATFORM node:18-alpine AS frontend-build
+WORKDIR /app
+
+# Copy package files first for better layer caching
+COPY frontend/package*.json ./
+RUN npm ci && npm install -g @angular/cli
+
+# Copy source code
+COPY frontend/ .
+
+# Build with appropriate base-href and deploy-url
+RUN npm run build
+
+# Build .NET backend
+FROM --platform=$BUILDPLATFORM mcr.microsoft.com/dotnet/sdk:9.0-bookworm-slim AS build
+ARG TARGETARCH
+ARG VERSION=0.0.1
+ARG PACKAGES_USERNAME
+ARG PACKAGES_PAT
+WORKDIR /app
+EXPOSE 11011
+
+# Copy solution and project files first for better layer caching
+# COPY backend/*.sln ./backend/
+# COPY backend/*/*.csproj ./backend/*/
+
+# Copy source code
+COPY backend/ ./backend/
+
+# Restore dependencies
+RUN dotnet nuget add source --username ${PACKAGES_USERNAME} --password ${PACKAGES_PAT} --store-password-in-clear-text --name Cleanuparr https://nuget.pkg.github.com/Cleanuparr/index.json
+
+# Build and publish
+RUN dotnet publish ./backend/Cleanuparr.Api/Cleanuparr.Api.csproj \
+    -a $TARGETARCH \
+    -c Release \
+    -o /app/publish \
+    /p:Version=${VERSION} \
+    /p:PublishSingleFile=true \
+    /p:DebugSymbols=false
+
+# Runtime stage
+FROM mcr.microsoft.com/dotnet/aspnet:9.0-bookworm-slim
+
+# Install required packages for user management and timezone support
+RUN apt-get update && apt-get install -y \
+    tzdata \
+    gosu \
+    && rm -rf /var/lib/apt/lists/*
+
+ENV PUID=1000 \
+    PGID=1000 \
+    UMASK=022 \
+    TZ=Etc/UTC \
+    HTTP_PORTS=11011
+
+# Fix FileSystemWatcher in Docker: https://github.com/dotnet/dotnet-docker/issues/3546
+ENV DOTNET_USE_POLLING_FILE_WATCHER=true
+
+WORKDIR /app
+
+# Copy backend
+COPY --from=build /app/publish .
+# Copy frontend to wwwroot
+COPY --from=frontend-build /app/dist/ui/browser ./wwwroot
+# Copy entrypoint script
+COPY entrypoint.sh /entrypoint.sh
+RUN chmod +x /entrypoint.sh
+
+ENTRYPOINT ["/entrypoint.sh"]
+CMD ["./Cleanuparr"]

code/Domain/Enums/InstanceType.cs

@@ -1,9 +0,0 @@
-namespace Domain.Enums;
-
-public enum InstanceType
-{
-    Sonarr,
-    Radarr,
-    Lidarr,
-    Readarr
-}

code/Domain/Models/Arr/Blocking/BlockedItem.cs

@@ -1,8 +0,0 @@
-namespace Domain.Models.Arr.Blocking;
-
-public record BlockedItem
-{
-    public required string Hash { get; init; }
-    
-    public required Uri InstanceUrl { get; init; }
-}

code/Domain/Models/Arr/Blocking/LidarrBlockedItem.cs

@@ -1,8 +0,0 @@
-namespace Domain.Models.Arr.Blocking;
-
-public sealed record LidarrBlockedItem : BlockedItem
-{
-    public required long AlbumId { get; init; }
-    
-    public required long ArtistId { get; init; }
-}

code/Domain/Models/Arr/Blocking/RadarrBlockedItem.cs

@@ -1,6 +0,0 @@
-namespace Domain.Models.Arr.Blocking;
-
-public sealed record RadarrBlockedItem : BlockedItem
-{
-    public required long MovieId { get; init; }
-}

code/Domain/Models/Arr/Blocking/SonarrBlockedItem.cs

@@ -1,10 +0,0 @@
-namespace Domain.Models.Arr.Blocking;
-
-public sealed record SonarrBlockedItem : BlockedItem
-{
-    public required long EpisodeId { get; init; }
-    
-    public required long SeasonNumber { get; init; }
-    
-    public required long SeriesId { get; init; }
-}

code/Executable/DependencyInjection/ConfigurationDI.cs

@@ -1,27 +0,0 @@
-using Common.Configuration.Arr;
-using Common.Configuration.ContentBlocker;
-using Common.Configuration.DownloadCleaner;
-using Common.Configuration.DownloadClient;
-using Common.Configuration.General;
-using Common.Configuration.Logging;
-using Common.Configuration.QueueCleaner;
-
-namespace Executable.DependencyInjection;
-
-public static class ConfigurationDI
-{
-    public static IServiceCollection AddConfiguration(this IServiceCollection services, IConfiguration configuration) =>
-        services
-            .Configure<DryRunConfig>(configuration)
-            .Configure<QueueCleanerConfig>(configuration.GetSection(QueueCleanerConfig.SectionName))
-            .Configure<ContentBlockerConfig>(configuration.GetSection(ContentBlockerConfig.SectionName))
-            .Configure<DownloadCleanerConfig>(configuration.GetSection(DownloadCleanerConfig.SectionName))
-            .Configure<DownloadClientConfig>(configuration)
-            .Configure<QBitConfig>(configuration.GetSection(QBitConfig.SectionName))
-            .Configure<DelugeConfig>(configuration.GetSection(DelugeConfig.SectionName))
-            .Configure<TransmissionConfig>(configuration.GetSection(TransmissionConfig.SectionName))
-            .Configure<SonarrConfig>(configuration.GetSection(SonarrConfig.SectionName))
-            .Configure<RadarrConfig>(configuration.GetSection(RadarrConfig.SectionName))
-            .Configure<LidarrConfig>(configuration.GetSection(LidarrConfig.SectionName))
-            .Configure<LoggingConfig>(configuration.GetSection(LoggingConfig.SectionName));
-}

code/Executable/DependencyInjection/LoggingDI.cs

@@ -1,81 +0,0 @@
-using Common.Configuration.Logging;
-using Domain.Enums;
-using Infrastructure.Verticals.ContentBlocker;
-using Infrastructure.Verticals.DownloadCleaner;
-using Infrastructure.Verticals.QueueCleaner;
-using Serilog;
-using Serilog.Events;
-using Serilog.Templates;
-using Serilog.Templates.Themes;
-
-namespace Executable.DependencyInjection;
-
-public static class LoggingDI
-{
-    public static ILoggingBuilder AddLogging(this ILoggingBuilder builder, IConfiguration configuration)
-    {
-        LoggingConfig? config = configuration.GetSection(LoggingConfig.SectionName).Get<LoggingConfig>();
-
-        if (!string.IsNullOrEmpty(config?.File?.Path) && !Directory.Exists(config.File.Path))
-        {
-            try
-            {
-                Directory.CreateDirectory(config.File.Path);
-            }
-            catch (Exception exception)
-            {
-                throw new Exception($"log file path is not a valid directory | {config.File.Path}", exception);
-            }
-        }
-        
-        LoggerConfiguration logConfig = new();
-        const string jobNameTemplate = "{#if JobName is not null} {Concat('[',JobName,']'),JOB_PAD}{#end}";
-        const string instanceNameTemplate = "{#if InstanceName is not null} {Concat('[',InstanceName,']'),ARR_PAD}{#end}";
-        const string consoleOutputTemplate = $"[{{@t:yyyy-MM-dd HH:mm:ss.fff}} {{@l:u3}}]{jobNameTemplate}{instanceNameTemplate} {{@m}}\n{{@x}}";
-        const string fileOutputTemplate = $"{{@t:yyyy-MM-dd HH:mm:ss.fff zzz}} [{{@l:u3}}]{jobNameTemplate}{instanceNameTemplate} {{@m:lj}}\n{{@x}}";
-        LogEventLevel level = LogEventLevel.Information;
-        List<string> names = [nameof(ContentBlocker), nameof(QueueCleaner), nameof(DownloadCleaner)];
-        int jobPadding = names.Max(x => x.Length) + 2;
-        names = [InstanceType.Sonarr.ToString(), InstanceType.Radarr.ToString(), InstanceType.Lidarr.ToString()];
-        int arrPadding = names.Max(x => x.Length) + 2;
-
-        string consoleTemplate = consoleOutputTemplate
-            .Replace("JOB_PAD", jobPadding.ToString())
-            .Replace("ARR_PAD", arrPadding.ToString());
-        string fileTemplate = fileOutputTemplate
-            .Replace("JOB_PAD", jobPadding.ToString())
-            .Replace("ARR_PAD", arrPadding.ToString());
-
-        if (config is not null)
-        {
-            level = config.LogLevel;
-
-            if (config.File?.Enabled is true)
-            {
-                logConfig.WriteTo.File(
-                    path: Path.Combine(config.File.Path, "cleanuperr-.txt"),
-                    formatter: new ExpressionTemplate(fileTemplate),
-                    fileSizeLimitBytes: 10L * 1024 * 1024,
-                    rollingInterval: RollingInterval.Day,
-                    rollOnFileSizeLimit: true
-                );
-            }
-        }
-
-        Log.Logger = logConfig
-            .MinimumLevel.Is(level)
-            .MinimumLevel.Override("MassTransit", LogEventLevel.Warning)
-            .MinimumLevel.Override("Microsoft.Hosting.Lifetime", LogEventLevel.Information)
-            .MinimumLevel.Override("Microsoft.Extensions.Http", LogEventLevel.Warning)
-            .MinimumLevel.Override("Quartz", LogEventLevel.Warning)
-            .MinimumLevel.Override("System.Net.Http.HttpClient", LogEventLevel.Error)
-            .WriteTo.Console(new ExpressionTemplate(consoleTemplate))
-            .Enrich.FromLogContext()
-            .Enrich.WithProperty("ApplicationName", "cleanuperr")
-            .CreateLogger();
-        
-        return builder
-            .ClearProviders()
-            .AddSerilog();
-    }
-}

code/Executable/DependencyInjection/MainDI.cs

@@ -1,97 +0,0 @@
-using System.Net;
-using Common.Configuration.General;
-using Common.Helpers;
-using Infrastructure.Verticals.DownloadClient.Deluge;
-using Infrastructure.Verticals.Notifications.Consumers;
-using Infrastructure.Verticals.Notifications.Models;
-using MassTransit;
-using Polly;
-using Polly.Extensions.Http;
-
-namespace Executable.DependencyInjection;
-
-public static class MainDI
-{
-    public static IServiceCollection AddInfrastructure(this IServiceCollection services, IConfiguration configuration) =>
-        services
-            .AddLogging(builder => builder.ClearProviders().AddConsole())
-            .AddHttpClients(configuration)
-            .AddConfiguration(configuration)
-            .AddMemoryCache(options => {
-                options.ExpirationScanFrequency = TimeSpan.FromMinutes(1);
-            })
-            .AddServices()
-            .AddQuartzServices(configuration)
-            .AddNotifications(configuration)
-            .AddMassTransit(config =>
-            {
-                config.AddConsumer<NotificationConsumer<FailedImportStrikeNotification>>();
-                config.AddConsumer<NotificationConsumer<StalledStrikeNotification>>();
-                config.AddConsumer<NotificationConsumer<SlowStrikeNotification>>();
-                config.AddConsumer<NotificationConsumer<QueueItemDeletedNotification>>();
-                config.AddConsumer<NotificationConsumer<DownloadCleanedNotification>>();
-                config.AddConsumer<NotificationConsumer<CategoryChangedNotification>>();
-
-                config.UsingInMemory((context, cfg) =>
-                {
-                    cfg.ReceiveEndpoint("notification-queue", e =>
-                    {
-                        e.ConfigureConsumer<NotificationConsumer<FailedImportStrikeNotification>>(context);
-                        e.ConfigureConsumer<NotificationConsumer<StalledStrikeNotification>>(context);
-                        e.ConfigureConsumer<NotificationConsumer<SlowStrikeNotification>>(context);
-                        e.ConfigureConsumer<NotificationConsumer<QueueItemDeletedNotification>>(context);
-                        e.ConfigureConsumer<NotificationConsumer<DownloadCleanedNotification>>(context);
-                        e.ConfigureConsumer<NotificationConsumer<CategoryChangedNotification>>(context);
-                        e.ConcurrentMessageLimit = 1;
-                        e.PrefetchCount = 1;
-                    });
-                });
-            });
-    
-    private static IServiceCollection AddHttpClients(this IServiceCollection services, IConfiguration configuration)
-    {
-        // add default HttpClient
-        services.AddHttpClient();
-        
-        HttpConfig config = configuration.Get<HttpConfig>() ?? new();
-        config.Validate();
-
-        // add retry HttpClient
-        services
-            .AddHttpClient(Constants.HttpClientWithRetryName, x =>
-            {
-                x.Timeout = TimeSpan.FromSeconds(config.Timeout);
-            })
-            .AddRetryPolicyHandler(config);
-
-        // add Deluge HttpClient
-        services
-            .AddHttpClient(nameof(DelugeService), x =>
-            {
-                x.Timeout = TimeSpan.FromSeconds(config.Timeout);
-            })
-            .ConfigurePrimaryHttpMessageHandler(_ =>
-            {
-                return new HttpClientHandler
-                {
-                    AllowAutoRedirect = true,
-                    UseCookies = true,
-                    CookieContainer = new CookieContainer(),
-                    AutomaticDecompression = DecompressionMethods.GZip | DecompressionMethods.Deflate,
-                    ServerCertificateCustomValidationCallback = (_, _, _, _) => true
-                };
-            })
-            .AddRetryPolicyHandler(config);
-
-        return services;
-    }
-
-    private static IHttpClientBuilder AddRetryPolicyHandler(this IHttpClientBuilder builder, HttpConfig config) =>
-        builder.AddPolicyHandler(
-            HttpPolicyExtensions
-                .HandleTransientHttpError()
-                // do not retry on Unauthorized
-                .OrResult(response => !response.IsSuccessStatusCode && response.StatusCode != HttpStatusCode.Unauthorized)
-                .WaitAndRetryAsync(config.MaxRetries, retryAttempt => TimeSpan.FromSeconds(Math.Pow(2, retryAttempt)))
-        );
-}

code/Executable/DependencyInjection/QuartzDI.cs

@@ -1,144 +0,0 @@
-using Common.Configuration;
-using Common.Configuration.ContentBlocker;
-using Common.Configuration.DownloadCleaner;
-using Common.Configuration.General;
-using Common.Configuration.QueueCleaner;
-using Common.Helpers;
-using Executable.Jobs;
-using Infrastructure.Verticals.ContentBlocker;
-using Infrastructure.Verticals.DownloadCleaner;
-using Infrastructure.Verticals.Jobs;
-using Infrastructure.Verticals.QueueCleaner;
-using Quartz;
-using Quartz.Spi;
-
-namespace Executable.DependencyInjection;
-
-public static class QuartzDI
-{
-    public static IServiceCollection AddQuartzServices(this IServiceCollection services, IConfiguration configuration) =>
-        services
-            .AddQuartz(q =>
-            {
-                TriggersConfig? config = configuration
-                    .GetRequiredSection(TriggersConfig.SectionName)
-                    .Get<TriggersConfig>();
-
-                if (config is null)
-                {
-                    throw new NullReferenceException("triggers configuration is null");
-                }
-
-                q.AddJobs(configuration, config);
-            })
-            .AddQuartzHostedService(opt =>
-            {
-                opt.WaitForJobsToComplete = true;
-            });
-
-    private static void AddJobs(
-        this IServiceCollectionQuartzConfigurator q,
-        IConfiguration configuration,
-        TriggersConfig triggersConfig
-    )
-    {
-        ContentBlockerConfig? contentBlockerConfig = configuration
-            .GetRequiredSection(ContentBlockerConfig.SectionName)
-            .Get<ContentBlockerConfig>();
-        
-        q.AddJob<ContentBlocker>(contentBlockerConfig, triggersConfig.ContentBlocker);
-        
-        QueueCleanerConfig? queueCleanerConfig = configuration
-            .GetRequiredSection(QueueCleanerConfig.SectionName)
-            .Get<QueueCleanerConfig>();
-
-        if (contentBlockerConfig?.Enabled is true && queueCleanerConfig is { Enabled: true, RunSequentially: true })
-        {
-            q.AddJob<QueueCleaner>(queueCleanerConfig, string.Empty);
-            q.AddJobListener(new JobChainingListener(nameof(ContentBlocker), nameof(QueueCleaner)));
-        }
-        else
-        {
-            q.AddJob<QueueCleaner>(queueCleanerConfig, triggersConfig.QueueCleaner);
-        }
-        
-        DownloadCleanerConfig? downloadCleanerConfig = configuration
-            .GetRequiredSection(DownloadCleanerConfig.SectionName)
-            .Get<DownloadCleanerConfig>();
-
-        q.AddJob<DownloadCleaner>(downloadCleanerConfig, triggersConfig.DownloadCleaner);
-    }
-    
-    private static void AddJob<T>(
-        this IServiceCollectionQuartzConfigurator q,
-        IJobConfig? config,
-        string trigger
-    ) where T: GenericHandler
-    {
-        string typeName = typeof(T).Name;
-        
-        if (config is null)
-        {
-            throw new NullReferenceException($"{typeName} configuration is null");
-        }
-
-        if (!config.Enabled)
-        {
-            return;
-        }
-
-        bool hasTrigger = trigger.Length > 0;
-
-        q.AddJob<GenericJob<T>>(opts =>
-        {
-            opts.WithIdentity(typeName);
-
-            if (!hasTrigger)
-            {
-                // jobs with no triggers need to be stored durably
-                opts.StoreDurably();
-            }
-        });
-
-        // skip empty triggers
-        if (!hasTrigger)
-        {
-            return;
-        }
-        
-        IOperableTrigger triggerObj = (IOperableTrigger)TriggerBuilder.Create()
-            .WithIdentity("ExampleTrigger")
-            .StartNow()
-            .WithCronSchedule(trigger)
-            .Build();
-
-        IReadOnlyList<DateTimeOffset> nextFireTimes = TriggerUtils.ComputeFireTimes(triggerObj, null, 2);
-        TimeSpan triggerValue = nextFireTimes[1] - nextFireTimes[0];
-        
-        if (triggerValue > Constants.TriggerMaxLimit)
-        {
-            throw new Exception($"{trigger} should have a fire time of maximum {Constants.TriggerMaxLimit.TotalHours} hours");
-        }
-
-        if (triggerValue > StaticConfiguration.TriggerValue)
-        {
-            StaticConfiguration.TriggerValue = triggerValue;
-        }
-        
-        q.AddTrigger(opts =>
-        {
-            opts.ForJob(typeName)
-                .WithIdentity($"{typeName}-trigger")
-                .WithCronSchedule(trigger, x =>x.WithMisfireHandlingInstructionDoNothing())
-                .StartNow();
-        });
-        
-        // Startup trigger
-        q.AddTrigger(opts =>
-        {
-            opts.ForJob(typeName)
-                .WithIdentity($"{typeName}-startup-trigger")
-                .StartNow();
-        });
-    }
-}

code/Executable/DependencyInjection/ServicesDI.cs

@@ -1,45 +0,0 @@
-using Common.Configuration.ContentBlocker;
-using Common.Configuration.DownloadCleaner;
-using Common.Configuration.QueueCleaner;
-using Infrastructure.Interceptors;
-using Infrastructure.Providers;
-using Infrastructure.Verticals.Arr;
-using Infrastructure.Verticals.ContentBlocker;
-using Infrastructure.Verticals.DownloadCleaner;
-using Infrastructure.Verticals.DownloadClient;
-using Infrastructure.Verticals.DownloadClient.Deluge;
-using Infrastructure.Verticals.DownloadClient.QBittorrent;
-using Infrastructure.Verticals.DownloadClient.Transmission;
-using Infrastructure.Verticals.Files;
-using Infrastructure.Verticals.ItemStriker;
-using Infrastructure.Verticals.QueueCleaner;
-
-namespace Executable.DependencyInjection;
-
-public static class ServicesDI
-{
-    public static IServiceCollection AddServices(this IServiceCollection services) =>
-        services
-            .AddTransient<IDryRunInterceptor, DryRunInterceptor>()
-            .AddTransient<SonarrClient>()
-            .AddTransient<RadarrClient>()
-            .AddTransient<LidarrClient>()
-            .AddTransient<QueueCleaner>()
-            .AddTransient<ContentBlocker>()
-            .AddTransient<DownloadCleaner>()
-            .AddTransient<IFilenameEvaluator, FilenameEvaluator>()
-            .AddTransient<IHardLinkFileService, HardLinkFileService>()
-            .AddTransient<UnixHardLinkFileService>()
-            .AddTransient<WindowsHardLinkFileService>()
-            .AddTransient<DummyDownloadService>()
-            .AddTransient<QBitService>()
-            .AddTransient<DelugeService>()
-            .AddTransient<TransmissionService>()
-            .AddTransient<ArrQueueIterator>()
-            .AddTransient<DownloadServiceFactory>()
-            .AddTransient<IStriker, Striker>()
-            .AddSingleton<BlocklistProvider>()
-            .AddSingleton<IgnoredDownloadsProvider<QueueCleanerConfig>>()
-            .AddSingleton<IgnoredDownloadsProvider<ContentBlockerConfig>>()
-            .AddSingleton<IgnoredDownloadsProvider<DownloadCleanerConfig>>();
-}

code/Executable/Executable.csproj

@@ -1,31 +0,0 @@
-<Project Sdk="Microsoft.NET.Sdk.Worker">
-
-    <PropertyGroup>
-        <AssemblyName>cleanuperr</AssemblyName>
-        <TargetFramework>net9.0</TargetFramework>
-        <Version Condition="'$(Version)' == ''">0.0.1</Version>
-        <Nullable>enable</Nullable>
-        <ImplicitUsings>enable</ImplicitUsings>
-        <UserSecretsId>dotnet-Executable-6108b2ba-f035-47bc-addf-aaf5e20da4b8</UserSecretsId>
-    </PropertyGroup>
-
-    <ItemGroup>
-        <PackageReference Include="Microsoft.Extensions.Hosting" Version="9.0.2" />
-        <PackageReference Include="Microsoft.Extensions.Http" Version="9.0.2" />
-        <PackageReference Include="Microsoft.Extensions.Http.Polly" Version="9.0.2" />
-        <PackageReference Include="Quartz" Version="3.13.1" />
-        <PackageReference Include="Quartz.Extensions.DependencyInjection" Version="3.13.1" />
-        <PackageReference Include="Quartz.Extensions.Hosting" Version="3.13.1" />
-        <PackageReference Include="Serilog" Version="4.2.0" />
-        <PackageReference Include="Serilog.Expressions" Version="5.0.0" />
-        <PackageReference Include="Serilog.Extensions.Hosting" Version="9.0.0" />
-        <PackageReference Include="Serilog.Settings.Configuration" Version="9.0.0" />
-        <PackageReference Include="Serilog.Sinks.Console" Version="6.0.0" />
-        <PackageReference Include="Serilog.Sinks.File" Version="6.0.0" />
-    </ItemGroup>
-
-    <ItemGroup>
-      <ProjectReference Include="..\Common\Common.csproj" />
-      <ProjectReference Include="..\Infrastructure\Infrastructure.csproj" />
-    </ItemGroup>
-</Project>

code/Executable/HostExtensions.cs

@@ -1,23 +0,0 @@
-using System.Reflection;
-
-namespace Executable;
-
-public static class HostExtensions
-{
-    public static IHost Init(this IHost host)
-    {
-        ILogger<Program> logger = host.Services.GetRequiredService<ILogger<Program>>();
-
-        Version? version = Assembly.GetExecutingAssembly().GetName().Version;
-
-        logger.LogInformation(
-            version is null
-                ? "cleanuperr version not detected"
-                : $"cleanuperr v{version.Major}.{version.Minor}.{version.Build}"
-        );
-        
-        logger.LogInformation("timezone: {tz}", TimeZoneInfo.Local.DisplayName);
-        
-        return host;
-    }
-}

code/Executable/Program.cs

@@ -1,12 +0,0 @@
-using Executable;
-using Executable.DependencyInjection;
-
-var builder = Host.CreateApplicationBuilder(args);
-
-builder.Services.AddInfrastructure(builder.Configuration);
-builder.Logging.AddLogging(builder.Configuration);
-
-var host = builder.Build();
-host.Init();
-
-host.Run();

code/Executable/appsettings.Development.json

@@ -1,144 +0,0 @@
-{
-  "DRY_RUN": true,
-  "HTTP_MAX_RETRIES": 0,
-  "HTTP_TIMEOUT": 10,
-  "Logging": {
-    "LogLevel": "Verbose",
-    "Enhanced": true,
-    "File": {
-      "Enabled": false,
-      "Path": ""
-    }
-  },
-  "Triggers": {
-    "QueueCleaner": "0/10 * * * * ?",
-    "ContentBlocker": "0/10 * * * * ?",
-    "DownloadCleaner": "0/10 * * * * ?"
-  },
-  "ContentBlocker": {
-    "Enabled": true,
-    "IGNORE_PRIVATE": true,
-    "DELETE_PRIVATE": false,
-    "IGNORED_DOWNLOADS_PATH": "../test/data/cleanuperr/ignored_downloads"
-  },
-  "QueueCleaner": {
-    "Enabled": true,
-    "RunSequentially": true,
-    "IGNORED_DOWNLOADS_PATH": "../test/data/cleanuperr/ignored_downloads",
-    "IMPORT_FAILED_MAX_STRIKES": 3,
-    "IMPORT_FAILED_IGNORE_PRIVATE": true,
-    "IMPORT_FAILED_DELETE_PRIVATE": false,
-    "IMPORT_FAILED_IGNORE_PATTERNS": [
-      "file is a sample"
-    ],
-    "STALLED_MAX_STRIKES": 3,
-    "STALLED_RESET_STRIKES_ON_PROGRESS": true,
-    "STALLED_IGNORE_PRIVATE": true,
-    "STALLED_DELETE_PRIVATE": false,
-    "DOWNLOADING_METADATA_MAX_STRIKES": 3,
-    "SLOW_MAX_STRIKES": 5,
-    "SLOW_RESET_STRIKES_ON_PROGRESS": true,
-    "SLOW_IGNORE_PRIVATE": false,
-    "SLOW_DELETE_PRIVATE": false,
-    "SLOW_MIN_SPEED": "1MB",
-    "SLOW_MAX_TIME": 20,
-    "SLOW_IGNORE_ABOVE_SIZE": "4GB"
-  },
-  "DownloadCleaner": {
-    "Enabled": false,
-    "DELETE_PRIVATE": false,
-    "CATEGORIES": [
-      {
-        "Name": "tv-sonarr",
-        "MAX_RATIO": -1,
-        "MIN_SEED_TIME": 0,
-        "MAX_SEED_TIME": 240
-      }
-    ],
-    "UNLINKED_TARGET_CATEGORY": "cleanuperr-unlinked",
-    "UNLINKED_IGNORED_ROOT_DIR": "",
-    "UNLINKED_CATEGORIES": [
-      "tv-sonarr",
-      "radarr"
-    ],
-    "IGNORED_DOWNLOADS_PATH": "../test/data/cleanuperr/ignored_downloads"
-  },
-  "DOWNLOAD_CLIENT": "qbittorrent",
-  "qBittorrent": {
-    "Url": "http://localhost:8080",
-    "URL_BASE": "",
-    "Username": "test",
-    "Password": "testing"
-  },
-  "Deluge": {
-    "Url": "http://localhost:8112",
-    "URL_BASE": "",
-    "Password": "testing"
-  },
-  "Transmission": {
-    "Url": "http://localhost:9091",
-    "URL_BASE": "transmission",
-    "Username": "test",
-    "Password": "testing"
-  },
-  "Sonarr": {
-    "Enabled": true,
-    "SearchType": "Episode",
-    "Block": {
-      "Type": "blacklist",
-      "Path": "https://raw.githubusercontent.com/flmorg/cleanuperr/refs/heads/main/blacklist"
-    },
-    "Instances": [
-      {
-        "Url": "http://localhost:8989",
-        "ApiKey": "425d1e713f0c405cbbf359ac0502c1f4"
-      }
-    ]
-  },
-  "Radarr": {
-    "Enabled": true,
-    "Block": {
-      "Type": "blacklist",
-      "Path": "https://raw.githubusercontent.com/flmorg/cleanuperr/refs/heads/main/blacklist"
-    },
-    "Instances": [
-      {
-        "Url": "http://localhost:7878",
-        "ApiKey": "8b7454f668e54c5b8f44f56f93969761"
-      }
-    ]
-  },
-  "Lidarr": {
-    "Enabled": true,
-    "Block": {
-      "Type": "blacklist",
-      "Path": "https://raw.githubusercontent.com/flmorg/cleanuperr/refs/heads/main/blacklist"
-    },
-    "Instances": [
-      {
-        "Url": "http://localhost:8686",
-        "ApiKey": "7f677cfdc074414397af53dd633860c5"
-      }
-    ]
-  },
-  "Notifiarr": {
-    "ON_IMPORT_FAILED_STRIKE": true,
-    "ON_STALLED_STRIKE": true,
-    "ON_SLOW_STRIKE": true,
-    "ON_QUEUE_ITEM_DELETED": true,
-    "ON_DOWNLOAD_CLEANED": true,
-    "ON_CATEGORY_CHANGED": true,
-    "API_KEY": "",
-    "CHANNEL_ID": ""
-  },
-  "Apprise": {
-    "ON_IMPORT_FAILED_STRIKE": true,
-    "ON_STALLED_STRIKE": true,
-    "ON_SLOW_STRIKE": true,
-    "ON_QUEUE_ITEM_DELETED": true,
-    "ON_DOWNLOAD_CLEANED": true,
-    "ON_CATEGORY_CHANGED": true,
-    "URL": "http://localhost:8000",
-    "KEY": ""
-  }
-}

code/Executable/appsettings.json

@@ -1,124 +0,0 @@
-{
-  "DRY_RUN": false,
-  "HTTP_MAX_RETRIES": 0,
-  "HTTP_TIMEOUT": 100,
-  "Logging": {
-    "LogLevel": "Information",
-    "Enhanced": true,
-    "File": {
-      "Enabled": false,
-      "Path": ""
-    }
-  },
-  "Triggers": {
-    "QueueCleaner": "0 0/5 * * * ?",
-    "ContentBlocker": "0 0/5 * * * ?",
-    "DownloadCleaner": "0 0 * * * ?"
-  },
-  "ContentBlocker": {
-    "Enabled": false,
-    "IGNORE_PRIVATE": false,
-    "IGNORED_DOWNLOADS_PATH": ""
-  },
-  "QueueCleaner": {
-    "Enabled": true,
-    "RunSequentially": true,
-    "IGNORED_DOWNLOADS_PATH": "",
-    "IMPORT_FAILED_MAX_STRIKES": 0,
-    "IMPORT_FAILED_IGNORE_PRIVATE": false,
-    "IMPORT_FAILED_DELETE_PRIVATE": false,
-    "IMPORT_FAILED_IGNORE_PATTERNS": [],
-    "STALLED_MAX_STRIKES": 0,
-    "STALLED_RESET_STRIKES_ON_PROGRESS": false,
-    "STALLED_IGNORE_PRIVATE": false,
-    "STALLED_DELETE_PRIVATE": false,
-    "DOWNLOADING_METADATA_MAX_STRIKES": 0
-  },
-  "DownloadCleaner": {
-    "Enabled": false,
-    "DELETE_PRIVATE": false,
-    "CATEGORIES": [],
-    "UNLINKED_TARGET_CATEGORY": "cleanuperr-unlinked",
-    "UNLINKED_IGNORED_ROOT_DIR": "",
-    "UNLINKED_CATEGORIES": [],
-    "IGNORED_DOWNLOADS_PATH": ""
-  },
-  "DOWNLOAD_CLIENT": "none",
-  "qBittorrent": {
-    "Url": "http://localhost:8080",
-    "URL_BASE": "",
-    "Username": "",
-    "Password": ""
-  },
-  "Deluge": {
-    "Url": "http://localhost:8112",
-    "URL_BASE": "",
-    "Password": "testing"
-  },
-  "Transmission": {
-    "Url": "http://localhost:9091",
-    "URL_BASE": "transmission",
-    "Username": "test",
-    "Password": "testing"
-  },
-  "Sonarr": {
-    "Enabled": false,
-    "SearchType": "Episode",
-    "Block": {
-      "Type": "blacklist",
-      "Path": ""
-    },
-    "Instances": [
-      {
-        "Url": "http://localhost:8989",
-        "ApiKey": ""
-      }
-    ]
-  },
-  "Radarr": {
-    "Enabled": false,
-    "Block": {
-      "Type": "blacklist",
-      "Path": ""
-    },
-    "Instances": [
-      {
-        "Url": "http://localhost:7878",
-        "ApiKey": ""
-      }
-    ]
-  },
-  "Lidarr": {
-    "Enabled": false,
-    "Block": {
-      "Type": "blacklist",
-      "Path": ""
-    },
-    "Instances": [
-      {
-        "Url": "http://localhost:8686",
-        "ApiKey": ""
-      }
-    ]
-  },
-  "Notifiarr": {
-    "ON_IMPORT_FAILED_STRIKE": false,
-    "ON_STALLED_STRIKE": false,
-    "ON_SLOW_STRIKE": false,
-    "ON_QUEUE_ITEM_DELETED": false,
-    "ON_DOWNLOAD_CLEANED": false,
-    "ON_CATEGORY_CHANGED": false,
-    "API_KEY": "",
-    "CHANNEL_ID": ""
-  },
-  "Apprise": {
-    "ON_IMPORT_FAILED_STRIKE": false,
-    "ON_STALLED_STRIKE": false,
-    "ON_SLOW_STRIKE": false,
-    "ON_QUEUE_ITEM_DELETED": false,
-    "ON_DOWNLOAD_CLEANED": false,
-    "ON_CATEGORY_CHANGED": false,
-    "URL": "",
-    "KEY": ""
-  }
-}

code/Infrastructure.Tests/Verticals/DownloadClient/DownloadServiceFixture.cs

@@ -1,80 +0,0 @@
-using Common.Configuration.ContentBlocker;
-using Common.Configuration.DownloadCleaner;
-using Common.Configuration.QueueCleaner;
-using Infrastructure.Interceptors;
-using Infrastructure.Verticals.ContentBlocker;
-using Infrastructure.Verticals.DownloadClient;
-using Infrastructure.Verticals.Files;
-using Infrastructure.Verticals.ItemStriker;
-using Infrastructure.Verticals.Notifications;
-using Microsoft.Extensions.Caching.Memory;
-using Microsoft.Extensions.Logging;
-using Microsoft.Extensions.Options;
-using NSubstitute;
-
-namespace Infrastructure.Tests.Verticals.DownloadClient;
-
-public class DownloadServiceFixture : IDisposable
-{
-    public ILogger<DownloadService> Logger { get; set; }
-    public IMemoryCache Cache { get; set; }
-    public IStriker Striker { get; set; }
-
-    public DownloadServiceFixture()
-    {
-        Logger = Substitute.For<ILogger<DownloadService>>();
-        Cache = Substitute.For<IMemoryCache>();
-        Striker = Substitute.For<IStriker>();
-    }
-
-    public TestDownloadService CreateSut(
-        QueueCleanerConfig? queueCleanerConfig = null,
-        ContentBlockerConfig? contentBlockerConfig = null
-    )
-    {
-        queueCleanerConfig ??= new QueueCleanerConfig
-        {
-            Enabled = true,
-            RunSequentially = true,
-            StalledResetStrikesOnProgress = true,
-            StalledMaxStrikes = 3
-        };
-
-        var queueCleanerOptions = Substitute.For<IOptions<QueueCleanerConfig>>();
-        queueCleanerOptions.Value.Returns(queueCleanerConfig);
-
-        contentBlockerConfig ??= new ContentBlockerConfig
-        {
-            Enabled = true
-        };
-        
-        var contentBlockerOptions = Substitute.For<IOptions<ContentBlockerConfig>>();
-        contentBlockerOptions.Value.Returns(contentBlockerConfig);
-
-        var downloadCleanerOptions = Substitute.For<IOptions<DownloadCleanerConfig>>();
-        downloadCleanerOptions.Value.Returns(new DownloadCleanerConfig());
-
-        var filenameEvaluator = Substitute.For<IFilenameEvaluator>();
-        var notifier = Substitute.For<INotificationPublisher>();
-        var dryRunInterceptor = Substitute.For<IDryRunInterceptor>();
-        var hardlinkFileService = Substitute.For<IHardLinkFileService>();
-
-        return new TestDownloadService(
-            Logger,
-            queueCleanerOptions,
-            contentBlockerOptions,
-            downloadCleanerOptions,
-            Cache,
-            filenameEvaluator,
-            Striker,
-            notifier,
-            dryRunInterceptor,
-            hardlinkFileService
-        );
-    }
-
-    public void Dispose()
-    {
-        // Cleanup if needed
-    }
-}

code/Infrastructure.Tests/Verticals/DownloadClient/DownloadServiceTests.cs

@@ -1,214 +0,0 @@
-using Common.Configuration.DownloadCleaner;
-using Domain.Enums;
-using Domain.Models.Cache;
-using Infrastructure.Helpers;
-using Infrastructure.Verticals.Context;
-using Infrastructure.Verticals.DownloadClient;
-using NSubstitute;
-using NSubstitute.ClearExtensions;
-using Shouldly;
-
-namespace Infrastructure.Tests.Verticals.DownloadClient;
-
-public class DownloadServiceTests : IClassFixture<DownloadServiceFixture>
-{
-    private readonly DownloadServiceFixture _fixture;
-
-    public DownloadServiceTests(DownloadServiceFixture fixture)
-    {
-        _fixture = fixture;
-        _fixture.Cache.ClearSubstitute();
-        _fixture.Striker.ClearSubstitute();
-    }
-
-    public class ResetStrikesOnProgressTests : DownloadServiceTests
-    {
-        public ResetStrikesOnProgressTests(DownloadServiceFixture fixture) : base(fixture)
-        {
-        }
-
-        [Fact]
-        public void WhenStalledStrikeDisabled_ShouldNotResetStrikes()
-        {
-            // Arrange
-            TestDownloadService sut = _fixture.CreateSut(queueCleanerConfig: new()
-            {
-                Enabled = true,
-                RunSequentially = true,
-                StalledResetStrikesOnProgress = false,
-            });
-
-            // Act
-            sut.ResetStalledStrikesOnProgress("test-hash", 100);
-
-            // Assert
-            _fixture.Cache.ReceivedCalls().ShouldBeEmpty();
-        }
-        
-        [Fact]
-        public void WhenProgressMade_ShouldResetStrikes()
-        {
-            // Arrange
-            const string hash = "test-hash";
-            StalledCacheItem stalledCacheItem = new StalledCacheItem { Downloaded = 100 };
-            
-            _fixture.Cache.TryGetValue(Arg.Any<object>(), out Arg.Any<object?>())
-                .Returns(x =>
-                {
-                    x[1] = stalledCacheItem;
-                    return true;
-                });
-            
-            TestDownloadService sut = _fixture.CreateSut();
-
-            // Act
-            sut.ResetStalledStrikesOnProgress(hash, 200);
-
-            // Assert
-            _fixture.Cache.Received(1).Remove(CacheKeys.Strike(StrikeType.Stalled, hash));
-        }
-
-        [Fact]
-        public void WhenNoProgress_ShouldNotResetStrikes()
-        {
-            // Arrange
-            const string hash = "test-hash";
-            StalledCacheItem stalledCacheItem = new StalledCacheItem { Downloaded = 200 };
-            
-            _fixture.Cache
-                .TryGetValue(Arg.Any<object>(), out Arg.Any<object?>())
-                .Returns(x =>
-                {
-                    x[1] = stalledCacheItem;
-                    return true;
-                });
-            
-            TestDownloadService sut = _fixture.CreateSut();
-
-            // Act
-            sut.ResetStalledStrikesOnProgress(hash, 100);
-
-            // Assert
-            _fixture.Cache.DidNotReceive().Remove(Arg.Any<object>());
-        }
-    }
-
-    public class StrikeAndCheckLimitTests : DownloadServiceTests
-    {
-        public StrikeAndCheckLimitTests(DownloadServiceFixture fixture) : base(fixture)
-        {
-        }
-    }
-
-    public class ShouldCleanDownloadTests : DownloadServiceTests
-    {
-        public ShouldCleanDownloadTests(DownloadServiceFixture fixture) : base(fixture) 
-        {
-            ContextProvider.Set("downloadName", "test-download");
-        }
-
-        [Fact]
-        public void WhenRatioAndMinSeedTimeReached_ShouldReturnTrue()
-        {
-            // Arrange
-            CleanCategory category = new()
-            {
-                Name = "test",
-                MaxRatio = 1.0,
-                MinSeedTime = 1,
-                MaxSeedTime = -1
-            };
-            const double ratio = 1.5;
-            TimeSpan seedingTime = TimeSpan.FromHours(2);
-            
-            TestDownloadService sut = _fixture.CreateSut();
-
-            // Act
-            var result = sut.ShouldCleanDownload(ratio, seedingTime, category);
-
-            // Assert
-            result.ShouldSatisfyAllConditions(
-                () => result.ShouldClean.ShouldBeTrue(),
-                () => result.Reason.ShouldBe(CleanReason.MaxRatioReached)
-            );
-        }
-
-        [Fact]
-        public void WhenRatioReachedAndMinSeedTimeNotReached_ShouldReturnFalse()
-        {
-            // Arrange
-            CleanCategory category = new()
-            {
-                Name = "test",
-                MaxRatio = 1.0,
-                MinSeedTime = 3,
-                MaxSeedTime = -1
-            };
-            const double ratio = 1.5;
-            TimeSpan seedingTime = TimeSpan.FromHours(2);
-            
-            TestDownloadService sut = _fixture.CreateSut();
-
-            // Act
-            var result = sut.ShouldCleanDownload(ratio, seedingTime, category);
-
-            // Assert
-            result.ShouldSatisfyAllConditions(
-                () => result.ShouldClean.ShouldBeFalse(),
-                () => result.Reason.ShouldBe(CleanReason.None)
-            );
-        }
-
-        [Fact]
-        public void WhenMaxSeedTimeReached_ShouldReturnTrue()
-        {
-            // Arrange
-            CleanCategory category = new()
-            {
-                Name = "test",
-                MaxRatio = -1,
-                MinSeedTime = 0,
-                MaxSeedTime = 1
-            };
-            const double ratio = 0.5;
-            TimeSpan seedingTime = TimeSpan.FromHours(2);
-            
-            TestDownloadService sut = _fixture.CreateSut();
-
-            // Act
-            SeedingCheckResult result = sut.ShouldCleanDownload(ratio, seedingTime, category);
-
-            // Assert
-            result.ShouldSatisfyAllConditions(
-                () => result.ShouldClean.ShouldBeTrue(),
-                () => result.Reason.ShouldBe(CleanReason.MaxSeedTimeReached)
-            );
-        }
-
-        [Fact]
-        public void WhenNeitherConditionMet_ShouldReturnFalse()
-        {
-            // Arrange
-            CleanCategory category = new()
-            {
-                Name = "test",
-                MaxRatio = 2.0,
-                MinSeedTime = 0,
-                MaxSeedTime = 3
-            };
-            const double ratio = 1.0;
-            TimeSpan seedingTime = TimeSpan.FromHours(1);
-            
-            TestDownloadService sut = _fixture.CreateSut();
-
-            // Act
-            var result = sut.ShouldCleanDownload(ratio, seedingTime, category);
-
-            // Assert
-            result.ShouldSatisfyAllConditions(
-                () => result.ShouldClean.ShouldBeFalse(),
-                () => result.Reason.ShouldBe(CleanReason.None)
-            );
-        }
-    }
-}

code/Infrastructure.Tests/Verticals/DownloadClient/TestDownloadService.cs

@@ -1,54 +0,0 @@
-using System.Collections.Concurrent;
-using System.Text.RegularExpressions;
-using Common.Configuration.ContentBlocker;
-using Common.Configuration.DownloadCleaner;
-using Common.Configuration.QueueCleaner;
-using Domain.Enums;
-using Infrastructure.Interceptors;
-using Infrastructure.Verticals.ContentBlocker;
-using Infrastructure.Verticals.DownloadClient;
-using Infrastructure.Verticals.Files;
-using Infrastructure.Verticals.ItemStriker;
-using Infrastructure.Verticals.Notifications;
-using Microsoft.Extensions.Caching.Memory;
-using Microsoft.Extensions.Logging;
-using Microsoft.Extensions.Options;
-
-namespace Infrastructure.Tests.Verticals.DownloadClient;
-
-public class TestDownloadService : DownloadService
-{
-    public TestDownloadService(
-        ILogger<DownloadService> logger,
-        IOptions<QueueCleanerConfig> queueCleanerConfig,
-        IOptions<ContentBlockerConfig> contentBlockerConfig,
-        IOptions<DownloadCleanerConfig> downloadCleanerConfig,
-        IMemoryCache cache,
-        IFilenameEvaluator filenameEvaluator,
-        IStriker striker,
-        INotificationPublisher notifier,
-        IDryRunInterceptor dryRunInterceptor,
-        IHardLinkFileService hardLinkFileService
-    ) : base(
-        logger, queueCleanerConfig, contentBlockerConfig, downloadCleanerConfig, cache,
-        filenameEvaluator, striker, notifier, dryRunInterceptor, hardLinkFileService
-    )
-    {
-    }
-
-    public override void Dispose() { }
-    public override Task LoginAsync() => Task.CompletedTask;
-    public override Task<DownloadCheckResult> ShouldRemoveFromArrQueueAsync(string hash, IReadOnlyList<string> ignoredDownloads) => Task.FromResult(new DownloadCheckResult());
-    public override Task<BlockFilesResult> BlockUnwantedFilesAsync(string hash, BlocklistType blocklistType,
-        ConcurrentBag<string> patterns, ConcurrentBag<Regex> regexes, IReadOnlyList<string> ignoredDownloads) => Task.FromResult(new BlockFilesResult());
-    public override Task DeleteDownload(string hash) => Task.CompletedTask;
-    public override Task CreateCategoryAsync(string name) => Task.CompletedTask;
-    public override Task<List<object>?> GetSeedingDownloads() => Task.FromResult<List<object>?>(null);
-    public override List<object>? FilterDownloadsToBeCleanedAsync(List<object>? downloads, List<CleanCategory> categories) => null;
-    public override List<object>? FilterDownloadsToChangeCategoryAsync(List<object>? downloads, List<string> categories) => null;
-    public override Task CleanDownloadsAsync(List<object>? downloads, List<CleanCategory> categoriesToClean, HashSet<string> excludedHashes, IReadOnlyList<string> ignoredDownloads) => Task.CompletedTask;
-    public override Task ChangeCategoryForNoHardLinksAsync(List<object>? downloads, HashSet<string> excludedHashes, IReadOnlyList<string> ignoredDownloads) => Task.CompletedTask;
-    // Expose protected methods for testing
-    public new void ResetStalledStrikesOnProgress(string hash, long downloaded) => base.ResetStalledStrikesOnProgress(hash, downloaded);
-    public new SeedingCheckResult ShouldCleanDownload(double ratio, TimeSpan seedingTime, CleanCategory category) => base.ShouldCleanDownload(ratio, seedingTime, category);
-}

code/Infrastructure/Infrastructure.csproj

@@ -1,26 +0,0 @@
-<Project Sdk="Microsoft.NET.Sdk">
-
-    <PropertyGroup>
-        <TargetFramework>net9.0</TargetFramework>
-        <ImplicitUsings>enable</ImplicitUsings>
-        <Nullable>enable</Nullable>
-    </PropertyGroup>
-
-    <ItemGroup>
-      <ProjectReference Include="..\Common\Common.csproj" />
-      <ProjectReference Include="..\Domain\Domain.csproj" />
-    </ItemGroup>
-
-    <ItemGroup>
-      <PackageReference Include="FLM.QBittorrent" Version="1.0.1" />
-      <PackageReference Include="FLM.Transmission" Version="1.0.3" />
-      <PackageReference Include="Mapster" Version="7.4.0" />
-      <PackageReference Include="MassTransit" Version="8.3.6" />
-      <PackageReference Include="Microsoft.Extensions.Caching.Memory" Version="9.0.2" />
-      <PackageReference Include="Microsoft.Extensions.Http" Version="9.0.2" />
-      <PackageReference Include="Mono.Posix.NETStandard" Version="1.0.0" />
-      <PackageReference Include="Quartz" Version="3.13.1" />
-      <PackageReference Include="Scrutor" Version="6.0.1" />
-    </ItemGroup>
-
-</Project>

code/Infrastructure/Providers/IgnoredDownloadsProvider.cs

@@ -1,82 +0,0 @@
-using Common.Configuration;
-using Infrastructure.Helpers;
-using Microsoft.Extensions.Caching.Memory;
-using Microsoft.Extensions.Logging;
-using Microsoft.Extensions.Options;
-
-namespace Infrastructure.Providers;
-
-public sealed class IgnoredDownloadsProvider<T>
-    where T : IIgnoredDownloadsConfig
-{
-    private readonly ILogger<IgnoredDownloadsProvider<T>> _logger;
-    private IIgnoredDownloadsConfig _config;
-    private readonly IMemoryCache _cache;
-    private DateTime _lastModified = DateTime.MinValue;
-
-    public IgnoredDownloadsProvider(ILogger<IgnoredDownloadsProvider<T>> logger, IOptionsMonitor<T> config, IMemoryCache cache)
-    {
-        _config = config.CurrentValue;
-        config.OnChange((newValue) => _config = newValue);
-        _logger = logger;
-        _cache = cache;
-
-        if (string.IsNullOrEmpty(_config.IgnoredDownloadsPath))
-        {
-            return;
-        }
-
-        if (!File.Exists(_config.IgnoredDownloadsPath))
-        {
-            throw new FileNotFoundException("file not found", _config.IgnoredDownloadsPath);
-        }
-    }
-
-    public async Task<IReadOnlyList<string>> GetIgnoredDownloads()
-    {
-        if (string.IsNullOrEmpty(_config.IgnoredDownloadsPath))
-        {
-            return Array.Empty<string>();
-        }
-
-        FileInfo fileInfo = new(_config.IgnoredDownloadsPath);
-        
-        if (fileInfo.LastWriteTime > _lastModified ||
-            !_cache.TryGetValue(CacheKeys.IgnoredDownloads(typeof(T).Name), out IReadOnlyList<string>? ignoredDownloads) ||
-            ignoredDownloads is null)
-        {
-            _lastModified = fileInfo.LastWriteTime;
-
-            return await LoadFile();
-        }
-        
-        return ignoredDownloads;
-    }
-
-    private async Task<IReadOnlyList<string>> LoadFile()
-    {
-        try
-        {
-            if (string.IsNullOrEmpty(_config.IgnoredDownloadsPath))
-            {
-                return Array.Empty<string>();
-            }
-
-            string[] ignoredDownloads = (await File.ReadAllLinesAsync(_config.IgnoredDownloadsPath))
-                .Where(x => !string.IsNullOrWhiteSpace(x))
-                .ToArray();
-
-            _cache.Set(CacheKeys.IgnoredDownloads(typeof(T).Name), ignoredDownloads);
-
-            _logger.LogInformation("ignored downloads reloaded");
-
-            return ignoredDownloads;
-        }
-        catch (Exception exception)
-        {
-            _logger.LogError(exception, "error while reading ignored downloads file | {file}", _config.IgnoredDownloadsPath);
-        }
-
-        return Array.Empty<string>();
-    }
-}

code/Infrastructure/Verticals/Arr/Interfaces/IArrClient.cs

@@ -1,19 +0,0 @@
-using Common.Configuration.Arr;
-using Domain.Enums;
-using Domain.Models.Arr;
-using Domain.Models.Arr.Queue;
-
-namespace Infrastructure.Verticals.Arr.Interfaces;
-
-public interface IArrClient
-{
-    Task<QueueListResponse> GetQueueItemsAsync(ArrInstance arrInstance, int page);
-
-    Task<bool> ShouldRemoveFromQueue(InstanceType instanceType, QueueRecord record, bool isPrivateDownload);
-
-    Task DeleteQueueItemAsync(ArrInstance arrInstance, QueueRecord record, bool removeFromClient, DeleteReason deleteReason);
-    
-    Task RefreshItemsAsync(ArrInstance arrInstance, HashSet<SearchItem>? items);
-    
-    bool IsRecordValid(QueueRecord record);
-}

code/Infrastructure/Verticals/Arr/Interfaces/ILidarrClient.cs

@@ -1,5 +0,0 @@
-namespace Infrastructure.Verticals.Arr.Interfaces;
-
-public interface ILidarrClient : IArrClient
-{
-}

code/Infrastructure/Verticals/Arr/Interfaces/IRadarrClient.cs

@@ -1,5 +0,0 @@
-namespace Infrastructure.Verticals.Arr.Interfaces;
-
-public interface IRadarrClient : IArrClient
-{
-}

code/Infrastructure/Verticals/Arr/Interfaces/ISonarrClient.cs

@@ -1,5 +0,0 @@
-namespace Infrastructure.Verticals.Arr.Interfaces;
-
-public interface ISonarrClient : IArrClient
-{
-}

code/Infrastructure/Verticals/ContentBlocker/BlocklistProvider.cs

@@ -1,163 +0,0 @@
-using System.Collections.Concurrent;
-using System.Diagnostics;
-using System.Text.RegularExpressions;
-using Common.Configuration.Arr;
-using Common.Configuration.ContentBlocker;
-using Common.Helpers;
-using Domain.Enums;
-using Infrastructure.Helpers;
-using Microsoft.Extensions.Caching.Memory;
-using Microsoft.Extensions.Logging;
-using Microsoft.Extensions.Options;
-
-namespace Infrastructure.Verticals.ContentBlocker;
-
-public sealed class BlocklistProvider
-{
-    private readonly ILogger<BlocklistProvider> _logger;
-    private readonly SonarrConfig _sonarrConfig;
-    private readonly RadarrConfig _radarrConfig;
-    private readonly LidarrConfig _lidarrConfig;
-    private readonly HttpClient _httpClient;
-    private readonly IMemoryCache _cache;
-    private bool _initialized;
-
-    public BlocklistProvider(
-        ILogger<BlocklistProvider> logger,
-        IOptions<SonarrConfig> sonarrConfig,
-        IOptions<RadarrConfig> radarrConfig,
-        IOptions<LidarrConfig> lidarrConfig,
-        IMemoryCache cache,
-        IHttpClientFactory httpClientFactory
-    )
-    {
-        _logger = logger;
-        _sonarrConfig = sonarrConfig.Value;
-        _radarrConfig = radarrConfig.Value;
-        _lidarrConfig = lidarrConfig.Value;
-        _cache = cache;
-        _httpClient = httpClientFactory.CreateClient(Constants.HttpClientWithRetryName);
-    }
-
-    public async Task LoadBlocklistsAsync()
-    {
-        if (_initialized)
-        {
-            _logger.LogTrace("blocklists already loaded");
-            return;
-        }
-        
-        try
-        {
-            await LoadPatternsAndRegexesAsync(_sonarrConfig, InstanceType.Sonarr);
-            await LoadPatternsAndRegexesAsync(_radarrConfig, InstanceType.Radarr);
-            await LoadPatternsAndRegexesAsync(_lidarrConfig, InstanceType.Lidarr);
-            
-            _initialized = true;
-        }
-        catch
-        {
-            _logger.LogError("failed to load blocklists");
-            throw;
-        }
-    }
-
-    public BlocklistType GetBlocklistType(InstanceType instanceType)
-    {
-        _cache.TryGetValue(CacheKeys.BlocklistType(instanceType), out BlocklistType? blocklistType);
-
-        return blocklistType ?? BlocklistType.Blacklist;
-    }
-    
-    public ConcurrentBag<string> GetPatterns(InstanceType instanceType)
-    {
-        _cache.TryGetValue(CacheKeys.BlocklistPatterns(instanceType), out ConcurrentBag<string>? patterns);
-
-        return patterns ?? [];
-    }
-
-    public ConcurrentBag<Regex> GetRegexes(InstanceType instanceType)
-    {
-        _cache.TryGetValue(CacheKeys.BlocklistRegexes(instanceType), out ConcurrentBag<Regex>? regexes);
-        
-        return regexes ?? [];
-    }
-
-    private async Task LoadPatternsAndRegexesAsync(ArrConfig arrConfig, InstanceType instanceType)
-    {
-        if (!arrConfig.Enabled)
-        {
-            return;
-        }
-        
-        if (string.IsNullOrEmpty(arrConfig.Block.Path))
-        {
-            return;
-        }
-        
-        string[] filePatterns = await ReadContentAsync(arrConfig.Block.Path);
-        
-        long startTime = Stopwatch.GetTimestamp();
-        ParallelOptions options = new() { MaxDegreeOfParallelism = 5 };
-        const string regexId = "regex:";
-        ConcurrentBag<string> patterns = [];
-        ConcurrentBag<Regex> regexes = [];
-        
-        Parallel.ForEach(filePatterns, options, pattern =>
-        {
-            if (!pattern.StartsWith(regexId))
-            {
-                patterns.Add(pattern);
-                return;
-            }
-            
-            pattern = pattern[regexId.Length..];
-            
-            try
-            {
-                Regex regex = new(pattern, RegexOptions.Compiled);
-                regexes.Add(regex);
-            }
-            catch (ArgumentException)
-            {
-                _logger.LogWarning("invalid regex | {pattern}", pattern);
-            }
-        });
-
-        TimeSpan elapsed = Stopwatch.GetElapsedTime(startTime);
-
-        _cache.Set(CacheKeys.BlocklistType(instanceType), arrConfig.Block.Type);
-        _cache.Set(CacheKeys.BlocklistPatterns(instanceType), patterns);
-        _cache.Set(CacheKeys.BlocklistRegexes(instanceType), regexes);
-        
-        _logger.LogDebug("loaded {count} patterns", patterns.Count);
-        _logger.LogDebug("loaded {count} regexes", regexes.Count);
-        _logger.LogDebug("blocklist loaded in {elapsed} ms | {path}", elapsed.TotalMilliseconds, arrConfig.Block.Path);
-    }
-    
-    private async Task<string[]> ReadContentAsync(string path)
-    {
-        if (Uri.TryCreate(path, UriKind.Absolute, out var uri) && (uri.Scheme == Uri.UriSchemeHttp || uri.Scheme == Uri.UriSchemeHttps))
-        {
-            // http(s) url
-            return await ReadFromUrlAsync(path);
-        }
-
-        if (File.Exists(path))
-        {
-            // local file path
-            return await File.ReadAllLinesAsync(path);
-        }
-
-        throw new ArgumentException($"blocklist not found | {path}");
-    }
-
-    private async Task<string[]> ReadFromUrlAsync(string url)
-    {
-        using HttpResponseMessage response = await _httpClient.GetAsync(url);
-        response.EnsureSuccessStatusCode();
-        
-        return (await response.Content.ReadAsStringAsync())
-            .Split(['\r','\n'], StringSplitOptions.RemoveEmptyEntries);
-    }
-}

code/Infrastructure/Verticals/ContentBlocker/ContentBlocker.cs

@@ -1,152 +0,0 @@
-using System.Collections.Concurrent;
-using System.Text.RegularExpressions;
-using Common.Configuration.Arr;
-using Common.Configuration.ContentBlocker;
-using Common.Configuration.DownloadClient;
-using Domain.Enums;
-using Domain.Models.Arr;
-using Domain.Models.Arr.Queue;
-using Infrastructure.Providers;
-using Infrastructure.Verticals.Arr;
-using Infrastructure.Verticals.Arr.Interfaces;
-using Infrastructure.Verticals.Context;
-using Infrastructure.Verticals.DownloadClient;
-using Infrastructure.Verticals.Jobs;
-using Infrastructure.Verticals.Notifications;
-using Microsoft.Extensions.Logging;
-using Microsoft.Extensions.Options;
-using Serilog.Context;
-
-namespace Infrastructure.Verticals.ContentBlocker;
-
-public sealed class ContentBlocker : GenericHandler
-{
-    private readonly ContentBlockerConfig _config;
-    private readonly BlocklistProvider _blocklistProvider;
-    private readonly IgnoredDownloadsProvider<ContentBlockerConfig> _ignoredDownloadsProvider;
-
-    public ContentBlocker(
-        ILogger<ContentBlocker> logger,
-        IOptions<ContentBlockerConfig> config,
-        IOptions<DownloadClientConfig> downloadClientConfig,
-        IOptions<SonarrConfig> sonarrConfig,
-        IOptions<RadarrConfig> radarrConfig,
-        IOptions<LidarrConfig> lidarrConfig,
-        SonarrClient sonarrClient,
-        RadarrClient radarrClient,
-        LidarrClient lidarrClient,
-        ArrQueueIterator arrArrQueueIterator,
-        BlocklistProvider blocklistProvider,
-        DownloadServiceFactory downloadServiceFactory,
-        INotificationPublisher notifier,
-        IgnoredDownloadsProvider<ContentBlockerConfig> ignoredDownloadsProvider
-    ) : base(
-        logger, downloadClientConfig,
-        sonarrConfig, radarrConfig, lidarrConfig,
-        sonarrClient, radarrClient, lidarrClient,
-        arrArrQueueIterator, downloadServiceFactory,
-        notifier
-    )
-    {
-        _config = config.Value;
-        _blocklistProvider = blocklistProvider;
-        _ignoredDownloadsProvider = ignoredDownloadsProvider;
-    }
-
-    public override async Task ExecuteAsync()
-    {
-        if (_downloadClientConfig.DownloadClient is Common.Enums.DownloadClient.None or Common.Enums.DownloadClient.Disabled)
-        {
-            _logger.LogWarning("download client is not set");
-            return;
-        }
-        
-        bool blocklistIsConfigured = _sonarrConfig.Enabled && !string.IsNullOrEmpty(_sonarrConfig.Block.Path) ||
-                                     _radarrConfig.Enabled && !string.IsNullOrEmpty(_radarrConfig.Block.Path) ||
-                                     _lidarrConfig.Enabled && !string.IsNullOrEmpty(_lidarrConfig.Block.Path);
-
-        if (!blocklistIsConfigured)
-        {
-            _logger.LogWarning("no blocklist is configured");
-            return;
-        }
-        
-        await _blocklistProvider.LoadBlocklistsAsync();
-        await base.ExecuteAsync();
-    }
-
-    protected override async Task ProcessInstanceAsync(ArrInstance instance, InstanceType instanceType)
-    {
-        IReadOnlyList<string> ignoredDownloads = await _ignoredDownloadsProvider.GetIgnoredDownloads();
-        
-        using var _ = LogContext.PushProperty("InstanceName", instanceType.ToString());
-
-        HashSet<SearchItem> itemsToBeRefreshed = [];
-        IArrClient arrClient = GetClient(instanceType);
-        BlocklistType blocklistType = _blocklistProvider.GetBlocklistType(instanceType);
-        ConcurrentBag<string> patterns = _blocklistProvider.GetPatterns(instanceType);
-        ConcurrentBag<Regex> regexes = _blocklistProvider.GetRegexes(instanceType);
-        
-        // push to context
-        ContextProvider.Set(nameof(ArrInstance) + nameof(ArrInstance.Url), instance.Url);
-        ContextProvider.Set(nameof(InstanceType), instanceType);
-
-        await _arrArrQueueIterator.Iterate(arrClient, instance, async items =>
-        {
-            var groups = items
-                .GroupBy(x => x.DownloadId)
-                .ToList();
-            
-            foreach (var group in groups)
-            {
-                QueueRecord record = group.First();
-                
-                if (record.Protocol is not "torrent")
-                {
-                    continue;
-                }
-                
-                if (string.IsNullOrEmpty(record.DownloadId))
-                {
-                    _logger.LogDebug("skip | download id is null for {title}", record.Title);
-                    continue;
-                }
-                
-                if (ignoredDownloads.Contains(record.DownloadId, StringComparer.InvariantCultureIgnoreCase))
-                {
-                    _logger.LogInformation("skip | {title} | ignored", record.Title);
-                    continue;
-                }
-                
-                // push record to context
-                ContextProvider.Set(nameof(QueueRecord), record);
-                
-                _logger.LogDebug("searching unwanted files for {title}", record.Title);
-
-                BlockFilesResult result = await _downloadService
-                    .BlockUnwantedFilesAsync(record.DownloadId, blocklistType, patterns, regexes, ignoredDownloads);
-                
-                if (!result.ShouldRemove)
-                {
-                    continue;
-                }
-                
-                _logger.LogDebug("all files are marked as unwanted | {hash}", record.Title);
-                
-                itemsToBeRefreshed.Add(GetRecordSearchItem(instanceType, record, group.Count() > 1));
-
-                bool removeFromClient = true;
-                
-                if (result.IsPrivate && !_config.DeletePrivate)
-                {
-                    removeFromClient = false;
-                }
-                
-                await arrClient.DeleteQueueItemAsync(instance, record, removeFromClient, DeleteReason.AllFilesBlocked);
-                await _notifier.NotifyQueueItemDeleted(removeFromClient, DeleteReason.AllFilesBlocked);
-            }
-        });
-        
-        await arrClient.RefreshItemsAsync(instance, itemsToBeRefreshed);
-    }
-}

code/Infrastructure/Verticals/DownloadCleaner/DownloadCleaner.cs

@@ -1,129 +0,0 @@
-using Common.Configuration.Arr;
-using Common.Configuration.DownloadCleaner;
-using Common.Configuration.DownloadClient;
-using Domain.Enums;
-using Domain.Models.Arr.Queue;
-using Infrastructure.Providers;
-using Infrastructure.Verticals.Arr;
-using Infrastructure.Verticals.Arr.Interfaces;
-using Infrastructure.Verticals.DownloadClient;
-using Infrastructure.Verticals.Jobs;
-using Infrastructure.Verticals.Notifications;
-using Microsoft.Extensions.Logging;
-using Microsoft.Extensions.Options;
-using Serilog.Context;
-
-namespace Infrastructure.Verticals.DownloadCleaner;
-
-public sealed class DownloadCleaner : GenericHandler
-{
-    private readonly DownloadCleanerConfig _config;
-    private readonly IgnoredDownloadsProvider<DownloadCleanerConfig> _ignoredDownloadsProvider;
-    private readonly HashSet<string> _excludedHashes = [];
-    
-    private static bool _hardLinkCategoryCreated;
-    
-    public DownloadCleaner(
-        ILogger<DownloadCleaner> logger,
-        IOptions<DownloadCleanerConfig> config,
-        IOptions<DownloadClientConfig> downloadClientConfig,
-        IOptions<SonarrConfig> sonarrConfig,
-        IOptions<RadarrConfig> radarrConfig,
-        IOptions<LidarrConfig> lidarrConfig,
-        SonarrClient sonarrClient,
-        RadarrClient radarrClient,
-        LidarrClient lidarrClient,
-        ArrQueueIterator arrArrQueueIterator,
-        DownloadServiceFactory downloadServiceFactory,
-        INotificationPublisher notifier,
-        IgnoredDownloadsProvider<DownloadCleanerConfig> ignoredDownloadsProvider
-    ) : base(
-        logger, downloadClientConfig,
-        sonarrConfig, radarrConfig, lidarrConfig,
-        sonarrClient, radarrClient, lidarrClient,
-        arrArrQueueIterator, downloadServiceFactory,
-        notifier
-    )
-    {
-        _config = config.Value;
-        _config.Validate();
-        _ignoredDownloadsProvider = ignoredDownloadsProvider;
-    }
-    
-    public override async Task ExecuteAsync()
-    {
-        if (_downloadClientConfig.DownloadClient is Common.Enums.DownloadClient.None or Common.Enums.DownloadClient.Disabled)
-        {
-            _logger.LogWarning("download client is not set");
-            return;
-        }
-        
-        if (_config.Categories?.Count is null or 0)
-        {
-            _logger.LogWarning("no categories configured");
-            return;
-        }
-        
-        IReadOnlyList<string> ignoredDownloads = await _ignoredDownloadsProvider.GetIgnoredDownloads();
-        
-        await _downloadService.LoginAsync();
-        List<object>? downloads = await _downloadService.GetSeedingDownloads();
-        List<object>? downloadsToChangeCategory = null;
-        
-        if (!string.IsNullOrEmpty(_config.UnlinkedTargetCategory) && _config.UnlinkedCategories?.Count > 0)
-        {
-            if (!_hardLinkCategoryCreated)
-            {
-                _logger.LogDebug("creating category {cat}", _config.UnlinkedTargetCategory);
-
-                await _downloadService.CreateCategoryAsync(_config.UnlinkedTargetCategory);
-                _hardLinkCategoryCreated = true;
-            }
-            
-            downloadsToChangeCategory = _downloadService.FilterDownloadsToChangeCategoryAsync(downloads, _config.UnlinkedCategories);
-        }
-
-        // wait for the downloads to appear in the arr queue
-        await Task.Delay(10 * 1000);
-
-        await ProcessArrConfigAsync(_sonarrConfig, InstanceType.Sonarr, true);
-        await ProcessArrConfigAsync(_radarrConfig, InstanceType.Radarr, true);
-        await ProcessArrConfigAsync(_lidarrConfig, InstanceType.Lidarr, true);
-        
-        _logger.LogTrace("looking for downloads to change category");
-        await _downloadService.ChangeCategoryForNoHardLinksAsync(downloadsToChangeCategory, _excludedHashes, ignoredDownloads);
-        
-        List<object>? downloadsToClean = _downloadService.FilterDownloadsToBeCleanedAsync(downloads, _config.Categories);
-        
-        // release unused objects
-        downloads = null;
-        
-        _logger.LogTrace("looking for downloads to clean");
-        await _downloadService.CleanDownloadsAsync(downloadsToClean, _config.Categories, _excludedHashes, ignoredDownloads);
-    }
-
-    protected override async Task ProcessInstanceAsync(ArrInstance instance, InstanceType instanceType)
-    {
-        using var _ = LogContext.PushProperty("InstanceName", instanceType.ToString());
-        
-        IArrClient arrClient = GetClient(instanceType);
-        
-        await _arrArrQueueIterator.Iterate(arrClient, instance, async items =>
-        {
-            var groups = items
-                .Where(x => !string.IsNullOrEmpty(x.DownloadId))
-                .GroupBy(x => x.DownloadId)
-                .ToList();
-
-            foreach (QueueRecord record in groups.Select(group => group.First()))
-            {
-                _excludedHashes.Add(record.DownloadId.ToLowerInvariant());
-            }
-        });
-    }
-    
-    public override void Dispose()
-    {
-        _downloadService.Dispose();
-    }
-}

code/Infrastructure/Verticals/DownloadClient/Deluge/DelugeService.cs

@@ -1,548 +0,0 @@
-using System.Collections.Concurrent;
-using System.Globalization;
-using System.Text.RegularExpressions;
-using Common.Attributes;
-using Common.Configuration.ContentBlocker;
-using Common.Configuration.DownloadCleaner;
-using Common.Configuration.DownloadClient;
-using Common.Configuration.QueueCleaner;
-using Common.CustomDataTypes;
-using Common.Exceptions;
-using Domain.Enums;
-using Domain.Models.Deluge.Response;
-using Infrastructure.Extensions;
-using Infrastructure.Interceptors;
-using Infrastructure.Verticals.ContentBlocker;
-using Infrastructure.Verticals.Context;
-using Infrastructure.Verticals.Files;
-using Infrastructure.Verticals.ItemStriker;
-using Infrastructure.Verticals.Notifications;
-using Microsoft.Extensions.Caching.Memory;
-using Microsoft.Extensions.Logging;
-using Microsoft.Extensions.Options;
-
-namespace Infrastructure.Verticals.DownloadClient.Deluge;
-
-public class DelugeService : DownloadService, IDelugeService
-{
-    private readonly DelugeClient _client;
-
-    public DelugeService(
-        ILogger<DelugeService> logger,
-        IOptions<DelugeConfig> config,
-        IHttpClientFactory httpClientFactory,
-        IOptions<QueueCleanerConfig> queueCleanerConfig,
-        IOptions<ContentBlockerConfig> contentBlockerConfig,
-        IOptions<DownloadCleanerConfig> downloadCleanerConfig,
-        IMemoryCache cache,
-        IFilenameEvaluator filenameEvaluator,
-        IStriker striker,
-        INotificationPublisher notifier,
-        IDryRunInterceptor dryRunInterceptor,
-        IHardLinkFileService hardLinkFileService
-    ) : base(
-        logger, queueCleanerConfig, contentBlockerConfig, downloadCleanerConfig, cache,
-        filenameEvaluator, striker, notifier, dryRunInterceptor, hardLinkFileService
-    )
-    {
-        config.Value.Validate();
-        _client = new (config, httpClientFactory);
-    }
-    
-    public override async Task LoginAsync()
-    {
-        await _client.LoginAsync();
-
-        if (!await _client.IsConnected() && !await _client.Connect())
-        {
-            throw new FatalException("Deluge WebUI is not connected to the daemon");
-        }
-    }
-
-    /// <inheritdoc/>
-    public override async Task<DownloadCheckResult> ShouldRemoveFromArrQueueAsync(string hash, IReadOnlyList<string> ignoredDownloads)
-    {
-        hash = hash.ToLowerInvariant();
-        
-        DelugeContents? contents = null;
-        DownloadCheckResult result = new();
-
-        DownloadStatus? download = await _client.GetTorrentStatus(hash);
-        
-        if (download?.Hash is null)
-        {
-            _logger.LogDebug("failed to find torrent {hash} in the download client", hash);
-            return result;
-        }
-        
-        result.IsPrivate = download.Private;
-        
-        if (ignoredDownloads.Count > 0 && download.ShouldIgnore(ignoredDownloads))
-        {
-            _logger.LogInformation("skip | download is ignored | {name}", download.Name);
-            return result;
-        }
-
-        try
-        {
-            contents = await _client.GetTorrentFiles(hash);
-        }
-        catch (Exception exception)
-        {
-            _logger.LogDebug(exception, "failed to find torrent {hash} in the download client", hash);
-        }
-        
-
-        bool shouldRemove = contents?.Contents?.Count > 0;
-        
-        ProcessFiles(contents.Contents, (_, file) =>
-        {
-            if (file.Priority > 0)
-            {
-                shouldRemove = false;
-            }
-        });
-
-        if (shouldRemove)
-        {
-            // remove if all files are unwanted
-            result.ShouldRemove = true;
-            result.DeleteReason = DeleteReason.AllFilesSkipped;
-            return result;
-        }
-        
-        // remove if download is stuck
-        (result.ShouldRemove, result.DeleteReason) = await EvaluateDownloadRemoval(download);
-
-        return result;
-    }
-
-    /// <inheritdoc/>
-    public override async Task<BlockFilesResult> BlockUnwantedFilesAsync(string hash,
-        BlocklistType blocklistType,
-        ConcurrentBag<string> patterns,
-        ConcurrentBag<Regex> regexes, IReadOnlyList<string> ignoredDownloads)
-    {
-        hash = hash.ToLowerInvariant();
-
-        DownloadStatus? download = await _client.GetTorrentStatus(hash);
-        BlockFilesResult result = new();
-        
-        if (download?.Hash is null)
-        {
-            _logger.LogDebug("failed to find torrent {hash} in the download client", hash);
-            return result;
-        }
-        
-        if (ignoredDownloads.Count > 0 && download.ShouldIgnore(ignoredDownloads))
-        {
-            _logger.LogInformation("skip | download is ignored | {name}", download.Name);
-            return result;
-        }
-
-        result.IsPrivate = download.Private;
-        
-        if (_contentBlockerConfig.IgnorePrivate && download.Private)
-        {
-            // ignore private trackers
-            _logger.LogDebug("skip files check | download is private | {name}", download.Name);
-            return result;
-        }
-        
-        DelugeContents? contents = null;
-
-        try
-        {
-            contents = await _client.GetTorrentFiles(hash);
-        }
-        catch (Exception exception)
-        {
-            _logger.LogDebug(exception, "failed to find torrent {hash} in the download client", hash);
-        }
-
-        if (contents is null)
-        {
-            return result;
-        }
-        
-        Dictionary<int, int> priorities = [];
-        bool hasPriorityUpdates = false;
-        long totalFiles = 0;
-        long totalUnwantedFiles = 0;
-
-        ProcessFiles(contents.Contents, (name, file) =>
-        {
-            totalFiles++;
-            int priority = file.Priority;
-
-            if (file.Priority is 0)
-            {
-                totalUnwantedFiles++;
-            }
-
-            if (file.Priority is not 0 && !_filenameEvaluator.IsValid(name, blocklistType, patterns, regexes))
-            {
-                totalUnwantedFiles++;
-                priority = 0;
-                hasPriorityUpdates = true;
-                _logger.LogInformation("unwanted file found | {file}", file.Path);
-            }
-            
-            priorities.Add(file.Index, priority);
-        });
-
-        if (!hasPriorityUpdates)
-        {
-            return result;
-        }
-        
-        _logger.LogDebug("changing priorities | torrent {hash}", hash);
-
-        List<int> sortedPriorities = priorities
-            .OrderBy(x => x.Key)
-            .Select(x => x.Value)
-            .ToList();
-
-        if (totalUnwantedFiles == totalFiles)
-        {
-            // Skip marking files as unwanted. The download will be removed completely.
-            result.ShouldRemove = true;
-            
-            return result;
-        }
-
-        await _dryRunInterceptor.InterceptAsync(ChangeFilesPriority, hash, sortedPriorities);
-
-        return result;
-    }
-
-    public override async Task<List<object>?> GetSeedingDownloads()
-    {
-        return (await _client.GetStatusForAllTorrents())
-            ?.Where(x => !string.IsNullOrEmpty(x.Hash))
-            .Where(x => x.State?.Equals("seeding", StringComparison.InvariantCultureIgnoreCase) is true)
-            .Cast<object>()
-            .ToList();
-    }
-
-    public override List<object>? FilterDownloadsToBeCleanedAsync(List<object>? downloads, List<CleanCategory> categories) =>
-        downloads
-            ?.Cast<DownloadStatus>()
-            .Where(x => categories.Any(cat => cat.Name.Equals(x.Label, StringComparison.InvariantCultureIgnoreCase)))
-            .Cast<object>()
-            .ToList();
-
-    public override List<object>? FilterDownloadsToChangeCategoryAsync(List<object>? downloads, List<string> categories) =>
-        downloads
-            ?.Cast<DownloadStatus>()
-            .Where(x => !string.IsNullOrEmpty(x.Hash))
-            .Where(x => categories.Any(cat => cat.Equals(x.Label, StringComparison.InvariantCultureIgnoreCase)))
-            .Cast<object>()
-            .ToList();
-
-    /// <inheritdoc/>
-    public override async Task CleanDownloadsAsync(List<object>? downloads, List<CleanCategory> categoriesToClean, HashSet<string> excludedHashes,
-        IReadOnlyList<string> ignoredDownloads)
-    {
-        if (downloads?.Count is null or 0)
-        {
-            return;
-        }
-        
-        foreach (DownloadStatus download in downloads)
-        {
-            if (string.IsNullOrEmpty(download.Hash))
-            {
-                continue;
-            }
-            
-            if (excludedHashes.Any(x => x.Equals(download.Hash, StringComparison.InvariantCultureIgnoreCase)))
-            {
-                _logger.LogDebug("skip | download is used by an arr | {name}", download.Name);
-                continue;
-            }
-
-            if (ignoredDownloads.Count > 0 && download.ShouldIgnore(ignoredDownloads))
-            {
-                _logger.LogInformation("skip | download is ignored | {name}", download.Name);
-                continue;
-            }
-            
-            CleanCategory? category = categoriesToClean
-                .FirstOrDefault(x => x.Name.Equals(download.Label, StringComparison.InvariantCultureIgnoreCase));
-
-            if (category is null)
-            {
-                continue;
-            }
-
-            if (!_downloadCleanerConfig.DeletePrivate && download.Private)
-            {
-                _logger.LogDebug("skip | download is private | {name}", download.Name);
-                continue;
-            }
-            
-            ContextProvider.Set("downloadName", download.Name);
-            ContextProvider.Set("hash", download.Hash);
-            
-            TimeSpan seedingTime = TimeSpan.FromSeconds(download.SeedingTime);
-            SeedingCheckResult result = ShouldCleanDownload(download.Ratio, seedingTime, category);
-
-            if (!result.ShouldClean)
-            {
-                continue;
-            }
-
-            await _dryRunInterceptor.InterceptAsync(DeleteDownload, download.Hash);
-
-            _logger.LogInformation(
-                "download cleaned | {reason} reached | {name}",
-                result.Reason is CleanReason.MaxRatioReached
-                    ? "MAX_RATIO & MIN_SEED_TIME"
-                    : "MAX_SEED_TIME",
-                download.Name
-            );
-            
-            await _notifier.NotifyDownloadCleaned(download.Ratio, seedingTime, category.Name, result.Reason);
-        }
-    }
-
-    public override async Task CreateCategoryAsync(string name)
-    {
-        IReadOnlyList<string> existingLabels = await _client.GetLabels();
-
-        if (existingLabels.Contains(name, StringComparer.InvariantCultureIgnoreCase))
-        {
-            return;
-        }
-        
-        await _dryRunInterceptor.InterceptAsync(CreateLabel, name);
-    }
-
-    public override async Task ChangeCategoryForNoHardLinksAsync(List<object>? downloads, HashSet<string> excludedHashes, IReadOnlyList<string> ignoredDownloads)
-    {
-        if (downloads?.Count is null or 0)
-        {
-            return;
-        }
-
-        if (!string.IsNullOrEmpty(_downloadCleanerConfig.UnlinkedIgnoredRootDir))
-        {
-            _hardLinkFileService.PopulateFileCounts(_downloadCleanerConfig.UnlinkedIgnoredRootDir);
-        }
-        
-        foreach (DownloadStatus download in downloads.Cast<DownloadStatus>())
-        {
-            if (string.IsNullOrEmpty(download.Hash) || string.IsNullOrEmpty(download.Name) || string.IsNullOrEmpty(download.Label))
-            {
-                continue;
-            }
-            
-            if (excludedHashes.Any(x => x.Equals(download.Hash, StringComparison.InvariantCultureIgnoreCase)))
-            {
-                _logger.LogDebug("skip | download is used by an arr | {name}", download.Name);
-                continue;
-            }
-
-            if (ignoredDownloads.Count > 0 && download.ShouldIgnore(ignoredDownloads))
-            {
-                _logger.LogInformation("skip | download is ignored | {name}", download.Name);
-                continue;
-            }
-        
-            ContextProvider.Set("downloadName", download.Name);
-            ContextProvider.Set("hash", download.Hash);
-            
-            DelugeContents? contents = null;
-            try
-            {
-                contents = await _client.GetTorrentFiles(download.Hash);
-            }
-            catch (Exception exception)
-            {
-                _logger.LogDebug(exception, "failed to find torrent files for {name}", download.Name);
-                continue;
-            }
-            
-            bool hasHardlinks = false;
-            
-            ProcessFiles(contents?.Contents, (_, file) =>
-            {
-                string filePath = string.Join(Path.DirectorySeparatorChar, Path.Combine(download.DownloadLocation, file.Path).Split(['\\', '/']));
-
-                if (file.Priority <= 0)
-                {
-                    _logger.LogDebug("skip | file is not downloaded | {file}", filePath);
-                    return;
-                }
-                
-                long hardlinkCount = _hardLinkFileService.GetHardLinkCount(filePath, !string.IsNullOrEmpty(_downloadCleanerConfig.UnlinkedIgnoredRootDir));
-        
-                if (hardlinkCount < 0)
-                {
-                    _logger.LogDebug("skip | could not get file properties | {file}", filePath);
-                    hasHardlinks = true;
-                    return;
-                }
-        
-                if (hardlinkCount > 0)
-                {
-                    hasHardlinks = true;
-                }
-            });
-            
-            if (hasHardlinks)
-            {
-                _logger.LogDebug("skip | download has hardlinks | {name}", download.Name);
-                continue;
-            }
-            
-            await _dryRunInterceptor.InterceptAsync(ChangeLabel, download.Hash, _downloadCleanerConfig.UnlinkedTargetCategory);
-            
-            _logger.LogInformation("category changed for {name}", download.Name);
-            
-            await _notifier.NotifyCategoryChanged(download.Label, _downloadCleanerConfig.UnlinkedTargetCategory);
-            
-            download.Label = _downloadCleanerConfig.UnlinkedTargetCategory;
-        }
-    }
-
-    /// <inheritdoc/>
-    [DryRunSafeguard]
-    public override async Task DeleteDownload(string hash)
-    {
-        hash = hash.ToLowerInvariant();
-        
-        await _client.DeleteTorrents([hash]);
-    }
-
-    [DryRunSafeguard]
-    protected async Task CreateLabel(string name)
-    {
-        await _client.CreateLabel(name);
-    }
-    
-    [DryRunSafeguard]
-    protected virtual async Task ChangeFilesPriority(string hash, List<int> sortedPriorities)
-    {
-        await _client.ChangeFilesPriority(hash, sortedPriorities);
-    }
-    
-    [DryRunSafeguard]
-    protected virtual async Task ChangeLabel(string hash, string newLabel)
-    {
-        await _client.SetTorrentLabel(hash, newLabel);
-    }
-    
-    private async Task<(bool, DeleteReason)> EvaluateDownloadRemoval(DownloadStatus status)
-    {
-        (bool ShouldRemove, DeleteReason Reason) result = await CheckIfSlow(status);
-
-        if (result.ShouldRemove)
-        {
-            return result;
-        }
-
-        return await CheckIfStuck(status);
-    }
-    
-    private async Task<(bool ShouldRemove, DeleteReason Reason)> CheckIfSlow(DownloadStatus download)
-    {
-        if (_queueCleanerConfig.SlowMaxStrikes is 0)
-        {
-            return (false, DeleteReason.None);
-        }
-        
-        if (download.State is null || !download.State.Equals("Downloading", StringComparison.InvariantCultureIgnoreCase))
-        {
-            return (false, DeleteReason.None);
-        }
-        
-        if (download.DownloadSpeed <= 0)
-        {
-            return (false, DeleteReason.None);
-        }
-        
-        if (_queueCleanerConfig.SlowIgnorePrivate && download.Private)
-        {
-            // ignore private trackers
-            _logger.LogDebug("skip slow check | download is private | {name}", download.Name);
-            return (false, DeleteReason.None);
-        }
-        
-        if (download.Size > (_queueCleanerConfig.SlowIgnoreAboveSizeByteSize?.Bytes ?? long.MaxValue))
-        {
-            _logger.LogDebug("skip slow check | download is too large | {name}", download.Name);
-            return (false, DeleteReason.None);
-        }
-        
-        ByteSize minSpeed = _queueCleanerConfig.SlowMinSpeedByteSize;
-        ByteSize currentSpeed = new ByteSize(download.DownloadSpeed);
-        SmartTimeSpan maxTime = SmartTimeSpan.FromHours(_queueCleanerConfig.SlowMaxTime);
-        SmartTimeSpan currentTime = SmartTimeSpan.FromSeconds(download.Eta);
-
-        return await CheckIfSlow(
-            download.Hash!,
-            download.Name!,
-            minSpeed,
-            currentSpeed,
-            maxTime,
-            currentTime
-        );
-    }
-    
-    private async Task<(bool ShouldRemove, DeleteReason Reason)> CheckIfStuck(DownloadStatus status)
-    {
-        if (_queueCleanerConfig.StalledMaxStrikes is 0)
-        {
-            return (false, DeleteReason.None);
-        }
-        
-        if (_queueCleanerConfig.StalledIgnorePrivate && status.Private)
-        {
-            // ignore private trackers
-            _logger.LogDebug("skip stalled check | download is private | {name}", status.Name);
-            return (false, DeleteReason.None);
-        }
-        
-        if (status.State is null || !status.State.Equals("Downloading", StringComparison.InvariantCultureIgnoreCase))
-        {
-            return (false, DeleteReason.None);
-        }
-
-        if (status.Eta > 0)
-        {
-            return (false, DeleteReason.None);
-        }
-        
-        ResetStalledStrikesOnProgress(status.Hash!, status.TotalDone);
-        
-        return (await _striker.StrikeAndCheckLimit(status.Hash!, status.Name!, _queueCleanerConfig.StalledMaxStrikes, StrikeType.Stalled), DeleteReason.Stalled);
-    }
-    
-    private static void ProcessFiles(Dictionary<string, DelugeFileOrDirectory>? contents, Action<string, DelugeFileOrDirectory> processFile)
-    {
-        if (contents is null)
-        {
-            return;
-        }
-        
-        foreach (var (name, data) in contents)
-        {
-            switch (data.Type)
-            {
-                case "file":
-                    processFile(name, data);
-                    break;
-                case "dir" when data.Contents is not null:
-                    // Recurse into subdirectories
-                    ProcessFiles(data.Contents, processFile);
-                    break;
-            }
-        }
-    }
-
-    public override void Dispose()
-    {
-    }
-}

code/Infrastructure/Verticals/DownloadClient/Deluge/IDelugeService.cs

@@ -1,5 +0,0 @@
-namespace Infrastructure.Verticals.DownloadClient.Deluge;
-
-public interface IDelugeService : IDownloadService
-{
-}

code/Infrastructure/Verticals/DownloadClient/DownloadServiceFactory.cs

@@ -1,31 +0,0 @@
-using Common.Configuration.DownloadClient;
-using Infrastructure.Verticals.DownloadClient.Deluge;
-using Infrastructure.Verticals.DownloadClient.QBittorrent;
-using Infrastructure.Verticals.DownloadClient.Transmission;
-using Microsoft.Extensions.DependencyInjection;
-using Microsoft.Extensions.Options;
-
-namespace Infrastructure.Verticals.DownloadClient;
-
-public sealed class DownloadServiceFactory
-{
-    private readonly IServiceProvider _serviceProvider;
-    private readonly Common.Enums.DownloadClient _downloadClient;
-    
-    public DownloadServiceFactory(IServiceProvider serviceProvider, IOptions<DownloadClientConfig> downloadClientConfig)
-    {
-        _serviceProvider = serviceProvider;
-        _downloadClient = downloadClientConfig.Value.DownloadClient;
-    }
-
-    public IDownloadService CreateDownloadClient() =>
-        _downloadClient switch
-        {
-            Common.Enums.DownloadClient.QBittorrent => _serviceProvider.GetRequiredService<QBitService>(),
-            Common.Enums.DownloadClient.Deluge => _serviceProvider.GetRequiredService<DelugeService>(),
-            Common.Enums.DownloadClient.Transmission => _serviceProvider.GetRequiredService<TransmissionService>(),
-            Common.Enums.DownloadClient.None => _serviceProvider.GetRequiredService<DummyDownloadService>(),
-            Common.Enums.DownloadClient.Disabled => _serviceProvider.GetRequiredService<DummyDownloadService>(),
-            _ => throw new ArgumentOutOfRangeException()
-        };
-}

code/Infrastructure/Verticals/DownloadClient/DummyDownloadService.cs

@@ -1,91 +0,0 @@
-using System.Collections.Concurrent;
-using System.Text.RegularExpressions;
-using Common.Configuration.ContentBlocker;
-using Common.Configuration.DownloadCleaner;
-using Common.Configuration.QueueCleaner;
-using Infrastructure.Interceptors;
-using Infrastructure.Verticals.ContentBlocker;
-using Infrastructure.Verticals.Files;
-using Infrastructure.Verticals.ItemStriker;
-using Infrastructure.Verticals.Notifications;
-using Microsoft.Extensions.Caching.Memory;
-using Microsoft.Extensions.Logging;
-using Microsoft.Extensions.Options;
-
-namespace Infrastructure.Verticals.DownloadClient;
-
-public class DummyDownloadService : DownloadService
-{
-    public DummyDownloadService(
-        ILogger<DownloadService> logger,
-        IOptions<QueueCleanerConfig> queueCleanerConfig,
-        IOptions<ContentBlockerConfig> contentBlockerConfig,
-        IOptions<DownloadCleanerConfig> downloadCleanerConfig,
-        IMemoryCache cache,
-        IFilenameEvaluator filenameEvaluator,
-        IStriker striker,
-        INotificationPublisher notifier,
-        IDryRunInterceptor dryRunInterceptor,
-        IHardLinkFileService hardLinkFileService
-    ) : base(
-        logger, queueCleanerConfig, contentBlockerConfig, downloadCleanerConfig,
-        cache, filenameEvaluator, striker, notifier, dryRunInterceptor, hardLinkFileService
-    )
-    {
-    }
-
-    public override void Dispose()
-    {
-    }
-
-    public override Task LoginAsync()
-    {
-        return Task.CompletedTask;
-    }
-
-    public override Task<DownloadCheckResult> ShouldRemoveFromArrQueueAsync(string hash, IReadOnlyList<string> ignoredDownloads)
-    {
-        throw new NotImplementedException();
-    }
-
-    public override Task<BlockFilesResult> BlockUnwantedFilesAsync(string hash, BlocklistType blocklistType, ConcurrentBag<string> patterns,
-        ConcurrentBag<Regex> regexes, IReadOnlyList<string> ignoredDownloads)
-    {
-        throw new NotImplementedException();
-    }
-
-    public override Task<List<object>?> GetSeedingDownloads()
-    {
-        throw new NotImplementedException();
-    }
-
-    public override List<object>? FilterDownloadsToBeCleanedAsync(List<object>? downloads, List<CleanCategory> categories)
-    {
-        throw new NotImplementedException();
-    }
-
-    public override List<object>? FilterDownloadsToChangeCategoryAsync(List<object>? downloads, List<string> categories)
-    {
-        throw new NotImplementedException();
-    }
-
-    public override Task CleanDownloadsAsync(List<object>? downloads, List<CleanCategory> categoriesToClean, HashSet<string> excludedHashes, IReadOnlyList<string> ignoredDownloads)
-    {
-        throw new NotImplementedException();
-    }
-
-    public override Task ChangeCategoryForNoHardLinksAsync(List<object>? downloads, HashSet<string> excludedHashes, IReadOnlyList<string> ignoredDownloads)
-    {
-        throw new NotImplementedException();
-    }
-
-    public override Task CreateCategoryAsync(string name)
-    {
-        throw new NotImplementedException();
-    }
-
-    public override Task DeleteDownload(string hash)
-    {
-        throw new NotImplementedException();
-    }
-}

code/Infrastructure/Verticals/DownloadClient/QBittorrent/IQBitService.cs

@@ -1,5 +0,0 @@
-namespace Infrastructure.Verticals.DownloadClient.QBittorrent;
-
-public interface IQBitService : IDownloadService, IDisposable
-{
-}

code/Infrastructure/Verticals/DownloadClient/QBittorrent/QBitService.cs

@@ -1,578 +0,0 @@
-using System.Collections.Concurrent;
-using System.Text.RegularExpressions;
-using Common.Attributes;
-using Common.Configuration.ContentBlocker;
-using Common.Configuration.DownloadCleaner;
-using Common.Configuration.DownloadClient;
-using Common.Configuration.QueueCleaner;
-using Common.CustomDataTypes;
-using Common.Helpers;
-using Domain.Enums;
-using Infrastructure.Extensions;
-using Infrastructure.Interceptors;
-using Infrastructure.Verticals.ContentBlocker;
-using Infrastructure.Verticals.Context;
-using Infrastructure.Verticals.Files;
-using Infrastructure.Verticals.ItemStriker;
-using Infrastructure.Verticals.Notifications;
-using Microsoft.Extensions.Caching.Memory;
-using Microsoft.Extensions.Logging;
-using Microsoft.Extensions.Options;
-using QBittorrent.Client;
-
-namespace Infrastructure.Verticals.DownloadClient.QBittorrent;
-
-public class QBitService : DownloadService, IQBitService
-{
-    private readonly QBitConfig _config;
-    private readonly QBittorrentClient _client;
-
-    public QBitService(
-        ILogger<QBitService> logger,
-        IHttpClientFactory httpClientFactory,
-        IOptions<QBitConfig> config,
-        IOptions<QueueCleanerConfig> queueCleanerConfig,
-        IOptions<ContentBlockerConfig> contentBlockerConfig,
-        IOptions<DownloadCleanerConfig> downloadCleanerConfig,
-        IMemoryCache cache,
-        IFilenameEvaluator filenameEvaluator,
-        IStriker striker,
-        INotificationPublisher notifier,
-        IDryRunInterceptor dryRunInterceptor,
-        IHardLinkFileService hardLinkFileService
-    ) : base(
-        logger, queueCleanerConfig, contentBlockerConfig, downloadCleanerConfig, cache,
-        filenameEvaluator, striker, notifier, dryRunInterceptor, hardLinkFileService
-    )
-    {
-        _config = config.Value;
-        _config.Validate();
-        UriBuilder uriBuilder = new(_config.Url);
-        uriBuilder.Path = string.IsNullOrEmpty(_config.UrlBase)
-            ? uriBuilder.Path
-            : $"{uriBuilder.Path.TrimEnd('/')}/{_config.UrlBase.TrimStart('/')}";
-        _client = new(httpClientFactory.CreateClient(Constants.HttpClientWithRetryName), uriBuilder.Uri);
-    }
-
-    public override async Task LoginAsync()
-    {
-        if (string.IsNullOrEmpty(_config.Username) && string.IsNullOrEmpty(_config.Password))
-        {
-            return;
-        }
-        
-        await _client.LoginAsync(_config.Username, _config.Password);
-    }
-
-    /// <inheritdoc/>
-    public override async Task<DownloadCheckResult> ShouldRemoveFromArrQueueAsync(string hash, IReadOnlyList<string> ignoredDownloads)
-    {
-        DownloadCheckResult result = new();
-        TorrentInfo? download = (await _client.GetTorrentListAsync(new TorrentListQuery { Hashes = [hash] }))
-            .FirstOrDefault();
-
-        if (download is null)
-        {
-            _logger.LogDebug("failed to find torrent {hash} in the download client", hash);
-            return result;
-        }
-
-        IReadOnlyList<TorrentTracker> trackers = await GetTrackersAsync(hash);
-        
-        if (ignoredDownloads.Count > 0 &&
-            (download.ShouldIgnore(ignoredDownloads) || trackers.Any(x => x.ShouldIgnore(ignoredDownloads)) is true))
-        {
-            _logger.LogInformation("skip | download is ignored | {name}", download.Name);
-            return result;
-        }
-
-        TorrentProperties? torrentProperties = await _client.GetTorrentPropertiesAsync(hash);
-
-        if (torrentProperties is null)
-        {
-            _logger.LogDebug("failed to find torrent properties {hash} in the download client", hash);
-            return result;
-        }
-
-        result.IsPrivate = torrentProperties.AdditionalData.TryGetValue("is_private", out var dictValue) &&
-                           bool.TryParse(dictValue?.ToString(), out bool boolValue)
-                           && boolValue;
-
-        IReadOnlyList<TorrentContent>? files = await _client.GetTorrentContentsAsync(hash);
-
-        if (files?.Count is > 0 && files.All(x => x.Priority is TorrentContentPriority.Skip))
-        {
-            result.ShouldRemove = true;
-            
-            // if all files were blocked by qBittorrent
-            if (download is { CompletionOn: not null, Downloaded: null or 0 })
-            {
-                result.DeleteReason = DeleteReason.AllFilesSkippedByQBit;
-                return result;
-            }
-            
-            // remove if all files are unwanted
-            result.DeleteReason = DeleteReason.AllFilesSkipped;
-            return result;
-        }
-
-        (result.ShouldRemove, result.DeleteReason) = await EvaluateDownloadRemoval(download, result.IsPrivate);
-
-        return result;
-    }
-
-    /// <inheritdoc/>
-    public override async Task<BlockFilesResult> BlockUnwantedFilesAsync(string hash,
-        BlocklistType blocklistType,
-        ConcurrentBag<string> patterns,
-        ConcurrentBag<Regex> regexes,
-        IReadOnlyList<string> ignoredDownloads
-    )
-    {
-        TorrentInfo? download = (await _client.GetTorrentListAsync(new TorrentListQuery { Hashes = [hash] }))
-            .FirstOrDefault();
-        BlockFilesResult result = new();
-
-        if (download is null)
-        {
-            _logger.LogDebug("failed to find torrent {hash} in the download client", hash);
-            return result;
-        }
-        
-        IReadOnlyList<TorrentTracker> trackers = await GetTrackersAsync(hash);
-        
-        if (ignoredDownloads.Count > 0 &&
-            (download.ShouldIgnore(ignoredDownloads) || trackers.Any(x => x.ShouldIgnore(ignoredDownloads)) is true))
-        {
-            _logger.LogInformation("skip | download is ignored | {name}", download.Name);
-            return result;
-        }
-        
-        TorrentProperties? torrentProperties = await _client.GetTorrentPropertiesAsync(hash);
-
-        if (torrentProperties is null)
-        {
-            _logger.LogDebug("failed to find torrent properties {hash} in the download client", hash);
-            return result;
-        }
-
-        bool isPrivate = torrentProperties.AdditionalData.TryGetValue("is_private", out var dictValue) &&
-                         bool.TryParse(dictValue?.ToString(), out bool boolValue)
-                         && boolValue;
-
-        result.IsPrivate = isPrivate;
-
-        if (_contentBlockerConfig.IgnorePrivate && isPrivate)
-        {
-            // ignore private trackers
-            _logger.LogDebug("skip files check | download is private | {name}", download.Name);
-            return result;
-        }
-        
-        IReadOnlyList<TorrentContent>? files = await _client.GetTorrentContentsAsync(hash);
-
-        if (files is null)
-        {
-            return result;
-        }
-
-        List<int> unwantedFiles = [];
-        long totalFiles = 0;
-        long totalUnwantedFiles = 0;
-        
-        foreach (TorrentContent file in files)
-        {
-            if (!file.Index.HasValue)
-            {
-                continue;
-            }
-
-            totalFiles++;
-
-            if (file.Priority is TorrentContentPriority.Skip)
-            {
-                totalUnwantedFiles++;
-                continue;
-            }
-
-            if (_filenameEvaluator.IsValid(file.Name, blocklistType, patterns, regexes))
-            {
-                continue;
-            }
-            
-            _logger.LogInformation("unwanted file found | {file}", file.Name);
-            unwantedFiles.Add(file.Index.Value);
-            totalUnwantedFiles++;
-        }
-
-        if (unwantedFiles.Count is 0)
-        {
-            return result;
-        }
-        
-        if (totalUnwantedFiles == totalFiles)
-        {
-            // Skip marking files as unwanted. The download will be removed completely.
-            result.ShouldRemove = true;
-            
-            return result;
-        }
-
-        foreach (int fileIndex in unwantedFiles)
-        {
-            await _dryRunInterceptor.InterceptAsync(SkipFile, hash, fileIndex);
-        }
-        
-        return result;
-    }
-    
-    /// <inheritdoc/>
-    public override async Task<List<object>?> GetSeedingDownloads() =>
-        (await _client.GetTorrentListAsync(new()
-        {
-            Filter = TorrentListFilter.Seeding
-        }))
-        ?.Where(x => !string.IsNullOrEmpty(x.Hash))
-        .Cast<object>()
-        .ToList();
-
-    /// <inheritdoc/>
-    public override List<object>? FilterDownloadsToBeCleanedAsync(List<object>? downloads, List<CleanCategory> categories) =>
-        downloads
-            ?.Cast<TorrentInfo>()
-            .Where(x => !string.IsNullOrEmpty(x.Hash))
-            .Where(x => categories.Any(cat => cat.Name.Equals(x.Category, StringComparison.InvariantCultureIgnoreCase)))
-            .Cast<object>()
-            .ToList();
-
-    /// <inheritdoc/>
-    public override List<object>? FilterDownloadsToChangeCategoryAsync(List<object>? downloads, List<string> categories) =>
-        downloads
-            ?.Cast<TorrentInfo>()
-            .Where(x => !string.IsNullOrEmpty(x.Hash))
-            .Where(x => categories.Any(cat => cat.Equals(x.Category, StringComparison.InvariantCultureIgnoreCase)))
-            .Cast<object>()
-            .ToList();
-
-    /// <inheritdoc/>
-    public override async Task CleanDownloadsAsync(List<object>? downloads, List<CleanCategory> categoriesToClean,
-        HashSet<string> excludedHashes, IReadOnlyList<string> ignoredDownloads)
-    {
-        if (downloads?.Count is null or 0)
-        {
-            return;
-        }
-        
-        foreach (TorrentInfo download in downloads)
-        {
-            if (string.IsNullOrEmpty(download.Hash))
-            {
-                continue;
-            }
-            
-            if (excludedHashes.Any(x => x.Equals(download.Hash, StringComparison.InvariantCultureIgnoreCase)))
-            {
-                _logger.LogDebug("skip | download is used by an arr | {name}", download.Name);
-                continue;
-            }
-            
-            IReadOnlyList<TorrentTracker> trackers = await GetTrackersAsync(download.Hash);
-
-            if (ignoredDownloads.Count > 0 &&
-                (download.ShouldIgnore(ignoredDownloads) || trackers.Any(x => x.ShouldIgnore(ignoredDownloads))))
-            {
-                _logger.LogInformation("skip | download is ignored | {name}", download.Name);
-                continue;
-            }
-            
-            CleanCategory? category = categoriesToClean
-                .FirstOrDefault(x => download.Category.Equals(x.Name, StringComparison.InvariantCultureIgnoreCase));
-            
-            if (category is null)
-            {
-                continue;
-            }
-            
-            if (!_downloadCleanerConfig.DeletePrivate)
-            {
-                TorrentProperties? torrentProperties = await _client.GetTorrentPropertiesAsync(download.Hash);
-
-                if (torrentProperties is null)
-                {
-                    _logger.LogDebug("failed to find torrent properties in the download client | {name}", download.Name);
-                    return;
-                }
-                
-                bool isPrivate = torrentProperties.AdditionalData.TryGetValue("is_private", out var dictValue) &&
-                                 bool.TryParse(dictValue?.ToString(), out bool boolValue)
-                                 && boolValue;
-
-                if (isPrivate)
-                {
-                    _logger.LogDebug("skip | download is private | {name}", download.Name);
-                    continue;
-                }
-            }
-            
-            ContextProvider.Set("downloadName", download.Name);
-            ContextProvider.Set("hash", download.Hash);
-
-            SeedingCheckResult result = ShouldCleanDownload(download.Ratio, download.SeedingTime ?? TimeSpan.Zero, category);
-
-            if (!result.ShouldClean)
-            {
-                continue;
-            }
-
-            await _dryRunInterceptor.InterceptAsync(DeleteDownload, download.Hash);
-
-            _logger.LogInformation(
-                "download cleaned | {reason} reached | {name}",
-                result.Reason is CleanReason.MaxRatioReached
-                    ? "MAX_RATIO & MIN_SEED_TIME"
-                    : "MAX_SEED_TIME",
-                download.Name
-            );
-            
-            await _notifier.NotifyDownloadCleaned(download.Ratio, download.SeedingTime ?? TimeSpan.Zero, category.Name, result.Reason);
-        }
-    }
-
-    public override async Task CreateCategoryAsync(string name)
-    {
-        IReadOnlyDictionary<string, Category>? existingCategories = await _client.GetCategoriesAsync();
-        
-        if (existingCategories.Any(x => x.Value.Name.Equals(name, StringComparison.InvariantCultureIgnoreCase)))
-        {
-            return;
-        }
-        
-        await _dryRunInterceptor.InterceptAsync(CreateCategory, name);
-    }
-
-    public override async Task ChangeCategoryForNoHardLinksAsync(List<object>? downloads, HashSet<string> excludedHashes, IReadOnlyList<string> ignoredDownloads)
-    {
-        if (downloads?.Count is null or 0)
-        {
-            return;
-        }
-        
-        if (!string.IsNullOrEmpty(_downloadCleanerConfig.UnlinkedIgnoredRootDir))
-        {
-            _hardLinkFileService.PopulateFileCounts(_downloadCleanerConfig.UnlinkedIgnoredRootDir);
-        }
-        
-        foreach (TorrentInfo download in downloads)
-        {
-            if (string.IsNullOrEmpty(download.Hash))
-            {
-                continue;
-            }
-            
-            if (excludedHashes.Any(x => x.Equals(download.Hash, StringComparison.InvariantCultureIgnoreCase)))
-            {
-                _logger.LogDebug("skip | download is used by an arr | {name}", download.Name);
-                continue;
-            }
-            
-            IReadOnlyList<TorrentTracker> trackers = await GetTrackersAsync(download.Hash);
-            
-            if (ignoredDownloads.Count > 0 &&
-                (download.ShouldIgnore(ignoredDownloads) || trackers.Any(x => x.ShouldIgnore(ignoredDownloads))))
-            {
-                _logger.LogInformation("skip | download is ignored | {name}", download.Name);
-                continue;
-            }
-            
-            IReadOnlyList<TorrentContent>? files = await _client.GetTorrentContentsAsync(download.Hash);
-
-            if (files is null)
-            {
-                _logger.LogDebug("failed to find files for {name}", download.Name);
-                continue;
-            }
-
-            ContextProvider.Set("downloadName", download.Name);
-            ContextProvider.Set("hash", download.Hash);
-            bool hasHardlinks = false;
-            
-            foreach (TorrentContent file in files)
-            {
-                if (!file.Index.HasValue)
-                {
-                    _logger.LogDebug("skip | file index is null for {name}", download.Name);
-                    hasHardlinks = true;
-                    break;
-                }
-
-                string filePath = string.Join(Path.DirectorySeparatorChar, Path.Combine(download.SavePath, file.Name).Split(['\\', '/']));
-
-                if (file.Priority is TorrentContentPriority.Skip)
-                {
-                    _logger.LogDebug("skip | file is not downloaded | {file}", filePath);
-                    continue;
-                }
-                
-                long hardlinkCount = _hardLinkFileService.GetHardLinkCount(filePath, !string.IsNullOrEmpty(_downloadCleanerConfig.UnlinkedIgnoredRootDir));
-
-                if (hardlinkCount < 0)
-                {
-                    _logger.LogDebug("skip | could not get file properties | {file}", filePath);
-                    hasHardlinks = true;
-                    break;
-                }
-
-                if (hardlinkCount > 0)
-                {
-                    hasHardlinks = true;
-                    break;
-                }
-            }
-            
-            if (hasHardlinks)
-            {
-                _logger.LogDebug("skip | download has hardlinks | {name}", download.Name);
-                continue;
-            }
-            
-            await _dryRunInterceptor.InterceptAsync(ChangeCategory, download.Hash, _downloadCleanerConfig.UnlinkedTargetCategory);
-            
-            _logger.LogInformation("category changed for {name}", download.Name);
-            
-            await _notifier.NotifyCategoryChanged(download.Category, _downloadCleanerConfig.UnlinkedTargetCategory);
-            
-            download.Category = _downloadCleanerConfig.UnlinkedTargetCategory;
-        }
-    }
-    
-    /// <inheritdoc/>
-    [DryRunSafeguard]
-    public override async Task DeleteDownload(string hash)
-    {
-        await _client.DeleteAsync(hash, deleteDownloadedData: true);
-    }
-
-    [DryRunSafeguard]
-    protected async Task CreateCategory(string name)
-    {
-        await _client.AddCategoryAsync(name);
-    }
-    
-    [DryRunSafeguard]
-    protected virtual async Task SkipFile(string hash, int fileIndex)
-    {
-        await _client.SetFilePriorityAsync(hash, fileIndex, TorrentContentPriority.Skip);
-    }
-
-    [DryRunSafeguard]
-    protected virtual async Task ChangeCategory(string hash, string newCategory)
-    {
-        await _client.SetTorrentCategoryAsync([hash], newCategory);
-    }
-
-    public override void Dispose()
-    {
-        _client.Dispose();
-    }
-
-    private async Task<(bool, DeleteReason)> EvaluateDownloadRemoval(TorrentInfo torrent, bool isPrivate)
-    {
-        (bool ShouldRemove, DeleteReason Reason) result = await CheckIfSlow(torrent, isPrivate);
-
-        if (result.ShouldRemove)
-        {
-            return result;
-        }
-
-        return await CheckIfStuck(torrent, isPrivate);
-    }
-
-    private async Task<(bool ShouldRemove, DeleteReason Reason)> CheckIfSlow(TorrentInfo download, bool isPrivate)
-    {
-        if (_queueCleanerConfig.SlowMaxStrikes is 0)
-        {
-            return (false, DeleteReason.None);
-        }
-        
-        if (download.State is not (TorrentState.Downloading or TorrentState.ForcedDownload))
-        {
-            return (false, DeleteReason.None);
-        }
-        
-        if (download.DownloadSpeed <= 0)
-        {
-            return (false, DeleteReason.None);
-        }
-        
-        if (_queueCleanerConfig.SlowIgnorePrivate && isPrivate)
-        {
-            // ignore private trackers
-            _logger.LogDebug("skip slow check | download is private | {name}", download.Name);
-            return (false, DeleteReason.None);
-        }
-
-        if (download.Size > (_queueCleanerConfig.SlowIgnoreAboveSizeByteSize?.Bytes ?? long.MaxValue))
-        {
-            _logger.LogDebug("skip slow check | download is too large | {name}", download.Name);
-            return (false, DeleteReason.None);
-        }
-        
-        ByteSize minSpeed = _queueCleanerConfig.SlowMinSpeedByteSize;
-        ByteSize currentSpeed = new ByteSize(download.DownloadSpeed);
-        SmartTimeSpan maxTime = SmartTimeSpan.FromHours(_queueCleanerConfig.SlowMaxTime);
-        SmartTimeSpan currentTime = new SmartTimeSpan(download.EstimatedTime ?? TimeSpan.Zero);
-
-        return await CheckIfSlow(
-            download.Hash,
-            download.Name,
-            minSpeed,
-            currentSpeed,
-            maxTime,
-            currentTime
-        );
-    }
-
-    private async Task<(bool ShouldRemove, DeleteReason Reason)> CheckIfStuck(TorrentInfo torrent, bool isPrivate)
-    {
-        if (_queueCleanerConfig.StalledMaxStrikes is 0 && _queueCleanerConfig.DownloadingMetadataMaxStrikes is 0)
-        {
-            return (false, DeleteReason.None);
-        }
-        
-        if (torrent.State is not TorrentState.StalledDownload and not TorrentState.FetchingMetadata
-            and not TorrentState.ForcedFetchingMetadata)
-        {
-            // ignore other states
-            return (false, DeleteReason.None);
-        }
-
-        if (_queueCleanerConfig.StalledMaxStrikes > 0 && torrent.State is TorrentState.StalledDownload)
-        {
-            if (_queueCleanerConfig.StalledIgnorePrivate && isPrivate)
-            {
-                // ignore private trackers
-                _logger.LogDebug("skip stalled check | download is private | {name}", torrent.Name);
-            }
-            else
-            {
-                ResetStalledStrikesOnProgress(torrent.Hash, torrent.Downloaded ?? 0);
-            
-                return (await _striker.StrikeAndCheckLimit(torrent.Hash, torrent.Name, _queueCleanerConfig.StalledMaxStrikes, StrikeType.Stalled), DeleteReason.Stalled);
-            }
-        }
-
-        if (_queueCleanerConfig.DownloadingMetadataMaxStrikes > 0 && torrent.State is not TorrentState.StalledDownload)
-        {
-            return (await _striker.StrikeAndCheckLimit(torrent.Hash, torrent.Name, _queueCleanerConfig.DownloadingMetadataMaxStrikes, StrikeType.DownloadingMetadata), DeleteReason.DownloadingMetadata);
-        }
-
-        return (false, DeleteReason.None);
-    }
-
-    private async Task<IReadOnlyList<TorrentTracker>> GetTrackersAsync(string hash)
-    {
-        return (await _client.GetTorrentTrackersAsync(hash))
-            .Where(x => x.Url.Contains("**"))
-            .ToList();
-    }
-}

code/Infrastructure/Verticals/DownloadClient/Transmission/ITransmissionService.cs

@@ -1,5 +0,0 @@
-namespace Infrastructure.Verticals.DownloadClient.Transmission;
-
-public interface ITransmissionService : IDownloadService
-{
-}

code/Infrastructure/Verticals/DownloadClient/Transmission/TransmissionService.cs

@@ -1,548 +0,0 @@
-using System.Collections.Concurrent;
-using System.Text.RegularExpressions;
-using Common.Attributes;
-using Common.Configuration.ContentBlocker;
-using Common.Configuration.DownloadCleaner;
-using Common.Configuration.DownloadClient;
-using Common.Configuration.QueueCleaner;
-using Common.CustomDataTypes;
-using Common.Helpers;
-using Domain.Enums;
-using Infrastructure.Extensions;
-using Infrastructure.Interceptors;
-using Infrastructure.Verticals.ContentBlocker;
-using Infrastructure.Verticals.Context;
-using Infrastructure.Verticals.Files;
-using Infrastructure.Verticals.ItemStriker;
-using Infrastructure.Verticals.Notifications;
-using Microsoft.Extensions.Caching.Memory;
-using Microsoft.Extensions.Logging;
-using Microsoft.Extensions.Options;
-using Transmission.API.RPC;
-using Transmission.API.RPC.Arguments;
-using Transmission.API.RPC.Entity;
-
-namespace Infrastructure.Verticals.DownloadClient.Transmission;
-
-public class TransmissionService : DownloadService, ITransmissionService
-{
-    private readonly TransmissionConfig _config;
-    private readonly Client _client;
-
-    private static readonly string[] Fields =
-    [
-        TorrentFields.FILES,
-        TorrentFields.FILE_STATS,
-        TorrentFields.HASH_STRING,
-        TorrentFields.ID,
-        TorrentFields.ETA,
-        TorrentFields.NAME,
-        TorrentFields.STATUS,
-        TorrentFields.IS_PRIVATE,
-        TorrentFields.DOWNLOADED_EVER,
-        TorrentFields.DOWNLOAD_DIR,
-        TorrentFields.SECONDS_SEEDING,
-        TorrentFields.UPLOAD_RATIO,
-        TorrentFields.TRACKERS,
-        TorrentFields.RATE_DOWNLOAD,
-        TorrentFields.TOTAL_SIZE,
-    ];
-
-    public TransmissionService(
-        IHttpClientFactory httpClientFactory,
-        ILogger<TransmissionService> logger,
-        IOptions<TransmissionConfig> config,
-        IOptions<QueueCleanerConfig> queueCleanerConfig,
-        IOptions<ContentBlockerConfig> contentBlockerConfig,
-        IOptions<DownloadCleanerConfig> downloadCleanerConfig,
-        IMemoryCache cache,
-        IFilenameEvaluator filenameEvaluator,
-        IStriker striker,
-        INotificationPublisher notifier,
-        IDryRunInterceptor dryRunInterceptor,
-        IHardLinkFileService hardLinkFileService
-    ) : base(
-        logger, queueCleanerConfig, contentBlockerConfig, downloadCleanerConfig, cache,
-        filenameEvaluator, striker, notifier, dryRunInterceptor, hardLinkFileService
-    )
-    {
-        _config = config.Value;
-        _config.Validate();
-        UriBuilder uriBuilder = new(_config.Url);
-        uriBuilder.Path = string.IsNullOrEmpty(_config.UrlBase)
-            ? $"{uriBuilder.Path.TrimEnd('/')}/rpc"
-            : $"{uriBuilder.Path.TrimEnd('/')}/{_config.UrlBase.TrimStart('/').TrimEnd('/')}/rpc";
-        _client = new(
-            httpClientFactory.CreateClient(Constants.HttpClientWithRetryName),
-            uriBuilder.Uri.ToString(),
-            login: _config.Username,
-            password: _config.Password
-        );
-    }
-
-    public override async Task LoginAsync()
-    {
-        await _client.GetSessionInformationAsync();
-    }
-
-    /// <inheritdoc/>
-    public override async Task<DownloadCheckResult> ShouldRemoveFromArrQueueAsync(string hash, IReadOnlyList<string> ignoredDownloads)
-    {
-        DownloadCheckResult result = new();
-        TorrentInfo? download = await GetTorrentAsync(hash);
-
-        if (download is null)
-        {
-            _logger.LogDebug("failed to find torrent {hash} in the download client", hash);
-            return result;
-        }
-        
-        if (ignoredDownloads.Count > 0 && download.ShouldIgnore(ignoredDownloads))
-        {
-            _logger.LogDebug("skip | download is ignored | {name}", download.Name);
-            return result;
-        }
-        
-        bool shouldRemove = download.FileStats?.Length > 0;
-        result.IsPrivate = download.IsPrivate ?? false;
-
-        foreach (TransmissionTorrentFileStats? stats in download.FileStats ?? [])
-        {
-            if (!stats.Wanted.HasValue)
-            {
-                // if any files stats are missing, do not remove
-                shouldRemove = false;
-            }
-            
-            if (stats.Wanted.HasValue && stats.Wanted.Value)
-            {
-                // if any files are wanted, do not remove
-                shouldRemove = false;
-            }
-        }
-        
-        if (shouldRemove)
-        {
-            // remove if all files are unwanted
-            result.ShouldRemove = true;
-            result.DeleteReason = DeleteReason.AllFilesBlocked;
-            return result;
-        }
-
-        // remove if download is stuck
-        (result.ShouldRemove, result.DeleteReason) = await EvaluateDownloadRemoval(download);
-
-        return result;
-    }
-
-    /// <inheritdoc/>
-    public override async Task<BlockFilesResult> BlockUnwantedFilesAsync(string hash,
-        BlocklistType blocklistType,
-        ConcurrentBag<string> patterns,
-        ConcurrentBag<Regex> regexes, IReadOnlyList<string> ignoredDownloads)
-    {
-        TorrentInfo? download = await GetTorrentAsync(hash);
-        BlockFilesResult result = new();
-
-        if (download?.FileStats is null || download.Files is null)
-        {
-            return result;
-        }
-        
-        if (ignoredDownloads.Count > 0 && download.ShouldIgnore(ignoredDownloads))
-        {
-            _logger.LogDebug("skip | download is ignored | {name}", download.Name);
-            return result;
-        }
-
-        bool isPrivate = download.IsPrivate ?? false;
-        result.IsPrivate = isPrivate;
-        
-        if (_contentBlockerConfig.IgnorePrivate && isPrivate)
-        {
-            // ignore private trackers
-            _logger.LogDebug("skip files check | download is private | {name}", download.Name);
-            return result;
-        }
-
-        List<long> unwantedFiles = [];
-        long totalFiles = 0;
-        long totalUnwantedFiles = 0;
-        
-        for (int i = 0; i < download.Files.Length; i++)
-        {
-            if (download.FileStats?[i].Wanted == null)
-            {
-                continue;
-            }
-
-            totalFiles++;
-            
-            if (!download.FileStats[i].Wanted.Value)
-            {
-                totalUnwantedFiles++;
-                continue;
-            }
-
-            if (_filenameEvaluator.IsValid(download.Files[i].Name, blocklistType, patterns, regexes))
-            {
-                continue;
-            }
-            
-            _logger.LogInformation("unwanted file found | {file}", download.Files[i].Name);
-            unwantedFiles.Add(i);
-            totalUnwantedFiles++;
-        }
-
-        if (unwantedFiles.Count is 0)
-        {
-            return result;
-        }
-
-        if (totalUnwantedFiles == totalFiles)
-        {
-            // Skip marking files as unwanted. The download will be removed completely.
-            result.ShouldRemove = true;
-            
-            return result;
-        }
-        
-        _logger.LogDebug("changing priorities | torrent {hash}", hash);
-
-        await _dryRunInterceptor.InterceptAsync(SetUnwantedFiles, download.Id, unwantedFiles.ToArray());
-
-        return result;
-    }
-    
-    public override async Task<List<object>?> GetSeedingDownloads() =>
-        (await _client.TorrentGetAsync(Fields))
-        ?.Torrents
-        ?.Where(x => !string.IsNullOrEmpty(x.HashString))
-        .Where(x => x.Status is 5 or 6)
-        .Cast<object>()
-        .ToList();
-
-    /// <inheritdoc/>
-    public override List<object>? FilterDownloadsToBeCleanedAsync(List<object>? downloads, List<CleanCategory> categories)
-    {
-        return downloads
-            ?
-            .Cast<TorrentInfo>()
-            .Where(x => categories
-                .Any(cat => cat.Name.Equals(x.GetCategory(), StringComparison.InvariantCultureIgnoreCase))
-            )
-            .Cast<object>()
-            .ToList();
-    }
-
-    public override List<object>? FilterDownloadsToChangeCategoryAsync(List<object>? downloads, List<string> categories)
-    {
-        return downloads
-            ?.Cast<TorrentInfo>()
-            .Where(x => !string.IsNullOrEmpty(x.HashString))
-            .Where(x => categories.Any(cat => cat.Equals(x.GetCategory(), StringComparison.InvariantCultureIgnoreCase)))
-            .Cast<object>()
-            .ToList();
-    }
-
-    /// <inheritdoc/>
-    public override async Task CleanDownloadsAsync(List<object>? downloads, List<CleanCategory> categoriesToClean,
-        HashSet<string> excludedHashes, IReadOnlyList<string> ignoredDownloads)
-    {
-        if (downloads?.Count is null or 0)
-        {
-            return;
-        }
-        
-        foreach (TorrentInfo download in downloads)
-        {
-            if (string.IsNullOrEmpty(download.HashString))
-            {
-                continue;
-            }
-            
-            if (excludedHashes.Any(x => x.Equals(download.HashString, StringComparison.InvariantCultureIgnoreCase)))
-            {
-                _logger.LogDebug("skip | download is used by an arr | {name}", download.Name);
-                continue;
-            }
-
-            if (ignoredDownloads.Count > 0 && download.ShouldIgnore(ignoredDownloads))
-            {
-                _logger.LogDebug("skip | download is ignored | {name}", download.Name);
-                continue;
-            }
-            
-            CleanCategory? category = categoriesToClean
-                .FirstOrDefault(x =>
-                {
-                    if (download.DownloadDir is null)
-                    {
-                        return false;
-                    }
-
-                    return Path.GetFileName(Path.TrimEndingDirectorySeparator(download.DownloadDir))
-                        .Equals(x.Name, StringComparison.InvariantCultureIgnoreCase);
-                });
-            
-            if (category is null)
-            {
-                continue;
-            }
-
-            if (!_downloadCleanerConfig.DeletePrivate && download.IsPrivate is true)
-            {
-                _logger.LogDebug("skip | download is private | {name}", download.Name);
-                continue;
-            }
-            
-            ContextProvider.Set("downloadName", download.Name);
-            ContextProvider.Set("hash", download.HashString);
-
-            TimeSpan seedingTime = TimeSpan.FromSeconds(download.SecondsSeeding ?? 0);
-            SeedingCheckResult result = ShouldCleanDownload(download.uploadRatio ?? 0, seedingTime, category);
-            
-            if (!result.ShouldClean)
-            {
-                continue;
-            }
-
-            await _dryRunInterceptor.InterceptAsync(RemoveDownloadAsync, download.Id);
-
-            _logger.LogInformation(
-                "download cleaned | {reason} reached | {name}",
-                result.Reason is CleanReason.MaxRatioReached
-                    ? "MAX_RATIO & MIN_SEED_TIME"
-                    : "MAX_SEED_TIME",
-                download.Name
-            );
-
-            await _notifier.NotifyDownloadCleaned(download.uploadRatio ?? 0, seedingTime, category.Name, result.Reason);
-        }
-    }
-    
-    public override async Task CreateCategoryAsync(string name)
-    {
-        await Task.CompletedTask;
-    }
-
-    public override async Task ChangeCategoryForNoHardLinksAsync(List<object>? downloads, HashSet<string> excludedHashes, IReadOnlyList<string> ignoredDownloads)
-    {
-        if (downloads?.Count is null or 0)
-        {
-            return;
-        }
-        
-        if (!string.IsNullOrEmpty(_downloadCleanerConfig.UnlinkedIgnoredRootDir))
-        {
-            _hardLinkFileService.PopulateFileCounts(_downloadCleanerConfig.UnlinkedIgnoredRootDir);
-        }
-        
-        foreach (TorrentInfo download in downloads.Cast<TorrentInfo>())
-        {
-            if (string.IsNullOrEmpty(download.HashString) || string.IsNullOrEmpty(download.Name) || download.DownloadDir == null)
-            {
-                continue;
-            }
-            
-            if (excludedHashes.Any(x => x.Equals(download.HashString, StringComparison.InvariantCultureIgnoreCase)))
-            {
-                _logger.LogDebug("skip | download is used by an arr | {name}", download.Name);
-                continue;
-            }
-            
-            if (ignoredDownloads.Count > 0 && download.ShouldIgnore(ignoredDownloads))
-            {
-                _logger.LogDebug("skip | download is ignored | {name}", download.Name);
-                continue;
-            }
-        
-            ContextProvider.Set("downloadName", download.Name);
-            ContextProvider.Set("hash", download.HashString);
-            
-            bool hasHardlinks = false;
-            
-            if (download.Files is null || download.FileStats is null)
-            {
-                _logger.LogDebug("skip | download has no files | {name}", download.Name);
-                continue;
-            }
-
-            for (int i = 0; i < download.Files.Length; i++)
-            {
-                TransmissionTorrentFiles file = download.Files[i];
-                TransmissionTorrentFileStats stats = download.FileStats[i];
-                
-                if (stats.Wanted is null or false || string.IsNullOrEmpty(file.Name))
-                {
-                    continue;
-                }
-
-                string filePath = string.Join(Path.DirectorySeparatorChar, Path.Combine(download.DownloadDir, file.Name).Split(['\\', '/']));
-                
-                long hardlinkCount = _hardLinkFileService.GetHardLinkCount(filePath, !string.IsNullOrEmpty(_downloadCleanerConfig.UnlinkedIgnoredRootDir));
-                
-                if (hardlinkCount < 0)
-                {
-                    _logger.LogDebug("skip | could not get file properties | {file}", filePath);
-                    hasHardlinks = true;
-                    break;
-                }
-
-                if (hardlinkCount > 0)
-                {
-                    hasHardlinks = true;
-                    break;
-                }
-            }
-
-            if (hasHardlinks)
-            {
-                _logger.LogDebug("skip | download has hardlinks | {name}", download.Name);
-                continue;
-            }
-            
-            string currentCategory = download.GetCategory();
-            string newLocation = string.Join(Path.DirectorySeparatorChar, Path.Combine(download.DownloadDir, _downloadCleanerConfig.UnlinkedTargetCategory).Split(['\\', '/']));
-            
-            await _dryRunInterceptor.InterceptAsync(ChangeDownloadLocation, download.Id, newLocation);
-            
-            _logger.LogInformation("category changed for {name}", download.Name);
-            
-            await _notifier.NotifyCategoryChanged(currentCategory, _downloadCleanerConfig.UnlinkedTargetCategory);
-
-            download.DownloadDir = newLocation;
-        }
-    }
-
-    [DryRunSafeguard]
-    protected virtual async Task ChangeDownloadLocation(long downloadId, string newLocation)
-    {
-        await _client.TorrentSetLocationAsync([downloadId], newLocation, true);
-    }
-
-    public override async Task DeleteDownload(string hash)
-    {
-        TorrentInfo? torrent = await GetTorrentAsync(hash);
-
-        if (torrent is null)
-        {
-            return;
-        }
-
-        await _client.TorrentRemoveAsync([torrent.Id], true);
-    }
-
-    public override void Dispose()
-    {
-    }
-    
-    [DryRunSafeguard]
-    protected virtual async Task RemoveDownloadAsync(long downloadId)
-    {
-        await _client.TorrentRemoveAsync([downloadId], true);
-    }
-    
-    [DryRunSafeguard]
-    protected virtual async Task SetUnwantedFiles(long downloadId, long[] unwantedFiles)
-    {
-        await _client.TorrentSetAsync(new TorrentSettings
-        {
-            Ids = [downloadId],
-            FilesUnwanted = unwantedFiles,
-        });
-    }
-    
-    private async Task<(bool, DeleteReason)> EvaluateDownloadRemoval(TorrentInfo torrent)
-    {
-        (bool ShouldRemove, DeleteReason Reason) result = await CheckIfSlow(torrent);
-
-        if (result.ShouldRemove)
-        {
-            return result;
-        }
-
-        return await CheckIfStuck(torrent);
-    }
-
-    private async Task<(bool ShouldRemove, DeleteReason Reason)> CheckIfSlow(TorrentInfo download)
-    {
-        if (_queueCleanerConfig.SlowMaxStrikes is 0)
-        {
-            return (false, DeleteReason.None);
-        }
-        
-        if (download.Status is not 4)
-        {
-            // not in downloading state
-            return (false, DeleteReason.None);
-        }
-        
-        if (download.RateDownload <= 0)
-        {
-            return (false, DeleteReason.None);
-        }
-        
-        if (_queueCleanerConfig.SlowIgnorePrivate && download.IsPrivate is true)
-        {
-            // ignore private trackers
-            _logger.LogDebug("skip slow check | download is private | {name}", download.Name);
-            return (false, DeleteReason.None);
-        }
-
-        if (download.TotalSize > (_queueCleanerConfig.SlowIgnoreAboveSizeByteSize?.Bytes ?? long.MaxValue))
-        {
-            _logger.LogDebug("skip slow check | download is too large | {name}", download.Name);
-            return (false, DeleteReason.None);
-        }
-        
-        ByteSize minSpeed = _queueCleanerConfig.SlowMinSpeedByteSize;
-        ByteSize currentSpeed = new ByteSize(download.RateDownload ?? long.MaxValue);
-        SmartTimeSpan maxTime = SmartTimeSpan.FromHours(_queueCleanerConfig.SlowMaxTime);
-        SmartTimeSpan currentTime = SmartTimeSpan.FromSeconds(download.Eta ?? 0);
-
-        return await CheckIfSlow(
-            download.HashString!,
-            download.Name!,
-            minSpeed,
-            currentSpeed,
-            maxTime,
-            currentTime
-        );
-    }
-
-    private async Task<(bool ShouldRemove, DeleteReason Reason)> CheckIfStuck(TorrentInfo download)
-    {
-        if (_queueCleanerConfig.StalledMaxStrikes is 0)
-        {
-            return (false, DeleteReason.None);
-        }
-        
-        if (download.Status is not 4)
-        {
-            // not in downloading state
-            return (false, DeleteReason.None);
-        }
-        
-        if (download.RateDownload > 0 || download.Eta > 0)
-        {
-            return (false, DeleteReason.None);
-        }
-        
-        if (_queueCleanerConfig.StalledIgnorePrivate && (download.IsPrivate ?? false))
-        {
-            // ignore private trackers
-            _logger.LogDebug("skip stalled check | download is private | {name}", download.Name);
-            return (false, DeleteReason.None);
-        }
-        
-        ResetStalledStrikesOnProgress(download.HashString!, download.DownloadedEver ?? 0);
-        
-        return (await _striker.StrikeAndCheckLimit(download.HashString!, download.Name!, _queueCleanerConfig.StalledMaxStrikes, StrikeType.Stalled), DeleteReason.Stalled);
-    }
-
-    private async Task<TorrentInfo?> GetTorrentAsync(string hash) =>
-        (await _client.TorrentGetAsync(Fields, hash))
-        ?.Torrents
-        ?.FirstOrDefault();
-}

code/Infrastructure/Verticals/Jobs/GenericHandler.cs

@@ -1,143 +0,0 @@
-using Common.Configuration.Arr;
-using Common.Configuration.DownloadClient;
-using Domain.Enums;
-using Domain.Models.Arr;
-using Domain.Models.Arr.Queue;
-using Infrastructure.Verticals.Arr;
-using Infrastructure.Verticals.Arr.Interfaces;
-using Infrastructure.Verticals.DownloadClient;
-using Infrastructure.Verticals.Notifications;
-using Microsoft.Extensions.Logging;
-using Microsoft.Extensions.Options;
-
-namespace Infrastructure.Verticals.Jobs;
-
-public abstract class GenericHandler : IHandler, IDisposable
-{
-    protected readonly ILogger<GenericHandler> _logger;
-    protected readonly DownloadClientConfig _downloadClientConfig;
-    protected readonly SonarrConfig _sonarrConfig;
-    protected readonly RadarrConfig _radarrConfig;
-    protected readonly LidarrConfig _lidarrConfig;
-    protected readonly ISonarrClient _sonarrClient;
-    protected readonly IRadarrClient _radarrClient;
-    protected readonly ILidarrClient _lidarrClient;
-    protected readonly ArrQueueIterator _arrArrQueueIterator;
-    protected readonly IDownloadService _downloadService;
-    protected readonly INotificationPublisher _notifier;
-
-    protected GenericHandler(
-        ILogger<GenericHandler> logger,
-        IOptions<DownloadClientConfig> downloadClientConfig,
-        IOptions<SonarrConfig> sonarrConfig,
-        IOptions<RadarrConfig> radarrConfig,
-        IOptions<LidarrConfig> lidarrConfig,
-        ISonarrClient sonarrClient,
-        IRadarrClient radarrClient,
-        ILidarrClient lidarrClient,
-        ArrQueueIterator arrArrQueueIterator,
-        DownloadServiceFactory downloadServiceFactory,
-        INotificationPublisher notifier
-    )
-    {
-        _logger = logger;
-        _downloadClientConfig = downloadClientConfig.Value;
-        _sonarrConfig = sonarrConfig.Value;
-        _radarrConfig = radarrConfig.Value;
-        _lidarrConfig = lidarrConfig.Value;
-        _sonarrClient = sonarrClient;
-        _radarrClient = radarrClient;
-        _lidarrClient = lidarrClient;
-        _arrArrQueueIterator = arrArrQueueIterator;
-        _downloadService = downloadServiceFactory.CreateDownloadClient();
-        _notifier = notifier;
-    }
-
-    public virtual async Task ExecuteAsync()
-    {
-        await _downloadService.LoginAsync();
-
-        await ProcessArrConfigAsync(_sonarrConfig, InstanceType.Sonarr);
-        await ProcessArrConfigAsync(_radarrConfig, InstanceType.Radarr);
-        await ProcessArrConfigAsync(_lidarrConfig, InstanceType.Lidarr);
-    }
-
-    public virtual void Dispose()
-    {
-        _downloadService.Dispose();
-    }
-
-    protected abstract Task ProcessInstanceAsync(ArrInstance instance, InstanceType instanceType);
-    
-    protected async Task ProcessArrConfigAsync(ArrConfig config, InstanceType instanceType, bool throwOnFailure = false)
-    {
-        if (!config.Enabled)
-        {
-            return;
-        }
-
-        foreach (ArrInstance arrInstance in config.Instances)
-        {
-            try
-            {
-                await ProcessInstanceAsync(arrInstance, instanceType);
-            }
-            catch (Exception exception)
-            {
-                _logger.LogError(exception, "failed to clean {type} instance | {url}", instanceType, arrInstance.Url);
-
-                if (throwOnFailure)
-                {
-                    throw;
-                }
-            }
-        }
-    }
-    
-    protected IArrClient GetClient(InstanceType type) =>
-        type switch
-        {
-            InstanceType.Sonarr => _sonarrClient,
-            InstanceType.Radarr => _radarrClient,
-            InstanceType.Lidarr => _lidarrClient,
-            _ => throw new NotImplementedException($"instance type {type} is not yet supported")
-        };
-
-    protected SearchItem GetRecordSearchItem(InstanceType type, QueueRecord record, bool isPack = false)
-    {
-        return type switch
-        {
-            InstanceType.Sonarr when _sonarrConfig.SearchType is SonarrSearchType.Episode && !isPack => new SonarrSearchItem
-            {
-                Id = record.EpisodeId,
-                SeriesId = record.SeriesId,
-                SearchType = SonarrSearchType.Episode
-            },
-            InstanceType.Sonarr when _sonarrConfig.SearchType is SonarrSearchType.Episode && isPack => new SonarrSearchItem
-            {
-                Id = record.SeasonNumber,
-                SeriesId = record.SeriesId,
-                SearchType = SonarrSearchType.Season
-            },
-            InstanceType.Sonarr when _sonarrConfig.SearchType is SonarrSearchType.Season => new SonarrSearchItem
-            {
-                Id = record.SeasonNumber,
-                SeriesId = record.SeriesId,
-                SearchType = SonarrSearchType.Series
-            },
-            InstanceType.Sonarr when _sonarrConfig.SearchType is SonarrSearchType.Series => new SonarrSearchItem
-            {
-                Id = record.SeriesId
-            },
-            InstanceType.Radarr => new SearchItem
-            {
-                Id = record.MovieId
-            },
-            InstanceType.Lidarr => new SearchItem
-            {
-                Id = record.AlbumId
-            },
-            _ => throw new NotImplementedException($"instance type {type} is not yet supported")
-        };
-    }
-}

code/Infrastructure/Verticals/Jobs/IHandler.cs

@@ -1,6 +0,0 @@
-namespace Infrastructure.Verticals.Jobs;
-
-public interface IHandler
-{
-    Task ExecuteAsync();
-}

code/Infrastructure/Verticals/Notifications/Apprise/IAppriseProxy.cs

@@ -1,6 +0,0 @@
-namespace Infrastructure.Verticals.Notifications.Apprise;
-
-public interface IAppriseProxy
-{
-    Task SendNotification(ApprisePayload payload, AppriseConfig config);
-}

code/Infrastructure/Verticals/Notifications/Models/FailedImportStrikeNotification.cs

@@ -1,5 +0,0 @@
-namespace Infrastructure.Verticals.Notifications.Models;
-
-public sealed record FailedImportStrikeNotification : ArrNotification
-{
-}

code/Infrastructure/Verticals/Notifications/Models/QueueItemDeletedNotification.cs

@@ -1,5 +0,0 @@
-namespace Infrastructure.Verticals.Notifications.Models;
-
-public sealed record QueueItemDeletedNotification : ArrNotification
-{
-}

code/Infrastructure/Verticals/Notifications/Models/SlowStrikeNotification.cs

@@ -1,5 +0,0 @@
-namespace Infrastructure.Verticals.Notifications.Models;
-
-public sealed record SlowStrikeNotification : ArrNotification
-{
-}

code/Infrastructure/Verticals/Notifications/Models/StalledStrikeNotification.cs

@@ -1,5 +0,0 @@
-namespace Infrastructure.Verticals.Notifications.Models;
-
-public sealed record StalledStrikeNotification : ArrNotification
-{
-}

code/Infrastructure/Verticals/Notifications/Notifiarr/INotifiarrProxy.cs

@@ -1,6 +0,0 @@
-namespace Infrastructure.Verticals.Notifications.Notifiarr;
-
-public interface INotifiarrProxy
-{
-    Task SendNotification(NotifiarrPayload payload, NotifiarrConfig config);
-}

code/Infrastructure/Verticals/QueueCleaner/QueueCleaner.cs

@@ -1,150 +0,0 @@
-using Common.Configuration.Arr;
-using Common.Configuration.DownloadClient;
-using Common.Configuration.QueueCleaner;
-using Domain.Enums;
-using Domain.Models.Arr;
-using Domain.Models.Arr.Queue;
-using Infrastructure.Providers;
-using Infrastructure.Verticals.Arr;
-using Infrastructure.Verticals.Arr.Interfaces;
-using Infrastructure.Verticals.Context;
-using Infrastructure.Verticals.DownloadClient;
-using Infrastructure.Verticals.Jobs;
-using Infrastructure.Verticals.Notifications;
-using Microsoft.Extensions.Logging;
-using Microsoft.Extensions.Options;
-using Serilog.Context;
-
-namespace Infrastructure.Verticals.QueueCleaner;
-
-public sealed class QueueCleaner : GenericHandler
-{
-    private readonly QueueCleanerConfig _config;
-    private readonly IgnoredDownloadsProvider<QueueCleanerConfig> _ignoredDownloadsProvider;
-
-    public QueueCleaner(
-        ILogger<QueueCleaner> logger,
-        IOptions<QueueCleanerConfig> config,
-        IOptions<DownloadClientConfig> downloadClientConfig,
-        IOptions<SonarrConfig> sonarrConfig,
-        IOptions<RadarrConfig> radarrConfig,
-        IOptions<LidarrConfig> lidarrConfig,
-        SonarrClient sonarrClient,
-        RadarrClient radarrClient,
-        LidarrClient lidarrClient,
-        ArrQueueIterator arrArrQueueIterator,
-        DownloadServiceFactory downloadServiceFactory,
-        INotificationPublisher notifier,
-        IgnoredDownloadsProvider<QueueCleanerConfig> ignoredDownloadsProvider
-    ) : base(
-        logger, downloadClientConfig,
-        sonarrConfig, radarrConfig, lidarrConfig,
-        sonarrClient, radarrClient, lidarrClient,
-        arrArrQueueIterator, downloadServiceFactory,
-        notifier
-    )
-    {
-        _config = config.Value;
-        _config.Validate();
-        _ignoredDownloadsProvider = ignoredDownloadsProvider;
-    }
-    
-    protected override async Task ProcessInstanceAsync(ArrInstance instance, InstanceType instanceType)
-    {
-        IReadOnlyList<string> ignoredDownloads = await _ignoredDownloadsProvider.GetIgnoredDownloads();
-        
-        using var _ = LogContext.PushProperty("InstanceName", instanceType.ToString());
-        
-        HashSet<SearchItem> itemsToBeRefreshed = [];
-        IArrClient arrClient = GetClient(instanceType);
-        
-        // push to context
-        ContextProvider.Set(nameof(ArrInstance) + nameof(ArrInstance.Url), instance.Url);
-        ContextProvider.Set(nameof(InstanceType), instanceType);
-
-        await _arrArrQueueIterator.Iterate(arrClient, instance, async items =>
-        {
-            var groups = items
-                .GroupBy(x => x.DownloadId)
-                .ToList();
-            
-            foreach (var group in groups)
-            {
-                if (group.Any(x => !arrClient.IsRecordValid(x)))
-                {
-                    continue;
-                }
-                
-                QueueRecord record = group.First();
-                
-                _logger.LogTrace("processing | {title} | {id}", record.Title, record.DownloadId);
-                
-                if (!arrClient.IsRecordValid(record))
-                {
-                    continue;
-                }
-                
-                if (ignoredDownloads.Contains(record.DownloadId, StringComparer.InvariantCultureIgnoreCase))
-                {
-                    _logger.LogInformation("skip | {title} | ignored", record.Title);
-                    continue;
-                }
-                
-                // push record to context
-                ContextProvider.Set(nameof(QueueRecord), record);
-
-                DownloadCheckResult downloadCheckResult = new();
-
-                if (record.Protocol is "torrent" && _downloadClientConfig.DownloadClient is not Common.Enums.DownloadClient.Disabled)
-                {
-                    if (_downloadClientConfig.DownloadClient is Common.Enums.DownloadClient.None)
-                    {
-                        _logger.LogWarning("skip | download client is not configured | {title}", record.Title);
-                        continue;
-                    }
-                    
-                    // stalled download check
-                    downloadCheckResult = await _downloadService.ShouldRemoveFromArrQueueAsync(record.DownloadId, ignoredDownloads);
-                }
-                
-                // failed import check
-                bool shouldRemoveFromArr = await arrClient.ShouldRemoveFromQueue(instanceType, record, downloadCheckResult.IsPrivate);
-                DeleteReason deleteReason = downloadCheckResult.ShouldRemove ? downloadCheckResult.DeleteReason : DeleteReason.ImportFailed;
-
-                if (!shouldRemoveFromArr && !downloadCheckResult.ShouldRemove)
-                {
-                    _logger.LogInformation("skip | {title}", record.Title);
-                    continue;
-                }
-                
-                itemsToBeRefreshed.Add(GetRecordSearchItem(instanceType, record, group.Count() > 1));
-
-                bool removeFromClient = true;
-
-                if (downloadCheckResult.IsPrivate)
-                {
-                    bool isStalledWithoutPruneFlag = 
-                        downloadCheckResult.DeleteReason is DeleteReason.Stalled &&
-                        !_config.StalledDeletePrivate;
-    
-                    bool isSlowWithoutPruneFlag = 
-                        downloadCheckResult.DeleteReason is DeleteReason.SlowSpeed or DeleteReason.SlowTime &&
-                        !_config.SlowDeletePrivate;
-    
-                    bool shouldKeepDueToDeleteRules = downloadCheckResult.ShouldRemove && (isStalledWithoutPruneFlag || isSlowWithoutPruneFlag);
-                    bool shouldKeepDueToImportRules = shouldRemoveFromArr && !_config.ImportFailedDeletePrivate;
-
-                    if (shouldKeepDueToDeleteRules || shouldKeepDueToImportRules)
-                    {
-                        removeFromClient = false;
-                    }
-                }
-                
-                await arrClient.DeleteQueueItemAsync(instance, record, removeFromClient, deleteReason);
-                await _notifier.NotifyQueueItemDeleted(removeFromClient, deleteReason);
-            }
-        });
-        
-        await arrClient.RefreshItemsAsync(instance, itemsToBeRefreshed);
-    }
-}

code/Makefile

@@ -0,0 +1,16 @@
+.DEFAULT_GOAL := no-default
+
+no-default:
+	$(error You must specify a make target)
+
+migrate-data:
+ifndef name
+	$(error name is required. Usage: make migrate-data name=YourMigrationName)
+endif
+	dotnet ef migrations add $(name) --context DataContext --project backend/Cleanuparr.Persistence/Cleanuparr.Persistence.csproj --startup-project backend/Cleanuparr.Api/Cleanuparr.Api.csproj --output-dir Migrations/Data
+
+migrate-events:
+ifndef name
+	$(error name is required. Usage: make migrate-events name=YourMigrationName)
+endif
+	dotnet ef migrations add $(name) --context EventsContext --project backend/Cleanuparr.Persistence/Cleanuparr.Persistence.csproj --startup-project backend/Cleanuparr.Api/Cleanuparr.Api.csproj --output-dir Migrations/Events

code/backend/Cleanuparr.Api/Cleanuparr.Api.csproj

@@ -0,0 +1,49 @@
+<Project Sdk="Microsoft.NET.Sdk.Web">
+
+    <PropertyGroup>
+        <AssemblyName>Cleanuparr</AssemblyName>
+        <Version Condition="'$(Version)' == ''">0.0.1</Version>
+        <TargetFramework>net9.0</TargetFramework>
+        <Nullable>enable</Nullable>
+        <ImplicitUsings>enable</ImplicitUsings>
+        <PublishReadyToRun>true</PublishReadyToRun>
+        <EnableMacOSCodeSign>false</EnableMacOSCodeSign>
+        <CodeSignOnCopy>false</CodeSignOnCopy>
+        <_CodeSignDuringBuild>false</_CodeSignDuringBuild>
+        <CodesignDisableTimestamp>true</CodesignDisableTimestamp>
+        <CodesignKeychain></CodesignKeychain>
+    </PropertyGroup>
+
+    <ItemGroup>
+      <Folder Include="wwwroot\" />
+    </ItemGroup>
+
+    <ItemGroup>
+      <ProjectReference Include="..\Cleanuparr.Application\Cleanuparr.Application.csproj" />
+      <ProjectReference Include="..\Cleanuparr.Infrastructure\Cleanuparr.Infrastructure.csproj" />
+    </ItemGroup>
+
+    <ItemGroup>
+        <PackageReference Include="Microsoft.EntityFrameworkCore.Design" Version="9.0.6">
+          <PrivateAssets>all</PrivateAssets>
+          <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+        </PackageReference>
+        <PackageReference Include="Microsoft.Extensions.Hosting" Version="9.0.6" />
+        <PackageReference Include="Microsoft.Extensions.Hosting.WindowsServices" Version="9.0.6" />
+        <PackageReference Include="Microsoft.Extensions.Http" Version="9.0.6" />
+        <PackageReference Include="Microsoft.Extensions.Http.Polly" Version="9.0.6" />
+        <PackageReference Include="Quartz" Version="3.14.0" />
+        <PackageReference Include="Quartz.Extensions.DependencyInjection" Version="3.14.0" />
+        <PackageReference Include="Quartz.Extensions.Hosting" Version="3.14.0" />
+        <PackageReference Include="Serilog" Version="4.3.0" />
+        <PackageReference Include="Serilog.Expressions" Version="5.0.0" />
+        <PackageReference Include="Serilog.Extensions.Hosting" Version="9.0.0" />
+        <PackageReference Include="Serilog.Settings.Configuration" Version="9.0.0" />
+        <PackageReference Include="Serilog.Sinks.Console" Version="6.0.0" />
+        <PackageReference Include="Serilog.Sinks.File" Version="7.0.0" />
+        <!-- API-related packages -->
+        <PackageReference Include="Microsoft.AspNetCore.OpenApi" Version="9.0.2" />
+        <PackageReference Include="Swashbuckle.AspNetCore" Version="6.5.0" />
+    </ItemGroup>
+
+</Project>

code/backend/Cleanuparr.Api/Controllers/ApiDocumentationController.cs

@@ -0,0 +1,14 @@
+using Microsoft.AspNetCore.Mvc;
+
+namespace Cleanuparr.Api.Controllers;
+
+[ApiController]
+[Route("api")]
+public class ApiDocumentationController : ControllerBase
+{
+    [HttpGet]
+    public IActionResult RedirectToSwagger()
+    {
+        return Redirect("/api/swagger");
+    }
+}

code/backend/Cleanuparr.Api/Controllers/EventsController.cs

@@ -0,0 +1,240 @@
+using System.Text.Json.Serialization;
+using Cleanuparr.Domain.Enums;
+using Cleanuparr.Persistence;
+using Cleanuparr.Persistence.Models.Events;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.EntityFrameworkCore;
+
+namespace Cleanuparr.Api.Controllers;
+
+[ApiController]
+[Route("api/[controller]")]
+public class EventsController : ControllerBase
+{
+    private readonly EventsContext _context;
+
+    public EventsController(EventsContext context)
+    {
+        _context = context;
+    }
+
+    /// <summary>
+    /// Gets events with pagination and filtering
+    /// </summary>
+    [HttpGet]
+    public async Task<ActionResult<PaginatedResult<AppEvent>>> GetEvents(
+        [FromQuery] int page = 1,
+        [FromQuery] int pageSize = 100,
+        [FromQuery] string? severity = null,
+        [FromQuery] string? eventType = null,
+        [FromQuery] DateTime? fromDate = null,
+        [FromQuery] DateTime? toDate = null,
+        [FromQuery] string? search = null)
+    {
+        // Validate pagination parameters
+        if (page < 1) page = 1;
+        if (pageSize < 1) pageSize = 100;
+        if (pageSize > 1000) pageSize = 1000; // Cap at 1000 for performance
+        
+        var query = _context.Events.AsQueryable();
+
+        // Apply filters
+        if (!string.IsNullOrWhiteSpace(severity))
+        {
+            if (Enum.TryParse<EventSeverity>(severity, true, out var severityEnum))
+                query = query.Where(e => e.Severity == severityEnum);
+        }
+
+        if (!string.IsNullOrWhiteSpace(eventType))
+        {
+            if (Enum.TryParse<EventType>(eventType, true, out var eventTypeEnum))
+                query = query.Where(e => e.EventType == eventTypeEnum);
+        }
+        
+        // Apply date range filters
+        if (fromDate.HasValue)
+        {
+            query = query.Where(e => e.Timestamp >= fromDate.Value);
+        }
+        
+        if (toDate.HasValue)
+        {
+            query = query.Where(e => e.Timestamp <= toDate.Value);
+        }
+
+        // Apply search filter if provided
+        if (!string.IsNullOrWhiteSpace(search))
+        {
+            string pattern = EventsContext.GetLikePattern(search);
+            query = query.Where(e =>
+                EF.Functions.Like(e.Message, pattern) ||
+                EF.Functions.Like(e.Data, pattern) ||
+                EF.Functions.Like(e.TrackingId.ToString(), pattern)
+            );
+        }
+
+        // Count total matching records for pagination
+        var totalCount = await query.CountAsync();
+        
+        // Calculate pagination
+        var totalPages = (int)Math.Ceiling(totalCount / (double)pageSize);
+        var skip = (page - 1) * pageSize;
+        
+        // Get paginated data
+        var events = await query
+            .OrderByDescending(e => e.Timestamp)
+            .Skip(skip)
+            .Take(pageSize)
+            .ToListAsync();
+
+        events = events
+            .OrderBy(e => e.Timestamp)
+            .ToList();
+
+        // Return paginated result
+        var result = new PaginatedResult<AppEvent>
+        {
+            Items = events,
+            Page = page,
+            PageSize = pageSize,
+            TotalCount = totalCount,
+            TotalPages = totalPages
+        };
+        
+        return Ok(result);
+    }
+
+    /// <summary>
+    /// Gets a specific event by ID
+    /// </summary>
+    [HttpGet("{id}")]
+    public async Task<ActionResult<AppEvent>> GetEvent(Guid id)
+    {
+        var eventEntity = await _context.Events.FindAsync(id);
+        
+        if (eventEntity == null)
+            return NotFound();
+
+        return Ok(eventEntity);
+    }
+
+    /// <summary>
+    /// Gets events by tracking ID
+    /// </summary>
+    [HttpGet("tracking/{trackingId}")]
+    public async Task<ActionResult<List<AppEvent>>> GetEventsByTracking(Guid trackingId)
+    {
+        var events = await _context.Events
+            .Where(e => e.TrackingId == trackingId)
+            .OrderBy(e => e.Timestamp)
+            .ToListAsync();
+
+        return Ok(events);
+    }
+
+    /// <summary>
+    /// Gets event statistics
+    /// </summary>
+    [HttpGet("stats")]
+    public async Task<ActionResult<object>> GetEventStats()
+    {
+        var stats = new
+        {
+            TotalEvents = await _context.Events.CountAsync(),
+            EventsBySeverity = await _context.Events
+                .GroupBy(e => e.Severity)
+                .Select(g => new { Severity = g.Key.ToString(), Count = g.Count() })
+                .ToListAsync(),
+            EventsByType = await _context.Events
+                .GroupBy(e => e.EventType)
+                .Select(g => new { EventType = g.Key.ToString(), Count = g.Count() })
+                .OrderByDescending(x => x.Count)
+                .Take(10)
+                .ToListAsync(),
+            RecentEventsCount = await _context.Events
+                .Where(e => e.Timestamp > DateTime.UtcNow.AddHours(-24))
+                .CountAsync()
+        };
+
+        return Ok(stats);
+    }
+
+    /// <summary>
+    /// Manually triggers cleanup of old events
+    /// </summary>
+    [HttpPost("cleanup")]
+    public async Task<ActionResult<object>> CleanupOldEvents([FromQuery] int retentionDays = 30)
+    {
+        var cutoffDate = DateTime.UtcNow.AddDays(-retentionDays);
+        
+        await _context.Events
+            .Where(e => e.Timestamp < cutoffDate)
+            .ExecuteDeleteAsync();
+        
+        return Ok();
+    }
+
+    /// <summary>
+    /// Gets unique event types
+    /// </summary>
+    [HttpGet("types")]
+    public async Task<ActionResult<List<string>>> GetEventTypes()
+    {
+        var types = Enum.GetNames(typeof(EventType)).ToList();
+        return Ok(types);
+    }
+
+    /// <summary>
+    /// Gets unique severities
+    /// </summary>
+    [HttpGet("severities")]
+    public async Task<ActionResult<List<string>>> GetSeverities()
+    {
+        var severities = Enum.GetNames(typeof(EventSeverity)).ToList();
+        return Ok(severities);
+    }
+} 
+
+/// <summary>
+/// Represents a paginated result set
+/// </summary>
+/// <typeparam name="T">Type of items in the result</typeparam>
+public class PaginatedResult<T>
+{
+    /// <summary>
+    /// The items in the current page
+    /// </summary>
+    public List<T> Items { get; set; } = new();
+    
+    /// <summary>
+    /// Current page number (1-based)
+    /// </summary>
+    public int Page { get; set; }
+    
+    /// <summary>
+    /// Number of items per page
+    /// </summary>
+    public int PageSize { get; set; }
+    
+    /// <summary>
+    /// Total number of items across all pages
+    /// </summary>
+    public int TotalCount { get; set; }
+    
+    /// <summary>
+    /// Total number of pages
+    /// </summary>
+    public int TotalPages { get; set; }
+    
+    /// <summary>
+    /// Whether there is a previous page
+    /// </summary>
+    [JsonIgnore]
+    public bool HasPrevious => Page > 1;
+    
+    /// <summary>
+    /// Whether there is a next page
+    /// </summary>
+    [JsonIgnore]
+    public bool HasNext => Page < TotalPages;
+}

code/backend/Cleanuparr.Api/Controllers/HealthCheckController.cs

@@ -0,0 +1,103 @@
+using Cleanuparr.Infrastructure.Health;
+using Microsoft.AspNetCore.Mvc;
+
+namespace Cleanuparr.Api.Controllers;
+
+/// <summary>
+/// Controller for checking the health of download clients
+/// </summary>
+[ApiController]
+[Route("api/health")]
+public class HealthCheckController : ControllerBase
+{
+    private readonly ILogger<HealthCheckController> _logger;
+    private readonly IHealthCheckService _healthCheckService;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="HealthCheckController"/> class
+    /// </summary>
+    public HealthCheckController(
+        ILogger<HealthCheckController> logger,
+        IHealthCheckService healthCheckService)
+    {
+        _logger = logger;
+        _healthCheckService = healthCheckService;
+    }
+
+    /// <summary>
+    /// Gets the health status of all download clients
+    /// </summary>
+    [HttpGet]
+    public IActionResult GetAllHealth()
+    {
+        try
+        {
+            var healthStatuses = _healthCheckService.GetAllClientHealth();
+            return Ok(healthStatuses);
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Error retrieving client health statuses");
+            return StatusCode(500, new { Error = "An error occurred while retrieving client health statuses" });
+        }
+    }
+
+    /// <summary>
+    /// Gets the health status of a specific download client
+    /// </summary>
+    [HttpGet("{id:guid}")]
+    public IActionResult GetClientHealth(Guid id)
+    {
+        try
+        {
+            var healthStatus = _healthCheckService.GetClientHealth(id);
+            if (healthStatus == null)
+            {
+                return NotFound(new { Message = $"Health status for client with ID '{id}' not found" });
+            }
+
+            return Ok(healthStatus);
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Error retrieving health status for client {id}", id);
+            return StatusCode(500, new { Error = "An error occurred while retrieving the client health status" });
+        }
+    }
+
+    /// <summary>
+    /// Triggers a health check for all download clients
+    /// </summary>
+    [HttpPost("check")]
+    public async Task<IActionResult> CheckAllHealth()
+    {
+        try
+        {
+            var results = await _healthCheckService.CheckAllClientsHealthAsync();
+            return Ok(results);
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Error checking health for all clients");
+            return StatusCode(500, new { Error = "An error occurred while checking client health" });
+        }
+    }
+
+    /// <summary>
+    /// Triggers a health check for a specific download client
+    /// </summary>
+    [HttpPost("check/{id:guid}")]
+    public async Task<IActionResult> CheckClientHealth(Guid id)
+    {
+        try
+        {
+            var result = await _healthCheckService.CheckClientHealthAsync(id);
+            return Ok(result);
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Error checking health for client {id}", id);
+            return StatusCode(500, new { Error = "An error occurred while checking client health" });
+        }
+    }
+}

code/backend/Cleanuparr.Api/Controllers/JobsController.cs

@@ -0,0 +1,163 @@
+using Cleanuparr.Api.Models;
+using Cleanuparr.Infrastructure.Models;
+using Infrastructure.Services.Interfaces;
+using Microsoft.AspNetCore.Mvc;
+
+namespace Cleanuparr.Api.Controllers;
+
+[ApiController]
+[Route("api/[controller]")]
+public class JobsController : ControllerBase
+{
+    private readonly IJobManagementService _jobManagementService;
+    private readonly ILogger<JobsController> _logger;
+
+    public JobsController(IJobManagementService jobManagementService, ILogger<JobsController> logger)
+    {
+        _jobManagementService = jobManagementService;
+        _logger = logger;
+    }
+
+    [HttpGet]
+    public async Task<IActionResult> GetAllJobs()
+    {
+        try
+        {
+            var result = await _jobManagementService.GetAllJobs();
+            return Ok(result);
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Error getting all jobs");
+            return StatusCode(500, "An error occurred while retrieving jobs");
+        }
+    }
+
+    [HttpGet("{jobType}")]
+    public async Task<IActionResult> GetJob(JobType jobType)
+    {
+        try
+        {
+            var jobInfo = await _jobManagementService.GetJob(jobType);
+            
+            if (jobInfo.Status == "Not Found")
+            {
+                return NotFound($"Job '{jobType}' not found");
+            }
+            return Ok(jobInfo);
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Error getting job {jobType}", jobType);
+            return StatusCode(500, $"An error occurred while retrieving job '{jobType}'");
+        }
+    }
+
+    [HttpPost("{jobType}/start")]
+    public async Task<IActionResult> StartJob(JobType jobType, [FromBody] ScheduleRequest scheduleRequest = null)
+    {
+        try
+        {
+            // Get the schedule from the request body if provided
+            JobSchedule jobSchedule = scheduleRequest.Schedule;
+            
+            var result = await _jobManagementService.StartJob(jobType, jobSchedule);
+            
+            if (!result)
+            {
+                return BadRequest($"Failed to start job '{jobType}'");
+            }
+            return Ok(new { Message = $"Job '{jobType}' started successfully" });
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Error starting job {jobType}", jobType);
+            return StatusCode(500, $"An error occurred while starting job '{jobType}'");
+        }
+    }
+
+    [HttpPost("{jobType}/stop")]
+    public async Task<IActionResult> StopJob(JobType jobType)
+    {
+        try
+        {
+            var result = await _jobManagementService.StopJob(jobType);
+            
+            if (!result)
+            {
+                return BadRequest($"Failed to stop job '{jobType}'");
+            }
+            return Ok(new { Message = $"Job '{jobType}' stopped successfully" });
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Error stopping job {jobType}", jobType);
+            return StatusCode(500, $"An error occurred while stopping job '{jobType}'");
+        }
+    }
+
+    [HttpPost("{jobType}/pause")]
+    public async Task<IActionResult> PauseJob(JobType jobType)
+    {
+        try
+        {
+            var result = await _jobManagementService.PauseJob(jobType);
+            
+            if (!result)
+            {
+                return BadRequest($"Failed to pause job '{jobType}'");
+            }
+            return Ok(new { Message = $"Job '{jobType}' paused successfully" });
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Error pausing job {jobType}", jobType);
+            return StatusCode(500, $"An error occurred while pausing job '{jobType}'");
+        }
+    }
+
+    [HttpPost("{jobType}/resume")]
+    public async Task<IActionResult> ResumeJob(JobType jobType)
+    {
+        try
+        {
+            var result = await _jobManagementService.ResumeJob(jobType);
+            
+            if (!result)
+            {
+                return BadRequest($"Failed to resume job '{jobType}'");
+            }
+            return Ok(new { Message = $"Job '{jobType}' resumed successfully" });
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Error resuming job {jobType}", jobType);
+            return StatusCode(500, $"An error occurred while resuming job '{jobType}'");
+        }
+    }
+
+    [HttpPut("{jobType}/schedule")]
+    public async Task<IActionResult> UpdateJobSchedule(JobType jobType, [FromBody] ScheduleRequest scheduleRequest)
+    {
+        if (scheduleRequest?.Schedule == null)
+        {
+            return BadRequest("Schedule is required");
+        }
+
+        try
+        {
+            var result = await _jobManagementService.UpdateJobSchedule(jobType, scheduleRequest.Schedule);
+            
+            if (!result)
+            {
+                return BadRequest($"Failed to update schedule for job '{jobType}'");
+            }
+            return Ok(new { Message = $"Job '{jobType}' schedule updated successfully" });
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Error updating job {jobType} schedule", jobType);
+            return StatusCode(500, $"An error occurred while updating schedule for job '{jobType}'");
+        }
+    }
+}

code/backend/Cleanuparr.Api/Controllers/StatusController.cs

@@ -0,0 +1,270 @@
+using System.Diagnostics;
+using Cleanuparr.Domain.Enums;
+using Cleanuparr.Infrastructure.Features.Arr;
+using Cleanuparr.Infrastructure.Features.DownloadClient;
+using Cleanuparr.Persistence;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.EntityFrameworkCore;
+
+namespace Cleanuparr.Api.Controllers;
+
+[ApiController]
+[Route("api/[controller]")]
+public class StatusController : ControllerBase
+{
+    private readonly ILogger<StatusController> _logger;
+    private readonly DataContext _dataContext;
+    private readonly DownloadServiceFactory _downloadServiceFactory;
+    private readonly ArrClientFactory _arrClientFactory;
+
+    public StatusController(
+        ILogger<StatusController> logger,
+        DataContext dataContext,
+        DownloadServiceFactory downloadServiceFactory,
+        ArrClientFactory arrClientFactory)
+    {
+        _logger = logger;
+        _dataContext = dataContext;
+        _downloadServiceFactory = downloadServiceFactory;
+        _arrClientFactory = arrClientFactory;
+    }
+
+    [HttpGet]
+    public async Task<IActionResult> GetSystemStatus()
+    {
+        try
+        {
+            var process = Process.GetCurrentProcess();
+            
+            // Get configuration
+            var downloadClients = await _dataContext.DownloadClients
+                .AsNoTracking()
+                .ToListAsync();
+            var sonarrConfig = await _dataContext.ArrConfigs
+                .Include(x => x.Instances)
+                .AsNoTracking()
+                .FirstAsync(x => x.Type == InstanceType.Sonarr);
+            var radarrConfig = await _dataContext.ArrConfigs
+                .Include(x => x.Instances)
+                .AsNoTracking()
+                .FirstAsync(x => x.Type == InstanceType.Radarr);
+            var lidarrConfig = await _dataContext.ArrConfigs
+                .Include(x => x.Instances)
+                .AsNoTracking()
+                .FirstAsync(x => x.Type == InstanceType.Lidarr);
+            
+            var status = new
+            {
+                Application = new
+                {
+                    Version = GetType().Assembly.GetName().Version?.ToString() ?? "Unknown",
+                    process.StartTime,
+                    UpTime = DateTime.Now - process.StartTime,
+                    MemoryUsageMB = Math.Round(process.WorkingSet64 / 1024.0 / 1024.0, 2),
+                    ProcessorTime = process.TotalProcessorTime
+                },
+                DownloadClient = new
+                {
+                    // TODO
+                },
+                MediaManagers = new
+                {
+                    Sonarr = new
+                    {
+                        InstanceCount = sonarrConfig.Instances.Count
+                    },
+                    Radarr = new
+                    {
+                        InstanceCount = radarrConfig.Instances.Count
+                    },
+                    Lidarr = new
+                    {
+                        InstanceCount = lidarrConfig.Instances.Count
+                    }
+                }
+            };
+
+            return Ok(status);
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Error retrieving system status");
+            return StatusCode(500, "An error occurred while retrieving system status");
+        }
+    }
+
+    [HttpGet("download-client")]
+    public async Task<IActionResult> GetDownloadClientStatus()
+    {
+        try
+        {
+            var downloadClients = await _dataContext.DownloadClients
+                .AsNoTracking()
+                .ToListAsync();
+            var result = new Dictionary<string, object>();
+            
+            // Check for configured clients
+            if (downloadClients.Count > 0)
+            {
+                var clientsStatus = new List<object>();
+                foreach (var client in downloadClients)
+                {
+                    clientsStatus.Add(new
+                    {
+                        client.Id,
+                        client.Name,
+                        Type = client.TypeName,
+                        client.Host,
+                        client.Enabled,
+                        IsConnected = client.Enabled, // We can't check connection status without implementing test methods
+                    });
+                }
+                
+                result["Clients"] = clientsStatus;
+            }
+
+            return Ok(result);
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Error retrieving download client status");
+            return StatusCode(500, "An error occurred while retrieving download client status");
+        }
+    }
+
+    [HttpGet("arrs")]
+    public async Task<IActionResult> GetMediaManagersStatus()
+    {
+        try
+        {
+            var status = new Dictionary<string, object>();
+            
+            // Get configurations
+            var enabledSonarrInstances = await _dataContext.ArrConfigs
+                .Include(x => x.Instances)
+                .Where(x => x.Type == InstanceType.Sonarr)
+                .SelectMany(x => x.Instances)
+                .Where(x => x.Enabled)
+                .AsNoTracking()
+                .ToListAsync();
+            var enabledRadarrInstances = await _dataContext.ArrConfigs
+                .Include(x => x.Instances)
+                .Where(x => x.Type == InstanceType.Radarr)
+                .SelectMany(x => x.Instances)
+                .Where(x => x.Enabled)
+                .AsNoTracking()
+                .ToListAsync();
+            var enabledLidarrInstances = await _dataContext.ArrConfigs
+                .Include(x => x.Instances)
+                .Where(x => x.Type == InstanceType.Lidarr)
+                .SelectMany(x => x.Instances)
+                .Where(x => x.Enabled)
+                .AsNoTracking()
+                .ToListAsync();;
+
+            
+            // Check Sonarr instances
+            var sonarrStatus = new List<object>();
+            
+            foreach (var instance in enabledSonarrInstances)
+            {
+                try
+                {
+                    var sonarrClient = _arrClientFactory.GetClient(InstanceType.Sonarr);
+                    await sonarrClient.TestConnectionAsync(instance);
+                    
+                    sonarrStatus.Add(new
+                    {
+                        instance.Name,
+                        instance.Url,
+                        IsConnected = true,
+                        Message = "Successfully connected"
+                    });
+                }
+                catch (Exception ex)
+                {
+                    sonarrStatus.Add(new
+                    {
+                        instance.Name,
+                        instance.Url,
+                        IsConnected = false,
+                        Message = $"Connection failed: {ex.Message}"
+                    });
+                }
+            }
+
+            status["Sonarr"] = sonarrStatus;
+
+            // Check Radarr instances
+            var radarrStatus = new List<object>();
+            
+            foreach (var instance in enabledRadarrInstances)
+            {
+                try
+                {
+                    var radarrClient = _arrClientFactory.GetClient(InstanceType.Radarr);
+                    await radarrClient.TestConnectionAsync(instance);
+                    
+                    radarrStatus.Add(new
+                    {
+                        instance.Name,
+                        instance.Url,
+                        IsConnected = true,
+                        Message = "Successfully connected"
+                    });
+                }
+                catch (Exception ex)
+                {
+                    radarrStatus.Add(new
+                    {
+                        instance.Name,
+                        instance.Url,
+                        IsConnected = false,
+                        Message = $"Connection failed: {ex.Message}"
+                    });
+                }
+            }
+
+            status["Radarr"] = radarrStatus;
+
+            // Check Lidarr instances
+            var lidarrStatus = new List<object>();
+            
+            foreach (var instance in enabledLidarrInstances)
+            {
+                try
+                {
+                    var lidarrClient = _arrClientFactory.GetClient(InstanceType.Lidarr);
+                    await lidarrClient.TestConnectionAsync(instance);
+                    
+                    lidarrStatus.Add(new
+                    {
+                        instance.Name,
+                        instance.Url,
+                        IsConnected = true,
+                        Message = "Successfully connected"
+                    });
+                }
+                catch (Exception ex)
+                {
+                    lidarrStatus.Add(new
+                    {
+                        instance.Name,
+                        instance.Url,
+                        IsConnected = false,
+                        Message = $"Connection failed: {ex.Message}"
+                    });
+                }
+            }
+
+            status["Lidarr"] = lidarrStatus;
+
+            return Ok(status);
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Error retrieving media managers status");
+            return StatusCode(500, "An error occurred while retrieving media managers status");
+        }
+    }
+}

code/backend/Cleanuparr.Api/DependencyInjection/ApiDI.cs

@@ -0,0 +1,148 @@
+using System.Text.Json.Serialization;
+using Cleanuparr.Api.Middleware;
+using Cleanuparr.Infrastructure.Health;
+using Cleanuparr.Infrastructure.Hubs;
+using Cleanuparr.Infrastructure.Logging;
+using Microsoft.AspNetCore.Http.Json;
+using Microsoft.OpenApi.Models;
+using System.Text;
+
+namespace Cleanuparr.Api.DependencyInjection;
+
+public static class ApiDI
+{
+    public static IServiceCollection AddApiServices(this IServiceCollection services)
+    {
+        services.Configure<JsonOptions>(options =>
+        {
+            options.SerializerOptions.Converters.Add(new JsonStringEnumConverter());
+            options.SerializerOptions.ReferenceHandler = ReferenceHandler.IgnoreCycles;
+        });
+        
+        // Add API-specific services
+        services
+            .AddControllers()
+            .AddJsonOptions(options =>
+            {
+                options.JsonSerializerOptions.Converters.Add(new JsonStringEnumConverter());
+                options.JsonSerializerOptions.ReferenceHandler = ReferenceHandler.IgnoreCycles;
+            });
+        services.AddEndpointsApiExplorer();
+        
+        // Add SignalR for real-time updates
+        services
+            .AddSignalR()
+            .AddJsonProtocol(options =>
+            {
+                options.PayloadSerializerOptions.Converters.Add(new JsonStringEnumConverter());
+            });
+        
+        // Add health status broadcaster
+        services.AddHostedService<HealthStatusBroadcaster>();
+        
+        // Add logging initializer service
+        services.AddHostedService<LoggingInitializer>();
+        
+        services.AddSwaggerGen(options =>
+        {
+            options.SwaggerDoc("v1", new OpenApiInfo
+            {
+                Title = "Cleanuparr API",
+                Version = "v1",
+                Description = "API for managing media downloads and cleanups",
+                Contact = new OpenApiContact
+                {
+                    Name = "Cleanuparr Team"
+                }
+            });
+        });
+
+        return services;
+    }
+
+    public static WebApplication ConfigureApi(this WebApplication app)
+    {
+        ILogger<Program> logger = app.Services.GetRequiredService<ILogger<Program>>();
+        
+        // Enable compression
+        app.UseResponseCompression();
+        
+        // Serve static files with caching
+        app.UseStaticFiles(new StaticFileOptions
+        {
+            OnPrepareResponse = ctx =>
+            {
+                // Cache static assets for 30 days
+                // if (ctx.File.Name.EndsWith(".js") || ctx.File.Name.EndsWith(".css"))
+                // {
+                //     ctx.Context.Response.Headers.CacheControl = "public,max-age=2592000";
+                // }
+            }
+        });
+        
+        // Add the global exception handling middleware first
+        app.UseMiddleware<ExceptionMiddleware>();
+        
+        app.UseCors("Any");
+        app.UseRouting();
+
+        if (app.Environment.IsDevelopment())
+        {
+            app.UseSwagger();
+            app.UseSwaggerUI(options =>
+            {
+                options.SwaggerEndpoint("v1/swagger.json", "Cleanuparr API v1");
+                options.RoutePrefix = "swagger";
+                options.DocumentTitle = "Cleanuparr API Documentation";
+            });
+        }
+
+        app.UseAuthorization();
+        app.MapControllers();
+        
+        // Custom SPA fallback to inject base path
+        app.MapFallback(async context =>
+        {
+            var basePath = app.Configuration.GetValue<string>("BASE_PATH") ?? "/";
+            
+            // Normalize the base path (remove trailing slash if not root)
+            if (basePath != "/" && basePath.EndsWith("/"))
+            {
+                basePath = basePath.TrimEnd('/');
+            }
+            
+            var webRoot = app.Environment.WebRootPath ?? Path.Combine(app.Environment.ContentRootPath, "wwwroot");
+            var indexPath = Path.Combine(webRoot, "index.html");
+            
+            if (!File.Exists(indexPath))
+            {
+                context.Response.StatusCode = 404;
+                await context.Response.WriteAsync("index.html not found");
+                return;
+            }
+            
+            var indexContent = await File.ReadAllTextAsync(indexPath);
+            
+            // Inject the base path into the HTML
+            var scriptInjection = $@"
+    <script>
+      window['_server_base_path'] = '{basePath}';
+    </script>";
+            
+            // Insert the script right before the existing script tag
+            indexContent = indexContent.Replace(
+                "  <script>",
+                scriptInjection + "\n  <script>"
+            );
+            
+            context.Response.ContentType = "text/html";
+            await context.Response.WriteAsync(indexContent, Encoding.UTF8);
+        });
+        
+        // Map SignalR hubs
+        app.MapHub<HealthStatusHub>("/api/hubs/health");
+        app.MapHub<AppHub>("/api/hubs/app");
+
+        return app;
+    }
+}

code/backend/Cleanuparr.Api/DependencyInjection/LoggingDI.cs

@@ -0,0 +1,93 @@
+using Cleanuparr.Domain.Enums;
+using Cleanuparr.Infrastructure.Models;
+using Cleanuparr.Shared.Helpers;
+using Serilog;
+using Serilog.Events;
+using Serilog.Templates;
+using Serilog.Templates.Themes;
+
+namespace Cleanuparr.Api.DependencyInjection;
+
+public static class LoggingDI
+{
+    public static ILoggingBuilder AddLogging(this ILoggingBuilder builder)
+    {
+        Log.Logger = GetDefaultLoggerConfiguration().CreateLogger();
+        
+        return builder.ClearProviders().AddSerilog();
+    }
+
+    public static LoggerConfiguration GetDefaultLoggerConfiguration()
+    {
+        LoggerConfiguration logConfig = new();
+        const string categoryTemplate = "{#if Category is not null} {Concat('[',Category,']'),CAT_PAD}{#end}";
+        const string jobNameTemplate = "{#if JobName is not null} {Concat('[',JobName,']'),JOB_PAD}{#end}";
+
+        const string consoleOutputTemplate = $"[{{@t:yyyy-MM-dd HH:mm:ss.fff}} {{@l:u3}}]{jobNameTemplate}{categoryTemplate} {{@m}}\n{{@x}}";
+        const string fileOutputTemplate = $"{{@t:yyyy-MM-dd HH:mm:ss.fff zzz}} [{{@l:u3}}]{jobNameTemplate}{categoryTemplate} {{@m:lj}}\n{{@x}}";
+
+        // Determine job name padding
+        List<string> jobNames = [nameof(JobType.QueueCleaner), nameof(JobType.ContentBlocker), nameof(JobType.DownloadCleaner)];
+        int jobPadding = jobNames.Max(x => x.Length) + 2;
+
+        // Determine instance name padding
+        List<string> categoryNames = [
+            InstanceType.Sonarr.ToString(),
+            InstanceType.Radarr.ToString(),
+            InstanceType.Lidarr.ToString(),
+            InstanceType.Readarr.ToString(),
+            InstanceType.Whisparr.ToString(),
+            "SYSTEM"
+        ];
+        int catPadding = categoryNames.Max(x => x.Length) + 2;
+
+        // Apply padding values to templates
+        string consoleTemplate = consoleOutputTemplate
+            .Replace("JOB_PAD", jobPadding.ToString())
+            .Replace("CAT_PAD", catPadding.ToString());
+
+        string fileTemplate = fileOutputTemplate
+            .Replace("JOB_PAD", jobPadding.ToString())
+            .Replace("CAT_PAD", catPadding.ToString());
+
+        // Configure base logger with dynamic level control
+        logConfig
+            .MinimumLevel.Is(LogEventLevel.Information)
+            .Enrich.FromLogContext()
+            .WriteTo.Console(new ExpressionTemplate(consoleTemplate, theme: TemplateTheme.Literate));
+        
+        // Create the logs directory
+        string logsPath = Path.Combine(ConfigurationPathProvider.GetConfigPath(), "logs");
+        if (!Directory.Exists(logsPath))
+        {
+            try
+            {
+                Directory.CreateDirectory(logsPath);
+            }
+            catch (Exception exception)
+            {
+                throw new Exception($"Failed to create log directory | {logsPath}", exception);
+            }
+        }
+
+        // Add main log file
+        logConfig.WriteTo.File(
+            path: Path.Combine(logsPath, "cleanuparr-.txt"),
+            formatter: new ExpressionTemplate(fileTemplate),
+            fileSizeLimitBytes: 10L * 1024 * 1024,
+            rollingInterval: RollingInterval.Day,
+            rollOnFileSizeLimit: true,
+            shared: true
+        );
+
+        logConfig
+            .MinimumLevel.Override("MassTransit", LogEventLevel.Warning)
+            .MinimumLevel.Override("Microsoft.Hosting.Lifetime", LogEventLevel.Information)
+            .MinimumLevel.Override("Microsoft", LogEventLevel.Warning)
+            .MinimumLevel.Override("Quartz", LogEventLevel.Warning)
+            .MinimumLevel.Override("System.Net.Http.HttpClient", LogEventLevel.Error)
+            .Enrich.WithProperty("ApplicationName", "Cleanuparr");
+
+        return logConfig;
+    }
+}

code/backend/Cleanuparr.Api/DependencyInjection/MainDI.cs

@@ -0,0 +1,91 @@
+using System.Text.Json.Serialization;
+using Cleanuparr.Infrastructure.Features.DownloadRemover.Consumers;
+using Cleanuparr.Infrastructure.Features.Notifications.Consumers;
+using Cleanuparr.Infrastructure.Health;
+using Cleanuparr.Infrastructure.Http;
+using Cleanuparr.Infrastructure.Http.DynamicHttpClientSystem;
+using Data.Models.Arr;
+using Infrastructure.Verticals.Notifications.Models;
+using MassTransit;
+using Microsoft.Extensions.Caching.Memory;
+
+namespace Cleanuparr.Api.DependencyInjection;
+
+public static class MainDI
+{
+    public static IServiceCollection AddInfrastructure(this IServiceCollection services, IConfiguration configuration) =>
+        services
+            .AddLogging(builder => builder.ClearProviders().AddConsole())
+            .AddHttpClients(configuration)
+            .AddSingleton<MemoryCache>()
+            .AddSingleton<IMemoryCache>(serviceProvider => serviceProvider.GetRequiredService<MemoryCache>())
+            .AddServices()
+            .AddHealthServices()
+            .AddQuartzServices(configuration)
+            .AddNotifications(configuration)
+            .AddMassTransit(config =>
+            {
+                config.AddConsumer<DownloadRemoverConsumer<SearchItem>>();
+                config.AddConsumer<DownloadRemoverConsumer<SonarrSearchItem>>();
+                
+                config.AddConsumer<NotificationConsumer<FailedImportStrikeNotification>>();
+                config.AddConsumer<NotificationConsumer<StalledStrikeNotification>>();
+                config.AddConsumer<NotificationConsumer<SlowStrikeNotification>>();
+                config.AddConsumer<NotificationConsumer<QueueItemDeletedNotification>>();
+                config.AddConsumer<NotificationConsumer<DownloadCleanedNotification>>();
+                config.AddConsumer<NotificationConsumer<CategoryChangedNotification>>();
+
+                config.UsingInMemory((context, cfg) =>
+                {
+                    cfg.ConfigureJsonSerializerOptions(options =>
+                    {
+                        options.Converters.Add(new JsonStringEnumConverter());
+                        options.ReferenceHandler = ReferenceHandler.IgnoreCycles;
+
+                        return options;
+                    });
+                    
+                    cfg.ReceiveEndpoint("download-remover-queue", e =>
+                    {
+                        e.ConfigureConsumer<DownloadRemoverConsumer<SearchItem>>(context);
+                        e.ConfigureConsumer<DownloadRemoverConsumer<SonarrSearchItem>>(context);
+                        e.ConcurrentMessageLimit = 1;
+                        e.PrefetchCount = 1;
+                    });
+                    
+                    cfg.ReceiveEndpoint("notification-queue", e =>
+                    {
+                        e.ConfigureConsumer<NotificationConsumer<FailedImportStrikeNotification>>(context);
+                        e.ConfigureConsumer<NotificationConsumer<StalledStrikeNotification>>(context);
+                        e.ConfigureConsumer<NotificationConsumer<SlowStrikeNotification>>(context);
+                        e.ConfigureConsumer<NotificationConsumer<QueueItemDeletedNotification>>(context);
+                        e.ConfigureConsumer<NotificationConsumer<DownloadCleanedNotification>>(context);
+                        e.ConfigureConsumer<NotificationConsumer<CategoryChangedNotification>>(context);
+                        e.ConcurrentMessageLimit = 1;
+                        e.PrefetchCount = 1;
+                    });
+                });
+            });
+    
+    private static IServiceCollection AddHttpClients(this IServiceCollection services, IConfiguration configuration)
+    {
+        // Add the dynamic HTTP client system - this replaces all the previous static configurations
+        services.AddDynamicHttpClients();
+        
+        // Add the dynamic HTTP client provider that uses the new system
+        services.AddSingleton<IDynamicHttpClientProvider, DynamicHttpClientProvider>();
+        
+        return services;
+    }
+
+    /// <summary>
+    /// Adds health check services to the service collection
+    /// </summary>
+    private static IServiceCollection AddHealthServices(this IServiceCollection services) =>
+        services
+            // Register the health check service
+            .AddSingleton<IHealthCheckService, HealthCheckService>()
+            
+            // Register the background service for periodic health checks
+            .AddHostedService<HealthCheckBackgroundService>();
+}

code/backend/Cleanuparr.Api/DependencyInjection/NotificationsDI.cs

@@ -1,15 +1,15 @@
-using Infrastructure.Verticals.Notifications;
-using Infrastructure.Verticals.Notifications.Apprise;
-using Infrastructure.Verticals.Notifications.Notifiarr;
+using Cleanuparr.Infrastructure.Features.Notifications;
+using Cleanuparr.Infrastructure.Features.Notifications.Apprise;
+using Cleanuparr.Infrastructure.Features.Notifications.Notifiarr;
+using Infrastructure.Verticals.Notifications;
 
-namespace Executable.DependencyInjection;
+namespace Cleanuparr.Api.DependencyInjection;
 
 public static class NotificationsDI
 {
     public static IServiceCollection AddNotifications(this IServiceCollection services, IConfiguration configuration) =>
         services
-            .Configure<NotifiarrConfig>(configuration.GetSection(NotifiarrConfig.SectionName))
-            .Configure<AppriseConfig>(configuration.GetSection(AppriseConfig.SectionName))
+            // Notification configs are now managed through ConfigManager
             .AddTransient<INotifiarrProxy, NotifiarrProxy>()
             .AddTransient<INotificationProvider, NotifiarrProvider>()
             .AddTransient<IAppriseProxy, AppriseProxy>()

code/backend/Cleanuparr.Api/DependencyInjection/QuartzDI.cs

@@ -0,0 +1,20 @@
+using Cleanuparr.Api.Jobs;
+using Quartz;
+
+namespace Cleanuparr.Api.DependencyInjection;
+
+public static class QuartzDI
+{
+    public static IServiceCollection AddQuartzServices(this IServiceCollection services, IConfiguration configuration) =>
+        services
+            .AddQuartz()
+            .AddQuartzHostedService(opt =>
+            {
+                opt.WaitForJobsToComplete = true;
+            })
+            // Register BackgroundJobManager as a hosted service
+            .AddSingleton<BackgroundJobManager>()
+            .AddHostedService(provider => provider.GetRequiredService<BackgroundJobManager>());
+
+    // Jobs are now managed by BackgroundJobManager
+}