139 lines
5.0 KiB
C#
139 lines
5.0 KiB
C#
using System.Text.RegularExpressions;
|
|
|
|
using Myriad.Types;
|
|
|
|
using PluralKit.Core;
|
|
|
|
namespace PluralKit.Bot;
|
|
|
|
public static class ContextArgumentsExt
|
|
{
|
|
public static string PopArgument(this Context ctx) =>
|
|
ctx.Parameters.Pop();
|
|
|
|
public static string PeekArgument(this Context ctx) =>
|
|
ctx.Parameters.Peek();
|
|
|
|
public static string RemainderOrNull(this Context ctx, bool skipFlags = true) =>
|
|
ctx.Parameters.Remainder(skipFlags).Length == 0 ? null : ctx.Parameters.Remainder(skipFlags);
|
|
|
|
public static bool HasNext(this Context ctx, bool skipFlags = true) =>
|
|
ctx.RemainderOrNull(skipFlags) != null;
|
|
|
|
public static string FullCommand(this Context ctx) =>
|
|
ctx.Parameters.FullCommand;
|
|
|
|
/// <summary>
|
|
/// Checks if the next parameter is equal to one of the given keywords. Case-insensitive.
|
|
/// </summary>
|
|
public static bool Match(this Context ctx, ref string used, params string[] potentialMatches)
|
|
{
|
|
var arg = ctx.PeekArgument();
|
|
foreach (var match in potentialMatches)
|
|
if (arg.Equals(match, StringComparison.InvariantCultureIgnoreCase))
|
|
{
|
|
used = ctx.PopArgument();
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Checks if the next parameter is equal to one of the given keywords. Case-insensitive.
|
|
/// </summary>
|
|
public static bool Match(this Context ctx, params string[] potentialMatches)
|
|
{
|
|
string used = null; // Unused and unreturned, we just yeet it
|
|
return ctx.Match(ref used, potentialMatches);
|
|
}
|
|
|
|
public static bool MatchFlag(this Context ctx, params string[] potentialMatches)
|
|
{
|
|
// Flags are *ALWAYS PARSED LOWERCASE*. This means we skip out on a "ToLower" call here.
|
|
// Can assume the caller array only contains lowercase *and* the set below only contains lowercase
|
|
|
|
var flags = ctx.Parameters.Flags();
|
|
return potentialMatches.Any(potentialMatch => flags.Contains(potentialMatch));
|
|
}
|
|
|
|
public static async Task<bool> MatchClear(this Context ctx, string toClear = null)
|
|
{
|
|
var matched = ctx.Match("clear", "reset") || ctx.MatchFlag("c", "clear");
|
|
if (matched && toClear != null)
|
|
return await ctx.ConfirmClear(toClear);
|
|
return matched;
|
|
}
|
|
|
|
public static bool MatchRaw(this Context ctx) =>
|
|
ctx.Match("r", "raw") || ctx.MatchFlag("r", "raw");
|
|
|
|
public static (ulong? messageId, ulong? channelId) MatchMessage(this Context ctx, bool parseRawMessageId)
|
|
{
|
|
if (ctx.Message.Type == Message.MessageType.Reply && ctx.Message.MessageReference?.MessageId != null)
|
|
return (ctx.Message.MessageReference.MessageId, ctx.Message.MessageReference.ChannelId);
|
|
|
|
var word = ctx.PeekArgument();
|
|
if (word == null)
|
|
return (null, null);
|
|
|
|
if (parseRawMessageId && ulong.TryParse(word, out var mid))
|
|
return (mid, null);
|
|
|
|
var match = Regex.Match(word, "https://(?:\\w+.)?discord(?:app)?.com/channels/\\d+/(\\d+)/(\\d+)");
|
|
if (!match.Success)
|
|
return (null, null);
|
|
|
|
var channelId = ulong.Parse(match.Groups[1].Value);
|
|
var messageId = ulong.Parse(match.Groups[2].Value);
|
|
ctx.PopArgument();
|
|
return (messageId, channelId);
|
|
}
|
|
|
|
public static async Task<List<PKMember>> ParseMemberList(this Context ctx, SystemId? restrictToSystem)
|
|
{
|
|
var members = new List<PKMember>();
|
|
|
|
// Loop through all the given arguments
|
|
while (ctx.HasNext())
|
|
{
|
|
// and attempt to match a member
|
|
var member = await ctx.MatchMember(restrictToSystem);
|
|
|
|
if (member == null)
|
|
// if we can't, big error. Every member name must be valid.
|
|
throw new PKError(ctx.CreateNotFoundError("Member", ctx.PopArgument()));
|
|
|
|
members.Add(member); // Then add to the final output list
|
|
}
|
|
|
|
if (members.Count == 0) throw new PKSyntaxError("You must input at least one member.");
|
|
|
|
return members;
|
|
}
|
|
|
|
public static async Task<List<PKGroup>> ParseGroupList(this Context ctx, SystemId? restrictToSystem)
|
|
{
|
|
var groups = new List<PKGroup>();
|
|
|
|
// Loop through all the given arguments
|
|
while (ctx.HasNext())
|
|
{
|
|
// and attempt to match a group
|
|
var group = await ctx.MatchGroup(restrictToSystem);
|
|
if (group == null)
|
|
// if we can't, big error. Every group name must be valid.
|
|
throw new PKError(ctx.CreateNotFoundError("Group", ctx.PopArgument()));
|
|
|
|
// todo: remove this, the database query enforces the restriction
|
|
if (restrictToSystem != null && group.System != restrictToSystem)
|
|
throw Errors.NotOwnGroupError; // TODO: name *which* group?
|
|
|
|
groups.Add(group); // Then add to the final output list
|
|
}
|
|
|
|
if (groups.Count == 0) throw new PKSyntaxError("You must input at least one group.");
|
|
|
|
return groups;
|
|
}
|
|
} |