Add scheduler

Bot/Handler/ChatCommand/ChatHandler.cs

@@ -4,65 +4,64 @@ using MediatR;
 using Microsoft.Extensions.Options;
 using OllamaSharp;
 
-namespace Lunaris2.Handler.ChatCommand
+namespace Lunaris2.Handler.ChatCommand;
+
+public record ChatCommand(SocketMessage Message, string FilteredMessage) : IRequest;
+
+public class ChatHandler : IRequestHandler<ChatCommand>
 {
-    public record ChatCommand(SocketMessage Message, string FilteredMessage) : IRequest;
+    private readonly OllamaApiClient _ollama;
+    private readonly Dictionary<ulong, Chat?> _chatContexts = new();
+    private readonly ChatSettings _chatSettings;
 
-    public class ChatHandler : IRequestHandler<ChatCommand>
+    public ChatHandler(IOptions<ChatSettings> chatSettings)
     {
-        private readonly OllamaApiClient _ollama;
-        private readonly Dictionary<ulong, Chat?> _chatContexts = new();
-        private readonly ChatSettings _chatSettings;
-
-        public ChatHandler(IOptions<ChatSettings> chatSettings)
+        _chatSettings = chatSettings.Value;
+        var uri = new Uri(chatSettings.Value.Url);
+            
+        _ollama = new OllamaApiClient(uri)
         {
-            _chatSettings = chatSettings.Value;
-            var uri = new Uri(chatSettings.Value.Url);
-            
-            _ollama = new OllamaApiClient(uri)
-            {
-                SelectedModel = chatSettings.Value.Model
-            };
-        }
-        
-        public async Task Handle(ChatCommand command, CancellationToken cancellationToken)
-        {
-            var channelId = command.Message.Channel.Id;
-            _chatContexts.TryAdd(channelId, null);
-
-            var userMessage = command.FilteredMessage;
-
-            var randomPersonality = _chatSettings.Personalities[new Random().Next(_chatSettings.Personalities.Count)];
-
-            userMessage = $"{randomPersonality.Instruction} {userMessage}";
-            
-            using var setTyping = command.Message.Channel.EnterTypingState();
-            
-            if (string.IsNullOrWhiteSpace(userMessage))
-            {
-                await command.Message.Channel.SendMessageAsync("Am I expected to read your mind?");
-                setTyping.Dispose();
-                return;
-            }
-            
-            var response = await GenerateResponse(userMessage, channelId, cancellationToken);
-            await command.Message.Channel.SendMessageAsync(response);
-            
-            setTyping.Dispose();
-        }
-
-        private async Task<string> GenerateResponse(string userMessage, ulong channelId, CancellationToken cancellationToken)
-        {
-            var response = new StringBuilder();
-
-            if (_chatContexts[channelId] == null)
-            {
-                _chatContexts[channelId] = _ollama.Chat(stream => response.Append(stream.Message?.Content ?? ""));
-            }
-
-            await _chatContexts[channelId].Send(userMessage, cancellationToken);
-
-            return response.ToString();
-        }
+            SelectedModel = chatSettings.Value.Model
+        };
     }
-}
+        
+    public async Task Handle(ChatCommand command, CancellationToken cancellationToken)
+    {
+        var channelId = command.Message.Channel.Id;
+        _chatContexts.TryAdd(channelId, null);
+
+        var userMessage = command.FilteredMessage;
+
+        var randomPersonality = _chatSettings.Personalities[new Random().Next(_chatSettings.Personalities.Count)];
+
+        userMessage = $"{randomPersonality.Instruction} {userMessage}";
+            
+        using var setTyping = command.Message.Channel.EnterTypingState();
+            
+        if (string.IsNullOrWhiteSpace(userMessage))
+        {
+            await command.Message.Channel.SendMessageAsync("Am I expected to read your mind?");
+            setTyping.Dispose();
+            return;
+        }
+            
+        var response = await GenerateResponse(userMessage, channelId, cancellationToken);
+        await command.Message.Channel.SendMessageAsync(response);
+            
+        setTyping.Dispose();
+    }
+
+    private async Task<string> GenerateResponse(string userMessage, ulong channelId, CancellationToken cancellationToken)
+    {
+        var response = new StringBuilder();
+
+        if (_chatContexts[channelId] == null)
+        {
+            _chatContexts[channelId] = _ollama.Chat(stream => response.Append(stream.Message?.Content ?? ""));
+        }
+
+        await _chatContexts[channelId].Send(userMessage, cancellationToken);
+
+        return response.ToString();
+    }
+}

Bot/Handler/MusicPlayer/Extensions.cs

@@ -68,9 +68,9 @@ public static class Extensions
         await message.RespondAsync(content, ephemeral: true);
     }
     
-        
-    public static string GetOptionValueByName(this SocketSlashCommand command, string optionName)
+    public static T? GetOptionValueByName<T>(this SocketSlashCommand command, string optionName)
     {
-        return command.Data.Options.FirstOrDefault(option => option.Name == optionName)?.Value.ToString() ?? string.Empty;
+        return (T?)(command.Data?.Options?
+            .FirstOrDefault(option => option.Name == optionName)?.Value ?? default(T));
     }
 }

Bot/Handler/MusicPlayer/PlayCommand/PlayHandler.cs

@@ -85,7 +85,7 @@ public class PlayHandler : IRequestHandler<PlayCommand>
                     return;
                 }
                 
-                var searchQuery = context.GetOptionValueByName(Option.Input);
+                var searchQuery = context.GetOptionValueByName<string>(Option.Input);
 
                 if (string.IsNullOrWhiteSpace(searchQuery))
                 {

Bot/Handler/Scheduler/ProcessMessageCommand.cs

@@ -0,0 +1,30 @@
+using Discord.WebSocket;
+using MediatR;
+
+namespace Lunaris2.Handler.Scheduler;
+
+public class ProcessMessageCommand : IRequest
+{
+    public ulong? Context { get; set; }
+    public string Content { get; set; }
+}
+
+public class ProcessMessageHandler(DiscordSocketClient client) : IRequestHandler<ProcessMessageCommand>
+{
+    public Task Handle(ProcessMessageCommand request, CancellationToken cancellationToken)
+    {
+        if (request.Context == null) 
+            return Task.FromResult(Unit.Value);
+        
+        var channel = client.GetChannel(request.Context.Value) as ISocketMessageChannel;
+        
+        if (channel == null)
+            return Task.FromResult(Unit.Value);
+        
+        using var setTyping = channel.EnterTypingState();
+        channel.SendMessageAsync(request.Content);
+        setTyping.Dispose();
+
+        return Task.FromResult(Unit.Value);
+    }
+}

Bot/Handler/Scheduler/ScheduleMessageCommand.cs

@@ -0,0 +1,137 @@
+using System.Globalization;
+using System.Text;
+using Discord.WebSocket;
+using Hangfire;
+using Lunaris2.Handler.ChatCommand;
+using Lunaris2.Handler.MusicPlayer;
+using Lunaris2.SlashCommand;
+using MediatR;
+using Microsoft.Extensions.Options;
+using Microsoft.IdentityModel.Tokens;
+using NCrontab;
+using OllamaSharp;
+using static System.DateTime;
+
+namespace Lunaris2.Handler.Scheduler;
+
+public record ScheduleMessageCommand(SocketSlashCommand Message) : IRequest;
+
+public class ScheduleMessageHandler : IRequestHandler<ScheduleMessageCommand>
+{
+    private readonly ChatSettings _chatSettings;
+    private readonly OllamaApiClient _ollama;
+    private readonly ISender _mediator;
+
+    private readonly string _cronInstruction = "You are only able to respond in CRON Format. " +
+                                              "Current time is: " + Now.ToString("yyyy-MM-dd HH:mm") + ". and it is " +
+                                              Now.DayOfWeek + ". " +
+                                              "Please use the a format parsable by ncrontab." +
+                                              "The user will describe the CRON format and you can only answer with the CRON format the user describes.";
+    
+    private readonly string _dateInstruction = "You are only able to respond in Date Format. " +
+                                               "Current time is: " + Now.ToString("dd/MM/yyyy HH:mm:ss") + ". and it is " +
+                                               Now.DayOfWeek + ". " +
+                                               "Please use the following format: dd/MM/yyyy HH:mm:ss. Convert following to date string with the current time as a context";
+    
+    public ScheduleMessageHandler(
+        IOptions<ChatSettings> chatSettings, 
+        ISender mediator)
+    {
+        _mediator = mediator;
+        _chatSettings = chatSettings.Value;
+
+        var uri = new Uri(_chatSettings.Url);
+        _ollama = new OllamaApiClient(uri)
+        {
+            SelectedModel = _chatSettings.Model
+        };
+    }
+
+    public async Task Handle(ScheduleMessageCommand request, CancellationToken cancellationToken)
+    {
+        var userDateInput = request.Message.GetOptionValueByName<string>(Option.Time);
+        var userMessage = request.Message.GetOptionValueByName<string>(Option.Message);
+        var recurring = request.Message.GetOptionValueByName<bool>(Option.IsRecurring);
+
+        if (recurring)
+        {
+            await ScheduleRecurringJob(request, userMessage, userDateInput, cancellationToken);
+        }
+        else
+        {
+            await ScheduleJob(request, userMessage, userDateInput, cancellationToken);
+            
+            await request.Message.Channel.SendMessageAsync("Message scheduled successfully.");
+        }
+    }
+
+    private async Task ScheduleRecurringJob(
+        ScheduleMessageCommand request,
+        string message,
+        string userDateInput,
+        CancellationToken cancellationToken)
+    {
+        using var setTyping = request.Message.Channel.EnterTypingState();
+        var cron = string.Empty;
+        var jobManager = new RecurringJobManager();
+        const int retries = 5;
+        var userMessage = $"{_cronInstruction}: {userDateInput}";
+        
+        for (var tries = 0; tries < retries; tries++)
+        {
+            var textToCronResponse = await GenerateResponse(userMessage, cancellationToken);
+            var isValid = CrontabSchedule.TryParse(textToCronResponse).ToString().IsNullOrEmpty();
+            
+            if(isValid)
+            {
+                await request.Message.Channel.SendMessageAsync("Sorry, I didn't understand that date format. Please try again.");
+                continue;
+            }
+            
+            cron = textToCronResponse;
+                
+            break;
+        }
+        var recurringJobId = $"channel_{request.Message.ChannelId}_{request.Message.Id}";
+
+        jobManager.AddOrUpdate(
+            recurringJobId,
+            () => _mediator.Send(new ProcessMessageCommand { Context = request.Message.ChannelId, Content = message}, cancellationToken),
+            cron
+        );
+            
+        setTyping.Dispose();
+        await request.Message.Channel.SendMessageAsync("Message scheduled successfully.");
+    }
+
+    private async Task ScheduleJob(
+        ScheduleMessageCommand request,
+        string userMessage,
+        string executeAt,
+        CancellationToken cancellationToken
+    )
+    {
+        var dateFormat = $"{_dateInstruction}: {executeAt}";
+
+        var formattedDate = await GenerateResponse(dateFormat, cancellationToken);
+        
+        var date = ParseExact(formattedDate, "dd/MM/yyyy HH:mm:ss", CultureInfo.CurrentCulture);
+
+        BackgroundJob.Schedule(
+            () => _mediator.Send(
+                new ProcessMessageCommand { Context = request.Message.ChannelId, Content = userMessage },
+                cancellationToken),
+            date);
+    }
+
+    private async Task<string> GenerateResponse(string userMessage, CancellationToken cancellationToken)
+    {
+        var response = new StringBuilder();
+
+        var chatContext = _ollama.Chat(stream => response.Append(stream.Message?.Content ?? ""));
+        
+        await chatContext.Send(userMessage, cancellationToken);
+        
+        return response.ToString();
+    }
+}

Bot/Handler/SlashCommandReceivedHandler.cs

@@ -4,6 +4,7 @@ using Lunaris2.Handler.MusicPlayer.PauseCommand;
 using Lunaris2.Handler.MusicPlayer.PlayCommand;
 using Lunaris2.Handler.MusicPlayer.ResumeCommand;
 using Lunaris2.Handler.MusicPlayer.SkipCommand;
+using Lunaris2.Handler.Scheduler;
 using Lunaris2.Notification;
 using Lunaris2.SlashCommand;
 using MediatR;
@@ -36,6 +37,9 @@ public class SlashCommandReceivedHandler(ISender mediator) : INotificationHandle
             case Command.Clear.Name:
                 await mediator.Send(new ClearQueueCommand(notification.Message), cancellationToken);
                 break;
+            case Command.Scheduler.Name:
+                await mediator.Send(new ScheduleMessageCommand(notification.Message), cancellationToken);
+                break;
         }
     }
 }