DSharpPlus · Instellate · Apr 24, 2023 · Apr 24, 2023 · Apr 25, 2023 · Apr 25, 2023
diff --git a/.editorconfig b/.editorconfig
@@ -137,7 +137,7 @@ csharp_style_throw_expression = true:error
 csharp_style_conditional_delegate_call = true:error
 
 # Modifier preferences
-csharp_preferred_modifier_order = public,private,protected,internal,static,extern,new,virtual,abstract,sealed,override,readonly,unsafe,volatile,async:error
+csharp_preferred_modifier_order = public, private, protected, internal, static, extern, new, virtual, abstract, sealed, override, readonly, unsafe, volatile, async:error
 
 # Expression-level preferences
 csharp_prefer_braces = true:error

diff --git a/DSharpPlus.Test/DSharpPlus.Test.csproj b/DSharpPlus.Test/DSharpPlus.Test.csproj
@@ -33,6 +33,7 @@
     <ProjectReference Include="..\DSharpPlus.CommandsNext\DSharpPlus.CommandsNext.csproj" />
     <ProjectReference Include="..\DSharpPlus.Interactivity\DSharpPlus.Interactivity.csproj" />
     <ProjectReference Include="..\DSharpPlus.VoiceNext\DSharpPlus.VoiceNext.csproj" />
+    <ProjectReference Include="..\DSharpPlus.UnifiedCommands\DSharpPlus.UnifiedCommands.csproj" />
   </ItemGroup>
 
   <ItemGroup>

diff --git a/DSharpPlus.Test/TestBot.cs b/DSharpPlus.Test/TestBot.cs
diff --git a/DSharpPlus.Test/UnifiedCommandsApplicationConditionsTest.cs b/DSharpPlus.Test/UnifiedCommandsApplicationConditionsTest.cs
@@ -0,0 +1,15 @@
+using System.Threading.Tasks;
+using DSharpPlus.Entities;
+using DSharpPlus.UnifiedCommands.Application.Conditions;
+using Microsoft.Extensions.Logging;
+
+namespace DSharpPlus.Test;
+
+public class UnifiedCommandsApplicationConditionsTest : IApplicationCondition
+{
+    public ValueTask<bool> InvokeAsync(DiscordInteraction _, DiscordClient client)
+    {
+        client.Logger.LogInformation("This got passed through this pass");
+        return ValueTask.FromResult(true);
+    }
+}
diff --git a/DSharpPlus.Test/UnifiedCommandsApplicationModuleTest.cs b/DSharpPlus.Test/UnifiedCommandsApplicationModuleTest.cs
@@ -0,0 +1,24 @@
+using System.Threading.Tasks;
+using DSharpPlus.Entities;
+using DSharpPlus.UnifiedCommands.Application;
+
+namespace DSharpPlus.Test;
+
+[ApplicationModule("app", "Random application commands.")]
+public class UnifiedCommandsApplicationModuleTest : ApplicationModule
+{
+    [ApplicationName("reply-test", "This is a reply test")]
+    public IApplicationResult ReplyTest()
+    {
+        DiscordEmbedBuilder builder = new();
+        builder.WithTitle("Hello, world!").WithDescription("This is a test. Thank you for joining in!");
+        return Reply(builder);
+    }
+
+    [ApplicationName("reply-opt-async", "This has options and replies async with a followup.")]
+    public async Task<IApplicationResult> ReplyOptAsync([ApplicationOption("user", "A user")] DiscordUser user)
+    {
+        await PostAsync(Reply("Test test."));
+        return FollowUp($"You selected user {Formatter.Mention(user)}");
+    }
+}
diff --git a/DSharpPlus.Test/UnifiedCommandsErrorHandler.cs b/DSharpPlus.Test/UnifiedCommandsErrorHandler.cs
@@ -0,0 +1,27 @@
+using System.Threading.Tasks;
+using DSharpPlus.Entities;
+using DSharpPlus.UnifiedCommands;
+using DSharpPlus.UnifiedCommands.Message.Errors;
+using Remora.Results;
+using Microsoft.Extensions.Logging;
+
+namespace DSharpPlus.Test;
+
+public class UnifiedCommandsErrorHandler : IErrorHandler
+{
+    public Task HandleInteractionErrorAsync(IResultError error, DiscordInteraction interaction, DiscordClient client)
+    {
+        client.Logger.LogError("Failed interaction with error: {Error}", error);
+        return Task.CompletedTask;
+    }
+
+    public Task HandleMessageErrorAsync(IResultError error, DiscordMessage message, DiscordClient client)
+    {
+        client.Logger.LogError("Failed message command with error: {Error}", error);
+
+
+        return error is FailedConversionError e
+            ? message.Channel.SendMessageAsync($"Option `{e.Name}` is invalid.")
+            : Task.CompletedTask;
+    }
+}
diff --git a/DSharpPlus.Test/UnifiedCommandsMessageModuleTest.cs b/DSharpPlus.Test/UnifiedCommandsMessageModuleTest.cs
@@ -0,0 +1,82 @@
+using System;
+using System.Threading.Tasks;
+using DSharpPlus.UnifiedCommands.Message;
+using DSharpPlus.UnifiedCommands.Message.Conditions;
+
+namespace DSharpPlus.Test;
+
+[MessageModule("test")]
+public class UnifiedCommandsMessageModuleTest : MessageModule
+{
+    // This is commented out until I have implemented default converters for all other types
+    private readonly string _str;
+
+    public UnifiedCommandsMessageModuleTest(string str) => _str = str;
+
+    [Message("sync")]
+    public IMessageResult TestSync() => Reply("Sync works.");
+
+    [Message("async")]
+    public async Task<IMessageResult> TestAsync()
+    {
+        await PostAsync(Reply("Async works"));
+        return Empty();
+    }
+
+    [Message("arg opt")]
+    public IMessageResult TestArgOpt(string argument,
+        [MessageOption("user", "u")] Entities.DiscordUser? user, [MessageOption("string", "s")] string str = "hello")
+        => Reply(
+            user is not null
+                ? $"Argument was `{argument}`, user {user.Username}, and string was `{str}`."
+                : $"Argument was `{argument}`, user wasn't provided, and string was `{str}`.");
+
+
+    [Message("permissions")]
+    [MessagePermission(Permissions.Administrator)]
+    public IMessageResult TestPermissions() => Reply("You are a admin.");
+
+    [Message("di")]
+    public IMessageResult TestDi() => Reply($"DI gave me value `{_str}`.");
+
+    [Message("no value")]
+    public async ValueTask TestNoValueAsync()
+    {
+        await PostAsync(Reply("This returns nothing."));
+        return;
+    }
+
+    // TODO: Implement this when new custom converters exist
+    [Message("remaining arguments")]
+    public IMessageResult TestRemainingArguments([RemainingArguments] string arguments,
+        [MessageOption("str", "s")] string? str)
+        => Reply(str is null
+            ? $"Remaining arguments is `{arguments}`. Str is null"
+            : $"Remaining arguments is `{arguments}`. Str is `{str}`.");
+
+    [Message("cooldown"), Cooldown(10)]
+    public IMessageResult TestCooldowns()
+        => Reply("No cooldown.");
+
+    [Message("failing")]
+    public IMessageResult TestFailing()
+        => throw new Exception("Fuck you");
+
+    [Message("overload")]
+    public IMessageResult TestOverload([MessageOption("str")] string str)
+    {
+        IMessageResult result = Reply(str);
+        return result;
+    }
+
+    [Message("overload")]
+    public IMessageResult TestOverload([MessageOption("int")] int num)
+    {
+        IMessageResult result = Reply(num.ToString());
+        return result;
+    }
+
+    [Message("overload nested")]
+    public IMessageResult TestOverloadNested()
+        => Reply("Nested \"overload\"");
+}
diff --git a/DSharpPlus.UnifiedCommands/Application/ApplicationModule.cs b/DSharpPlus.UnifiedCommands/Application/ApplicationModule.cs
@@ -0,0 +1,30 @@
+using DSharpPlus.Entities;
+using DSharpPlus.UnifiedCommands.Application.Internals;
+
+namespace DSharpPlus.UnifiedCommands.Application;
+
+public abstract class ApplicationModule
+{
+    internal ApplicationHandler _handler = null!;
+
+    public DiscordClient Client { get; internal set; } = null!;
+    public DiscordInteraction Interaction { get; internal set; } = null!;
+
+    protected Task PostAsync(IApplicationResult result)
+        => _handler.TurnResultIntoActionAsync(result);
+
+    protected IApplicationResult Reply(ApplicationResult result)
+    {
+        result.Type = ApplicationResultType.Reply;
+        return result;
+    }
+
+    protected IApplicationResult FollowUp(ApplicationResult result)
+    {
+        result.Type = ApplicationResultType.FollowUp;
+        return result;
+    }
+
+    protected Task<DiscordMessage> GetOriginalResponseAsync()
+        => Interaction.GetOriginalResponseAsync();
+}
diff --git a/DSharpPlus.UnifiedCommands/Application/ApplicationModuleAttribute.cs b/DSharpPlus.UnifiedCommands/Application/ApplicationModuleAttribute.cs
@@ -0,0 +1,18 @@
+namespace DSharpPlus.UnifiedCommands.Application;
+
+[AttributeUsage(AttributeTargets.Class)]
+public class ApplicationModuleAttribute : Attribute
+{
+    public string? Name { get; }
+    public string? Description { get; }
+
+    public ApplicationModuleAttribute()
+    {
+    }
+
+    public ApplicationModuleAttribute(string name, string description)
+    {
+        Name = name;
+        Description = description;
+    }
+}
diff --git a/DSharpPlus.UnifiedCommands/Application/ApplicationNameAttribute.cs b/DSharpPlus.UnifiedCommands/Application/ApplicationNameAttribute.cs
@@ -0,0 +1,14 @@
+namespace DSharpPlus.UnifiedCommands.Application;
+
+[AttributeUsage(AttributeTargets.Method)]
+public class ApplicationNameAttribute : Attribute
+{
+    public string Name { get; }
+    public string Description { get; }
+
+    public ApplicationNameAttribute(string name, string description)
+    {
+        Name = name;
+        Description = description;
+    }
+}
diff --git a/DSharpPlus.UnifiedCommands/Application/ApplicationOptionAttribute.cs b/DSharpPlus.UnifiedCommands/Application/ApplicationOptionAttribute.cs
@@ -0,0 +1,14 @@
+namespace DSharpPlus.UnifiedCommands.Application;
+
+[AttributeUsage(AttributeTargets.Parameter)]
+public class ApplicationOptionAttribute : Attribute
+{
+    public string Name { get; }
+    public string Description { get; }
+
+    public ApplicationOptionAttribute(string name, string description)
+    {
+        Name = name;
+        Description = description;
+    }
+}
diff --git a/DSharpPlus.UnifiedCommands/Application/ApplicationResult.cs b/DSharpPlus.UnifiedCommands/Application/ApplicationResult.cs
@@ -0,0 +1,28 @@
+using DSharpPlus.Entities;
+
+namespace DSharpPlus.UnifiedCommands.Application;
+
+public class ApplicationResult : IApplicationResult
+{
+    public ApplicationResultType Type { get; set; }
+    public List<DiscordEmbed>? Embeds { get; set; }
+    public string? Content { get; set; }
+
+    public static implicit operator ApplicationResult(DiscordEmbed embed)
+    {
+        ApplicationResult result = new() { Embeds = new() { embed } };
+        return result;
+    }
+
+    public static implicit operator ApplicationResult(DiscordEmbedBuilder builder)
+    {
+        ApplicationResult result = new() { Embeds = new() { builder.Build() } };
+        return result;
+    }
+
+    public static implicit operator ApplicationResult(string content)
+    {
+        ApplicationResult result = new() { Content = content };
+        return result;
+    }
+}
diff --git a/DSharpPlus.UnifiedCommands/Application/ApplicationResultType.cs b/DSharpPlus.UnifiedCommands/Application/ApplicationResultType.cs
@@ -0,0 +1,10 @@
+namespace DSharpPlus.UnifiedCommands.Application;
+
+public enum ApplicationResultType
+{
+    Reply,
+    FollowUp,
+    Edit,
+    Defer,
+    Modal,
+}
diff --git a/DSharpPlus.UnifiedCommands/Application/Conditions/IApplicationCondition.cs b/DSharpPlus.UnifiedCommands/Application/Conditions/IApplicationCondition.cs
@@ -0,0 +1,8 @@
+using DSharpPlus.Entities;
+
+namespace DSharpPlus.UnifiedCommands.Application.Conditions;
+
+public interface IApplicationCondition
+{
+    public ValueTask<bool> InvokeAsync(DiscordInteraction interaction, DiscordClient client);
+}
diff --git a/DSharpPlus.UnifiedCommands/Application/Entities/DiscordModalBuilder.cs b/DSharpPlus.UnifiedCommands/Application/Entities/DiscordModalBuilder.cs
@@ -0,0 +1,6 @@
+namespace DSharpPlus.UnifiedCommands.Application.Entities;
+
+public class DiscordModalBuilder
+{
+    public string Title { get; private set; } = string.Empty;
+}
diff --git a/DSharpPlus.UnifiedCommands/Application/IApplicationResult.cs b/DSharpPlus.UnifiedCommands/Application/IApplicationResult.cs
@@ -0,0 +1,10 @@
+using DSharpPlus.Entities;
+
+namespace DSharpPlus.UnifiedCommands.Application;
+
+public interface IApplicationResult
+{
+    public ApplicationResultType Type { get; set; }
+    public List<DiscordEmbed>? Embeds { get; set; }
+    public string? Content { get; set; }
+}