youys
/
Discord.Net
Not watched
1
0
Fork 0
Code
Releases 34 Wiki Activity
Issues 0 Pull Requests 0 Datasets Model Cloudbrain
Browse Source

SlashCommandBuilder added

pull/1733/head
quin lynch 5 years ago
parent
18ffc40e54
commit
21c2a7fa3a
1 changed files with 491 additions and 0 deletions
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. +491
    -0
      src/Discord.Net.Commands/Builders/SlashCommandBuilder.cs

+ 491
- 0
src/Discord.Net.Commands/Builders/SlashCommandBuilder.cs View File

@@ -0,0 +1,491 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading.Tasks;

namespace Discord.Commands.Builders
{
/// <summary>
/// A class used to build slash commands.
/// </summary>
public class SlashCommandBuilder
{
/// <summary>
/// Returns the maximun length a commands name allowed by Discord
/// </summary>
public const int MaxNameLength = 32;
/// <summary>
/// Returns the maximum length of a commands description allowed by Discord.
/// </summary>
public const int MaxDescriptionLength = 100;
/// <summary>
/// Returns the maximum count of command options allowed by Discord
/// </summary>
public const int MaxOptionsCount = 10;

/// <summary>
/// The name of this slash command.
/// </summary>
public string Name
{
get
{
return _name;
}
set
{
Preconditions.NotNullOrEmpty(value, nameof(Name));
Preconditions.AtLeast(value.Length, 3, nameof(Name));
Preconditions.AtMost(value.Length, MaxNameLength, nameof(Name));

// Discord updated the docs, this regex prevents special characters like @!$%(... etc,
// https://discord.com/developers/docs/interactions/slash-commands#applicationcommand
if (!Regex.IsMatch(value, @"^[\w-]{3,32}$"))
throw new ArgumentException("Command name cannot contian any special characters or whitespaces!");

_name = value;
}
}

/// <summary>
/// A 1-100 length description of this slash command
/// </summary>
public string Description
{
get
{
return _description;
}
set
{
Preconditions.AtLeast(value.Length, 1, nameof(Description));
Preconditions.AtMost(value.Length, MaxDescriptionLength, nameof(Description));

_description = value;
}
}

public ulong GuildId
{
get
{
return _guildId ?? 0;
}
set
{
if (value == 0)
{
throw new ArgumentException("Guild ID cannot be 0!");
}

_guildId = value;

if (isGlobal)
isGlobal = false;
}
}
/// <summary>
/// Gets or sets the options for this command.
/// </summary>
public List<SlashCommandOptionBuilder> Options
{
get
{
return _options;
}
set
{
if (value != null)
if (value.Count > MaxOptionsCount)
throw new ArgumentException(message: $"Option count must be less than or equal to {MaxOptionsCount}.", paramName: nameof(Options));

_options = value;
}
}

private ulong? _guildId { get; set; }
private string _name { get; set; }
private string _description { get; set; }
private List<SlashCommandOptionBuilder> _options { get; set; }

internal bool isGlobal { get; set; }


public SlashCommandCreationProperties Build()
{
SlashCommandCreationProperties props = new SlashCommandCreationProperties()
{
Name = this.Name,
Description = this.Description,
};

if(this.Options != null || this.Options.Any())
{
var options = new List<ApplicationCommandOptionProperties>();

this.Options.ForEach(x => options.Add(x.Build()));

props.Options = options;
}

return props;

}

/// <summary>
/// Makes this command a global application command .
/// </summary>
/// <returns>The current builder.</returns>
public SlashCommandBuilder MakeGlobal()
{
this.isGlobal = true;
return this;
}

/// <summary>
/// Makes this command a guild specific command.
/// </summary>
/// <param name="GuildId">The Id of the target guild.</param>
/// <returns>The current builder.</returns>
public SlashCommandBuilder ForGuild(ulong GuildId)
{
this.GuildId = GuildId;
return this;
}

public SlashCommandBuilder WithName(string Name)
{
this.Name = Name;
return this;
}

/// <summary>
/// Sets the description of the current command.
/// </summary>
/// <param name="Description">The description of this command.</param>
/// <returns>The current builder.</returns>
public SlashCommandBuilder WithDescription(string Description)
{
this.Description = Description;
return this;
}

/// <summary>
/// Adds an option to the current slash command.
/// </summary>
/// <param name="Name">The name of the option to add.</param>
/// <param name="Type">The type of this option.</param>
/// <param name="Description">The description of this option.</param>
/// <param name="Required">If this option is required for this command.</param>
/// <param name="Default">If this option is the default option.</param>
/// <param name="Options">The options of the option to add.</param>
/// <param name="Choices">The choices of this option.</param>
/// <returns>The current builder.</returns>
public SlashCommandBuilder AddOption(string Name, ApplicationCommandOptionType Type,
string Description, bool Required = true, bool Default = false, List<SlashCommandOptionBuilder> Options = null, params ApplicationCommandOptionChoiceProperties[] Choices)
{
// Make sure the name matches the requirements from discord
Preconditions.NotNullOrEmpty(Name, nameof(Name));
Preconditions.AtLeast(Name.Length, 3, nameof(Name));
Preconditions.AtMost(Name.Length, MaxNameLength, nameof(Name));

// Discord updated the docs, this regex prevents special characters like @!$%( and s p a c e s.. etc,
// https://discord.com/developers/docs/interactions/slash-commands#applicationcommand
if (!Regex.IsMatch(Name, @"^[\w-]{3,32}$"))
throw new ArgumentException("Command name cannot contian any special characters or whitespaces!", nameof(Name));

// same with description
Preconditions.NotNullOrEmpty(Description, nameof(Description));
Preconditions.AtLeast(Description.Length, 3, nameof(Description));
Preconditions.AtMost(Description.Length, MaxDescriptionLength, nameof(Description));

// make sure theres only one option with default set to true
if (Default)
{
if (this.Options != null)
if (this.Options.Any(x => x.Default))
throw new ArgumentException("There can only be one command option with default set to true!", nameof(Default));
}

SlashCommandOptionBuilder option = new SlashCommandOptionBuilder();
option.Name = Name;
option.Description = Description;
option.Required = Required;
option.Default = Default;
option.Options = Options;
option.Choices = Choices != null ? new List<ApplicationCommandOptionChoiceProperties>(Choices) : null;

return AddOption(option);
}

/// <summary>
/// Adds an option to the current slash command.
/// </summary>
/// <param name="Name">The name of the option to add.</param>
/// <param name="Type">The type of this option.</param>
/// <param name="Description">The description of this option.</param>
/// <param name="Required">If this option is required for this command.</param>
/// <param name="Default">If this option is the default option.</param>
/// <param name="Choices">The choices of this option.</param>
/// <returns>The current builder.</returns>
public SlashCommandBuilder AddOption(string Name, ApplicationCommandOptionType Type,
string Description, bool Required = true, bool Default = false, params ApplicationCommandOptionChoiceProperties[] Choices)
=> AddOption(Name, Type, Description, Required, Default, null, Choices);

/// <summary>
/// Adds an option to the current slash command.
/// </summary>
/// <param name="Name">The name of the option to add.</param>
/// <param name="Type">The type of this option.</param>
/// <param name="Description">The sescription of this option.</param>
/// <returns>The current builder.</returns>
public SlashCommandBuilder AddOption(string Name, ApplicationCommandOptionType Type, string Description)
=> AddOption(Name, Type, Description, Options: null, Choices: null);

/// <summary>
/// Adds an option to this slash command.
/// </summary>
/// <param name="Parameter">The option to add.</param>
/// <returns>The current builder.</returns>
public SlashCommandBuilder AddOption(SlashCommandOptionBuilder Option)
{
if (this.Options == null)
this.Options = new List<SlashCommandOptionBuilder>();

if (this.Options.Count >= MaxOptionsCount)
throw new ArgumentOutOfRangeException(nameof(Options), $"Cannot have more than {MaxOptionsCount} options!");

if (Option == null)
throw new ArgumentNullException(nameof(Option), "Option cannot be null");

this.Options.Add(Option);
return this;
}
/// <summary>
/// Adds a collection of options to the current slash command.
/// </summary>
/// <param name="Parameter">The collection of options to add.</param>
/// <returns>The current builder.</returns>
public SlashCommandBuilder AddOptions(params SlashCommandOptionBuilder[] Options)
{
if (Options == null)
throw new ArgumentNullException(nameof(Options), "Options cannot be null!");

if (Options.Length == 0)
throw new ArgumentException(nameof(Options), "Options cannot be empty!");

if (this.Options == null)
this.Options = new List<SlashCommandOptionBuilder>();

if (this.Options.Count + Options.Length > MaxOptionsCount)
throw new ArgumentOutOfRangeException(nameof(Options), $"Cannot have more than {MaxOptionsCount} options!");

this.Options.AddRange(Options);
return this;
}
}

/// <summary>
/// Represents a class used to build options for the <see cref="SlashCommandBuilder"/>.
/// </summary>
public class SlashCommandOptionBuilder
{
/// <summary>
/// The max length of a choice's name allowed by Discord.
/// </summary>
public const int ChoiceNameMaxLength = 100;

/// <summary>
/// The maximum number of choices allowed by Discord.
/// </summary>
public const int MaxChoiceCount = 10;

private string _name;
private string _description;

/// <summary>
/// The name of this option.
/// </summary>
public string Name
{
get => _name;
set
{
if (value?.Length > SlashCommandBuilder.MaxNameLength)
throw new ArgumentException("Name length must be less than or equal to 32");
if(value?.Length < 3)
throw new ArgumentException("Name length must at least 3 characters in length");

// Discord updated the docs, this regex prevents special characters like @!$%(... etc,
// https://discord.com/developers/docs/interactions/slash-commands#applicationcommand
if (!Regex.IsMatch(value, @"^[\w-]{3,32}$"))
throw new ArgumentException("Option name cannot contian any special characters or whitespaces!");

_name = value;
}
}

/// <summary>
/// The description of this option.
/// </summary>
public string Description
{
get => _description;
set
{
if (value?.Length > SlashCommandBuilder.MaxDescriptionLength)
throw new ArgumentException("Description length must be less than or equal to 100");
if (value?.Length < 1)
throw new ArgumentException("Name length must at least 1 character in length");

_description = value;
}
}

/// <summary>
/// The type of this option.
/// </summary>
public ApplicationCommandOptionType Type { get; set; }

/// <summary>
/// The first required option for the user to complete. only one option can be default.
/// </summary>
public bool Default { get; set; }

/// <summary>
/// <see langword="true"/> if this option is required for this command, otherwise <see langword="false"/>.
/// </summary>
public bool Required { get; set; }

/// <summary>
/// choices for string and int types for the user to pick from.
/// </summary>
public List<ApplicationCommandOptionChoiceProperties> Choices { get; set; }

/// <summary>
/// If the option is a subcommand or subcommand group type, this nested options will be the parameters.
/// </summary>
public List<SlashCommandOptionBuilder> Options { get; set; }

/// <summary>
/// Builds the current option.
/// </summary>
/// <returns>The build version of this option</returns>
public ApplicationCommandOptionProperties Build()
{
bool isSubType = this.Type == ApplicationCommandOptionType.SubCommand || this.Type == ApplicationCommandOptionType.SubCommandGroup;

if (isSubType && (Options == null || !Options.Any()))
throw new ArgumentException(nameof(Options), "SubCommands/SubCommandGroups must have at least one option");

if (!isSubType && (Options != null && Options.Any()))
throw new ArgumentException(nameof(Options), $"Cannot have options on {Type} type");

return new ApplicationCommandOptionProperties()
{
Name = this.Name,
Description = this.Description,
Default = this.Default,
Required = this.Required,
Type = this.Type,
Options = new List<ApplicationCommandOptionProperties>(this.Options.Select(x => x.Build())),
Choices = this.Choices
};
}

/// <summary>
/// Adds a sub
/// </summary>
/// <param name="option"></param>
/// <returns></returns>
public SlashCommandOptionBuilder AddOption(SlashCommandOptionBuilder option)
{
if (this.Options == null)
this.Options = new List<SlashCommandOptionBuilder>();

if (this.Options.Count >= SlashCommandBuilder.MaxOptionsCount)
throw new ArgumentOutOfRangeException(nameof(Choices), $"There can only be {SlashCommandBuilder.MaxOptionsCount} options per sub command group!");

if (option == null)
throw new ArgumentNullException(nameof(option), "Option cannot be null");

Options.Add(option);
return this;
}

public SlashCommandOptionBuilder AddChoice(string Name, int Value)
{
if (Choices == null)
Choices = new List<ApplicationCommandOptionChoiceProperties>();

if (Choices.Count >= MaxChoiceCount)
throw new ArgumentOutOfRangeException(nameof(Choices), $"Cannot add more than {MaxChoiceCount} choices!");

Choices.Add(new ApplicationCommandOptionChoiceProperties()
{
Name = Name,
Value = Value
});

return this;
}
public SlashCommandOptionBuilder AddChoice(string Name, string Value)
{
if (Choices == null)
Choices = new List<ApplicationCommandOptionChoiceProperties>();

if (Choices.Count >= MaxChoiceCount)
throw new ArgumentOutOfRangeException(nameof(Choices), $"Cannot add more than {MaxChoiceCount} choices!");

Choices.Add(new ApplicationCommandOptionChoiceProperties()
{
Name = Name,
Value = Value
});

return this;
}

public SlashCommandOptionBuilder WithName(string Name, int Value)
{
if (Choices == null)
Choices = new List<ApplicationCommandOptionChoiceProperties>();

if (Choices.Count >= MaxChoiceCount)
throw new ArgumentOutOfRangeException(nameof(Choices), $"Cannot add more than {MaxChoiceCount} choices!");

Choices.Add(new ApplicationCommandOptionChoiceProperties()
{
Name = Name,
Value = Value
});

return this;
}

public SlashCommandOptionBuilder WithDescription(string Description)
{
this.Description = Description;
return this;
}

public SlashCommandOptionBuilder WithRequired(bool value)
{
this.Required = value;
return this;
}

public SlashCommandOptionBuilder WithDefault(bool value)
{
this.Default = value;
return this;
}
public SlashCommandOptionBuilder WithType(ApplicationCommandOptionType Type)
{
this.Type = Type;
return this;
}
}
}

Write Preview
Loading…
Cancel
Save