feat(infra): playlist processing saga + generalize fault handling (phase 3)

Adds the PlayList picture-processing lifecycle saga (correlated by PlayListId) mirroring the track one, and generalizes the failure plumbing: - Rename the track fault translator to ProcessingSlipFaultConsumer and use a generic Workflow.SubjectId variable + ProcessKind; it now emits typed Track{Picture,Audio}/PlayListPicture ProcessingFailed events for all slips - PlayListProcessingStateMachine (+ EF-persisted PlayListProcessingState, migration): starts on CreatePlayListResourcesEvent, finalizes on PlayListPictureProcessed, and on failure marks the playlist Failed and removes the orphaned final picture (PlayListProcessingFailedConsumer + MarkPlayListAsFailedActivity) - UpdatePlayListPictureActivity publishes PlayListPictureProcessed on success - Picture slip carries SubjectId + PlayListPicture kind + fault subscription Verified end-to-end in Docker (RabbitMQ + migrated Postgres): both saga endpoints, the fault translator and cleanup consumers configure, and an addressing cross-check confirms all 21 activity execute queues the builders address exist (caught + fixed a kebab mismatch on mark-play-list-as-failed). Build: 0 warnings, 0 errors. Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
feat(infra): track saga failure handling + cleanup (phase 2)
2026-07-05 14:55:40 +02:00 · 2026-07-05 14:49:33 +02:00 · 2026-07-05 14:41:19 +02:00 · 2026-07-05 14:22:26 +02:00 · 2026-07-05 04:58:27 +02:00 · 2026-07-05 04:38:12 +02:00
764 changed files with 1380 additions and 70307 deletions
@@ -1,24 +0,0 @@
 {
 	"version": "0.0.1",
 	"configurations": [
 		{
 			"name": "musify-web",
 			"runtimeExecutable": "npm",
 			"runtimeArgs": ["--prefix", "web-player", "run", "dev"],
 			"port": 3000,
 			"autoPort": true
 		},
 		{
 			"name": "musify-api",
 			"runtimeExecutable": "dotnet",
 			"runtimeArgs": ["run", "--project", "backend/Hosts/Musify.Api"],
 			"port": 5111
 		},
 		{
 			"name": "musify-streaming-gateway",
 			"runtimeExecutable": "dotnet",
 			"runtimeArgs": ["run", "--project", "backend/Hosts/Musify.StreamingGateway"],
 			"port": 8081
 		}
 	]
 }
@@ -4,13 +4,6 @@
 # Force LF for shell scripts
 *.sh text eol=lf
 # Env templates get `cp`-ed straight into deploy/.env / deploy/.env.prod,
 # which containers (e.g. zitadel-init in deploy/compose.yml) parse with
 # plain shell text tools — keep them LF so a Windows checkout can't
 # reintroduce CRLF into a value that then looks non-empty but isn't.
 .env.example text eol=lf
 .env.prod.example text eol=lf
 # Treat common binaries as binary
 *.png binary
 *.jpg binary
@@ -1,115 +0,0 @@
 name: CI/CD
 on:
  push:
    branches: ['**']
  pull_request:
    branches: ['**']
 concurrency:
  group: production-deploy
  cancel-in-progress: false
 jobs:
  backend-tests:
    name: BackEnd
    runs-on: ubuntu-latest
    timeout-minutes: 20
    defaults:
      run:
        working-directory: backend
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-dotnet@v4
        with:
          dotnet-version: '10.0.x'
      - name: Restore
        run: dotnet restore Musify.slnx
      - name: Build
        run: dotnet build Musify.slnx --no-restore -c Release
      - name: Test
        run: dotnet test Musify.slnx --no-build -c Release
  web-player-checks:
    name: WebPlayer
    runs-on: ubuntu-latest
    timeout-minutes: 15
    defaults:
      run:
        working-directory: web-player
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
        with:
          node-version: '22'
          cache: npm
          cache-dependency-path: web-player/package-lock.json
      - run: npm ci
      - name: Type-check
        run: npm run check
      - name: Lint
        run: npm run lint
  # Runs on the production host itself, through the existing self-hosted
  # Gitea Actions runner (act_runner), which also carries a "production"
  # label registered in native (non-docker) mode so its steps see the host's
  # real Docker daemon directly (Docker socket + a bind-mounted deploy
  # directory — see deploy/README.md for how that runner is set up).
  #
  # DEPLOY_PATH is the persistent clone already on that host (the one whose
  # deploy/.env.prod is filled in and matches SharedServices/.env.prod) —
  # deploy reuses it instead of a fresh checkout, since .env.prod is
  # untracked and only lives there.
  deploy:
    name: Deploy
    needs: [backend-tests, web-player-checks]
    if: github.ref == 'refs/heads/master' && github.event_name == 'push'
    runs-on: [production]
    timeout-minutes: 20
    env:
      DEPLOY_PATH: /home/ubuntu/deploys/musify
      COMPOSE: docker compose --env-file deploy/.env.prod -f deploy/compose.yml -f deploy/compose.prod.yml
    steps:
      - name: Pull latest master
        run: |
          set -euo pipefail
          git config --global --add safe.directory "$DEPLOY_PATH"
          cd "$DEPLOY_PATH"
          git fetch origin master
          git reset --hard origin/master
      - name: Migrate database, generate keys
        run: |
          set -euo pipefail
          cd "$DEPLOY_PATH"
          $COMPOSE up -d wait-for-postgres keys-init migrate
      # Both jobs verify themselves through the public auth./s3. URLs, served
      # by the shared edge nginx (Infrastructure's edge/), and are idempotent.
      - name: Create OIDC app and S3 bucket
        run: |
          set -euo pipefail
          cd "$DEPLOY_PATH"
          $COMPOSE up -d seaweedfs-init zitadel-init
          for job in musify-seaweedfs-init musify-zitadel-init; do
            code=$(docker wait "$job")
            if [ "$code" != "0" ]; then
              docker logs "$job"
              echo "$job exited with $code"
              exit 1
            fi
          done
      - name: Build and start apps
        run: |
          set -euo pipefail
          cd "$DEPLOY_PATH"
          $COMPOSE --profile apps up -d --build api worker gateway web-player
@@ -0,0 +1,4 @@
 # Copilot Instructions
 ## Project Guidelines
 - No crear pruebas/tests si el usuario no lo solicita explícitamente; evitar cambios no pedidos.
@@ -7,9 +7,6 @@ obj/
 *.userosscache
 .vs/
 artifacts/
 TestResults/
 *.trx
 *.coverage
 # Rider / VS
 .idea/
@@ -18,14 +15,5 @@ TestResults/
 Thumbs.db
 .DS_Store
-# Environment files (deploy/.env, deploy/.env.prod, web-player/.env, ...)
+# Secrets / local
 .env
 .env.*
 *.env
 !.env.example
 !.env.prod.example
 # Deploy secrets and runtime state
 deploy/keys/
 deploy/secrets/
 deploy/zitadel/.output/
@@ -1,55 +0,0 @@
 # Musify
 A music streaming app. Upload your own tracks, organize them into playlists
 and albums, and stream them back with a web player built around your
 listening habits: auto-generated mixes, a home feed, search, likes, and an
 Explore page for finding something new.
 ## What it does
 - **Upload and organize your own music**: tracks, albums, cover art, artist credits.
 - **Playlists**, likes, and a "recently played" history.
 - **Mixes**, playlists generated automatically from what you actually listen to.
 - **Explore**, genre browsing and search across tracks, albums, playlists and people.
 - **Real streaming**, not just file downloads: seek, queue, shuffle, repeat.
 - **Accounts via OIDC login**, with an optional anonymous listening mode.
 - Light and dark themes, and a layout that works on both desktop and mobile.
 ## How it's built
 **Backend**: .NET 10, split into a REST API, a background worker, and a
 dedicated streaming gateway.
 - Clean architecture (Domain / Application / Infrastructure) with CQRS (Mediator) and `ErrorOr` results.
 - PostgreSQL via EF Core for metadata. RabbitMQ and MassTransit handle async processing (audio transcoding, thumbnails) with saga-based rollback.
 - SeaweedFS (S3-compatible) for file storage. Uploads and downloads go straight between the client and storage, never through the API.
 - ffmpeg for audio transcoding, ImageSharp for thumbnails.
 - A YARP reverse proxy that streams the audio and checks a signed, short-lived ticket on every request.
 - Zitadel for login (OIDC/OAuth2).
 **Web client**: SvelteKit 2 on Svelte 5 (runes), TypeScript, Tailwind 4.
 The session lives on the server, so the backend access token never reaches the browser.
 **Infrastructure**: Musify's own apps run from Docker Compose (dev and
 production overlays). Postgres, RabbitMQ, SeaweedFS, Zitadel and Jaeger are
 shared infrastructure that lives in a separate `Infrastructure` git
 repository, used by Musify and by other projects that need the same OIDC
 provider and object storage.
 ## Project layout
 ```
 backend/      .NET solution: Api, Worker, StreamingGateway, and the shared Domain/Application/Infrastructure
 web-player/   the SvelteKit web client
 deploy/       Docker Compose stacks for dev and production
 docs/         architecture notes, one file per area
 ```
 Postgres, Zitadel, SeaweedFS, RabbitMQ and Jaeger are not part of this
 layout. They live in the separate `Infrastructure` repository instead.
 ## Digging deeper
 [docs/](docs/README.md) covers how each piece works and why: architecture,
 authentication, storage, streaming, media processing, and the local dev
 setup. [deploy/README.md](deploy/README.md) has the full instructions for
 running the stack, in development or on a production server.
@@ -1,12 +0,0 @@
 **/bin/
 **/obj/
 **/.vs/
 **/.idea/
 .git/
 .github/
 .agents/
 .claude/
 **/DesignSettings.json
 *.user
 # Test projects: never shipped, no app Dockerfile needs them in its build context.
 Tests/
@@ -1,82 +0,0 @@
 using ErrorOr;
 using Mediator;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.Extensions.Logging;
 using Musify.Application.Contracts;
 using Musify.Domain.Entities;
 namespace Musify.Application.Albums
 {
    public record AddTrackToAlbumCommand(long UserId, Guid AlbumId, Guid TrackId)
        : ICommand<ErrorOr<Success>>;
    public class AddTrackToAlbumCommandHandler(
        IDatabase database,
        ILogger<AddTrackToAlbumCommandHandler> logger)
        : ICommandHandler<AddTrackToAlbumCommand, ErrorOr<Success>>
    {
        public async ValueTask<ErrorOr<Success>> Handle(AddTrackToAlbumCommand request, CancellationToken cancellationToken)
        {
            var album = await database.Albums
                .AsNoTracking()
                .SingleOrDefaultAsync(a => a.Id == request.AlbumId, cancellationToken);
            if (album == null)
            {
                logger.LogInformation("Album {AlbumId} not found", request.AlbumId);
                return Error.NotFound();
            }
            if (album.OwnerUserId != request.UserId)
            {
                logger.LogWarning("User {UserId} is not the owner of album {AlbumId}", request.UserId, request.AlbumId);
                return Error.Unauthorized();
            }
            var track = await database.Tracks
                .AsNoTracking()
                .SingleOrDefaultAsync(t => t.Id == request.TrackId, cancellationToken);
            if (track == null)
            {
                logger.LogInformation("Track {TrackId} not found", request.TrackId);
                return Error.NotFound(description: $"Track {request.TrackId} not found");
            }
            if (track.OwnerUserId != request.UserId)
            {
                logger.LogWarning("User {UserId} does not own track {TrackId}", request.UserId, request.TrackId);
                return Error.Unauthorized();
            }
            var alreadyAdded = await database.AlbumHasTracks
                .AsNoTracking()
                .AnyAsync(albumTrack => albumTrack.AlbumId == request.AlbumId && albumTrack.TrackId == request.TrackId, cancellationToken);
            if (alreadyAdded)
            {
                logger.LogInformation("Track {TrackId} already in album {AlbumId}", request.TrackId, request.AlbumId);
                return Error.Conflict(description: "Track is already in the album.");
            }
            var albumTracksQuery = database.AlbumHasTracks
                .Where(albumTrack => albumTrack.AlbumId == request.AlbumId);
            var hasTracks = await albumTracksQuery.AnyAsync(cancellationToken);
            var nextTrackNumber = hasTracks
                ? await albumTracksQuery.MaxAsync(albumTrack => albumTrack.TrackNumber, cancellationToken) + 1
                : 1;
            await database.AlbumHasTracks.AddAsync(new AlbumHasTrack
            {
                AlbumId = request.AlbumId,
                TrackId = request.TrackId,
                TrackNumber = nextTrackNumber
            }, cancellationToken);
            await database.SaveChangesAsync(cancellationToken);
            logger.LogInformation("Added track {TrackId} to album {AlbumId} as number {TrackNumber}",
                request.TrackId, request.AlbumId, nextTrackNumber);
            return new Success();
        }
    }
 }
@@ -1,128 +0,0 @@
 using ErrorOr;
 using Mediator;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.Extensions.Logging;
 using Musify.Application.Configuration;
 using Musify.Application.Shared;
 using Musify.Application.Events;
 using Musify.Application.Albums.Responses;
 using Musify.Application.Services;
 using Musify.Domain.Entities;
 using Musify.Domain.ValueObjects;
 using Musify.Application.Contracts;
 namespace Musify.Application.Albums
 {
    public record CreateAlbumCommand(
        long UserId,
        string Title,
        string? Description,
        int? ReleaseYear,
        Guid PictureIntentId)
        : ICommand<ErrorOr<AlbumApplicationResponse>>;
    public class CreateAlbumCommandHandler(
        IEventBus eventBus,
        IDatabase database,
        UploadIntentValidator uploadIntentValidator,
        ILogger<CreateAlbumCommandHandler> logger,
        ApplicationStorageConfiguration storageConfiguration,
        AlbumConfiguration albumConfiguration,
        UploadIntentConfiguration uploadIntentConfiguration)
        : ICommandHandler<CreateAlbumCommand, ErrorOr<AlbumApplicationResponse>>
    {
        public async ValueTask<ErrorOr<AlbumApplicationResponse>> Handle(CreateAlbumCommand request, CancellationToken cancellationToken)
        {
            var userExists = await database.Users
                .AsNoTracking()
                .AnyAsync(user => user.Id == request.UserId, cancellationToken);
            if (!userExists)
            {
                logger.LogWarning("User {UserId} not found", request.UserId);
                return Error.NotFound(description: $"User {request.UserId} not found");
            }
            var pictureIntent = await uploadIntentValidator.ValidateAndLoadAsync(
                uploadIntentConfiguration, request.PictureIntentId, request.UserId, cancellationToken);
            if (pictureIntent.IsError)
                return pictureIntent.Errors;
            var intent = pictureIntent.Value;
            var title = request.Title.Trim();
            var album = new Album
            {
                OwnerUserId = request.UserId,
                Title = title,
                NormalizedTitle = title.ToUpperInvariant(),
                Description = request.Description,
                ReleaseYear = request.ReleaseYear,
                Pictures = new AlbumPictures
                {
                    OriginalName = intent.ObjectName,
                    SmallName = intent.ObjectName,
                    MediumName = intent.ObjectName,
                    LargeName = intent.ObjectName
                }
            };
            await database.Albums.AddAsync(album, cancellationToken);
            var finalPictureKey = albumConfiguration.Routes.BuildOriginalPicturePath(request.UserId, intent.ObjectName);
            var publishResult = await PublishCreateAlbumEventAsync(album.Id, intent, finalPictureKey, cancellationToken);
            if (publishResult.IsError)
                return publishResult.Errors;
            try
            {
                await database.SaveChangesAsync(cancellationToken);
            }
            catch (Exception exception)
            {
                logger.LogError(exception, "Failed to save album for user {UserId}", request.UserId);
                return Error.Failure(description: $"Failed to create album for user {request.UserId}");
            }
            logger.LogInformation("Created album {AlbumId} for user {UserId}", album.Id, request.UserId);
            return AlbumApplicationResponse.FromEntity(album, trackCount: 0);
        }
        private async Task<ErrorOr<Success>> PublishCreateAlbumEventAsync(
            Guid albumId,
            UploadIntent pictureIntent,
            string finalPictureKey,
            CancellationToken cancellationToken)
        {
            try
            {
                await eventBus.PublishAsync(
                    new CreateAlbumResourcesEvent(
                        albumId,
                        pictureIntent.Id,
                        storageConfiguration.Bucket,
                        pictureIntent.Key,
                        finalPictureKey,
                        new ImageSize(
                            albumConfiguration.Routes.SmallPicturesPath,
                            albumConfiguration.PicturesSizes.SmallPictureWidth,
                            albumConfiguration.PicturesSizes.SmallPictureHeight),
                        new ImageSize(
                            albumConfiguration.Routes.MediumPicturesPath,
                            albumConfiguration.PicturesSizes.MediumPictureWidth,
                            albumConfiguration.PicturesSizes.MediumPictureHeight),
                        new ImageSize(
                            albumConfiguration.Routes.LargePicturesPath,
                            albumConfiguration.PicturesSizes.LargePictureWidth,
                            albumConfiguration.PicturesSizes.LargePictureHeight)),
                    cancellationToken);
                return new Success();
            }
            catch (Exception exception)
            {
                logger.LogError(exception, "Failed to publish create album event for album {AlbumId}", albumId);
                return Error.Failure(description: $"Failed to publish create album event for album {albumId}");
            }
        }
    }
 }
@@ -1,50 +0,0 @@
 using ErrorOr;
 using Mediator;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.Extensions.Logging;
 using Musify.Application.Contracts;
 namespace Musify.Application.Albums
 {
    public record DeleteAlbumCommand(long UserId, Guid AlbumId)
        : ICommand<ErrorOr<Success>>;
    public class DeleteAlbumCommandHandler(
        IDatabase database,
        ILogger<DeleteAlbumCommandHandler> logger)
        : ICommandHandler<DeleteAlbumCommand, ErrorOr<Success>>
    {
        public async ValueTask<ErrorOr<Success>> Handle(DeleteAlbumCommand request, CancellationToken cancellationToken)
        {
            var album = await database.Albums
                .SingleOrDefaultAsync(a => a.Id == request.AlbumId, cancellationToken);
            if (album == null)
            {
                logger.LogDebug("Album {AlbumId} not found", request.AlbumId);
                return Error.NotFound();
            }
            if (album.OwnerUserId != request.UserId)
            {
                logger.LogWarning("Album {AlbumId} does not belong to user {UserId}", request.AlbumId, request.UserId);
                return Error.Unauthorized();
            }
            database.Albums.Remove(album);
            try
            {
                await database.SaveChangesAsync(cancellationToken);
            }
            catch (Exception exception)
            {
                logger.LogError(exception, "Failed to delete album {AlbumId}", request.AlbumId);
                return Error.Failure(description: $"Failed to delete album {request.AlbumId}");
            }
            logger.LogInformation("Deleted album {AlbumId} for user {UserId}", request.AlbumId, request.UserId);
            return new Success();
        }
    }
 }
@@ -1,38 +0,0 @@
 using ErrorOr;
 using Mediator;
 using Microsoft.EntityFrameworkCore;
 using Musify.Application.Albums.Responses;
 using Musify.Application.Contracts;
 namespace Musify.Application.Albums
 {
    public record GetAlbumByIdQuery(Guid Id)
        : IQuery<ErrorOr<AlbumApplicationResponse>>;
    public class GetAlbumByIdQueryHandler(IDatabase database)
        : IQueryHandler<GetAlbumByIdQuery, ErrorOr<AlbumApplicationResponse>>
    {
        public async ValueTask<ErrorOr<AlbumApplicationResponse>> Handle(GetAlbumByIdQuery request, CancellationToken cancellationToken)
        {
            var album = await database.Albums
                .AsNoTracking()
                .Where(a => a.Id == request.Id)
                .Select(a => new
                {
                    Album = a,
                    TrackCount = a.AlbumTracks.Count,
                    CoverTrackIds = a.AlbumTracks
                        .OrderBy(albumTrack => albumTrack.TrackNumber)
                        .Take(AlbumApplicationResponse.CoverTrackCount)
                        .Select(albumTrack => albumTrack.TrackId)
                        .ToList()
                })
                .SingleOrDefaultAsync(cancellationToken);
            if (album == null)
                return Error.NotFound();
            return AlbumApplicationResponse.FromEntity(album.Album, album.TrackCount, album.CoverTrackIds);
        }
    }
 }
@@ -1,49 +0,0 @@
 using ErrorOr;
 using Mediator;
 using Microsoft.EntityFrameworkCore;
 using MimeMapping;
 using Musify.Application.Configuration;
 using Musify.Application.Contracts;
 namespace Musify.Application.Albums
 {
    public record GetAlbumCoverQuery(Guid AlbumId, string Size)
        : IQuery<ErrorOr<AlbumCoverLocation>>;
    public record AlbumCoverLocation(string Bucket, string Key, string ContentType);
    public class GetAlbumCoverQueryHandler(
        IDatabase database,
        ApplicationStorageConfiguration storageConfiguration,
        AlbumConfiguration albumConfiguration)
        : IQueryHandler<GetAlbumCoverQuery, ErrorOr<AlbumCoverLocation>>
    {
        public async ValueTask<ErrorOr<AlbumCoverLocation>> Handle(GetAlbumCoverQuery request, CancellationToken cancellationToken)
        {
            var pictures = await database.Albums.AsNoTracking()
                .Where(a => a.Id == request.AlbumId)
                .Select(a => a.Pictures)
                .SingleOrDefaultAsync(cancellationToken);
            if (pictures == null)
                return Error.NotFound();
            var routes = albumConfiguration.Routes;
            var (name, key) = request.Size.ToLowerInvariant() switch
            {
                "small" => (pictures.SmallName, BuildKey(routes.BuildSmallPicturePath, pictures.SmallName)),
                "large" => (pictures.LargeName, BuildKey(routes.BuildLargePicturePath, pictures.LargeName)),
                _ => (pictures.MediumName, BuildKey(routes.BuildMediumPicturePath, pictures.MediumName))
            };
            if (string.IsNullOrEmpty(name) || string.IsNullOrEmpty(key))
                return Error.NotFound();
            var contentType = MimeUtility.GetMimeMapping(name);
            return new AlbumCoverLocation(storageConfiguration.Bucket, key, contentType);
        }
        private static string? BuildKey(Func<string, string> builder, string? name)
            => string.IsNullOrEmpty(name) ? null : builder(name);
    }
 }
@@ -1,49 +0,0 @@
 using ErrorOr;
 using Mediator;
 using Microsoft.EntityFrameworkCore;
 using Musify.Application.Contracts;
 using Musify.Application.Shared;
 using Musify.Application.Tracks.Responses;
 using X.PagedList;
 using X.PagedList.EF;
 namespace Musify.Application.Albums
 {
    public record GetAlbumTracksQuery(
        Guid AlbumId,
        int PageNumber,
        int PageSize)
        : IQuery<ErrorOr<PaginatedResponse<TrackApplicationResponse>>>;
    public class GetAlbumTracksQueryHandler(IDatabase database)
        : IQueryHandler<GetAlbumTracksQuery, ErrorOr<PaginatedResponse<TrackApplicationResponse>>>
    {
        public async ValueTask<ErrorOr<PaginatedResponse<TrackApplicationResponse>>> Handle(GetAlbumTracksQuery request, CancellationToken cancellationToken)
        {
            var albumExists = await database.Albums
                .AsNoTracking()
                .AnyAsync(album => album.Id == request.AlbumId, cancellationToken);
            if (!albumExists)
                return Error.NotFound();
            var tracksQuery = database.AlbumHasTracks
                .AsNoTracking()
                .Include(albumTrack => albumTrack.Track.Owner)
                .Include(albumTrack => albumTrack.Track.Tags)
                .Where(albumTrack => albumTrack.AlbumId == request.AlbumId);
            var totalCount = await tracksQuery.CountAsync(cancellationToken);
            var pagedEntities = await tracksQuery
                .OrderBy(albumTrack => albumTrack.TrackNumber)
                .Select(albumTrack => new { albumTrack.Track, ListensCount = albumTrack.Track.ListeningHistories.Count })
                .ToPagedListAsync(request.PageNumber, request.PageSize, totalCount, cancellationToken);
            var pagedTracks = new StaticPagedList<TrackApplicationResponse>(
                pagedEntities.Select(entry => TrackApplicationResponse.FromEntity(entry.Track, entry.ListensCount)),
                pagedEntities.PageNumber, pagedEntities.PageSize, pagedEntities.TotalItemCount);
            return PaginatedResponse<TrackApplicationResponse>.FromPagedList(pagedTracks);
        }
    }
 }
@@ -1,60 +0,0 @@
 using ErrorOr;
 using Mediator;
 using Microsoft.EntityFrameworkCore;
 using Musify.Application.Albums.Responses;
 using Musify.Application.Contracts;
 using X.PagedList;
 using X.PagedList.EF;
 namespace Musify.Application.Albums
 {
    public record GetAlbumsQuery(string? Title, int PageNumber, int PageSize)
        : IQuery<ErrorOr<AlbumsSearchResponse>>;
    public class GetAlbumsQueryHandler(IDatabase database)
        : IQueryHandler<GetAlbumsQuery, ErrorOr<AlbumsSearchResponse>>
    {
        public async ValueTask<ErrorOr<AlbumsSearchResponse>> Handle(GetAlbumsQuery request, CancellationToken cancellationToken)
        {
            var albumsQuery = database.Albums
                .AsNoTracking()
                .AsQueryable();
            if (!string.IsNullOrEmpty(request.Title))
            {
                var normalizedTitle = request.Title.Trim().ToUpperInvariant();
                albumsQuery = albumsQuery.Where(album => album.NormalizedTitle.Contains(normalizedTitle));
            }
            var totalCount = await albumsQuery.CountAsync(cancellationToken);
            var pagedEntities = await albumsQuery
                .OrderByDescending(album => album.CreatedAt)
                .Select(album => new
                {
                    Album = album,
                    TrackCount = album.AlbumTracks.Count,
                    CoverTrackIds = album.AlbumTracks
                        .OrderBy(albumTrack => albumTrack.TrackNumber)
                        .Take(AlbumApplicationResponse.CoverTrackCount)
                        .Select(albumTrack => albumTrack.TrackId)
                        .ToList()
                })
                .ToPagedListAsync(request.PageNumber, request.PageSize, totalCount, cancellationToken);
            var items = pagedEntities
                .Select(entry => AlbumSearchItemResponse.FromAlbum(
                    AlbumApplicationResponse.FromEntity(entry.Album, entry.TrackCount, entry.CoverTrackIds)))
                .ToList();
            return new AlbumsSearchResponse(
                items,
                pagedEntities.PageNumber,
                pagedEntities.PageSize,
                pagedEntities.PageCount,
                pagedEntities.TotalItemCount,
                pagedEntities.HasPreviousPage,
                pagedEntities.HasNextPage);
        }
    }
 }
@@ -1,53 +0,0 @@
 using ErrorOr;
 using Mediator;
 using Microsoft.EntityFrameworkCore;
 using Musify.Application.Albums.Responses;
 using Musify.Application.Contracts;
 using Musify.Application.Shared;
 using X.PagedList;
 using X.PagedList.EF;
 namespace Musify.Application.Albums
 {
    public record GetAlbumsByUserIdQuery(long UserId, int PageNumber, int PageSize)
        : IQuery<ErrorOr<PaginatedResponse<AlbumApplicationResponse>>>;
    public class GetAlbumsByUserIdQueryHandler(IDatabase database)
        : IQueryHandler<GetAlbumsByUserIdQuery, ErrorOr<PaginatedResponse<AlbumApplicationResponse>>>
    {
        public async ValueTask<ErrorOr<PaginatedResponse<AlbumApplicationResponse>>> Handle(GetAlbumsByUserIdQuery request, CancellationToken cancellationToken)
        {
            var userExists = await database.Users
                .AsNoTracking()
                .AnyAsync(user => user.Id == request.UserId, cancellationToken);
            if (!userExists)
                return Error.NotFound(description: $"User {request.UserId} not found");
            var albumsQuery = database.Albums
                .AsNoTracking()
                .Where(album => album.OwnerUserId == request.UserId);
            var totalCount = await albumsQuery.CountAsync(cancellationToken);
            var pagedEntities = await albumsQuery
                .OrderByDescending(album => album.CreatedAt)
                .Select(album => new
                {
                    Album = album,
                    TrackCount = album.AlbumTracks.Count,
                    CoverTrackIds = album.AlbumTracks
                        .OrderBy(albumTrack => albumTrack.TrackNumber)
                        .Take(AlbumApplicationResponse.CoverTrackCount)
                        .Select(albumTrack => albumTrack.TrackId)
                        .ToList()
                })
                .ToPagedListAsync(request.PageNumber, request.PageSize, totalCount, cancellationToken);
            var pagedAlbums = new StaticPagedList<AlbumApplicationResponse>(
                pagedEntities.Select(entry => AlbumApplicationResponse.FromEntity(entry.Album, entry.TrackCount, entry.CoverTrackIds)),
                pagedEntities.PageNumber, pagedEntities.PageSize, pagedEntities.TotalItemCount);
            return PaginatedResponse<AlbumApplicationResponse>.FromPagedList(pagedAlbums);
        }
    }
 }
@@ -1,61 +0,0 @@
 using ErrorOr;
 using Mediator;
 using Microsoft.EntityFrameworkCore;
 using Musify.Application.Albums.Responses;
 using Musify.Application.Contracts;
 namespace Musify.Application.Albums
 {
    public record GetRecentlyListenedAlbumsQuery(long UserId, int Limit)
        : IQuery<ErrorOr<IReadOnlyList<AlbumApplicationResponse>>>;
    public class GetRecentlyListenedAlbumsQueryHandler(IDatabase database)
        : IQueryHandler<GetRecentlyListenedAlbumsQuery, ErrorOr<IReadOnlyList<AlbumApplicationResponse>>>
    {
        public async ValueTask<ErrorOr<IReadOnlyList<AlbumApplicationResponse>>> Handle(GetRecentlyListenedAlbumsQuery request, CancellationToken cancellationToken)
        {
            var listenedTrackIds = database.ListeningHistories
                .AsNoTracking()
                .Where(history => history.UserId == request.UserId);
            var ranked = await database.AlbumHasTracks
                .AsNoTracking()
                .Join(
                    listenedTrackIds,
                    albumTrack => albumTrack.TrackId,
                    history => history.TrackId,
                    (albumTrack, history) => new { albumTrack.AlbumId, history.ListenedAt })
                .GroupBy(entry => entry.AlbumId)
                .Select(group => new { AlbumId = group.Key, LastListenedAt = group.Max(entry => entry.ListenedAt) })
                .OrderByDescending(entry => entry.LastListenedAt)
                .Take(request.Limit)
                .ToListAsync(cancellationToken);
            if (ranked.Count == 0)
                return new List<AlbumApplicationResponse>();
            var albumIds = ranked.Select(entry => entry.AlbumId).ToList();
            var albums = await database.Albums
                .AsNoTracking()
                .Where(album => albumIds.Contains(album.Id))
                .Select(album => new
                {
                    Album = album,
                    TrackCount = album.AlbumTracks.Count,
                    CoverTrackIds = album.AlbumTracks
                        .OrderBy(albumTrack => albumTrack.TrackNumber)
                        .Take(AlbumApplicationResponse.CoverTrackCount)
                        .Select(albumTrack => albumTrack.TrackId)
                        .ToList()
                })
                .ToDictionaryAsync(entry => entry.Album.Id, cancellationToken);
            return ranked
                .Where(entry => albums.ContainsKey(entry.AlbumId))
                .Select(entry => albums[entry.AlbumId])
                .Select(entry => AlbumApplicationResponse.FromEntity(entry.Album, entry.TrackCount, entry.CoverTrackIds))
                .ToList();
        }
    }
 }
@@ -1,59 +0,0 @@
 using ErrorOr;
 using Mediator;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.Extensions.Logging;
 using Musify.Application.Contracts;
 namespace Musify.Application.Albums
 {
    public record RemoveTrackFromAlbumCommand(long UserId, Guid AlbumId, Guid TrackId)
        : ICommand<ErrorOr<Success>>;
    public class RemoveTrackFromAlbumCommandHandler(
        IDatabase database,
        ILogger<RemoveTrackFromAlbumCommandHandler> logger)
        : ICommandHandler<RemoveTrackFromAlbumCommand, ErrorOr<Success>>
    {
        public async ValueTask<ErrorOr<Success>> Handle(RemoveTrackFromAlbumCommand request, CancellationToken cancellationToken)
        {
            var album = await database.Albums
                .AsNoTracking()
                .SingleOrDefaultAsync(a => a.Id == request.AlbumId, cancellationToken);
            if (album == null)
            {
                logger.LogInformation("Album {AlbumId} not found", request.AlbumId);
                return Error.NotFound();
            }
            if (album.OwnerUserId != request.UserId)
            {
                logger.LogWarning("User {UserId} is not the owner of album {AlbumId}", request.UserId, request.AlbumId);
                return Error.Unauthorized();
            }
            var albumTracks = await database.AlbumHasTracks
                .Where(albumTrack => albumTrack.AlbumId == request.AlbumId)
                .OrderBy(albumTrack => albumTrack.TrackNumber)
                .ToListAsync(cancellationToken);
            var link = albumTracks.SingleOrDefault(albumTrack => albumTrack.TrackId == request.TrackId);
            if (link == null)
            {
                logger.LogInformation("Track {TrackId} not in album {AlbumId}", request.TrackId, request.AlbumId);
                return Error.NotFound(description: "Track is not in the album.");
            }
            database.AlbumHasTracks.Remove(link);
            var trackNumber = 1;
            foreach (var remaining in albumTracks.Where(albumTrack => albumTrack.Id != link.Id))
                remaining.TrackNumber = trackNumber++;
            await database.SaveChangesAsync(cancellationToken);
            logger.LogInformation("Removed track {TrackId} from album {AlbumId}", request.TrackId, request.AlbumId);
            return new Success();
        }
    }
 }
@@ -1,105 +0,0 @@
 using ErrorOr;
 using Mediator;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.Extensions.Logging;
 using Musify.Application.Configuration;
 using Musify.Application.Albums.Responses;
 using Musify.Application.Services;
 using Musify.Domain.Entities;
 using Musify.Domain.ValueObjects;
 using Musify.Application.Contracts;
 namespace Musify.Application.Albums
 {
    public record RequestAlbumPictureUploadCommand(
        long UserId,
        string FileType,
        string ContentType,
        long? ExpectedSizeBytes = null)
        : ICommand<ErrorOr<AlbumPictureUploadResponse>>;
    public class RequestAlbumPictureUploadCommandHandler(
        IDatabase database,
        UploadIntentValidator uploadIntentValidator,
        IStorageService storageService,
        ILogger<RequestAlbumPictureUploadCommandHandler> logger,
        ApplicationStorageConfiguration storageConfiguration,
        AlbumConfiguration albumConfiguration,
        UploadIntentConfiguration uploadIntentConfiguration)
        : ICommandHandler<RequestAlbumPictureUploadCommand, ErrorOr<AlbumPictureUploadResponse>>
    {
        public async ValueTask<ErrorOr<AlbumPictureUploadResponse>> Handle(RequestAlbumPictureUploadCommand request, CancellationToken cancellationToken)
        {
            var userExists = await database.Users
                .AsNoTracking()
                .AnyAsync(u => u.Id == request.UserId, cancellationToken);
            if (!userExists)
            {
                logger.LogWarning("User {UserId} not found", request.UserId);
                return Error.NotFound(description: $"User {request.UserId} not found");
            }
            var effectiveSizeBytes = request.ExpectedSizeBytes
                ?? uploadIntentConfiguration.DefaultExpectedPictureSizeBytes;
            var objectName = $"{Guid.NewGuid()}.{request.FileType.TrimStart('.').ToLowerInvariant()}";
            var tempKey = albumConfiguration.Routes.BuildTempPicturePath(
                uploadIntentConfiguration.TemporalRootPrefix, request.UserId, objectName);
            try
            {
                var uploadUrl = await storageService.GetUploadUrlAsync(
                    storageConfiguration.Bucket,
                    tempKey,
                    request.ContentType,
                    TimeSpan.FromSeconds(uploadIntentConfiguration.UploadUrlExpiresInSeconds),
                    cancellationToken);
                await using var transaction = await database.BeginTransactionAsync(
                    System.Data.IsolationLevel.Serializable, cancellationToken);
                var quotaCheck = await uploadIntentValidator.CheckQuotaAsync(
                    uploadIntentConfiguration,
                    request.UserId, effectiveSizeBytes, 1, cancellationToken);
                if (quotaCheck.IsError)
                {
                    logger.LogWarning("User {UserId} failed upload intent quota check", request.UserId);
                    return quotaCheck.Errors;
                }
                var intent = new UploadIntent
                {
                    UserId = request.UserId,
                    Bucket = storageConfiguration.Bucket,
                    Key = tempKey,
                    ObjectName = objectName,
                    ContentType = request.ContentType,
                    ExpectedSizeBytes = effectiveSizeBytes,
                    Purpose = UploadIntentPurpose.AlbumPicture,
                    ExpiresAt = DateTime.UtcNow.AddSeconds(uploadIntentConfiguration.UploadUrlExpiresInSeconds),
                };
                await database.UploadIntents.AddAsync(intent, cancellationToken);
                await database.SaveChangesAsync(cancellationToken);
                await transaction.CommitAsync(cancellationToken);
                logger.LogInformation("Issued upload intent {IntentId} for user {UserId} (AlbumPicture, temp key: {Key})", intent.Id, request.UserId, tempKey);
                return new AlbumPictureUploadResponse(
                    intent.Id,
                    storageConfiguration.Bucket,
                    tempKey,
                    objectName,
                    request.ContentType,
                    uploadIntentConfiguration.UploadUrlExpiresInSeconds,
                    uploadUrl);
            }
            catch (Exception exception)
            {
                logger.LogError(exception, "Failed to generate album picture upload URL for user {UserId}", request.UserId);
                return Error.Failure(description: "Failed to generate upload URL");
            }
        }
    }
 }
@@ -1,43 +0,0 @@
 using System.Text.Json.Serialization;
 using Musify.Domain.Entities;
 using Musify.Application.Serialization;
 namespace Musify.Application.Albums.Responses
 {
    public record AlbumApplicationResponse(
        Guid Id,
        string Title,
        string? Description,
        int? ReleaseYear,
        [property: JsonConverter(typeof(LongAsStringConverter))] long OwnerUserId,
        int TrackCount,
        string? SmallImageKeyName,
        string? MediumImageKeyName,
        string? LargeImageKeyName,
        DateTime CreatedAt,
        DateTime UpdatedAt,
        IReadOnlyList<Guid> CoverTrackIds)
    {
        public const int CoverTrackCount = 4;
        public static AlbumApplicationResponse FromEntity(
            Album album,
            int trackCount,
            IReadOnlyList<Guid>? coverTrackIds = null)
        {
            return new AlbumApplicationResponse(
                album.Id,
                album.Title,
                album.Description,
                album.ReleaseYear,
                album.OwnerUserId,
                trackCount,
                album.Pictures?.SmallName,
                album.Pictures?.MediumName,
                album.Pictures?.LargeName,
                album.CreatedAt,
                album.UpdatedAt,
                coverTrackIds ?? []);
        }
    }
 }
@@ -1,11 +0,0 @@
 namespace Musify.Application.Albums.Responses
 {
    public record AlbumPictureUploadResponse(
        Guid IntentId,
        string Bucket,
        string Key,
        string PictureName,
        string ContentType,
        int ExpiresInSeconds,
        string UploadUrl);
 }
@@ -1,7 +0,0 @@
 namespace Musify.Application.Albums.Responses
 {
    public record AlbumSearchItemResponse(AlbumApplicationResponse Album)
    {
        public static AlbumSearchItemResponse FromAlbum(AlbumApplicationResponse album) => new(album);
    }
 }
@@ -1,12 +0,0 @@
 namespace Musify.Application.Albums.Responses
 {
    public record AlbumsSearchResponse(
        IReadOnlyList<AlbumSearchItemResponse> Items,
        int PageNumber,
        int PageSize,
        int PageCount,
        int TotalItemCount,
        bool HasPreviousPage,
        bool HasNextPage);
 }
@@ -1,150 +0,0 @@
 using ErrorOr;
 using Mediator;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.Extensions.Logging;
 using Musify.Application.Configuration;
 using Musify.Application.Shared;
 using Musify.Application.Events;
 using Musify.Application.Albums.Responses;
 using Musify.Application.Services;
 using Musify.Domain.Entities;
 using Musify.Domain.ValueObjects;
 using Musify.Application.Contracts;
 namespace Musify.Application.Albums
 {
    public record UpdateAlbumCommand(
        long UserId,
        Guid AlbumId,
        string Title,
        string? Description,
        int? ReleaseYear,
        Guid? NewPictureIntentId)
        : ICommand<ErrorOr<AlbumApplicationResponse>>;
    public class UpdateAlbumCommandHandler(
        IEventBus eventBus,
        IDatabase database,
        UploadIntentValidator uploadIntentValidator,
        ILogger<UpdateAlbumCommandHandler> logger,
        ApplicationStorageConfiguration storageConfiguration,
        AlbumConfiguration albumConfiguration,
        UploadIntentConfiguration uploadIntentConfiguration)
        : ICommandHandler<UpdateAlbumCommand, ErrorOr<AlbumApplicationResponse>>
    {
        public async ValueTask<ErrorOr<AlbumApplicationResponse>> Handle(UpdateAlbumCommand request, CancellationToken cancellationToken)
        {
            var album = await database.Albums
                .SingleOrDefaultAsync(a => a.Id == request.AlbumId, cancellationToken);
            if (album == null)
            {
                logger.LogInformation("Album {AlbumId} not found", request.AlbumId);
                return Error.NotFound();
            }
            if (album.OwnerUserId != request.UserId)
            {
                logger.LogWarning("Album {AlbumId} does not belong to user {UserId}", request.AlbumId, request.UserId);
                return Error.Unauthorized();
            }
            var title = request.Title.Trim();
            album.Title = title;
            album.NormalizedTitle = title.ToUpperInvariant();
            album.Description = request.Description;
            album.ReleaseYear = request.ReleaseYear;
            UploadIntent? pictureIntent = null;
            string? finalPictureKey = null;
            if (request.NewPictureIntentId.HasValue)
            {
                var validation = await uploadIntentValidator.ValidateAndLoadAsync(
                    uploadIntentConfiguration,
                    request.NewPictureIntentId.Value, request.UserId, cancellationToken);
                if (validation.IsError)
                    return validation.Errors;
                pictureIntent = validation.Value;
                album.Pictures = new AlbumPictures
                {
                    OriginalName = pictureIntent.ObjectName,
                    SmallName = pictureIntent.ObjectName,
                    MediumName = pictureIntent.ObjectName,
                    LargeName = pictureIntent.ObjectName
                };
                finalPictureKey = albumConfiguration.Routes.BuildOriginalPicturePath(request.UserId, pictureIntent.ObjectName);
            }
            if (pictureIntent != null && finalPictureKey != null)
            {
                var publishResult = await PublishUpdateAlbumPictureSourceEventAsync(
                    album.Id, pictureIntent, finalPictureKey, cancellationToken);
                if (publishResult.IsError)
                    return publishResult.Errors;
            }
            try
            {
                await database.SaveChangesAsync(cancellationToken);
            }
            catch (Exception exception)
            {
                logger.LogError(exception, "Failed to update album {AlbumId}", request.AlbumId);
                return Error.Failure(description: $"Failed to update album {request.AlbumId}");
            }
            var albumTracks = database.AlbumHasTracks
                .AsNoTracking()
                .Where(albumTrack => albumTrack.AlbumId == album.Id);
            var trackCount = await albumTracks.CountAsync(cancellationToken);
            var coverTrackIds = await albumTracks
                .OrderBy(albumTrack => albumTrack.TrackNumber)
                .Take(AlbumApplicationResponse.CoverTrackCount)
                .Select(albumTrack => albumTrack.TrackId)
                .ToListAsync(cancellationToken);
            logger.LogInformation("Updated album {AlbumId}", album.Id);
            return AlbumApplicationResponse.FromEntity(album, trackCount, coverTrackIds);
        }
        private async Task<ErrorOr<Success>> PublishUpdateAlbumPictureSourceEventAsync(
            Guid albumId,
            UploadIntent pictureIntent,
            string finalPictureKey,
            CancellationToken cancellationToken)
        {
            try
            {
                await eventBus.PublishAsync(
                    new UpdateAlbumPictureSourceEvent(
                        albumId,
                        pictureIntent.Id,
                        storageConfiguration.Bucket,
                        pictureIntent.Key,
                        finalPictureKey,
                        new ImageSize(
                            albumConfiguration.Routes.SmallPicturesPath,
                            albumConfiguration.PicturesSizes.SmallPictureWidth,
                            albumConfiguration.PicturesSizes.SmallPictureHeight),
                        new ImageSize(
                            albumConfiguration.Routes.MediumPicturesPath,
                            albumConfiguration.PicturesSizes.MediumPictureWidth,
                            albumConfiguration.PicturesSizes.MediumPictureHeight),
                        new ImageSize(
                            albumConfiguration.Routes.LargePicturesPath,
                            albumConfiguration.PicturesSizes.LargePictureWidth,
                            albumConfiguration.PicturesSizes.LargePictureHeight)),
                    cancellationToken);
                return new Success();
            }
            catch (Exception exception)
            {
                logger.LogError(exception, "Failed to publish update album picture source event for album {AlbumId}", albumId);
                return Error.Failure(description: $"Failed to publish update album picture source event for album {albumId}");
            }
        }
    }
 }
@@ -1,79 +0,0 @@
 using System.ComponentModel.DataAnnotations;
 using Musify.Application.Shared;
 namespace Musify.Application.Configuration
 {
    public class AlbumConfiguration
    {
        public const string SectionName = "Album";
        [Required]
        public AlbumRoutes Routes { get; set; } = new AlbumRoutes();
        [Required]
        public AlbumPicturesSizes PicturesSizes { get; set; } = new AlbumPicturesSizes();
    }
    public class AlbumRoutes
    {
        [Required]
        public string UploadsFolder { get; set; } = "uploads";
        [Required]
        public string ParentFolders { get; set; } = "Albums";
        [Required]
        public string OriginalPicturesFolder { get; set; } = "OriginalPictures";
        [Required]
        public string SmallPicturesFolder { get; set; } = "SmallPictures";
        [Required]
        public string MediumPicturesFolder { get; set; } = "MediumPictures";
        [Required]
        public string LargePicturesFolder { get; set; } = "LargePictures";
        public string SmallPicturesPath => StorageKey.Combine(ParentFolders, SmallPicturesFolder);
        public string MediumPicturesPath => StorageKey.Combine(ParentFolders, MediumPicturesFolder);
        public string LargePicturesPath => StorageKey.Combine(ParentFolders, LargePicturesFolder);
        public string OriginalPicturesPath => StorageKey.Combine(ParentFolders, OriginalPicturesFolder);
        public string BuildOriginalPicturePath(string pictureName) => StorageKey.Combine(ParentFolders, OriginalPicturesFolder, pictureName);
        public string BuildOriginalPicturePath(long userId, string pictureName) => StorageKey.Combine(UploadsFolder, userId.ToString(), ParentFolders, OriginalPicturesFolder, pictureName);
        public string BuildSmallPicturePath(string pictureName) => StorageKey.Combine(ParentFolders, SmallPicturesFolder, pictureName);
        public string BuildMediumPicturePath(string pictureName) => StorageKey.Combine(ParentFolders, MediumPicturesFolder, pictureName);
        public string BuildLargePicturePath(string pictureName) => StorageKey.Combine(ParentFolders, LargePicturesFolder, pictureName);
        public string BuildTempPicturePath(string tempRootPrefix, long userId, string objectName) =>
            StorageKey.Combine(tempRootPrefix, userId.ToString(), ParentFolders, objectName);
    }
    public class AlbumPicturesSizes
    {
        [Range(1, 1024)]
        public int SmallPictureWidth { get; set; } = 128;
        [Range(1, 1024)]
        public int SmallPictureHeight { get; set; } = 128;
        [Range(1, 1024)]
        public int MediumPictureWidth { get; set; } = 256;
        [Range(1, 1024)]
        public int MediumPictureHeight { get; set; } = 256;
        [Range(1, 1024)]
        public int LargePictureWidth { get; set; } = 512;
        [Range(1, 1024)]
        public int LargePictureHeight { get; set; } = 512;
    }
 }
@@ -1,17 +0,0 @@
 using Mediator;
 using Musify.Application.Configuration.Responses;
 namespace Musify.Application.Configuration
 {
    public record GetPlaybackPublicConfigQuery : IQuery<PlaybackPublicConfigResponse>;
    public class GetPlaybackPublicConfigQueryHandler(PlaybackConfiguration playbackConfiguration)
        : IQueryHandler<GetPlaybackPublicConfigQuery, PlaybackPublicConfigResponse>
    {
        public ValueTask<PlaybackPublicConfigResponse> Handle(GetPlaybackPublicConfigQuery query, CancellationToken cancellationToken) =>
            ValueTask.FromResult(new PlaybackPublicConfigResponse(
                playbackConfiguration.AllowAnonymousListening,
                playbackConfiguration.AnonymousFragmentSeconds));
    }
 }
@@ -1,12 +0,0 @@
 using System.ComponentModel.DataAnnotations;
 namespace Musify.Application.Configuration
 {
    public class MixConfiguration
    {
        public const string SectionName = "Mix";
        [Range(4, 100)]
        public int ItemsPerMix { get; set; } = 12;
    }
 }
@@ -1,18 +0,0 @@
 using System.ComponentModel.DataAnnotations;
 namespace Musify.Application.Configuration
 {
    public sealed class PlaybackConfiguration
    {
        public const string SectionName = "Playback";
        public bool AllowAnonymousListening { get; set; }
        [Range(0, 3600)]
        public int AnonymousFragmentSeconds { get; set; }
        [Range(1, int.MaxValue)]
        public int EstimatedAudioBytesPerSecond { get; set; } = 16_000;
    }
 }
@@ -1,5 +0,0 @@
 namespace Musify.Application.Configuration.Responses
 {
    public record PlaybackPublicConfigResponse(bool AllowAnonymousListening, int AnonymousFragmentSeconds);
 }
@@ -1,4 +0,0 @@
 namespace Musify.Application.Contracts
 {
    public record AudioTranscodeResult(int StatusCode, TimeSpan Duration);
 }
@@ -1,4 +0,0 @@
 namespace Musify.Application.Events
 {
    public record AlbumPictureProcessed(Guid AlbumId);
 }
@@ -1,4 +0,0 @@
 namespace Musify.Application.Events
 {
    public record AlbumPictureProcessingFailed(Guid AlbumId);
 }
@@ -1,7 +0,0 @@
 namespace Musify.Application.Events
 {
    public record AlbumProcessingFailed(
        Guid AlbumId,
        string? Bucket,
        string? PictureKey);
 }
@@ -1,14 +0,0 @@
 using Musify.Application.Shared;
 namespace Musify.Application.Events
 {
    public record CreateAlbumResourcesEvent(
        Guid AlbumId,
        Guid PictureIntentId,
        string Bucket,
        string PictureSourceKey,
        string PictureDestinationKey,
        ImageSize Small,
        ImageSize Medium,
        ImageSize Large);
 }
@@ -1,12 +0,0 @@
 using Musify.Application.Shared;
 namespace Musify.Application.Events
 {
    public record UpdateAlbumPictureEvent(
        Guid AlbumId,
        string Bucket,
        string SourceKey,
        ImageSize Small,
        ImageSize Medium,
        ImageSize Large);
 }
@@ -1,14 +0,0 @@
 using Musify.Application.Shared;
 namespace Musify.Application.Events
 {
    public record UpdateAlbumPictureSourceEvent(
        Guid AlbumId,
        Guid PictureIntentId,
        string Bucket,
        string PictureSourceKey,
        string PictureDestinationKey,
        ImageSize Small,
        ImageSize Medium,
        ImageSize Large);
 }
@@ -1,43 +0,0 @@
 using ErrorOr;
 using Mediator;
 using Microsoft.EntityFrameworkCore;
 using Musify.Application.Contracts;
 using Musify.Application.Shared;
 using Musify.Application.Tracks.Responses;
 using X.PagedList;
 using X.PagedList.EF;
 namespace Musify.Application.Likes
 {
    public record GetLikedTracksQuery(
        long UserId,
        int PageNumber,
        int PageSize)
        : IQuery<ErrorOr<PaginatedResponse<TrackApplicationResponse>>>;
    public class GetLikedTracksQueryHandler(IDatabase database)
        : IQueryHandler<GetLikedTracksQuery, ErrorOr<PaginatedResponse<TrackApplicationResponse>>>
    {
        public async ValueTask<ErrorOr<PaginatedResponse<TrackApplicationResponse>>> Handle(GetLikedTracksQuery request, CancellationToken cancellationToken)
        {
            var likesQuery = database.TrackLikes
                .AsNoTracking()
                .Include(like => like.Track.Owner)
                .Include(like => like.Track.Tags)
                .Where(like => like.UserId == request.UserId);
            var totalCount = await likesQuery.CountAsync(cancellationToken);
            var pagedEntities = await likesQuery
                .OrderByDescending(like => like.CreatedAt)
                .Select(like => new { like.Track, ListensCount = like.Track.ListeningHistories.Count })
                .ToPagedListAsync(request.PageNumber, request.PageSize, totalCount, cancellationToken);
            var pagedTracks = new StaticPagedList<TrackApplicationResponse>(
                pagedEntities.Select(x => TrackApplicationResponse.FromEntity(x.Track, x.ListensCount)),
                pagedEntities.PageNumber, pagedEntities.PageSize, pagedEntities.TotalItemCount);
            return PaginatedResponse<TrackApplicationResponse>.FromPagedList(pagedTracks);
        }
    }
 }
@@ -1,56 +0,0 @@
 using ErrorOr;
 using Mediator;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.Extensions.Logging;
 using Musify.Application.Contracts;
 using Musify.Domain.Entities;
 namespace Musify.Application.Likes
 {
    public record ToggleTrackLikeCommand(long UserId, Guid TrackId)
        : ICommand<ErrorOr<bool>>;
    public class ToggleTrackLikeCommandHandler(
        IDatabase database,
        ILogger<ToggleTrackLikeCommandHandler> logger)
        : ICommandHandler<ToggleTrackLikeCommand, ErrorOr<bool>>
    {
        public async ValueTask<ErrorOr<bool>> Handle(ToggleTrackLikeCommand request, CancellationToken cancellationToken)
        {
            var trackExists = await database.Tracks
                .AsNoTracking()
                .AnyAsync(t => t.Id == request.TrackId, cancellationToken);
            if (!trackExists)
            {
                logger.LogInformation("Track {TrackId} not found", request.TrackId);
                return Error.NotFound(description: $"Track {request.TrackId} not found");
            }
            var existingLike = await database.TrackLikes
                .SingleOrDefaultAsync(like => like.UserId == request.UserId && like.TrackId == request.TrackId, cancellationToken);
            bool nowLiked;
            if (existingLike != null)
            {
                database.TrackLikes.Remove(existingLike);
                nowLiked = false;
            }
            else
            {
                await database.TrackLikes.AddAsync(new TrackLike
                {
                    UserId = request.UserId,
                    TrackId = request.TrackId
                }, cancellationToken);
                nowLiked = true;
            }
            await database.SaveChangesAsync(cancellationToken);
            logger.LogInformation("User {UserId} {Action} track {TrackId}",
                request.UserId, nowLiked ? "liked" : "unliked", request.TrackId);
            return nowLiked;
        }
    }
 }
@@ -1,153 +0,0 @@
 using ErrorOr;
 using Mediator;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.Extensions.Logging;
 using Musify.Application.Configuration;
 using Musify.Application.Contracts;
 using Musify.Domain.Entities;
 using Musify.Domain.ValueObjects;
 namespace Musify.Application.Mixes
 {
    public record GenerateMixesForUserCommand(long UserId)
        : ICommand<ErrorOr<Success>>;
    public class GenerateMixesForUserCommandHandler(
        IDatabase database,
        MixConfiguration mixConfiguration,
        ILogger<GenerateMixesForUserCommandHandler> logger)
        : ICommandHandler<GenerateMixesForUserCommand, ErrorOr<Success>>
    {
        private sealed record MixDraft(string Title, string? Subtitle, IReadOnlyList<Guid> TrackIds);
        public async ValueTask<ErrorOr<Success>> Handle(GenerateMixesForUserCommand request, CancellationToken cancellationToken)
        {
            var userId = request.UserId;
            var libraryTrackIds = await database.UserHasTracks
                .AsNoTracking()
                .Where(userTrack => userTrack.UserId == userId && userTrack.Track.LifeCycleStatus == LifeCycleStatus.Active)
                .Select(userTrack => userTrack.TrackId)
                .ToListAsync(cancellationToken);
            if (libraryTrackIds.Count == 0)
            {
                logger.LogInformation("User {UserId} has no tracks yet, skipping mix generation", userId);
                return new Success();
            }
            var historyTrackIds = await database.ListeningHistories
                .AsNoTracking()
                .Where(history => history.UserId == userId)
                .Select(history => history.TrackId)
                .Distinct()
                .ToListAsync(cancellationToken);
            var historySet = new HashSet<Guid>(historyTrackIds);
            var unheardTrackIds = libraryTrackIds.Where(id => !historySet.Contains(id)).ToList();
            var drafts = new List<MixDraft>();
            var discovery = Take(Shuffle(unheardTrackIds));
            if (discovery.Count > 0)
            {
                drafts.Add(new MixDraft(
                    "Descubrimiento",
                    "Canciones de tu biblioteca que todavía no has escuchado.",
                    discovery));
            }
            var daily = Take(Interleave(Shuffle(historyTrackIds), Shuffle(unheardTrackIds)));
            if (daily.Count > 0)
            {
                drafts.Add(new MixDraft(
                    "Tu mezcla diaria",
                    "Lo que más escuchas, con alguna sorpresa de tu biblioteca.",
                    daily));
            }
            if (drafts.Count == 0)
            {
                logger.LogInformation("No candidate songs found for user {UserId}, skipping mix generation", userId);
                return new Success();
            }
            await ReplaceMixesAsync(userId, drafts, cancellationToken);
            try
            {
                await database.SaveChangesAsync(cancellationToken);
            }
            catch (Exception exception)
            {
                logger.LogError(exception, "Failed to generate mixes for user {UserId}", userId);
                return Error.Failure(description: $"Failed to generate mixes for user {userId}");
            }
            logger.LogInformation("Generated {Count} mixes for user {UserId}", drafts.Count, userId);
            return new Success();
        }
        private List<Guid> Take(IEnumerable<Guid> trackIds) =>
            [.. trackIds.Take(mixConfiguration.ItemsPerMix)];
        private static List<Guid> Shuffle(IEnumerable<Guid> trackIds) =>
            [.. trackIds.OrderBy(_ => Guid.NewGuid())];
        private static List<Guid> Interleave(IReadOnlyList<Guid> first, IReadOnlyList<Guid> second)
        {
            var merged = new List<Guid>(first.Count + second.Count);
            for (var index = 0; index < Math.Max(first.Count, second.Count); index++)
            {
                if (index < first.Count)
                    merged.Add(first[index]);
                if (index < second.Count)
                    merged.Add(second[index]);
            }
            return merged;
        }
        private async Task ReplaceMixesAsync(long userId, IReadOnlyList<MixDraft> drafts, CancellationToken cancellationToken)
        {
            var previousMixes = await database.Mixes
                .Where(mix => mix.UserId == userId)
                .ToListAsync(cancellationToken);
            if (previousMixes.Count > 0)
            {
                var previousIds = previousMixes.Select(mix => mix.Id).ToList();
                var previousItems = await database.MixItems
                    .Where(item => previousIds.Contains(item.MixId))
                    .ToListAsync(cancellationToken);
                database.MixItems.RemoveRange(previousItems);
                database.Mixes.RemoveRange(previousMixes);
            }
            for (var position = 0; position < drafts.Count; position++)
            {
                var draft = drafts[position];
                var mix = new Mix
                {
                    UserId = userId,
                    Title = draft.Title,
                    Subtitle = draft.Subtitle,
                    Position = position
                };
                await database.Mixes.AddAsync(mix, cancellationToken);
                for (var itemPosition = 0; itemPosition < draft.TrackIds.Count; itemPosition++)
                {
                    await database.MixItems.AddAsync(new MixItem
                    {
                        MixId = mix.Id,
                        Position = itemPosition,
                        TrackId = draft.TrackIds[itemPosition]
                    }, cancellationToken);
                }
            }
        }
    }
 }
@@ -1,31 +0,0 @@
 using ErrorOr;
 using Mediator;
 using Microsoft.EntityFrameworkCore;
 using Musify.Application.Contracts;
 using Musify.Application.Mixes.Responses;
 namespace Musify.Application.Mixes
 {
    public record GetMixByIdQuery(long UserId, Guid MixId)
        : IQuery<ErrorOr<MixApplicationResponse>>;
    public class GetMixByIdQueryHandler(IDatabase database)
        : IQueryHandler<GetMixByIdQuery, ErrorOr<MixApplicationResponse>>
    {
        public async ValueTask<ErrorOr<MixApplicationResponse>> Handle(GetMixByIdQuery request, CancellationToken cancellationToken)
        {
            var mix = await database.Mixes
                .AsNoTracking()
                .Include(mix => mix.Items)
                .SingleOrDefaultAsync(mix => mix.Id == request.MixId && mix.UserId == request.UserId, cancellationToken);
            if (mix == null)
                return Error.NotFound(description: $"Mix {request.MixId} was not found");
            var orderedItems = mix.Items.OrderBy(item => item.Position).ToList();
            var items = await MixItemMapper.ToResponsesAsync(database, orderedItems, cancellationToken);
            return new MixApplicationResponse(mix.Id, mix.Title, mix.Subtitle, items.Count, items);
        }
    }
 }
@@ -1,37 +0,0 @@
 using ErrorOr;
 using Mediator;
 using Microsoft.EntityFrameworkCore;
 using Musify.Application.Contracts;
 using Musify.Application.Mixes.Responses;
 namespace Musify.Application.Mixes
 {
    public record GetMixesByUserIdQuery(long UserId)
        : IQuery<ErrorOr<IReadOnlyList<MixApplicationResponse>>>;
    public class GetMixesByUserIdQueryHandler(IDatabase database)
        : IQueryHandler<GetMixesByUserIdQuery, ErrorOr<IReadOnlyList<MixApplicationResponse>>>
    {
        public async ValueTask<ErrorOr<IReadOnlyList<MixApplicationResponse>>> Handle(GetMixesByUserIdQuery request, CancellationToken cancellationToken)
        {
            var mixes = await database.Mixes
                .AsNoTracking()
                .Where(mix => mix.UserId == request.UserId)
                .Include(mix => mix.Items)
                .OrderBy(mix => mix.Position)
                .ToListAsync(cancellationToken);
            var responses = new List<MixApplicationResponse>(mixes.Count);
            foreach (var mix in mixes)
            {
                var orderedItems = mix.Items.OrderBy(item => item.Position).ToList();
                var coverItems = await MixItemMapper.ToResponsesAsync(
                    database, orderedItems.Take(MixApplicationResponse.CoverItemCount).ToList(), cancellationToken);
                responses.Add(new MixApplicationResponse(mix.Id, mix.Title, mix.Subtitle, orderedItems.Count, coverItems));
            }
            return responses;
        }
    }
 }
@@ -1,40 +0,0 @@
 using Microsoft.EntityFrameworkCore;
 using Musify.Application.Contracts;
 using Musify.Application.Mixes.Responses;
 using Musify.Domain.Entities;
 namespace Musify.Application.Mixes
 {
    internal static class MixItemMapper
    {
        public static async Task<List<MixItemApplicationResponse>> ToResponsesAsync(
            IDatabase database,
            IReadOnlyList<MixItem> orderedItems,
            CancellationToken cancellationToken)
        {
            var trackIds = orderedItems.Select(item => item.TrackId).Distinct().ToList();
            var tracksById = await database.Tracks
                .AsNoTracking()
                .Include(track => track.Owner)
                .Where(track => trackIds.Contains(track.Id))
                .Select(track => new { Track = track, ListensCount = track.ListeningHistories.Count })
                .ToDictionaryAsync(x => x.Track.Id, cancellationToken);
            return orderedItems
                .Where(item => tracksById.ContainsKey(item.TrackId))
                .Select(item =>
                {
                    var entry = tracksById[item.TrackId];
                    return new MixItemApplicationResponse(
                        item.TrackId,
                        entry.Track.Title,
                        entry.Track.Owner.Name,
                        entry.Track.DurationSeconds,
                        entry.ListensCount);
                })
                .ToList();
        }
    }
 }
@@ -1,12 +0,0 @@
 namespace Musify.Application.Mixes.Responses
 {
    public record MixApplicationResponse(
        Guid Id,
        string Title,
        string? Subtitle,
        int ItemCount,
        IReadOnlyList<MixItemApplicationResponse> Items)
    {
        public const int CoverItemCount = 4;
    }
 }
@@ -1,9 +0,0 @@
 namespace Musify.Application.Mixes.Responses
 {
    public record MixItemApplicationResponse(
        Guid TrackId,
        string Title,
        string? Artist,
        double DurationSeconds,
        int ListensCount);
 }
@@ -1,42 +0,0 @@
 using ErrorOr;
 using Microsoft.EntityFrameworkCore;
 using Musify.Application.PlayLists.Responses;
 using Mediator;
 using Musify.Application.Contracts;
 using Musify.Domain.ValueObjects;
 namespace Musify.Application.PlayLists
 {
    public record GetPlayListByIdQuery(Guid Id, long? RequestingUserId = null)
        : IQuery<ErrorOr<PlayListApplicationResponse>>;
    public class GetPlayListByIdQueryHandler(IDatabase database)
        : IQueryHandler<GetPlayListByIdQuery, ErrorOr<PlayListApplicationResponse>>
    {
        public async ValueTask<ErrorOr<PlayListApplicationResponse>> Handle(GetPlayListByIdQuery request, CancellationToken cancellationToken)
        {
            var entry = await database.PlayLists
                .AsNoTracking()
                .Where(p => p.Id == request.Id)
                .Select(p => new
                {
                    PlayList = p,
                    CoverTrackIds = p.PlayListTracks
                        .OrderBy(plt => plt.Position)
                        .Take(PlayListApplicationResponse.CoverTrackCount)
                        .Select(plt => plt.TrackId)
                        .ToList()
                })
                .SingleOrDefaultAsync(cancellationToken);
            if (entry == null)
                return Error.NotFound();
            if (entry.PlayList.Visibility == PlaylistVisibility.Private
                && entry.PlayList.UserId != request.RequestingUserId)
                return Error.NotFound();
            return PlayListApplicationResponse.FromEntity(entry.PlayList, entry.CoverTrackIds);
        }
    }
 }
@@ -1,49 +0,0 @@
 using ErrorOr;
 using Mediator;
 using Microsoft.EntityFrameworkCore;
 using MimeMapping;
 using Musify.Application.Configuration;
 using Musify.Application.Contracts;
 namespace Musify.Application.PlayLists
 {
    public record GetPlayListCoverQuery(Guid PlayListId, string Size)
        : IQuery<ErrorOr<PlayListCoverLocation>>;
    public record PlayListCoverLocation(string Bucket, string Key, string ContentType);
    public class GetPlayListCoverQueryHandler(
        IDatabase database,
        ApplicationStorageConfiguration storageConfiguration,
        PlayListConfiguration playListConfiguration)
        : IQueryHandler<GetPlayListCoverQuery, ErrorOr<PlayListCoverLocation>>
    {
        public async ValueTask<ErrorOr<PlayListCoverLocation>> Handle(GetPlayListCoverQuery request, CancellationToken cancellationToken)
        {
            var pictures = await database.PlayLists.AsNoTracking()
                .Where(p => p.Id == request.PlayListId)
                .Select(p => p.Pictures)
                .SingleOrDefaultAsync(cancellationToken);
            if (pictures == null)
                return Error.NotFound();
            var routes = playListConfiguration.Routes;
            var (name, key) = request.Size.ToLowerInvariant() switch
            {
                "small" => (pictures.SmallName, BuildKey(routes.BuildSmallPicturePath, pictures.SmallName)),
                "large" => (pictures.LargeName, BuildKey(routes.BuildLargePicturePath, pictures.LargeName)),
                _ => (pictures.MediumName, BuildKey(routes.BuildMediumPicturePath, pictures.MediumName))
            };
            if (string.IsNullOrEmpty(name) || string.IsNullOrEmpty(key))
                return Error.NotFound();
            var contentType = MimeUtility.GetMimeMapping(name);
            return new PlayListCoverLocation(storageConfiguration.Bucket, key, contentType);
        }
        private static string? BuildKey(Func<string, string> builder, string? name)
            => string.IsNullOrEmpty(name) ? null : builder(name);
    }
 }
@@ -1,43 +0,0 @@
 using ErrorOr;
 using Microsoft.EntityFrameworkCore;
 using Musify.Application.Shared;
 using Musify.Application.PlayLists.Responses;
 using X.PagedList;
 using X.PagedList.EF;
 using Mediator;
 using Musify.Application.Contracts;
 namespace Musify.Application.PlayLists
 {
    public record GetPlayListsQuery(int PageNumber, int PageSize)
        : IQuery<ErrorOr<PaginatedResponse<PlayListApplicationResponse>>>;
    public class GetPlayListsQueryHandler(IDatabase database)
        : IQueryHandler<GetPlayListsQuery, ErrorOr<PaginatedResponse<PlayListApplicationResponse>>>
    {
        public async ValueTask<ErrorOr<PaginatedResponse<PlayListApplicationResponse>>> Handle(GetPlayListsQuery request, CancellationToken cancellationToken)
        {
            var totalCount = await database.PlayLists.CountAsync(cancellationToken);
            var pagedEntities = await database.PlayLists
                .AsNoTracking()
                .OrderBy(p => p.Id)
                .Select(p => new
                {
                    PlayList = p,
                    CoverTrackIds = p.PlayListTracks
                        .OrderBy(plt => plt.Position)
                        .Take(PlayListApplicationResponse.CoverTrackCount)
                        .Select(plt => plt.TrackId)
                        .ToList()
                })
                .ToPagedListAsync(request.PageNumber, request.PageSize, totalCount, cancellationToken);
            var pagedPlayLists = new StaticPagedList<PlayListApplicationResponse>(
                pagedEntities.Select(entry => PlayListApplicationResponse.FromEntity(entry.PlayList, entry.CoverTrackIds)),
                pagedEntities.PageNumber, pagedEntities.PageSize, pagedEntities.TotalItemCount);
            return PaginatedResponse<PlayListApplicationResponse>.FromPagedList(pagedPlayLists);
        }
    }
 }
@@ -1,64 +0,0 @@
 using ErrorOr;
 using Mediator;
 using Microsoft.EntityFrameworkCore;
 using Musify.Application.Contracts;
 using Musify.Application.PlayLists.Responses;
 using Musify.Application.Shared;
 using Musify.Domain.ValueObjects;
 using X.PagedList;
 using X.PagedList.EF;
 namespace Musify.Application.PlayLists
 {
    public record GetPlayListsByUserIdQuery(
        long UserId,
        string? Name,
        int PageNumber,
        int PageSize,
        bool OnlyPublic = false)
        : IQuery<ErrorOr<PaginatedResponse<PlayListApplicationResponse>>>;
    public class GetPlayListsByUserIdQueryHandler(IDatabase database)
        : IQueryHandler<GetPlayListsByUserIdQuery, ErrorOr<PaginatedResponse<PlayListApplicationResponse>>>
    {
        public async ValueTask<ErrorOr<PaginatedResponse<PlayListApplicationResponse>>> Handle(GetPlayListsByUserIdQuery request, CancellationToken cancellationToken)
        {
            var playListsQuery = database.PlayLists
                .AsNoTracking()
                .Where(p => p.UserId == request.UserId);
            if (request.OnlyPublic)
            {
                playListsQuery = playListsQuery.Where(p => p.Visibility == PlaylistVisibility.Public);
            }
            if (!string.IsNullOrEmpty(request.Name))
            {
                var normalizedName = request.Name.Trim().ToUpperInvariant();
                playListsQuery = playListsQuery.Where(p => p.NormalizedName.Contains(normalizedName));
            }
            var totalCount = await playListsQuery.CountAsync(cancellationToken);
            var pagedEntities = await playListsQuery
                .OrderBy(p => p.CreatedAt)
                .Where(p => p.LifeCycleStatus == LifeCycleStatus.Active)
                .Select(p => new
                {
                    PlayList = p,
                    CoverTrackIds = p.PlayListTracks
                        .OrderBy(plt => plt.Position)
                        .Take(PlayListApplicationResponse.CoverTrackCount)
                        .Select(plt => plt.TrackId)
                        .ToList()
                })
                .ToPagedListAsync(request.PageNumber, request.PageSize, totalCount, cancellationToken);
            var pagedPlayLists = new StaticPagedList<PlayListApplicationResponse>(
                pagedEntities.Select(entry => PlayListApplicationResponse.FromEntity(entry.PlayList, entry.CoverTrackIds)),
                pagedEntities.PageNumber, pagedEntities.PageSize, pagedEntities.TotalItemCount);
            return PaginatedResponse<PlayListApplicationResponse>.FromPagedList(pagedPlayLists);
        }
    }
 }
@@ -1,37 +0,0 @@
 using Musify.Domain.Entities;
 using Musify.Domain.ValueObjects;
 namespace Musify.Application.PlayLists.Responses
 {
    public record PlayListApplicationResponse(
        Guid Id,
        string Name,
        string? Description,
        string? SmallImageKeyName,
        string? MediumImageKeyName,
        string? LargeImageKeyName,
        PlaylistVisibility Visibility,
        DateTime CreatedAt,
        DateTime UpdatedAt,
        IReadOnlyList<Guid> CoverTrackIds)
    {
        public const int CoverTrackCount = 4;
        public static PlayListApplicationResponse FromEntity(
            PlayList playList,
            IReadOnlyList<Guid>? coverTrackIds = null)
        {
            return new PlayListApplicationResponse(
                playList.Id,
                playList.Name,
                playList.Description,
                playList.Pictures?.SmallName,
                playList.Pictures?.MediumName,
                playList.Pictures?.LargeName,
                playList.Visibility,
                playList.CreatedAt,
                playList.UpdatedAt,
                coverTrackIds ?? []);
        }
    }
 }
@@ -1,37 +0,0 @@
 using System.Globalization;
 using System.Text.Json;
 using System.Text.Json.Serialization;
 namespace Musify.Application.Serialization;
 public sealed class LongAsStringConverter : JsonConverter<long>
 {
    public override long Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options) =>
        reader.TokenType == JsonTokenType.String
            ? long.Parse(reader.GetString()!, CultureInfo.InvariantCulture)
            : reader.GetInt64();
    public override void Write(Utf8JsonWriter writer, long value, JsonSerializerOptions options) =>
        writer.WriteStringValue(value.ToString(CultureInfo.InvariantCulture));
 }
 public sealed class NullableLongAsStringConverter : JsonConverter<long?>
 {
    public override long? Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
    {
        if (reader.TokenType == JsonTokenType.Null)
            return null;
        return reader.TokenType == JsonTokenType.String
            ? string.IsNullOrEmpty(reader.GetString()) ? null : long.Parse(reader.GetString()!, CultureInfo.InvariantCulture)
            : reader.GetInt64();
    }
    public override void Write(Utf8JsonWriter writer, long? value, JsonSerializerOptions options)
    {
        if (value.HasValue)
            writer.WriteStringValue(value.Value.ToString(CultureInfo.InvariantCulture));
        else
            writer.WriteNullValue();
    }
 }
@@ -1,54 +0,0 @@
 using Musify.Application.Configuration;
 using Musify.Application.Contracts;
 using Musify.Application.Tracks.Responses;
 using Musify.Domain.Entities;
 namespace Musify.Application.Services;
 public sealed class TrackStreamIssuer(
    IDatabase database,
    IStreamTicketService ticketService,
    TrackConfiguration trackConfiguration,
    StreamGatewayConfiguration streamGatewayConfiguration,
    PlaybackConfiguration playbackConfiguration)
 {
    public async Task<TrackStreamResponse> IssueAsync(
        Guid trackId,
        string audioFolderName,
        long? userId,
        CancellationToken cancellationToken)
    {
        var folderPath = trackConfiguration.Routes.BuildProcessedAudioPath(audioFolderName);
        var keyPrefix = $"{folderPath}/";
        var maxBytes = AnonymousFragmentBytes(userId);
        var ticket = ticketService.IssueTicket(userId, keyPrefix, maxBytes);
        var manifestUrl = string.Join('/',
            streamGatewayConfiguration.PublicBaseUrl.TrimEnd('/'),
            "media",
            folderPath,
            streamGatewayConfiguration.AudioFileName);
        if (userId != null)
        {
            var newListeningHistory = new ListeningHistory
            {
                UserId = userId.Value,
                TrackId = trackId,
            };
            await database.ListeningHistories.AddAsync(newListeningHistory, cancellationToken);
            await database.SaveChangesAsync(cancellationToken);
        }
        return new TrackStreamResponse(manifestUrl, ticket.Token, ticket.ExpiresInSeconds);
    }
    private long? AnonymousFragmentBytes(long? userId)
    {
        if (userId != null || playbackConfiguration.AnonymousFragmentSeconds <= 0)
            return null;
        return (long)playbackConfiguration.AnonymousFragmentSeconds * playbackConfiguration.EstimatedAudioBytesPerSecond;
    }
 }
@@ -1,30 +0,0 @@
 using ErrorOr;
 using Mediator;
 using Microsoft.EntityFrameworkCore;
 using Musify.Application.Contracts;
 using Musify.Application.Tracks.Responses;
 namespace Musify.Application.Tracks
 {
    public record GetLastTrackListenedByUserIdQuery(long UserId) : IQuery<ErrorOr<TrackApplicationResponse>>;
    public class GetLastTrackListenedByUserIdQueryHandler(IDatabase database)
        : IQueryHandler<GetLastTrackListenedByUserIdQuery, ErrorOr<TrackApplicationResponse>>
    {
        public async ValueTask<ErrorOr<TrackApplicationResponse>> Handle(GetLastTrackListenedByUserIdQuery query, CancellationToken cancellationToken)
        {
            var track = await database.ListeningHistories
                .AsNoTracking()
                .Include(t => t.Track.Owner)
                .Include(t => t.Track.Tags)
                .Where(t => t.UserId == query.UserId)
                .OrderByDescending(t => t.ListenedAt)
                .Select(t => TrackApplicationResponse.FromEntity(t.Track, t.Track.ListeningHistories.Count))
                .FirstOrDefaultAsync(cancellationToken);
            return track == null
                ? Error.NotFound("Track.NotFound", "No track found for the given user ID.")
                : track;
        }
    }
 }
@@ -1,40 +0,0 @@
 using Mediator;
 using Microsoft.EntityFrameworkCore;
 using Musify.Application.Contracts;
 using Musify.Application.Tracks.Responses;
 namespace Musify.Application.Tracks
 {
    public record GetListeningHistoryQuery(long UserId) : IQuery<IEnumerable<TrackApplicationResponse>>;
    public class GetListeningHistoryQueryHandler(
        IDatabase database)
        : IQueryHandler<GetListeningHistoryQuery, IEnumerable<TrackApplicationResponse>>
    {
        public const int ListSize = 15;
        public async ValueTask<IEnumerable<TrackApplicationResponse>> Handle(GetListeningHistoryQuery query, CancellationToken cancellationToken)
        {
            var recentTrackIds = await database.ListeningHistories
                .AsNoTracking()
                .Where(l => l.UserId == query.UserId)
                .GroupBy(l => l.TrackId)
                .OrderByDescending(g => g.Max(l => l.ListenedAt))
                .Select(g => g.Key)
                .Take(ListSize)
                .ToListAsync(cancellationToken);
            var tracksById = await database.Tracks
                .AsNoTracking()
                .Include(t => t.Owner)
                .Include(t => t.Tags)
                .Where(t => recentTrackIds.Contains(t.Id))
                .Select(t => new { t.Id, Track = t, ListensCount = t.ListeningHistories.Count })
                .ToDictionaryAsync(t => t.Id, cancellationToken);
            return recentTrackIds
                .Select(id => tracksById[id])
                .Select(t => TrackApplicationResponse.FromEntity(t.Track, t.ListensCount));
        }
    }
 }
@@ -1,53 +0,0 @@
 using ErrorOr;
 using Mediator;
 using Microsoft.EntityFrameworkCore;
 using Musify.Application.Configuration;
 using Musify.Application.Contracts;
 namespace Musify.Application.Tracks
 {
    public record GetTrackCoverQuery(Guid TrackId, string Size)
        : IQuery<ErrorOr<TrackCoverLocation>>;
    public record TrackCoverLocation(string Bucket, string Key, string ContentType);
    public class GetTrackCoverQueryHandler(
        IDatabase database,
        ApplicationStorageConfiguration storageConfiguration,
        TrackConfiguration trackConfiguration)
        : IQueryHandler<GetTrackCoverQuery, ErrorOr<TrackCoverLocation>>
    {
        public async ValueTask<ErrorOr<TrackCoverLocation>> Handle(GetTrackCoverQuery request, CancellationToken cancellationToken)
        {
            var track = await database.Tracks.AsNoTracking()
                .Where(t => t.Id == request.TrackId)
                .Select(t => new { t.Pictures.SmallName, t.Pictures.MediumName, t.Pictures.LargeName })
                .SingleOrDefaultAsync(cancellationToken);
            if (track == null)
                return Error.NotFound();
            var routes = trackConfiguration.Routes;
            var (name, key) = request.Size.ToLowerInvariant() switch
            {
                "small" => (track.SmallName, BuildKey(routes.BuildSmallPicturePath, track.SmallName)),
                "large" => (track.LargeName, BuildKey(routes.BuildLargePicturePath, track.LargeName)),
                _ => (track.MediumName, BuildKey(routes.BuildMediumPicturePath, track.MediumName))
            };
            if (string.IsNullOrEmpty(name) || key == null)
                return Error.NotFound();
            var contentType = name.EndsWith(".webp", StringComparison.OrdinalIgnoreCase)
                ? "image/webp"
                : name.EndsWith(".png", StringComparison.OrdinalIgnoreCase)
                    ? "image/png"
                    : "image/jpeg";
            return new TrackCoverLocation(storageConfiguration.Bucket, key, contentType);
        }
        private static string? BuildKey(Func<string, string> builder, string? name)
            => string.IsNullOrEmpty(name) ? null : builder(name);
    }
 }
@@ -1,53 +0,0 @@
 using ErrorOr;
 using Mediator;
 using Microsoft.EntityFrameworkCore;
 using Musify.Application.Tracks.Responses;
 using X.PagedList;
 using X.PagedList.EF;
 using Musify.Application.Contracts;
 namespace Musify.Application.Tracks
 {
    public record GetTracksQuery(string? Name, int PageNumber, int PageSize)
        : IQuery<ErrorOr<TracksSearchResponse>>;
    public class GetTracksQueryHandler(IDatabase database)
        : IQueryHandler<GetTracksQuery, ErrorOr<TracksSearchResponse>>
    {
        public async ValueTask<ErrorOr<TracksSearchResponse>> Handle(GetTracksQuery request, CancellationToken cancellationToken)
        {
            var tracksQuery = database.UserHasTracks
                .AsNoTracking()
                .Include(ut => ut.Track.Owner)
                .Include(ut => ut.Track.Tags)
                .AsQueryable();
            if (!string.IsNullOrEmpty(request.Name))
            {
                var normalizedName = request.Name.Trim().ToUpperInvariant();
                tracksQuery = tracksQuery.Where(t => t.Track.NormalizedTitle.Contains(normalizedName));
            }
            var totalCount = await tracksQuery.CountAsync(cancellationToken);
            var pagedEntities = await tracksQuery
                .OrderByDescending(t => t.Track.CreatedAt)
                .ThenBy(t => t.Id)
                .Select(t => new { t.Track, ListensCount = t.Track.ListeningHistories.Count })
                .ToPagedListAsync(request.PageNumber, request.PageSize, totalCount, cancellationToken);
            var items = pagedEntities
                .Select(x => TrackSearchItemResponse.FromTrack(TrackApplicationResponse.FromEntity(x.Track, x.ListensCount)))
                .ToList();
            return new TracksSearchResponse(
                items,
                pagedEntities.PageNumber,
                pagedEntities.PageSize,
                pagedEntities.PageCount,
                pagedEntities.TotalItemCount,
                pagedEntities.HasPreviousPage,
                pagedEntities.HasNextPage);
        }
    }
 }
@@ -1,33 +0,0 @@
 using Musify.Application.Serialization;
 using Musify.Domain.Entities;
 using Musify.Domain.ValueObjects;
 using System.Text.Json.Serialization;
 namespace Musify.Application.Tracks.Responses
 {
    public record TrackApplicationResponse(
        Guid Id,
        string Title,
        string? Artist,
        ProcessingStatus AudioStatus,
        double Duration,
        int ListensCount,
        DateTime CreatedAt,
        DateTime UpdatedAt,
        [property: JsonConverter(typeof(LongAsStringConverter))] long OwnerUserId,
        IReadOnlyCollection<Genre> Tags)
    {
        public static TrackApplicationResponse FromEntity(Track track, int listensCount) =>
            new(
                track.Id,
                track.Title,
                track.Owner.Name,
                track.Audio.TranscodeStatus,
                track.DurationSeconds,
                listensCount,
                track.CreatedAt,
                track.UpdatedAt,
                track.OwnerUserId,
                track.Tags.Select(tag => tag.Tag).ToList());
    }
 }
@@ -1,7 +0,0 @@
 namespace Musify.Application.Tracks.Responses
 {
    public record TrackSearchItemResponse(TrackApplicationResponse Track)
    {
        public static TrackSearchItemResponse FromTrack(TrackApplicationResponse track) => new(track);
    }
 }
@@ -1,12 +0,0 @@
 namespace Musify.Application.Tracks.Responses
 {
    public record TracksSearchResponse(
        IReadOnlyList<TrackSearchItemResponse> Items,
        int PageNumber,
        int PageSize,
        int PageCount,
        int TotalItemCount,
        bool HasPreviousPage,
        bool HasNextPage);
 }
@@ -1,50 +0,0 @@
 using ErrorOr;
 using Mediator;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.Extensions.Logging;
 using Musify.Application.Contracts;
 using Musify.Domain.Entities;
 namespace Musify.Application.Users
 {
    public record FollowUserCommand(long FollowerId, long FollowedId) : ICommand<ErrorOr<Success>>;
    public class FollowUserCommandHandler(
        IDatabase database,
        ILogger<FollowUserCommandHandler> logger)
        : ICommandHandler<FollowUserCommand, ErrorOr<Success>>
    {
        public async ValueTask<ErrorOr<Success>> Handle(FollowUserCommand request, CancellationToken cancellationToken)
        {
            if (request.FollowerId == request.FollowedId)
                return Error.Validation(description: "A user cannot follow themselves.");
            var followedExists = await database.Users
                .AsNoTracking()
                .AnyAsync(u => u.Id == request.FollowedId, cancellationToken);
            if (!followedExists)
            {
                logger.LogInformation("User {FollowedId} not found", request.FollowedId);
                return Error.NotFound(description: $"User {request.FollowedId} not found");
            }
            var alreadyFollowing = await database.UserFollows
                .AsNoTracking()
                .AnyAsync(f => f.FollowerId == request.FollowerId && f.FollowedId == request.FollowedId, cancellationToken);
            if (alreadyFollowing)
                return new Success();
            await database.UserFollows.AddAsync(new UserFollow
            {
                FollowerId = request.FollowerId,
                FollowedId = request.FollowedId
            }, cancellationToken);
            await database.SaveChangesAsync(cancellationToken);
            logger.LogInformation("User {FollowerId} followed user {FollowedId}", request.FollowerId, request.FollowedId);
            return new Success();
        }
    }
 }
@@ -1,50 +0,0 @@
 using Mediator;
 using Microsoft.EntityFrameworkCore;
 using Musify.Application.Contracts;
 namespace Musify.Application.Users
 {
    public record GetListeningStatsQuery(long UserId) : IQuery<ListeningStatsResponse>;
    public record ListeningStatsResponse(int TracksThisWeek, int SecondsThisWeek, int StreakDays);
    public class GetListeningStatsQueryHandler(IDatabase database)
        : IQueryHandler<GetListeningStatsQuery, ListeningStatsResponse>
    {
        public async ValueTask<ListeningStatsResponse> Handle(GetListeningStatsQuery request, CancellationToken cancellationToken)
        {
            var weekAgo = DateTime.UtcNow.AddDays(-7);
            var thisWeekHistory = database.ListeningHistories
                .AsNoTracking()
                .Where(l => l.UserId == request.UserId && l.ListenedAt >= weekAgo);
            var tracksThisWeek = await thisWeekHistory
                .Select(l => l.TrackId)
                .Distinct()
                .CountAsync(cancellationToken);
            var secondsThisWeek = await thisWeekHistory
                .Join(database.Tracks.AsNoTracking(), l => l.TrackId, t => t.Id, (l, t) => t.DurationSeconds)
                .SumAsync(cancellationToken);
            var listenedDates = await database.ListeningHistories
                .AsNoTracking()
                .Where(l => l.UserId == request.UserId)
                .Select(l => l.ListenedAt.Date)
                .Distinct()
                .ToListAsync(cancellationToken);
            var listenedDateSet = listenedDates.ToHashSet();
            var streakDays = 0;
            var day = DateTime.UtcNow.Date;
            while (listenedDateSet.Contains(day))
            {
                streakDays++;
                day = day.AddDays(-1);
            }
            return new ListeningStatsResponse(tracksThisWeek, (int)Math.Round(secondsThisWeek), streakDays);
        }
    }
 }
@@ -1,63 +0,0 @@
 using System.Text.Json.Serialization;
 using ErrorOr;
 using Mediator;
 using Microsoft.EntityFrameworkCore;
 using Musify.Application.Contracts;
 using Musify.Application.Serialization;
 namespace Musify.Application.Users
 {
    public record GetUserProfileQuery(long UserId) : IQuery<ErrorOr<UserProfileResponse>>;
    public record UserProfileResponse(
        [property: JsonConverter(typeof(LongAsStringConverter))] long Id,
        string Name,
        string? FirstName,
        string? SecondName,
        string? ProfilePictureUrl,
        DateTime CreatedAt,
        int FollowersCount,
        int FollowingCount);
    public class GetUserProfileQueryHandler(IDatabase database)
        : IQueryHandler<GetUserProfileQuery, ErrorOr<UserProfileResponse>>
    {
        public async ValueTask<ErrorOr<UserProfileResponse>> Handle(GetUserProfileQuery request, CancellationToken cancellationToken)
        {
            var user = await database.Users
                .AsNoTracking()
                .Where(u => u.Id == request.UserId)
                .Select(u => new
                {
                    u.Id,
                    u.Name,
                    u.FirstName,
                    u.SecondName,
                    u.ProfilePictureUrl,
                    u.CreatedAt
                })
                .SingleOrDefaultAsync(cancellationToken);
            if (user == null)
                return Error.NotFound();
            var followersCount = await database.UserFollows
                .AsNoTracking()
                .CountAsync(f => f.FollowedId == request.UserId, cancellationToken);
            var followingCount = await database.UserFollows
                .AsNoTracking()
                .CountAsync(f => f.FollowerId == request.UserId, cancellationToken);
            return new UserProfileResponse(
                user.Id,
                user.Name,
                user.FirstName,
                user.SecondName,
                user.ProfilePictureUrl,
                user.CreatedAt,
                followersCount,
                followingCount);
        }
    }
 }
@@ -1,17 +0,0 @@
 using Mediator;
 using Microsoft.EntityFrameworkCore;
 using Musify.Application.Contracts;
 namespace Musify.Application.Users
 {
    public record IsFollowingUserQuery(long FollowerId, long FollowedId) : IQuery<bool>;
    public class IsFollowingUserQueryHandler(IDatabase database)
        : IQueryHandler<IsFollowingUserQuery, bool>
    {
        public ValueTask<bool> Handle(IsFollowingUserQuery request, CancellationToken cancellationToken) =>
            new(database.UserFollows
                .AsNoTracking()
                .AnyAsync(f => f.FollowerId == request.FollowerId && f.FollowedId == request.FollowedId, cancellationToken));
    }
 }
@@ -1,32 +0,0 @@
 using ErrorOr;
 using Mediator;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.Extensions.Logging;
 using Musify.Application.Contracts;
 namespace Musify.Application.Users
 {
    public record UnfollowUserCommand(long FollowerId, long FollowedId) : ICommand<ErrorOr<Success>>;
    public class UnfollowUserCommandHandler(
        IDatabase database,
        ILogger<UnfollowUserCommandHandler> logger)
        : ICommandHandler<UnfollowUserCommand, ErrorOr<Success>>
    {
        public async ValueTask<ErrorOr<Success>> Handle(UnfollowUserCommand request, CancellationToken cancellationToken)
        {
            var follow = await database.UserFollows
                .SingleOrDefaultAsync(f => f.FollowerId == request.FollowerId && f.FollowedId == request.FollowedId, cancellationToken);
            if (follow == null)
                return new Success();
            database.UserFollows.Remove(follow);
            await database.SaveChangesAsync(cancellationToken);
            logger.LogInformation("User {FollowerId} unfollowed user {FollowedId}", request.FollowerId, request.FollowedId);
            return new Success();
        }
    }
 }
@@ -1,8 +0,0 @@
 <Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <AssemblyName>Musify.Domain</AssemblyName>
    <RootNamespace>Musify.Domain</RootNamespace>
  </PropertyGroup>
 </Project>
@@ -1,46 +0,0 @@
 using System.ComponentModel.DataAnnotations;
 using System.ComponentModel.DataAnnotations.Schema;
 using Musify.Domain.Abstractions;
 using Musify.Domain.ValueObjects;
 namespace Musify.Domain.Entities
 {
 #pragma warning disable CS8618
    public class Album : IAuditable
    {
        [Key]
        public Guid Id { get; set; } = Guid.NewGuid();
        [Required]
        [MaxLength(200)]
        public required string Title { get; set; }
        [Required]
        [MaxLength(200)]
        public required string NormalizedTitle { get; set; }
        [MaxLength(256)]
        public string? Description { get; set; }
        public int? ReleaseYear { get; set; }
        public AlbumPictures? Pictures { get; set; }
        [Required]
        public required long OwnerUserId { get; set; }
        [ForeignKey(nameof(OwnerUserId))]
        public User Owner { get; set; }
        [Required]
        public LifeCycleStatus LifeCycleStatus { get; set; } = LifeCycleStatus.Active;
        [Required]
        public DateTime CreatedAt { get; set; } = DateTime.UtcNow;
        [Required]
        public DateTime UpdatedAt { get; set; } = DateTime.UtcNow;
        public ICollection<AlbumHasTrack> AlbumTracks { get; set; } = new List<AlbumHasTrack>();
    }
 }
@@ -1,30 +0,0 @@
 using System.ComponentModel.DataAnnotations;
 using System.ComponentModel.DataAnnotations.Schema;
 namespace Musify.Domain.Entities
 {
 #pragma warning disable CS8618
    [Table("AlbumHasTrack")]
    public class AlbumHasTrack
    {
        public Guid Id { get; set; } = Guid.NewGuid();
        [Required]
        public required Guid AlbumId { get; set; }
        [Required]
        public required Guid TrackId { get; set; }
        [Required]
        public int TrackNumber { get; set; } = 1;
        [Required]
        public DateTime AddedAt { get; set; } = DateTime.UtcNow;
        [ForeignKey(nameof(AlbumId))]
        public Album Album { get; set; }
        [ForeignKey(nameof(TrackId))]
        public Track Track { get; set; }
    }
 }
@@ -1,28 +0,0 @@
 using System.ComponentModel.DataAnnotations;
 using System.ComponentModel.DataAnnotations.Schema;
 namespace Musify.Domain.Entities
 {
 #pragma warning disable CS8618
    [Table("ListeningHistory")]
    public class ListeningHistory
    {
        [Key]
        public Guid Id { get; set; } = Guid.NewGuid();
        [Required]
        public required long UserId { get; set; }
        [Required]
        public required Guid TrackId { get; set; }
        [Required]
        public DateTime ListenedAt { get; set; } = DateTime.UtcNow;
        [ForeignKey(nameof(UserId) )]
        public User User { get; set; }
        [ForeignKey(nameof(TrackId)) ]
        public Track Track { get; set; }
    }
 }
@@ -1,39 +0,0 @@
 using System.ComponentModel.DataAnnotations;
 using System.ComponentModel.DataAnnotations.Schema;
 using Musify.Domain.Abstractions;
 namespace Musify.Domain.Entities
 {
 #pragma warning disable CS8618
    [Table("Mixes")]
    public class Mix : IAuditable
    {
        [Key]
        public Guid Id { get; set; } = Guid.NewGuid();
        [Required]
        public required long UserId { get; set; }
        [Required]
        [MaxLength(100)]
        public required string Title { get; set; }
        [MaxLength(256)]
        public string? Subtitle { get; set; }
        [Required]
        public int Position { get; set; } = 0;
        [Required]
        public DateTime CreatedAt { get; set; } = DateTime.UtcNow;
        [Required]
        public DateTime UpdatedAt { get; set; } = DateTime.UtcNow;
        [ForeignKey(nameof(UserId))]
        public User User { get; set; }
        public ICollection<MixItem> Items { get; set; } = new List<MixItem>();
    }
 }
@@ -1,28 +0,0 @@
 using System.ComponentModel.DataAnnotations;
 using System.ComponentModel.DataAnnotations.Schema;
 namespace Musify.Domain.Entities
 {
 #pragma warning disable CS8618
    [Table("MixItems")]
    public class MixItem
    {
        [Key]
        public Guid Id { get; set; } = Guid.NewGuid();
        [Required]
        public required Guid MixId { get; set; }
        [Required]
        public int Position { get; set; } = 0;
        [Required]
        public required Guid TrackId { get; set; }
        [ForeignKey(nameof(MixId))]
        public Mix Mix { get; set; }
        [ForeignKey(nameof(TrackId))]
        public Track Track { get; set; }
    }
 }
@@ -1,54 +0,0 @@
 using System.ComponentModel.DataAnnotations;
 using System.ComponentModel.DataAnnotations.Schema;
 using Musify.Domain.Abstractions;
 using Musify.Domain.ValueObjects;
 namespace Musify.Domain.Entities
 {
 #pragma warning disable CS8618
    public class Track : IAuditable
    {
        [Key]
        public Guid Id { get; set; } = Guid.NewGuid();
        [Required]
        [MaxLength(200)]
        public required string Title { get; set; }
        [Required]
        [MaxLength(200)]
        public required string NormalizedTitle { get; set; }
        [Required]
        public double DurationSeconds { get; set; }
        [Required]
        public required long OwnerUserId { get; set; }
        [ForeignKey(nameof(OwnerUserId))]
        public required User Owner { get; set; }
        [Required]
        public LifeCycleStatus LifeCycleStatus { get; set; } = LifeCycleStatus.Active;
        [Required]
        public DateTime CreatedAt { get; set; } = DateTime.UtcNow;
        [Required]
        public DateTime UpdatedAt { get; set; } = DateTime.UtcNow;
        public TrackPictures Pictures { get; set; } = new();
        public TrackAudio Audio { get; set; } = new();
        public ICollection<UserHasTrack> UserTracks { get; set; } = new List<UserHasTrack>();
        public ICollection<PlayListHasTrack> PlayListTracks { get; set; } = new List<PlayListHasTrack>();
        public ICollection<AlbumHasTrack> AlbumTracks { get; set; } = new List<AlbumHasTrack>();
        public ICollection<ListeningHistory> ListeningHistories { get; set; } = new List<ListeningHistory>();
        public ICollection<TrackTag> Tags { get; set; } = new List<TrackTag>();
    }
 }
@@ -1,28 +0,0 @@
 using System.ComponentModel.DataAnnotations;
 using System.ComponentModel.DataAnnotations.Schema;
 namespace Musify.Domain.Entities
 {
 #pragma warning disable CS8618
    [Table("TrackLikes")]
    public class TrackLike
    {
        [Key]
        public Guid Id { get; set; } = Guid.NewGuid();
        [Required]
        public required long UserId { get; set; }
        [Required]
        public required Guid TrackId { get; set; }
        [Required]
        public DateTime CreatedAt { get; set; } = DateTime.UtcNow;
        [ForeignKey(nameof(UserId))]
        public User User { get; set; }
        [ForeignKey(nameof(TrackId))]
        public Track Track { get; set; }
    }
 }
@@ -1,22 +0,0 @@
 using System.ComponentModel.DataAnnotations;
 using System.ComponentModel.DataAnnotations.Schema;
 using Musify.Domain.ValueObjects;
 namespace Musify.Domain.Entities
 {
 #pragma warning disable CS8618
    public class TrackTag
    {
        [Key]
        public Guid Id { get; set; } = Guid.NewGuid();
        [Required]
        public required Guid TrackId { get; set; }
        [Required]
        public required Genre Tag { get; set; }
        [ForeignKey(nameof(TrackId))]
        public Track Track { get; set; }
    }
 }
@@ -1,28 +0,0 @@
 using System.ComponentModel.DataAnnotations;
 using System.ComponentModel.DataAnnotations.Schema;
 namespace Musify.Domain.Entities
 {
 #pragma warning disable CS8618
    [Table("UserFollows")]
    public class UserFollow
    {
        [Key]
        public Guid Id { get; set; } = Guid.NewGuid();
        [Required]
        public required long FollowerId { get; set; }
        [Required]
        public required long FollowedId { get; set; }
        [Required]
        public DateTime CreatedAt { get; set; } = DateTime.UtcNow;
        [ForeignKey(nameof(FollowerId))]
        public User Follower { get; set; }
        [ForeignKey(nameof(FollowedId))]
        public User Followed { get; set; }
    }
 }
@@ -1,19 +0,0 @@
 using System.ComponentModel.DataAnnotations;
 namespace Musify.Domain.ValueObjects
 {
    public class AlbumPictures
    {
        [Required]
        public required string OriginalName { get; set; }
        [Required]
        public required string SmallName { get; set; }
        [Required]
        public required string MediumName { get; set; }
        [Required]
        public required string LargeName { get; set; }
    }
 }
@@ -1,32 +0,0 @@
 namespace Musify.Domain.ValueObjects
 {
    public enum Genre
    {
        Pop = 0,
        Rock = 1,
        HipHop = 2,
        RnB = 3,
        Jazz = 4,
        Blues = 5,
        Classical = 6,
        Electronic = 7,
        House = 8,
        Techno = 9,
        Trance = 10,
        Dubstep = 11,
        DrumAndBass = 12,
        Metal = 13,
        Punk = 14,
        Reggae = 15,
        Reggaeton = 16,
        Country = 17,
        Folk = 18,
        Indie = 19,
        KPop = 20,
        Latin = 21,
        Soul = 22,
        Funk = 23,
        Ambient = 24,
        Lofi = 25
    }
 }
@@ -1,48 +0,0 @@
 namespace Musify.Domain.ValueObjects
 {
    public static class GenreCompatibility
    {
        private static readonly HashSet<(Genre, Genre)> IncompatiblePairs = BuildIncompatiblePairs();
        private static HashSet<(Genre, Genre)> BuildIncompatiblePairs()
        {
            var pairs = new HashSet<(Genre, Genre)>();
            void Add(Genre a, Genre b)
            {
                pairs.Add((a, b));
                pairs.Add((b, a));
            }
            var intense = new[] { Genre.Metal, Genre.Punk, Genre.Dubstep, Genre.DrumAndBass };
            var mellow = new[] { Genre.Classical, Genre.Ambient, Genre.Lofi };
            foreach (var intenseGenre in intense)
                foreach (var mellowGenre in mellow)
                    Add(intenseGenre, mellowGenre);
            return pairs;
        }
        public static bool AreCompatible(Genre a, Genre b) =>
            a == b || !IncompatiblePairs.Contains((a, b));
        public static IReadOnlyCollection<(Genre First, Genre Second)> FindConflicts(IEnumerable<Genre> tags)
        {
            var distinctTags = tags.Distinct().ToList();
            var conflicts = new List<(Genre, Genre)>();
            for (var i = 0; i < distinctTags.Count; i++)
            {
                for (var j = i + 1; j < distinctTags.Count; j++)
                {
                    if (!AreCompatible(distinctTags[i], distinctTags[j]))
                        conflicts.Add((distinctTags[i], distinctTags[j]));
                }
            }
            return conflicts;
        }
    }
 }
@@ -1,19 +0,0 @@
 using System.ComponentModel.DataAnnotations;
 namespace Musify.Domain.ValueObjects
 {
    public class PlayListPictures
    {
        [Required]
        public required string OriginalName { get; set; }
        [Required]
        public required string SmallName { get; set; }
        [Required]
        public required string MediumName { get; set; }
        [Required]
        public required string LargeName { get; set; }
    }
 }
@@ -1,8 +0,0 @@
 namespace Musify.Domain.ValueObjects
 {
    public enum PlaylistVisibility
    {
        Private = 0,
        Public = 1
    }
 }
@@ -1,27 +0,0 @@
 using System.Diagnostics.CodeAnalysis;
 namespace Musify.Domain.ValueObjects
 {
 #pragma warning disable CS8618
    public class TrackAudio
    {
        public string? OriginalName { get; set; }
        public string? FolderName { get; set; }
        public ProcessingStatus TranscodeStatus { get; set; } = ProcessingStatus.Pending;
        public bool DownloadRequested { get; set; }
        public int RetryCount { get; set; }
        public DateTime? LastRetryAt { get; set; }
        [MemberNotNullWhen(true, nameof(FolderName))]
        public bool IsProcessed => TranscodeStatus == ProcessingStatus.Completed;
        public bool IsFailed => TranscodeStatus == ProcessingStatus.Failed;
        public bool IsInProgress => TranscodeStatus is ProcessingStatus.Pending or ProcessingStatus.Processing;
    }
 }
@@ -1,23 +0,0 @@
 using System.Diagnostics.CodeAnalysis;
 namespace Musify.Domain.ValueObjects
 {
 #pragma warning disable CS8618
    public class TrackPictures
    {
        public string? OriginalName { get; set; }
        public string? SmallName { get; set; }
        public string? MediumName { get; set; }
        public string? LargeName { get; set; }
        public ProcessingStatus ProcessingStatus { get; set; } = ProcessingStatus.Pending;
        [MemberNotNullWhen(true, nameof(SmallName))]
        [MemberNotNullWhen(true, nameof(MediumName))]
        [MemberNotNullWhen(true, nameof(LargeName))]
        public bool IsProcessed => ProcessingStatus == ProcessingStatus.Completed;
    }
 }
@@ -1,37 +0,0 @@
 using Mediator;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.Extensions.Logging;
 using Musify.Application.Contracts;
 using Musify.Application.Mixes;
 namespace Musify.Infrastructure.Jobs
 {
    public class DailyMixGenerationJob(
        IDatabase database,
        IMediator mediator,
        ILogger<DailyMixGenerationJob> logger)
    {
        public async Task RunAsync(CancellationToken cancellationToken)
        {
            var userIds = await database.ListeningHistories
                .AsNoTracking()
                .Select(history => history.UserId)
                .Distinct()
                .ToListAsync(cancellationToken);
            logger.LogInformation("Starting daily mix generation for {Count} users", userIds.Count);
            foreach (var userId in userIds)
            {
                var result = await mediator.Send(new GenerateMixesForUserCommand(userId), cancellationToken);
                if (result.IsError)
                {
                    logger.LogWarning("Failed to generate mixes for user {UserId}: {Error}",
                        userId, result.FirstError.Description);
                }
            }
            logger.LogInformation("Finished daily mix generation");
        }
    }
 }
@@ -1,32 +0,0 @@
 using MassTransit;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.Extensions.Logging;
 using Musify.Application.Contracts;
 using Musify.Domain.ValueObjects;
 using Musify.Infrastructure.MassTransit.Arguments;
 namespace Musify.Infrastructure.MassTransit.Activities.Albums
 {
    internal class MarkAlbumAsFailedActivity(
        IDatabase database,
        ILogger<MarkAlbumAsFailedActivity> logger)
        : IExecuteActivity<MarkAlbumAsFailedArguments>
    {
        public const string ExecuteEndpointName = "mark-album-as-failed";
        public async Task<ExecutionResult> Execute(ExecuteContext<MarkAlbumAsFailedArguments> executeContext)
        {
            var album = await database.Albums
                .SingleOrDefaultAsync(a => a.Id == executeContext.Arguments.AlbumId, executeContext.CancellationToken);
            if (album != null)
            {
                album.LifeCycleStatus = LifeCycleStatus.Failed;
                await database.SaveChangesAsync(executeContext.CancellationToken);
                logger.LogInformation("Marked album {AlbumId} as failed", executeContext.Arguments.AlbumId);
            }
            return executeContext.Completed();
        }
    }
 }
@@ -1,34 +0,0 @@
 using MassTransit;
 using Microsoft.Extensions.Logging;
 using Musify.Application.Events;
 using Musify.Infrastructure.MassTransit.Arguments;
 namespace Musify.Infrastructure.MassTransit.Activities.Albums
 {
    internal class PublishAlbumPictureProcessingEventActivity(
        IPublishEndpoint publishEndpoint,
        ILogger<PublishAlbumPictureProcessingEventActivity> logger)
        : IExecuteActivity<PublishAlbumPictureProcessingEventArguments>
    {
        public const string ExecuteEndpointName = "publish-album-picture-processing-event";
        public async Task<ExecutionResult> Execute(ExecuteContext<PublishAlbumPictureProcessingEventArguments> executeContext)
        {
            var arguments = executeContext.Arguments;
            await publishEndpoint.Publish(
                new UpdateAlbumPictureEvent(
                    arguments.AlbumId,
                    arguments.Bucket,
                    arguments.FinalPictureKey,
                    arguments.Small,
                    arguments.Medium,
                    arguments.Large),
                executeContext.CancellationToken);
            logger.LogInformation("Published picture processing event for album {AlbumId}", arguments.AlbumId);
            return executeContext.Completed();
        }
    }
 }
@@ -1,69 +0,0 @@
 using MassTransit;
 using Microsoft.Extensions.Logging;
 using Musify.Infrastructure.MassTransit.Arguments;
 using Musify.Infrastructure.MassTransit.Logs;
 namespace Musify.Infrastructure.MassTransit.Activities.Files
 {
    internal class DownloadFileFromUrlActivity(
        IHttpClientFactory httpClientFactory,
        ILogger<DownloadFileFromUrlActivity> logger)
        : IActivity<DownloadFileFromUrlArguments, DownloadFileFromUrlLog>
    {
        public const string ExecuteEndpointName = "download-file-from-url";
        public async Task<ExecutionResult> Execute(ExecuteContext<DownloadFileFromUrlArguments> executeContext)
        {
            var destinationPath = executeContext.GetVariable<string>(executeContext.Arguments.DestinationFilePathVariable);
            ArgumentNullException.ThrowIfNull(destinationPath, nameof(destinationPath));
            try
            {
                var httpClient = httpClientFactory.CreateClient();
                using var response = await httpClient.GetAsync(
                    executeContext.Arguments.SourceUrl,
                    HttpCompletionOption.ResponseHeadersRead,
                    executeContext.CancellationToken);
                response.EnsureSuccessStatusCode();
                var destinationDirectory = Path.GetDirectoryName(destinationPath);
                if (!string.IsNullOrWhiteSpace(destinationDirectory))
                    Directory.CreateDirectory(destinationDirectory);
                await using (var destinationStream = File.Create(destinationPath))
                {
                    await response.Content.CopyToAsync(destinationStream, executeContext.CancellationToken);
                }
                logger.LogInformation("Downloaded {SourceUrl} to {DestinationPath}",
                    executeContext.Arguments.SourceUrl, destinationPath);
                return executeContext.Completed(new DownloadFileFromUrlLog(
                    executeContext.Arguments.SourceUrl,
                    destinationPath));
            }
            catch (Exception exception)
            {
                logger.LogError(exception, "Failed to download file from {SourceUrl}", executeContext.Arguments.SourceUrl);
                throw;
            }
        }
        public Task<CompensationResult> Compensate(CompensateContext<DownloadFileFromUrlLog> compensateContext)
        {
            try
            {
                if (File.Exists(compensateContext.Log.DestinationFilePath))
                    File.Delete(compensateContext.Log.DestinationFilePath);
                return Task.FromResult(compensateContext.Compensated());
            }
            catch (Exception exception)
            {
                logger.LogError(exception, "Failed to compensate downloaded file {DestinationFilePath}",
                    compensateContext.Log.DestinationFilePath);
                return Task.FromResult(compensateContext.Failed(exception));
            }
        }
    }
 }
@@ -1,113 +0,0 @@
 using MassTransit;
 using Microsoft.Extensions.Logging;
 using Musify.Application.Contracts;
 using Musify.Application.Events;
 using Musify.Domain.ValueObjects;
 using Musify.Infrastructure.MassTransit.Arguments;
 using Musify.Infrastructure.MassTransit.Logs;
 namespace Musify.Infrastructure.MassTransit.Activities.Pictures
 {
    internal class UpdateAlbumPictureActivity(
        IDatabase database,
        IPublishEndpoint publishEndpoint,
        ILogger<UpdateAlbumPictureActivity> logger)
        : IActivity<UpdateAlbumPictureArguments, UpdateAlbumPictureLog>
    {
        public const string ExecuteEndpointName = "update-album-picture";
        public async Task<ExecutionResult> Execute(ExecuteContext<UpdateAlbumPictureArguments> executeContext)
        {
            var smallResizedVariable = executeContext.GetVariable<string>(executeContext.Arguments.SmallPictureVariable);
            ArgumentNullException.ThrowIfNull(smallResizedVariable, nameof(smallResizedVariable));
            var mediumResizedVariable = executeContext.GetVariable<string>(executeContext.Arguments.MediumPictureVariable);
            ArgumentNullException.ThrowIfNull(mediumResizedVariable, nameof(mediumResizedVariable));
            var largeResizedVariable = executeContext.GetVariable<string>(executeContext.Arguments.LargePictureVariable);
            ArgumentNullException.ThrowIfNull(largeResizedVariable, nameof(largeResizedVariable));
            try
            {
                var album = await database.Albums.FindAsync(
                    [executeContext.Arguments.AlbumId],
                    cancellationToken: executeContext.CancellationToken);
                if (album == null)
                {
                    logger.LogWarning("Album {AlbumId} not found",
                        executeContext.Arguments.AlbumId);
                    throw new InvalidOperationException($"Album with id {executeContext.Arguments.AlbumId} not found");
                }
                if (album.Pictures == null)
                {
                    logger.LogWarning("Album {AlbumId} has no pending picture upload",
                        executeContext.Arguments.AlbumId);
                    throw new InvalidOperationException($"Album with id {executeContext.Arguments.AlbumId} has no pending picture upload");
                }
                var log = new UpdateAlbumPictureLog(
                    album.Id,
                    album.Pictures.OriginalName,
                    album.Pictures.SmallName,
                    album.Pictures.MediumName,
                    album.Pictures.LargeName);
                album.Pictures.OriginalName = Path.GetFileName(executeContext.Arguments.OriginalPictureKey);
                album.Pictures.SmallName = Path.GetFileName(smallResizedVariable);
                album.Pictures.MediumName = Path.GetFileName(mediumResizedVariable);
                album.Pictures.LargeName = Path.GetFileName(largeResizedVariable);
                database.Albums.Update(album);
                await database.SaveChangesAsync(executeContext.CancellationToken);
                logger.LogInformation("Updated album {AlbumId} pictures",
                    executeContext.Arguments.AlbumId);
                await publishEndpoint.Publish(
                    new AlbumPictureProcessed(executeContext.Arguments.AlbumId),
                    executeContext.CancellationToken);
                return executeContext.Completed();
            }
            catch (Exception exception)
            {
                logger.LogError(exception, "Failed to update album {AlbumId} pictures",
                    executeContext.Arguments.AlbumId);
                throw;
            }
        }
        public async Task<CompensationResult> Compensate(CompensateContext<UpdateAlbumPictureLog> compensateContext)
        {
            try
            {
                var album = await database.Albums.FindAsync(
                    [compensateContext.Log.AlbumId],
                    cancellationToken: compensateContext.CancellationToken);
                if (album == null)
                {
                    return compensateContext.Compensated();
                }
                album.Pictures = new AlbumPictures
                {
                    OriginalName = compensateContext.Log.PreviousOriginalPictureKey,
                    SmallName = compensateContext.Log.PreviousSmallPictureKey,
                    MediumName = compensateContext.Log.PreviousMediumPictureKey,
                    LargeName = compensateContext.Log.PreviousLargePictureKey
                };
                database.Albums.Update(album);
                await database.SaveChangesAsync(compensateContext.CancellationToken);
                return compensateContext.Compensated();
            }
            catch (Exception exception)
            {
                logger.LogError(exception, "Failed to compensate album {AlbumId} pictures", compensateContext.Log.AlbumId);
                return compensateContext.Failed(exception);
            }
        }
    }
 }
@@ -1,6 +0,0 @@
 namespace Musify.Infrastructure.MassTransit.Arguments
 {
    public record DownloadFileFromUrlArguments(
        string SourceUrl,
        string DestinationFilePathVariable);
 }
@@ -1,4 +0,0 @@
 namespace Musify.Infrastructure.MassTransit.Arguments
 {
    public record MarkAlbumAsFailedArguments(Guid AlbumId);
 }
@@ -1,12 +0,0 @@
 using Musify.Application.Shared;
 namespace Musify.Infrastructure.MassTransit.Arguments
 {
    public record PublishAlbumPictureProcessingEventArguments(
        Guid AlbumId,
        string Bucket,
        string FinalPictureKey,
        ImageSize Small,
        ImageSize Medium,
        ImageSize Large);
 }
@@ -1,9 +0,0 @@
 namespace Musify.Infrastructure.MassTransit.Arguments
 {
    public record UpdateAlbumPictureArguments(
        Guid AlbumId,
        string OriginalPictureKey,
        string SmallPictureVariable,
        string MediumPictureVariable,
        string LargePictureVariable);
 }
@@ -1,36 +0,0 @@
 using MassTransit;
 using MassTransit.Courier.Contracts;
 using Musify.Application.Events;
 using Musify.Infrastructure.MassTransit.Activities.Albums;
 using Musify.Infrastructure.MassTransit.Activities.Files;
 using Musify.Infrastructure.MassTransit.Arguments;
 using Musify.Infrastructure.MassTransit.RoutingSlip;
 namespace Musify.Infrastructure.MassTransit.Consumers
 {
    public class AlbumProcessingFailedConsumer(IBus bus) : IConsumer<AlbumProcessingFailed>
    {
        public async Task Consume(ConsumeContext<AlbumProcessingFailed> context)
        {
            var message = context.Message;
            var builder = new RoutingSlipBuilder(NewId.NextGuid());
            builder.AddSubscription(
                EndpointHelper.BuildConsumerUri(RoutingSlipCleanUpConsumer.QueueName),
                RoutingSlipEvents.Completed | RoutingSlipEvents.Faulted);
            if (!string.IsNullOrWhiteSpace(message.Bucket) && !string.IsNullOrWhiteSpace(message.PictureKey))
                builder.AddActivity(
                    ActivityNames.RemoveAlbumOriginalPicture,
                    EndpointHelper.BuildExecuteActivityUri(RemoveFileFromBucketActivity.ExecuteEndpointName),
                    new RemoveFileFromBucketArguments(message.Bucket, message.PictureKey));
            builder.AddActivity(
                ActivityNames.MarkAlbumAsFailed,
                EndpointHelper.BuildExecuteActivityUri(MarkAlbumAsFailedActivity.ExecuteEndpointName),
                new MarkAlbumAsFailedArguments(message.AlbumId));
            await bus.Execute(builder.Build());
        }
    }
 }
@@ -1,22 +0,0 @@
 using MassTransit;
 using Musify.Application.Events;
 using Musify.Infrastructure.MassTransit.RoutingSlip.Builders;
 namespace Musify.Infrastructure.MassTransit.Consumers
 {
    public class CreateAlbumConsumer(
        IBus bus,
        AlbumPictureSourceRoutingSlipBuilder routingSlipBuilder)
        : IConsumer<CreateAlbumResourcesEvent>
    {
        public async Task Consume(ConsumeContext<CreateAlbumResourcesEvent> consumeContext)
        {
            var routingSlip = routingSlipBuilder
                .Build(consumeContext.Message, consumeContext.CorrelationId)
                .Build();
            await bus.Execute(routingSlip);
        }
    }
 }
@@ -1,22 +0,0 @@
 using MassTransit;
 using Musify.Application.Events;
 using Musify.Infrastructure.MassTransit.RoutingSlip.Builders;
 namespace Musify.Infrastructure.MassTransit.Consumers
 {
    public class UpdateAlbumPictureConsumer(
        IBus bus,
        PictureWorkflowRoutingSlipBuilder routingSlipBuilder)
        : IConsumer<UpdateAlbumPictureEvent>
    {
        public async Task Consume(ConsumeContext<UpdateAlbumPictureEvent> consumeContext)
        {
            var routingSlip = routingSlipBuilder
                .Build(consumeContext.Message, consumeContext.CorrelationId)
                .Build();
            await bus.Execute(routingSlip);
        }
    }
 }
@@ -1,22 +0,0 @@
 using MassTransit;
 using Musify.Application.Events;
 using Musify.Infrastructure.MassTransit.RoutingSlip.Builders;
 namespace Musify.Infrastructure.MassTransit.Consumers
 {
    public class UpdateAlbumPictureSourceConsumer(
        IBus bus,
        AlbumPictureSourceRoutingSlipBuilder routingSlipBuilder)
        : IConsumer<UpdateAlbumPictureSourceEvent>
    {
        public async Task Consume(ConsumeContext<UpdateAlbumPictureSourceEvent> consumeContext)
        {
            var routingSlip = routingSlipBuilder
                .Build(consumeContext.Message, consumeContext.CorrelationId)
                .Build();
            await bus.Execute(routingSlip);
        }
    }
 }
@@ -1,6 +0,0 @@
 namespace Musify.Infrastructure.MassTransit.Logs
 {
    public record DownloadFileFromUrlLog(
        string SourceUrl,
        string DestinationFilePath);
 }
@@ -1,9 +0,0 @@
 namespace Musify.Infrastructure.MassTransit.Logs
 {
    public record UpdateAlbumPictureLog(
        Guid AlbumId,
        string PreviousOriginalPictureKey,
        string PreviousSmallPictureKey,
        string PreviousMediumPictureKey,
        string PreviousLargePictureKey);
 }
@@ -1,9 +0,0 @@
 namespace Musify.Infrastructure.MassTransit.Logs
 {
    public record UpdateTrackPictureLog(
        Guid TrackId,
        string? PreviousOriginalPictureKey,
        string? PreviousSmallPictureKey,
        string? PreviousMediumPictureKey,
        string? PreviousLargePictureKey);
 }
@@ -1,85 +0,0 @@
 using MassTransit;
 using MassTransit.Courier.Contracts;
 using Musify.Application.Shared;
 using Musify.Application.Events;
 using Musify.Infrastructure.MassTransit.Activities.Albums;
 using Musify.Infrastructure.MassTransit.Activities.Files;
 using Musify.Infrastructure.MassTransit.Activities.UploadIntents;
 using Musify.Infrastructure.MassTransit.Arguments;
 using Musify.Infrastructure.MassTransit.Consumers;
 namespace Musify.Infrastructure.MassTransit.RoutingSlip.Builders
 {
    public class AlbumPictureSourceRoutingSlipBuilder
    {
        public RoutingSlipBuilder Build(CreateAlbumResourcesEvent message, Guid? correlationId)
            => BuildSlip(
                message.AlbumId,
                message.PictureIntentId,
                message.Bucket,
                message.PictureSourceKey,
                message.PictureDestinationKey,
                message.Small,
                message.Medium,
                message.Large,
                correlationId);
        public RoutingSlipBuilder Build(UpdateAlbumPictureSourceEvent message, Guid? correlationId)
            => BuildSlip(
                message.AlbumId,
                message.PictureIntentId,
                message.Bucket,
                message.PictureSourceKey,
                message.PictureDestinationKey,
                message.Small,
                message.Medium,
                message.Large,
                correlationId);
        static RoutingSlipBuilder BuildSlip(
            Guid albumId,
            Guid pictureIntentId,
            string bucket,
            string pictureSourceKey,
            string pictureDestinationKey,
            ImageSize small,
            ImageSize medium,
            ImageSize large,
            Guid? correlationId)
        {
            var routingSlipBuilder = new RoutingSlipBuilder(NewId.NextGuid());
            routingSlipBuilder.AddVariable(RoutingSlipVariableNames.Workflow.CorrelationId, correlationId ?? Guid.Empty);
            routingSlipBuilder.AddSubscription(
                EndpointHelper.BuildConsumerUri(RoutingSlipCleanUpConsumer.QueueName),
                RoutingSlipEvents.Completed | RoutingSlipEvents.Faulted);
            routingSlipBuilder.AddActivity(
                ActivityNames.CopyPictureToFinal,
                EndpointHelper.BuildExecuteActivityUri(CopyFileInBucketActivity.ExecuteEndpointName),
                new CopyFileInBucketArguments(
                    bucket,
                    pictureSourceKey,
                    bucket,
                    pictureDestinationKey));
            routingSlipBuilder.AddActivity(
                ActivityNames.ConsumeUploadIntents,
                EndpointHelper.BuildExecuteActivityUri(ConsumeUploadIntentsActivity.ExecuteEndpointName),
                new ConsumeUploadIntentsArguments([pictureIntentId]));
            routingSlipBuilder.AddActivity(
                ActivityNames.PublishAlbumPictureProcessingEvent,
                EndpointHelper.BuildExecuteActivityUri(PublishAlbumPictureProcessingEventActivity.ExecuteEndpointName),
                new PublishAlbumPictureProcessingEventArguments(
                    albumId,
                    bucket,
                    pictureDestinationKey,
                    small,
                    medium,
                    large));
            return routingSlipBuilder;
        }
    }
 }
@@ -1,19 +0,0 @@
 using MassTransit;
 namespace Musify.Infrastructure.MassTransit.Sagas
 {
    public class AlbumProcessingState : SagaStateMachineInstance
    {
        public Guid CorrelationId { get; set; }
        public string CurrentState { get; set; } = null!;
        public string? Bucket { get; set; }
        public string? PictureKey { get; set; }
        public DateTime CreatedAt { get; set; }
        public DateTime UpdatedAt { get; set; }
    }
 }
@@ -1,51 +0,0 @@
 using MassTransit;
 using Musify.Application.Events;
 namespace Musify.Infrastructure.MassTransit.Sagas
 {
    public sealed class AlbumProcessingStateMachine : MassTransitStateMachine<AlbumProcessingState>
    {
        public State Processing { get; private set; } = null!;
        public State Failed { get; private set; } = null!;
        public Event<CreateAlbumResourcesEvent> ProcessingStarted { get; private set; } = null!;
        public Event<AlbumPictureProcessed> PictureProcessed { get; private set; } = null!;
        public Event<AlbumPictureProcessingFailed> PictureFailed { get; private set; } = null!;
        public AlbumProcessingStateMachine()
        {
            InstanceState(state => state.CurrentState);
            Event(() => ProcessingStarted, config => config.CorrelateById(context => context.Message.AlbumId));
            Event(() => PictureProcessed, config => config.CorrelateById(context => context.Message.AlbumId));
            Event(() => PictureFailed, config => config.CorrelateById(context => context.Message.AlbumId));
            Initially(
                When(ProcessingStarted)
                    .Then(context =>
                    {
                        context.Saga.CreatedAt = DateTime.UtcNow;
                        context.Saga.UpdatedAt = DateTime.UtcNow;
                        context.Saga.Bucket = context.Message.Bucket;
                        context.Saga.PictureKey = context.Message.PictureDestinationKey;
                    } )
                    .TransitionTo(Processing));
            During(Processing,
                When(PictureProcessed).Finalize(),
                When(PictureFailed)
                    .Then(context => context.Saga.UpdatedAt = DateTime.UtcNow)
                    .TransitionTo(Failed)
                    .Publish(context => new AlbumProcessingFailed(
                        context.Saga.CorrelationId,
                        context.Saga.Bucket,
                        context.Saga.PictureKey)));
            During(Failed,
                Ignore(PictureProcessed),
                Ignore(PictureFailed));
            SetCompletedWhenFinalized();
        }
    }
 }
@@ -1,216 +0,0 @@
 using Microsoft.EntityFrameworkCore;
 using Microsoft.EntityFrameworkCore.Storage;
 using MassTransit;
 using Musify.Domain.Entities;
 using Musify.Domain.ValueObjects;
 using Musify.Infrastructure.Configuration;
 using Musify.Infrastructure.MassTransit.Sagas;
 using AppIDatabase = Musify.Application.Contracts.IDatabase;
 using Musify.Application.Contracts;
 namespace Musify.Infrastructure.Persistence
 {
    public class Database(DatabaseConfiguration configuration)
        : DbContext, AppIDatabase
    {
        private static readonly AuditableEntityInterceptor AuditInterceptor = new();
        protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
        {
            optionsBuilder
                .UseNpgsql(configuration.ConnectionString, o => o.MapEnum<Genre>("genre"))
                .AddInterceptors(AuditInterceptor);
        }
        protected override void OnModelCreating(ModelBuilder modelBuilder)
        {
            base.OnModelCreating(modelBuilder);
            modelBuilder.AddInboxStateEntity();
            modelBuilder.AddOutboxMessageEntity();
            modelBuilder.AddOutboxStateEntity();
            var trackProcessing = modelBuilder.Entity<TrackProcessingState>();
            trackProcessing.HasKey(state => state.CorrelationId);
            trackProcessing.Property(state => state.CorrelationId).ValueGeneratedNever();
            trackProcessing.Property(state => state.CurrentState).HasMaxLength(64);
            modelBuilder.Entity<Track>()
                .OwnsOne(track => track.Pictures, pictures =>
                {
                    pictures.Property(p => p.OriginalName).HasColumnName("OriginalPictureName").HasMaxLength(64);
                    pictures.Property(p => p.SmallName).HasColumnName("SmallPictureName").HasMaxLength(64);
                    pictures.Property(p => p.MediumName).HasColumnName("MediumPictureName").HasMaxLength(64);
                    pictures.Property(p => p.LargeName).HasColumnName("LargePictureName").HasMaxLength(64);
                    pictures.Property(p => p.ProcessingStatus).HasColumnName("PicturesProcessingStatus");
                });
            modelBuilder.Entity<Track>().Navigation(track => track.Pictures).IsRequired();
            modelBuilder.Entity<Track>()
                .OwnsOne(track => track.Audio, audio =>
                {
                    audio.Property(a => a.OriginalName).HasColumnName("OriginalAudioName").HasMaxLength(64);
                    audio.Property(a => a.FolderName).HasColumnName("AudioFolderName").HasMaxLength(64);
                    audio.Property(a => a.TranscodeStatus).HasColumnName("AudioTranscodeProcessingStatus");
                    audio.Property(a => a.DownloadRequested).HasColumnName("DownloadRequested");
                    audio.Property(a => a.RetryCount).HasColumnName("RetryCount");
                    audio.Property(a => a.LastRetryAt).HasColumnName("LastRetryAt");
                });
            modelBuilder.Entity<Track>().Navigation(track => track.Audio).IsRequired();
            modelBuilder.Entity<Track>()
                .HasOne(track => track.Owner)
                .WithMany()
                .HasForeignKey(track => track.OwnerUserId)
                .OnDelete(DeleteBehavior.Restrict);
            modelBuilder.Entity<PlayList>()
                .Property(playList => playList.Visibility)
                .HasDefaultValue(PlaylistVisibility.Private);
            modelBuilder.Entity<PlayList>()
                .OwnsOne(playList => playList.Pictures, pictures =>
                {
                    pictures.Property(p => p.OriginalName).HasColumnName("OriginalPictureName").HasMaxLength(64).IsRequired(false);
                    pictures.Property(p => p.SmallName).HasColumnName("SmallPictureName").HasMaxLength(64).IsRequired(false);
                    pictures.Property(p => p.MediumName).HasColumnName("MediumPictureName").HasMaxLength(64).IsRequired(false);
                    pictures.Property(p => p.LargeName).HasColumnName("LargePictureName").HasMaxLength(64).IsRequired(false);
                });
            modelBuilder.Entity<PlayList>().Navigation(playList => playList.Pictures).IsRequired(false);
            modelBuilder.Entity<Album>()
                .OwnsOne(album => album.Pictures, pictures =>
                {
                    pictures.Property(p => p.OriginalName).HasColumnName("OriginalPictureName").HasMaxLength(64);
                    pictures.Property(p => p.SmallName).HasColumnName("SmallPictureName").HasMaxLength(64);
                    pictures.Property(p => p.MediumName).HasColumnName("MediumPictureName").HasMaxLength(64);
                    pictures.Property(p => p.LargeName).HasColumnName("LargePictureName").HasMaxLength(64);
                });
            modelBuilder.Entity<Album>().Navigation(album => album.Pictures).IsRequired(false);
            modelBuilder.Entity<Album>()
                .HasOne(album => album.Owner)
                .WithMany()
                .HasForeignKey(album => album.OwnerUserId)
                .OnDelete(DeleteBehavior.Restrict);
            modelBuilder.Entity<AlbumHasTrack>()
                .HasOne(albumTrack => albumTrack.Album)
                .WithMany(album => album.AlbumTracks)
                .HasForeignKey(albumTrack => albumTrack.AlbumId)
                .OnDelete(DeleteBehavior.Cascade);
            modelBuilder.Entity<AlbumHasTrack>()
                .HasOne(albumTrack => albumTrack.Track)
                .WithMany(track => track.AlbumTracks)
                .HasForeignKey(albumTrack => albumTrack.TrackId)
                .OnDelete(DeleteBehavior.Cascade);
            modelBuilder.Entity<AlbumHasTrack>()
                .HasIndex(albumTrack => new { albumTrack.AlbumId, albumTrack.TrackId })
                .IsUnique();
            modelBuilder.Entity<Mix>()
                .HasIndex(mix => new { mix.UserId, mix.Position });
            modelBuilder.Entity<MixItem>()
                .HasOne(item => item.Mix)
                .WithMany(mix => mix.Items)
                .HasForeignKey(item => item.MixId)
                .OnDelete(DeleteBehavior.Cascade);
            modelBuilder.Entity<MixItem>()
                .HasOne(item => item.Track)
                .WithMany()
                .HasForeignKey(item => item.TrackId)
                .OnDelete(DeleteBehavior.Cascade);
            modelBuilder.Entity<MixItem>()
                .HasIndex(item => new { item.MixId, item.Position });
            modelBuilder.Entity<TrackLike>()
                .HasIndex(like => new { like.UserId, like.TrackId })
                .IsUnique();
            modelBuilder.Entity<TrackTag>()
                .HasOne(trackTag => trackTag.Track)
                .WithMany(track => track.Tags)
                .HasForeignKey(trackTag => trackTag.TrackId)
                .OnDelete(DeleteBehavior.Cascade);
            modelBuilder.Entity<TrackTag>()
                .HasIndex(trackTag => new { trackTag.TrackId, trackTag.Tag })
                .IsUnique();
            modelBuilder.Entity<UserFollow>()
                .HasOne(follow => follow.Follower)
                .WithMany()
                .HasForeignKey(follow => follow.FollowerId)
                .OnDelete(DeleteBehavior.Restrict);
            modelBuilder.Entity<UserFollow>()
                .HasOne(follow => follow.Followed)
                .WithMany()
                .HasForeignKey(follow => follow.FollowedId)
                .OnDelete(DeleteBehavior.Restrict);
            modelBuilder.Entity<UserFollow>()
                .HasIndex(follow => new { follow.FollowerId, follow.FollowedId })
                .IsUnique();
            var playListProcessing = modelBuilder.Entity<PlayListProcessingState>();
            playListProcessing.HasKey(state => state.CorrelationId);
            playListProcessing.Property(state => state.CorrelationId).ValueGeneratedNever();
            playListProcessing.Property(state => state.CurrentState).HasMaxLength(64);
            var albumProcessing = modelBuilder.Entity<AlbumProcessingState>();
            albumProcessing.HasKey(state => state.CorrelationId);
            albumProcessing.Property(state => state.CorrelationId).ValueGeneratedNever();
            albumProcessing.Property(state => state.CurrentState).HasMaxLength(64);
        }
        public DbSet<User> Users => Set<User>();
        public DbSet<Track> Tracks => Set<Track>();
        public DbSet<PlayList> PlayLists => Set<PlayList>();
        public DbSet<Album> Albums => Set<Album>();
        public DbSet<AlbumHasTrack> AlbumHasTracks => Set<AlbumHasTrack>();
        public DbSet<UserHasTrack> UserHasTracks => Set<UserHasTrack>();
        public DbSet<PlayListHasTrack> PlayListHasTracks => Set<PlayListHasTrack>();
        public DbSet<Mix> Mixes => Set<Mix>();
        public DbSet<MixItem> MixItems => Set<MixItem>();
        public DbSet<Upload> Uploads => Set<Upload>();
        public DbSet<UploadIntent> UploadIntents => Set<UploadIntent>();
        public DbSet<ListeningHistory> ListeningHistories => Set<ListeningHistory>();
        public DbSet<TrackLike> TrackLikes => Set<TrackLike>();
        public DbSet<TrackTag> TrackTags => Set<TrackTag>();
        public DbSet<UserFollow> UserFollows => Set<UserFollow>();
        public async Task<IDatabaseTransaction> BeginTransactionAsync(System.Data.IsolationLevel isolationLevel, CancellationToken cancellationToken)
        {
            var transaction = await Database.BeginTransactionAsync(isolationLevel, cancellationToken);
            return new DatabaseTransaction(transaction);
        }
        private sealed class DatabaseTransaction(IDbContextTransaction inner) : IDatabaseTransaction
        {
            public Task CommitAsync(CancellationToken cancellationToken) =>
                inner.CommitAsync(cancellationToken);
            public ValueTask DisposeAsync() => inner.DisposeAsync();
        }
    }
 }
@@ -1,56 +0,0 @@
 using Microsoft.EntityFrameworkCore.Migrations;
 #nullable disable
 namespace Musify.Infrastructure.Persistence.Migrations
 {
    public partial class AddListeningHistory : Migration
    {
        protected override void Up(MigrationBuilder migrationBuilder)
        {
            migrationBuilder.CreateTable(
                name: "ListeningHistory",
                columns: table => new
                {
                    Id = table.Column<Guid>(type: "uuid", nullable: false),
                    UserId = table.Column<long>(type: "bigint", nullable: false),
                    TrackId = table.Column<Guid>(type: "uuid", nullable: false),
                    ListenedAt = table.Column<DateTime>(type: "timestamp with time zone", nullable: false)
                },
                constraints: table =>
                {
                    table.PrimaryKey("PK_ListeningHistory", x => x.Id);
                    table.ForeignKey(
                        name: "FK_ListeningHistory_Tracks_TrackId",
                        column: x => x.TrackId,
                        principalTable: "Tracks",
                        principalColumn: "Id",
                        onDelete: ReferentialAction.Cascade);
                    table.ForeignKey(
                        name: "FK_ListeningHistory_User_UserId",
                        column: x => x.UserId,
                        principalTable: "User",
                        principalColumn: "Id",
                        onDelete: ReferentialAction.Cascade);
                });
            migrationBuilder.CreateIndex(
                name: "IX_ListeningHistory_TrackId",
                table: "ListeningHistory",
                column: "TrackId");
            migrationBuilder.CreateIndex(
                name: "IX_ListeningHistory_UserId",
                table: "ListeningHistory",
                column: "UserId");
        }
        protected override void Down(MigrationBuilder migrationBuilder)
        {
            migrationBuilder.DropTable(
                name: "ListeningHistory");
        }
    }
 }
--- a/Show More
+++ b/Show More