Merge pull request #80 from standleypg-dev/Migrate-To-NetCord

Refine retry failing player mechanism

Author: standleypg

src/Application/DTOs/PlayRequest.cs

@@ -1,3 +1,18 @@
 namespace Application.DTOs;
 
-public record PlayRequest<TContext>(TContext Context, Func<string, Task> Callbacks);
+// Non-generic base type (holds members that don't depend on T)
+public abstract class PlayRequest
+{
+    public Guid Id { get; set; } = Guid.NewGuid();
+    public int RetryCount { get; set; }
+    public Func<string, Task> Callbacks { get; set; } = null!;
+
+    public abstract object ContextAsObject { get; }
+}
+
+public class PlayRequest<TContext> : PlayRequest
+{
+    public TContext Context { get; init; } = default!;
+
+    public override object ContextAsObject => Context!;
+}

src/Application/Interfaces/Services/IMusicQueueService.cs

@@ -8,4 +8,5 @@ public interface IMusicQueueService
     PlayRequest<T>? Peek<T>();
     void DequeueAsync(CancellationToken cancellationToken);
     int Count { get; }
+    PlayRequest[] GetAllRequests();
 }

src/Application/Interfaces/Services/INativePlaceMusicProcessorService.cs

@@ -5,7 +5,7 @@ namespace Application.Interfaces.Services;
 public interface INativePlaceMusicProcessorService
 {
     Task<Process> CreateStreamAsync(string audioUrl, CancellationToken cancellationToken);
-    event Func<Task>? OnExitProcess;
+    event Func<Task>? OnPlaySongCompleted;
     event Func<Task>? OnProcessStart;
-    event Func<Task>? ErrorDataReceived;
+    event Func<Task>? OnForbiddenUrlRequest;
 }

src/Infrastructure/Commands/NetCordCommand.cs

@@ -1,34 +1,36 @@
 using Application.Interfaces.Services;
 using Domain.Common;
 using Domain.Eventing;
-using Microsoft.Extensions.Configuration;
+using Domain.Events;
+using Infrastructure.Services;
 using Microsoft.Extensions.DependencyInjection;
 using NetCord.Rest;
-using NetCord.Services;
 using NetCord.Services.ApplicationCommands;
 using NetCord.Services.Commands;
+using NetCord.Services.ComponentInteractions;
 using YoutubeExplode;
 using YoutubeExplode.Common;
 using Constants = Domain.Common.Constants;
 
 namespace Infrastructure.Commands;
 
-public class NetCordCommand(IServiceProvider serviceProvider, IConfiguration configuration)
+public class NetCordCommand(IServiceProvider serviceProvider, IMusicQueueService queue)
     : ApplicationCommandModule<ApplicationCommandContext>
 {
-    [SlashCommand("play", "Play a track from SoundCloud")]
+    [SlashCommand("play", "Play a track from Youtube or a radio station")]
     public async Task PingAsync([CommandParameter(Remainder = true)] string command)
     {
         if (await NotInVoiceChannel())
         {
             return;
         }
+
         // `AddApplicationCommands()` registers services as singleton,
         // so scope is needed to resolve scoped services.
         using var scope = serviceProvider.CreateScope();
         var youtubeClient = scope.ServiceProvider.GetRequiredService<YoutubeClient>();
         var radioSourceService = scope.ServiceProvider.GetRequiredService<IRadioSourceService>();
-        
+
         var message = CreateMessage<InteractionMessageProperties>("Select a track to play:");
 
         switch (command)
@@ -69,9 +71,8 @@ public async Task Stop()
         {
             return;
         }
-        using var scope = serviceProvider.CreateScope();
-        var eventDispatcher = scope.ServiceProvider.GetRequiredService<IEventDispatcher>();
-        eventDispatcher.Dispatch(new EventType.Stop());
+
+        DispatchEvent(new EventType.Stop());
         var message = CreateMessage<InteractionMessageProperties>("Stopping playback and clearing the queue.");
         await RespondAsync(InteractionCallback.Message(message));
     }
@@ -83,13 +84,47 @@ public async Task Skip()
         {
             return;
         }
-        using var scope = serviceProvider.CreateScope();
-        var eventDispatcher = scope.ServiceProvider.GetRequiredService<IEventDispatcher>();
-        eventDispatcher.Dispatch(new EventType.Skip());
+
+        DispatchEvent(new EventType.Skip());
         var message = CreateMessage<InteractionMessageProperties>("Skipping the current track.");
         await RespondAsync(InteractionCallback.Message(message));
     }
 
+    [SlashCommand("playlist", "Show the current playlist")]
+    public async Task Playlist()
+    {
+        if (await NotInVoiceChannel())
+        {
+            return;
+        }
+
+
+        if (queue.Count == 0)
+            await RespondAsync(InteractionCallback.Message("No songs in queue."));
+        else
+        {
+            using var scope = serviceProvider.CreateScope();
+            var youtubeService = scope.ServiceProvider.GetRequiredKeyedService<IStreamService>(nameof(YoutubeService));
+            var songs = queue.GetAllRequests().Select(async r =>
+                {
+                    var title = await youtubeService.GetVideoTitleAsync(
+                        (r.ContextAsObject as StringMenuInteractionContext)?.SelectedValues[0], CancellationToken.None);
+                    return title;
+                }
+            ).ToList();
+            
+            var titles = await Task.WhenAll(songs);
+            
+            var response = "Queues: " + Environment.NewLine + string.Join(Environment.NewLine,
+                titles.Select((title, index) =>
+                {
+                    var isPlayingNowMsg = index == 0 ? "(Playing now)" : "";
+                    return $"{index + 1}. {title} {isPlayingNowMsg}";
+                }));
+            await RespondAsync(InteractionCallback.Message(response));
+        }
+    }
+
     private static T CreateMessage<T>(string message) where T : IMessageProperties, new()
     {
         return new()
@@ -113,7 +148,7 @@ private static IEnumerable<IMessageComponentProperties> CreateComponent<T>(T sou
             }
         ];
     }
-    
+
     private async Task<bool> NotInVoiceChannel()
     {
         if (!Context.Guild!.VoiceStates.TryGetValue(Context.User.Id, out _))
@@ -127,5 +162,13 @@ private async Task<bool> NotInVoiceChannel()
         return false;
     }
 
+    private void DispatchEvent<TEvent>(TEvent @event) where TEvent : IEvent
+    {
+        using var scope = serviceProvider.CreateScope();
+        var eventDispatcher = scope.ServiceProvider.GetRequiredService<IEventDispatcher>();
+
+        eventDispatcher.Dispatch(@event);
+    }
+
     private record ComponentModel(string Title, string Url, string? Description = null);
 }

src/Infrastructure/Interaction/NetCordInteraction.cs

@@ -19,7 +19,11 @@ public class NetCordInteraction(
     [ComponentInteraction(Constants.CustomIds.Play)]
     public async Task<string> Play()
     {
-        var context = Context;
+        if (!CheckMessageExpiration())
+        {
+            return "This interaction has expired. Please use the play command again.";
+        }
+        
         if (!NotInVoiceChannel())
         {
             return "You must be in a voice channel to use this command.";
@@ -33,7 +37,11 @@ public async Task<string> Play()
         logger.LogInformation("Play command invoked by user {UserId} in guild {GuildId}", Context.User.Id,
             Context.Guild?.Id);
 
-        var playRequest = new PlayRequest<StringMenuInteractionContext>(Context, RespondAsyncCallback);
+        var playRequest = new PlayRequest<StringMenuInteractionContext>
+        {
+            Context = Context,
+            Callbacks = async message => await RespondAsyncCallback(message),
+        };
         queueService.Enqueue(playRequest);
         eventDispatcher.Dispatch(new EventType.Play());
         var selectedValue = Context.SelectedValues[0];
@@ -64,15 +72,12 @@ private bool NotDeafened()
         return !(voiceState.IsDeafened || voiceState.IsSelfDeafened);
     }
 
-    private bool UserAndBotInSameVoiceChannel()
+    private bool CheckMessageExpiration()
     {
-        var voiceState = Context.Guild!.VoiceStates[Context.User.Id];
-        if (!Context.Guild.VoiceStates.TryGetValue(Context.Client.Id, out var botVoiceState))
-        {
-            return false;
-        }
-        
-        return voiceState.ChannelId == botVoiceState.ChannelId;
+        var messageCreationTime = Context.Message.CreatedAt;
+        var interactionTime = Context.Interaction.CreatedAt;
+        var timeDifference = interactionTime - messageCreationTime;
+        return timeDifference.TotalMinutes <= 15;
     }
 
     private Task<InteractionCallbackResponse> RespondAsyncCallback(string message) => RespondAsync(InteractionCallback.Message(message))!;