feat: bring over the albums, explore and player work from the worktree

Moves the remaining uncommitted work: the home gets quick mixes and a
"Tus álbumes" shelf, saving a YouTube album now goes through
addYoutubeAlbumToPlaylistAction instead of the SaveYouTubeAlbum command,
and UserAlbum drops its unused ExternalId.

The mixes section keeps its current shape (no refresh action, no badge,
hidden when empty) rather than the older version the worktree carried.

backend/Musify.Api/Endpoints/AlbumEndpoints.cs

@@ -50,15 +50,6 @@ public static class AlbumEndpoints
             .Produces(StatusCodes.Status401Unauthorized)
             .Produces(StatusCodes.Status404NotFound);
 
-        group.MapPost("/youtube/{albumId}", SaveYouTubeAlbum)
-            .WithName("SaveYouTubeAlbum")
-            .WithSummary("Save A YouTube Music Album To Your Library With All Of Its Tracks.")
-            .RequireAuthorization()
-            .Produces<AlbumApplicationResponse>(StatusCodes.Status201Created)
-            .Produces(StatusCodes.Status401Unauthorized)
-            .Produces(StatusCodes.Status404NotFound)
-            .Produces(StatusCodes.Status409Conflict);
-
         group.MapPut("/{albumId}", UpdateAlbum)
             .WithName("UpdateAlbum")
             .WithSummary("Update An Album.")
@@ -152,19 +143,6 @@ public static class AlbumEndpoints
         return result.ToCreatedResult(album => $"/albums/{album.Id}");
     }
 
-    private static async Task<IResult> SaveYouTubeAlbum(
-        IMediator mediator,
-        CurrentUser currentUser,
-        string albumId,
-        CancellationToken cancellationToken)
-    {
-        var result = await mediator.Send(
-            new SaveYouTubeAlbumCommand(currentUser.RequiredId, albumId),
-            cancellationToken);
-
-        return result.ToCreatedResult(album => $"/albums/{album.Id}");
-    }
-
     private static async Task<IResult> UpdateAlbum(
         IMediator mediator,
         CurrentUser currentUser,

backend/Musify.Application/Albums/SaveYouTubeAlbum.cs

@@ -1,112 +0,0 @@
-using ErrorOr;
-using Mediator;
-using Microsoft.EntityFrameworkCore;
-using Microsoft.Extensions.Logging;
-using Musify.Application.Albums.Responses;
-using Musify.Application.Contracts;
-using Musify.Application.Services;
-using Musify.Domain.Entities;
-
-namespace Musify.Application.Albums
-{
-    public record SaveYouTubeAlbumCommand(long UserId, string AlbumId)
-        : ICommand<ErrorOr<AlbumApplicationResponse>>;
-
-    public class SaveYouTubeAlbumCommandHandler(
-        IDatabase database,
-        IYouTubeMusicService youTubeMusicService,
-        YouTubeTrackProvisioner provisioner,
-        ILogger<SaveYouTubeAlbumCommandHandler> logger)
-        : ICommandHandler<SaveYouTubeAlbumCommand, ErrorOr<AlbumApplicationResponse>>
-    {
-        public async ValueTask<ErrorOr<AlbumApplicationResponse>> Handle(SaveYouTubeAlbumCommand 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 alreadySaved = await database.UserAlbums
-                .AsNoTracking()
-                .AnyAsync(album => album.OwnerUserId == request.UserId && album.ExternalId == request.AlbumId, cancellationToken);
-            if (alreadySaved)
-            {
-                logger.LogInformation("Album {AlbumId} is already saved for user {UserId}", request.AlbumId, request.UserId);
-                return Error.Conflict(description: "The album is already in your library.");
-            }
-
-            var detailResult = await youTubeMusicService.GetAlbumAsync(request.AlbumId, cancellationToken);
-            if (detailResult.IsError)
-                return detailResult.Errors;
-
-            var detail = detailResult.Value;
-            if (detail.Tracks.Count == 0)
-                return Error.NotFound(description: "The album has no playable tracks.");
-
-            var title = Truncate(detail.Album.Title, 200);
-            var album = new UserAlbum
-            {
-                OwnerUserId = request.UserId,
-                ExternalId = request.AlbumId,
-                Title = title,
-                NormalizedTitle = title.ToUpperInvariant(),
-                Description = Truncate(detail.Description, 256),
-                ReleaseYear = detail.Album.ReleaseYear
-            };
-
-            await database.UserAlbums.AddAsync(album, cancellationToken);
-
-            var linkedTrackIds = new HashSet<Guid>();
-            foreach (var track in detail.Tracks)
-            {
-                var provisionResult = await provisioner.GetOrCreateAsync(track.VideoId, cancellationToken);
-                if (provisionResult.IsError)
-                {
-                    logger.LogWarning("Skipped track {VideoId} of album {AlbumId}: {Error}",
-                        track.VideoId, request.AlbumId, provisionResult.FirstError.Description);
-                    continue;
-                }
-
-                if (!linkedTrackIds.Add(provisionResult.Value.Track.Id))
-                    continue;
-
-                await database.AlbumHasTracks.AddAsync(new AlbumHasTrack
-                {
-                    AlbumId = album.Id,
-                    TrackId = provisionResult.Value.Track.Id,
-                    TrackNumber = track.TrackNumber
-                }, cancellationToken);
-            }
-
-            try
-            {
-                await database.SaveChangesAsync(cancellationToken);
-            }
-            catch (Exception exception)
-            {
-                logger.LogError(exception, "Failed to save YouTube album {AlbumId} for user {UserId}", request.AlbumId, request.UserId);
-                return Error.Failure(description: $"Failed to save 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("Saved YouTube album {AlbumId} as {AlbumGuid} with {TrackCount} tracks",
-                request.AlbumId, album.Id, trackCount);
-
-            return AlbumApplicationResponse.FromEntity(album, trackCount, coverTrackIds);
-        }
-
-        private static string Truncate(string value, int maxLength) =>
-            value.Length <= maxLength ? value : value[..maxLength];
-    }
-}

backend/Musify.Domain/Entities/UserAlbum.cs

@@ -9,9 +9,6 @@ namespace Musify.Domain.Entities
         [Required]
         public required long OwnerUserId { get; set; }
 
-        [MaxLength(64)]
-        public string? ExternalId { get; set; }
-
         [ForeignKey(nameof(OwnerUserId))]
         public User Owner { get; set; }
     }

backend/Musify.Infrastructure/Persistence/Database.cs

@@ -111,10 +111,6 @@ namespace Musify.Infrastructure.Persistence
             modelBuilder.Entity<UserAlbum>()
                 .ToTable("UserAlbums");
 
-            modelBuilder.Entity<UserAlbum>()
-                .HasIndex(album => new { album.OwnerUserId, album.ExternalId })
-                .IsUnique();
-
             modelBuilder.Entity<UserAlbum>()
                 .HasOne(album => album.Owner)
                 .WithMany()

backend/Musify.Infrastructure/Persistence/Migrations/20260721161653_RemoveUserAlbumExternalId.cs

@@ -0,0 +1,48 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace Musify.Infrastructure.Persistence.Migrations
+{
+    /// <inheritdoc />
+    public partial class RemoveUserAlbumExternalId : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropIndex(
+                name: "IX_UserAlbums_OwnerUserId_ExternalId",
+                table: "UserAlbums");
+
+            migrationBuilder.DropColumn(
+                name: "ExternalId",
+                table: "UserAlbums");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_UserAlbums_OwnerUserId",
+                table: "UserAlbums",
+                column: "OwnerUserId");
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropIndex(
+                name: "IX_UserAlbums_OwnerUserId",
+                table: "UserAlbums");
+
+            migrationBuilder.AddColumn<string>(
+                name: "ExternalId",
+                table: "UserAlbums",
+                type: "character varying(64)",
+                maxLength: 64,
+                nullable: true);
+
+            migrationBuilder.CreateIndex(
+                name: "IX_UserAlbums_OwnerUserId_ExternalId",
+                table: "UserAlbums",
+                columns: new[] { "OwnerUserId", "ExternalId" },
+                unique: true);
+        }
+    }
+}

backend/Musify.Infrastructure/Persistence/Migrations/DatabaseModelSnapshot.cs

@@ -728,15 +728,10 @@ namespace Musify.Infrastructure.Persistence.Migrations
                 {
                     b.HasBaseType("Musify.Domain.Entities.Album");
 
-                    b.Property<string>("ExternalId")
-                        .HasMaxLength(64)
-                        .HasColumnType("character varying(64)");
-
                     b.Property<long>("OwnerUserId")
                         .HasColumnType("bigint");
 
-                    b.HasIndex("OwnerUserId", "ExternalId")
-                        .IsUnique();
+                    b.HasIndex("OwnerUserId");
 
                     b.ToTable("UserAlbums", (string)null);
                 });

backend/Musify.Infrastructure/Services/YouTubeMusicService.cs

@@ -162,7 +162,7 @@ namespace Musify.Infrastructure.Services
 
                 return new YouTubeAlbumDetail(
                     album,
-                    info.Description ?? string.Empty,
+                    StripWikipediaAttribution(info.Description),
                     (int)info.Duration.TotalSeconds,
                     tracks);
             }
@@ -173,6 +173,16 @@ namespace Musify.Infrastructure.Services
             }
         }
 
+        private static string StripWikipediaAttribution(string? description)
+        {
+            if (string.IsNullOrEmpty(description))
+                return string.Empty;
+
+            var markerIndex = description.IndexOf("From Wikipedia", StringComparison.OrdinalIgnoreCase);
+            var cleaned = markerIndex >= 0 ? description[..markerIndex] : description;
+            return cleaned.TrimEnd();
+        }
+
         private YouTubeAlbumResult ToAlbumResult(AlbumSearchResult album) =>
             new(
                 album.Id,

backend/Musify.Worker/AppSettings.Development.json

@@ -16,6 +16,9 @@
     "OpenTelemetry": {
         "OtlpEndpoint": "http://localhost:4317"
     },
+    "YouTube": {
+        "GeographicalLocation": "ES"
+    },
     "InfrastructureStorage": {
         "Address": "http://localhost:8333",
         "AccessKey": "admin_access_key",