Reorganize backend to mirror Musify.slnx folder structure

Moves the six backend projects on disk into Core/ and Hosts/
subfolders, matching the solution folders already defined in
Musify.slnx, so the file explorer reflects the same layout as the
solution:

  backend/Core/Musify.Domain
  backend/Core/Musify.Application
  backend/Core/Musify.Infrastructure
  backend/Hosts/Musify.Api
  backend/Hosts/Musify.Worker
  backend/Hosts/Musify.StreamingGateway

Updates every reference to the old paths: ProjectReference entries in
Musify.Api.csproj and Musify.Worker.csproj, the three Dockerfiles,
deploy/scripts/migrate.ps1|sh, deploy/zitadel/provision.ps1,
deploy/up.ps1, deploy/README.md and docs/development.md. Also fixes a
stale Dockerfile comment pointing at a compose file that no longer
exists.

Verified with `dotnet build Musify.slnx` against the new layout.

backend/Core/Musify.Domain/Abstractions/IAuditable.cs

@@ -0,0 +1,9 @@
+namespace Musify.Domain.Abstractions
+{
+    public interface IAuditable
+    {
+        DateTime CreatedAt { get; set; }
+
+        DateTime UpdatedAt { get; set; }
+    }
+}

backend/Core/Musify.Domain/Entities/Album.cs

@@ -0,0 +1,39 @@
+using System.ComponentModel.DataAnnotations;
+using Musify.Domain.Abstractions;
+using Musify.Domain.ValueObjects;
+
+namespace Musify.Domain.Entities
+{
+#pragma warning disable CS8618
+    public abstract 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 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>();
+    }
+}

backend/Core/Musify.Domain/Entities/AlbumHasTrack.cs

@@ -0,0 +1,30 @@
+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; }
+    }
+}

backend/Core/Musify.Domain/Entities/Artist.cs

@@ -0,0 +1,32 @@
+using System.ComponentModel.DataAnnotations;
+using Musify.Domain.Abstractions;
+
+namespace Musify.Domain.Entities
+{
+#pragma warning disable CS8618
+    public class Artist : IAuditable
+    {
+        [Key]
+        public Guid Id { get; set; } = Guid.NewGuid();
+
+        [Required]
+        [MaxLength(200)]
+        public required string Name { get; set; }
+
+        [Required]
+        [MaxLength(200)]
+        public required string NormalizedName { get; set; }
+
+        [Required]
+        [MaxLength(64)]
+        public required string ExternalId { get; set; }
+
+        [Required]
+        public DateTime CreatedAt { get; set; } = DateTime.UtcNow;
+
+        [Required]
+        public DateTime UpdatedAt { get; set; } = DateTime.UtcNow;
+
+        public ICollection<TrackArtist> TrackArtists { get; set; } = new List<TrackArtist>();
+    }
+}

backend/Core/Musify.Domain/Entities/ExternalAlbum.cs

@@ -0,0 +1,18 @@
+using System.ComponentModel.DataAnnotations;
+using Musify.Domain.ValueObjects;
+
+namespace Musify.Domain.Entities
+{
+    public class ExternalAlbum : Album
+    {
+        [Required]
+        public required TrackSource Source { get; set; }
+
+        [Required]
+        [MaxLength(64)]
+        public required string ExternalId { get; set; }
+
+        [MaxLength(512)]
+        public string? ThumbnailUrl { get; set; }
+    }
+}

backend/Core/Musify.Domain/Entities/ExternalTrack.cs

@@ -0,0 +1,17 @@
+using System.ComponentModel.DataAnnotations;
+using Musify.Domain.ValueObjects;
+
+namespace Musify.Domain.Entities
+{
+    public class ExternalTrack : Track
+    {
+        [Required]
+        public required TrackSource Source { get; set; }
+
+        [Required]
+        [MaxLength(64)]
+        public required string ExternalId { get; set; }
+
+        public ICollection<TrackArtist> TrackArtists { get; set; } = new List<TrackArtist>();
+    }
+}

backend/Core/Musify.Domain/Entities/ListeningHistory.cs

@@ -0,0 +1,28 @@
+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; }
+    }
+}

backend/Core/Musify.Domain/Entities/LocalTrack.cs

@@ -0,0 +1,14 @@
+using System.ComponentModel.DataAnnotations;
+using System.ComponentModel.DataAnnotations.Schema;
+
+namespace Musify.Domain.Entities
+{
+    public class LocalTrack : Track
+    {
+        [Required]
+        public required long OwnerUserId { get; set; }
+
+        [ForeignKey(nameof(OwnerUserId)) ]
+        public required User Owner { get; set; }
+    }
+}

backend/Core/Musify.Domain/Entities/Mix.cs

@@ -0,0 +1,39 @@
+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>();
+    }
+}

backend/Core/Musify.Domain/Entities/MixItem.cs

@@ -0,0 +1,50 @@
+using System.ComponentModel.DataAnnotations;
+using System.ComponentModel.DataAnnotations.Schema;
+
+using Musify.Domain.ValueObjects;
+
+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 MixItemSource Source { get; set; }
+
+        public Guid? TrackId { get; set; }
+
+        [MaxLength(64)]
+        public string? VideoId { get; set; }
+
+        [MaxLength(300)]
+        public string? Title { get; set; }
+
+        [MaxLength(300)]
+        public string? Artist { get; set; }
+
+        [MaxLength(512)]
+        public string? ThumbnailUrl { get; set; }
+
+        [Required]
+        public double DurationSeconds { get; set; }
+
+        [Required]
+        public bool IsExplicit { get; set; }
+
+        [ForeignKey(nameof(MixId))]
+        public Mix Mix { get; set; }
+
+        [ForeignKey(nameof(TrackId))]
+        public Track? Track { get; set; }
+    }
+}

backend/Core/Musify.Domain/Entities/PlayList.cs

@@ -0,0 +1,47 @@
+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
+    [Table("PlayLists")]
+    public class PlayList : IAuditable
+    {
+        [Key]
+        public Guid Id { get; set; } = Guid.NewGuid();
+
+        [Required]
+        public required long UserId { get; set; }
+
+        [Required]
+        [MaxLength(50)]
+        public required string Name { get; set; }
+
+        [Required]
+        [MaxLength(50)]
+        public required string NormalizedName { get; set; }
+
+        [MaxLength(256)]
+        public string? Description { get; set; }
+
+        [Required]
+        public required PlayListPictures Pictures { 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;
+
+        [ForeignKey(nameof(UserId)) ]
+        public User User { get; set; }
+
+        public ICollection<PlayListHasTrack> PlayListTracks { get; set; } = new List<PlayListHasTrack>();
+    }
+}

backend/Core/Musify.Domain/Entities/PlayListHasTrack.cs

@@ -0,0 +1,30 @@
+using System.ComponentModel.DataAnnotations;
+using System.ComponentModel.DataAnnotations.Schema;
+
+namespace Musify.Domain.Entities
+{
+#pragma warning disable CS8618
+    [Table("PlayListHasTrack")]
+    public class PlayListHasTrack
+    {
+        public Guid Id { get; set; } = Guid.NewGuid();
+
+        [Required]
+        public required Guid PlayListId { get; set; }
+
+        [Required]
+        public required Guid TrackId { get; set; }
+
+        [Required]
+        public int Position { get; set; } = 0;
+
+        [Required]
+        public DateTime AddedAt { get; set; } = DateTime.UtcNow;
+
+        [ForeignKey(nameof(PlayListId)) ]
+        public PlayList PlayList { get; set; }
+
+        [ForeignKey(nameof(TrackId)) ]
+        public Track Track { get; set; }
+    }
+}

backend/Core/Musify.Domain/Entities/Track.cs

@@ -0,0 +1,45 @@
+using System.ComponentModel.DataAnnotations;
+using Musify.Domain.Abstractions;
+using Musify.Domain.ValueObjects;
+
+namespace Musify.Domain.Entities
+{
+#pragma warning disable CS8618
+    public abstract 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 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>();
+    }
+}

backend/Core/Musify.Domain/Entities/TrackArtist.cs

@@ -0,0 +1,25 @@
+using System.ComponentModel.DataAnnotations;
+using System.ComponentModel.DataAnnotations.Schema;
+
+namespace Musify.Domain.Entities
+{
+#pragma warning disable CS8618
+    [Table("TrackArtist")]
+    public class TrackArtist
+    {
+        [Required]
+        public required Guid TrackId { get; set; }
+
+        [Required]
+        public required Guid ArtistId { get; set; }
+
+        [Required]
+        public int Position { get; set; } = 0;
+
+        [ForeignKey(nameof(TrackId)) ]
+        public ExternalTrack Track { get; set; }
+
+        [ForeignKey(nameof(ArtistId)) ]
+        public Artist Artist { get; set; }
+    }
+}

backend/Core/Musify.Domain/Entities/Upload.cs

@@ -0,0 +1,29 @@
+using System.ComponentModel.DataAnnotations;
+using System.ComponentModel.DataAnnotations.Schema;
+
+using Musify.Domain.ValueObjects;
+
+namespace Musify.Domain.Entities
+{
+    [Table("Upload")]
+    public class Upload
+    {
+        [Key]
+        public Guid Id { get; set; } = Guid.NewGuid();
+
+        [Required]
+        public required string Bucket { get; set; }
+
+        [Required]
+        public required string Key { get; set; }
+
+        [Required]
+        public required string ContentType { get; set; }
+
+        [Required]
+        public DateTime CreatedTime { get; set; } = DateTime.UtcNow;
+
+        [Required]
+        public UploadState State { get; set; } = UploadState.Pending;
+    }
+}

backend/Core/Musify.Domain/Entities/UploadIntent.cs

@@ -0,0 +1,52 @@
+using System.ComponentModel.DataAnnotations;
+using System.ComponentModel.DataAnnotations.Schema;
+
+using Musify.Domain.ValueObjects;
+
+namespace Musify.Domain.Entities
+{
+    [Table("UploadIntents")]
+    public class UploadIntent
+    {
+        [Key]
+        public Guid Id { get; set; } = Guid.NewGuid();
+
+        [Required]
+        public required long UserId { get; set; }
+
+        [Required, MaxLength(128)]
+        public required string Bucket { get; set; }
+
+        [Required, MaxLength(512)]
+        public required string Key { get; set; }
+
+        [Required, MaxLength(128)]
+        public required string ObjectName { get; set; }
+
+        [Required, MaxLength(128)]
+        public required string ContentType { get; set; }
+
+        public long? ExpectedSizeBytes { get; set; }
+
+        [Required]
+        public UploadIntentPurpose Purpose { get; set; }
+
+        [Required]
+        public UploadIntentStatus Status { get; set; } = UploadIntentStatus.Issued;
+
+        [Required]
+        public DateTime ExpiresAt { get; set; }
+
+        [Required]
+        public DateTime CreatedAt { get; set; } = DateTime.UtcNow;
+
+        [NotMapped]
+        public bool IsConsumed => Status == UploadIntentStatus.Consumed;
+
+        [NotMapped]
+        public bool IsExpired => Status == UploadIntentStatus.Expired || ExpiresAt < DateTime.UtcNow;
+
+        [ForeignKey(nameof(UserId)) ]
+        public User User { get; set; } = null!;
+    }
+}

backend/Core/Musify.Domain/Entities/User.cs

@@ -0,0 +1,43 @@
+using System.ComponentModel.DataAnnotations;
+using System.ComponentModel.DataAnnotations.Schema;
+using Musify.Domain.Abstractions;
+
+namespace Musify.Domain.Entities
+{
+    [Table("User")]
+    public class User : IAuditable
+    {
+        [Key]
+        [DatabaseGenerated(DatabaseGeneratedOption.None)]
+        public required long Id { get; set; }
+
+        [Required]
+        [MaxLength(48)]
+        public required string Name { get; set; }
+
+        [Required]
+        [MaxLength(48)]
+        public required string NormalizedName { get; set; }
+
+        [MaxLength(48)]
+        public string? FirstName { get; set; }
+
+        [MaxLength(48)]
+        public string? SecondName { get; set; }
+
+        [MaxLength(2048)]
+        public string? ProfilePictureUrl { get; set; }
+
+        [Required]
+        public DateTime CreatedAt { get; set; } = DateTime.UtcNow;
+
+        [Required]
+        public DateTime UpdatedAt { get; set; } = DateTime.UtcNow;
+
+        public ICollection<UserHasTrack> UserTracks { get; set; } = new List<UserHasTrack>();
+
+        public ICollection<PlayList> PlayLists { get; set; } = new List<PlayList>();
+
+        public ICollection<ListeningHistory> ListeningHistories { get; set; } = new List<ListeningHistory>();
+    }
+}

backend/Core/Musify.Domain/Entities/UserAlbum.cs

@@ -0,0 +1,15 @@
+using System.ComponentModel.DataAnnotations;
+using System.ComponentModel.DataAnnotations.Schema;
+
+namespace Musify.Domain.Entities
+{
+#pragma warning disable CS8618
+    public class UserAlbum : Album
+    {
+        [Required]
+        public required long OwnerUserId { get; set; }
+
+        [ForeignKey(nameof(OwnerUserId)) ]
+        public User Owner { get; set; }
+    }
+}

backend/Core/Musify.Domain/Entities/UserHasTrack.cs

@@ -0,0 +1,24 @@
+using System.ComponentModel.DataAnnotations;
+using System.ComponentModel.DataAnnotations.Schema;
+
+namespace Musify.Domain.Entities
+{
+#pragma warning disable CS8618
+    [Table("UserHasTrack")]
+    public class UserHasTrack
+    {
+        public Guid Id { get; set; } = Guid.NewGuid();
+
+        [Required]
+        public required long UserId { get; set; }
+
+        [Required]
+        public required Guid TrackId { get; set; }
+
+        [ForeignKey(nameof(UserId)) ]
+        public User User { get; set; }
+
+        [ForeignKey(nameof(TrackId)) ]
+        public Track Track { get; set; }
+    }
+}

backend/Core/Musify.Domain/Musify.Domain.csproj

@@ -0,0 +1,3 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+</Project>

backend/Core/Musify.Domain/ValueObjects/AlbumPictures.cs

@@ -0,0 +1,13 @@
+namespace Musify.Domain.ValueObjects
+{
+    public class AlbumPictures
+    {
+        public string? OriginalName { get; set; }
+
+        public string? SmallName { get; set; }
+
+        public string? MediumName { get; set; }
+
+        public string? LargeName { get; set; }
+    }
+}

backend/Core/Musify.Domain/ValueObjects/LifeCycleStatus.cs

@@ -0,0 +1,9 @@
+namespace Musify.Domain.ValueObjects
+{
+    public enum LifeCycleStatus
+    {
+        Active = 0,
+        Removing = 1,
+        Failed = 2
+    }
+}

backend/Core/Musify.Domain/ValueObjects/MixItemSource.cs

@@ -0,0 +1,8 @@
+namespace Musify.Domain.ValueObjects
+{
+    public enum MixItemSource
+    {
+        Musify = 0,
+        YouTube = 1
+    }
+}

backend/Core/Musify.Domain/ValueObjects/PlayListPictures.cs

@@ -0,0 +1,19 @@
+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; }
+    }
+}

backend/Core/Musify.Domain/ValueObjects/ProcessingStatus.cs

@@ -0,0 +1,10 @@
+namespace Musify.Domain.ValueObjects
+{
+    public enum ProcessingStatus
+    {
+        Pending = 0,
+        Processing = 1,
+        Completed = 2,
+        Failed = 3
+    }
+}

backend/Core/Musify.Domain/ValueObjects/TrackAudio.cs

@@ -0,0 +1,27 @@
+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;
+    }
+}

backend/Core/Musify.Domain/ValueObjects/TrackPictures.cs

@@ -0,0 +1,23 @@
+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;
+    }
+}

backend/Core/Musify.Domain/ValueObjects/TrackSource.cs

@@ -0,0 +1,8 @@
+namespace Musify.Domain.ValueObjects
+{
+    public enum TrackSource
+    {
+        Local = 0,
+        YouTube = 1
+    }
+}

backend/Core/Musify.Domain/ValueObjects/UploadIntentPurpose.cs

@@ -0,0 +1,9 @@
+namespace Musify.Domain.ValueObjects
+{
+    public enum UploadIntentPurpose
+    {
+        PlayListPicture,
+        TrackPicture,
+        TrackAudio,
+    }
+}

backend/Core/Musify.Domain/ValueObjects/UploadIntentStatus.cs

@@ -0,0 +1,9 @@
+namespace Musify.Domain.ValueObjects
+{
+    public enum UploadIntentStatus
+    {
+        Issued,
+        Consumed,
+        Expired,
+    }
+}

backend/Core/Musify.Domain/ValueObjects/UploadState.cs

@@ -0,0 +1,9 @@
+namespace Musify.Domain.ValueObjects
+{
+    public enum UploadState
+    {
+        Pending,
+        Failed,
+        Successful,
+    }
+}