protected override Task <ArgumentParseResult> ParseArgumentsGuildAsync(IGuildCommandContext context)
{
ArgumentContainer argOut = new ArgumentContainer();
if (!ArgumentParsing.TryParseGuildTextChannel(context, context.Arguments.First, out argOut.channel))
{
return(Task.FromResult(new ArgumentParseResult(Arguments[0], "Failed to parse to a guild text channel!")));
}
if (context.Message.Content.Length > Identifier.Length + context.Arguments.First.Length + 2)
{
context.Arguments.Index++;
string embedText = context.RemoveArgumentsFront(1).Replace("[3`]", "```");
if (JSONContainer.TryParse(embedText, out JSONContainer json, out string errormessage))
{
if (EmbedHelper.TryGetMessageFromJSONObject(json, out argOut.embed, out argOut.messageContent, out string error))
{
return(Task.FromResult(new ArgumentParseResult(argOut)));
}
else
{
return(Task.FromResult(new ArgumentParseResult(Arguments[1], error)));
}
}
else
{
return(Task.FromResult(new ArgumentParseResult(Arguments[1], $"Unable to parse JSON text to a json data structure! Error: `{errormessage}`")));
}
}
protected override ArgumentParseResult TryParseArgumentsGuildSynchronous(GuildCommandContext context)
{
if (context.Arguments.Count == 0)
{
Mode = CommandMode.list;
Role = null;
}
else
{
if (!Enum.TryParse(context.Arguments.First, out Mode))
{
return(new ArgumentParseResult(ARGS[0], $"Unable to parse `{context.Arguments.First}` to a valid command mode!"));
}
context.Arguments.Index++;
if (context.Arguments.Count == 0 && Mode != CommandMode.list)
{
return(new ArgumentParseResult(ARGS[1], $"Mode `{Mode}` requires a role as second argument!"));
}
if (Mode != CommandMode.list)
{
if (!ArgumentParsing.TryParseRole(context, context.Arguments.First, out Role))
{
if (Mode == CommandMode.add)
{
return(new ArgumentParseResult(ARGS[1], $"Could not parse `{context.Arguments.First}` to a valid role!"));
}
else
{
if (!ulong.TryParse(context.Arguments.First, out RoleId))
{
return(new ArgumentParseResult(ARGS[1], $"Could not parse `{context.Arguments.First}` to a valid role!"));
}
}
}
if (Role != null)
{
RoleId = Role.Id;
}
bool hasRole = EventLogger.AutoAssignRoleIds.Contains(RoleId);
if (Mode == CommandMode.add && hasRole)
{
return(new ArgumentParseResult(ARGS[1], $"{Role.Mention} is already amongst the auto assign roles!"));
}
else if (Mode == CommandMode.remove && !hasRole)
{
return(new ArgumentParseResult(ARGS[1], $"Can not remove {Role.Mention} from the list of auto assign roles, as it isn't in that list already!"));
}
}
}
return(ArgumentParseResult.SuccessfullParse);
}
protected override Task <ArgumentParseResult> ParseArgumentsGuildAsync(IGuildCommandContext context)
{
ArgumentContainer args = new ArgumentContainer();
if (!ArgumentParsing.TryParseGuildUser(context, context.Arguments.First, out args.TargetUser, allowSelf: false, allowName: false))
{
return(Task.FromResult(new ArgumentParseResult(ARGS[0])));
}
context.Arguments.Index++;
args.Reason = context.Arguments.First;
return(Task.FromResult(new ArgumentParseResult(args)));
}
protected override Task <ArgumentParseResult> ParseArgumentsGuildAsync(IGuildCommandContext context)
{
ArgumentContainer argOut = new ArgumentContainer();
if (!ArgumentParsing.TryParseGuildUser(context, context.Arguments.First, out argOut.TargetUser))
{
return(Task.FromResult(new ArgumentParseResult(Arguments[0])));
}
context.Arguments.Index++;
argOut.Warning = context.Arguments.First;
return(Task.FromResult(new ArgumentParseResult(argOut)));
}
protected override Task <ArgumentParseResult> ParseArgumentsGuildAsync(IGuildCommandContext context)
{
ArgumentContainer argOut = new ArgumentContainer();
if (!ArgumentParsing.TryParseGuildUser(context, context.Arguments.First, out argOut.TargetUser))
{
return(Task.FromResult(new ArgumentParseResult(Arguments[0], $"Could not parse {context.Arguments.First} to a discord guild user!")));
}
context.Arguments.Index++;
argOut.NewNickname = context.Arguments.First;
return(Task.FromResult(new ArgumentParseResult(argOut)));
}
protected override ArgumentParseResult TryParseArgumentsGuildSynchronous(GuildCommandContext context)
{
channel = null;
if (!Enum.TryParse(context.Arguments[0], out channelType))
{
return(new ArgumentParseResult(ARGS[0], $"Could not parse to an output channel type. Available are: `{Macros.GetEnumNames<OutputChannelType>()}`"));
}
if (context.Arguments.Count == 2)
{
if (!ArgumentParsing.TryParseGuildChannel(context, context.Arguments[1], out channel))
{
return(new ArgumentParseResult(ARGS[1], $"Could not parse to a channel in this guild"));
}
}
return(ArgumentParseResult.SuccessfullParse);
}
protected override Task <ArgumentParseResult> ParseArgumentsGuildAsync(IGuildCommandContext context)
{
ArgumentContainer argOut = new ArgumentContainer();
if (!ArgumentParsing.TryParseGuildUser(context, context.Arguments.First, out argOut.TargetUser))
{
if (!ulong.TryParse(context.Arguments.First, out argOut.UserId))
{
argOut.TargetUser = null;
argOut.UserId = 0;
return(Task.FromResult(new ArgumentParseResult(Arguments[0])));
}
}
else
{
argOut.UserId = argOut.TargetUser.Id;
}
return(Task.FromResult(new ArgumentParseResult(argOut)));
}
protected override ArgumentParseResult TryParseArgumentsGuildSynchronous(GuildCommandContext context)
{
if (!Enum.TryParse(context.Arguments[0], out RoleIdentifier))
{
return(new ArgumentParseResult(ARGS[0], $"Could not parse to a role identifier. Available are: `{string.Join(", ", Enum.GetNames(typeof(SettingRoles)))}`"));
}
if (context.Arguments.Count == 2)
{
if (!ArgumentParsing.TryParseRole(context, context.Arguments[1], out Role))
{
return(new ArgumentParseResult(ARGS[1], $"Could not parse to a role in this guild"));
}
}
else
{
Role = null;
}
return(ArgumentParseResult.SuccessfullParse);
}
protected override Task <ArgumentParseResult> ParseArgumentsGuildAsync(IGuildCommandContext context)
{
SocketUser User;
if (context.Arguments.Count == 0)
{
User = context.User;
}
else
{
if (ArgumentParsing.TryParseGuildUser(context, context.Arguments.First, out SocketGuildUser guildUser))
{
User = guildUser;
}
else
{
return(Task.FromResult(new ArgumentParseResult(Arguments[0], "Failed to parse to a User!")));
}
}
return(Task.FromResult(new ArgumentParseResult(User)));
}
protected override ArgumentParseResult TryParseArgumentsGuildSynchronous(GuildCommandContext context)
{
if (!ArgumentParsing.TryParseGuildChannel(context, context.Arguments[0], out Channel))
{
return(new ArgumentParseResult(ARGS[0], "Failed to parse to a guild channel!"));
}
Configs.Clear();
if (context.Arguments.Count > 1)
{
context.Arguments.Index++;
foreach (string arg in context.Arguments)
{
string[] argSplit = arg.Split(':');
if (argSplit.Length == 2)
{
if (!Enum.TryParse(argSplit[0], out ConfigIdentifier configIdentifier))
{
return(new ArgumentParseResult(ARGS[1], $"{arg} - Could not parse to config identifier. Available are `{Macros.GetEnumNames<ConfigIdentifier>()}`!"));
}
if (!bool.TryParse(argSplit[1], out bool setting))
{
return(new ArgumentParseResult(ARGS[1], $"{arg} - Could not parse boolean value!"));
}
Configs.Add(new Tuple <ConfigIdentifier, bool>(configIdentifier, setting));
}
else
{
return(new ArgumentParseResult(ARGS[1], $"{arg} - Could not split into config identifer and setting!"));
}
}
context.Arguments.Index--;
}
return(ArgumentParseResult.SuccessfullParse);
}
protected override Task <ArgumentParseResult> ParseArguments(IDMCommandContext context)
{
ArgumentContainer argOut = new ArgumentContainer();
// Parse <Context> argument
if (context.Arguments.First.ToLower() == "save")
{
argOut.mode = CommandMode.save;
return(Task.FromResult(new ArgumentParseResult(argOut)));
}
else if (context.Arguments.First.ToLower() == "global")
{
argOut.TargetBotVarCollection = BotVarManager.GlobalBotVars;
}
else
{
if (!ArgumentParsing.TryParseGuild(context, context.Arguments.First, out SocketGuild guild))
{
return(Task.FromResult(new ArgumentParseResult(Arguments[0])));
}
argOut.TargetBotVarCollection = BotVarManager.GetGuildBotVarCollection(guild.Id);
}
context.Arguments.Index++;
if (context.Arguments.TotalCount == 1) // If argcnt is 1 (only context provided), commandmode is to list all botvars
{
argOut.mode = CommandMode.list;
return(Task.FromResult(new ArgumentParseResult(argOut)));
}
// Parse <BotVar Id> argument
argOut.BotVarId = context.Arguments.First;
argOut.TargetBotVarCollection.TryGetBotVar(argOut.BotVarId, out argOut.BotVar);
if (context.Arguments.TotalCount == 2) // If argcnt is 2 (only context and BotVar id provided), commandmode is to display the requested botvar
{
argOut.mode = CommandMode.get;
if (argOut.BotVar.IsDefined)
{
return(Task.FromResult(new ArgumentParseResult(argOut)));
}
else
{
return(Task.FromResult(new ArgumentParseResult(Arguments[0], $"Couldn't locate a config variable named `{argOut.BotVarId}`!")));
}
}
context.Arguments.Index++;
// Parse argument <Type>
if (!parseArgument_Type(context, argOut, out ArgumentParseResult failedTypeArgParse))
{
return(Task.FromResult(failedTypeArgParse));
}
if (argOut.mode == CommandMode.delete) // No further parsing required as mode is delete
{
return(Task.FromResult(new ArgumentParseResult(argOut)));
}
if (context.Arguments.TotalCount == 3) // No value argument provided
{
return(Task.FromResult(new ArgumentParseResult(Arguments[2], "Cannot assign an empty value!")));
}
context.Arguments.Index++;
// Parse value argument
if (!parseArgument_Value(context, argOut, out ArgumentParseResult failedValueArgParse))
{
return(Task.FromResult(failedValueArgParse));
}
return(Task.FromResult(new ArgumentParseResult(argOut)));
}
protected override Task <ArgumentParseResult> ParseArgumentsGuildAsync(IGuildCommandContext context)
{
ArgumentContainer args = new ArgumentContainer();
if (!ArgumentParsing.TryParseGuildUser(context, context.Arguments.First, out args.TargetUser, allowName: false, allowSelf: false))
{
return(Task.FromResult(new ArgumentParseResult(Arguments[0])));
}
context.Arguments.Index++;
if (context.Arguments.First.ToLower() == "perma")
{
args.MuteUntil = DateTimeOffset.MaxValue;
}
else
{
if (context.Arguments.First.Length == 1)
{
return(Task.FromResult(new ArgumentParseResult(Arguments[1])));
}
char format = context.Arguments.First[context.Arguments.First.Length - 1];
string amount_str = context.Arguments.First.Substring(0, context.Arguments.First.Length - 1);
if (double.TryParse(amount_str, out double amount))
{
switch (format)
{
case 'm':
args.Duration = TimeSpan.FromMinutes(amount);
break;
case 'h':
args.Duration = TimeSpan.FromHours(amount);
break;
case 'd':
args.Duration = TimeSpan.FromDays(amount);
break;
case 'M':
args.Duration = TimeSpan.FromDays(amount * 30.4375);
break;
case 'y':
args.Duration = TimeSpan.FromDays(amount * 365.25);
break;
default:
return(Task.FromResult(new ArgumentParseResult(Arguments[1])));
}
args.MuteUntil = DateTimeOffset.UtcNow + args.Duration;
}
else
{
return(Task.FromResult(new ArgumentParseResult(Arguments[1])));
}
}
context.Arguments.Index++;
args.Reason = context.Arguments.First;
return(Task.FromResult(new ArgumentParseResult(args)));
}
protected override Task <ArgumentParseResult> ParseArgumentsGuildAsync(IGuildCommandContext context)
{
ArgumentContainer argOut = new ArgumentContainer();
if (!Enum.TryParse(context.Arguments.First, true, out argOut.Filter))
{
return(Task.FromResult(new ArgumentParseResult(Arguments[0], $"Could not select a filter mode from `{context.Arguments.First}`!")));
}
if (argOut.Filter == SelectFilter.User)
{
context.Arguments.Index++;
if (!ArgumentParsing.TryParseGuildUser(context, context.Arguments.First, out argOut.User))
{
return(Task.FromResult(new ArgumentParseResult(Arguments[1], $"Could not select a user from `{context.Arguments.First}`!")));
}
}
context.Arguments.Index++;
if (!Enum.TryParse(context.Arguments.First, true, out argOut.End))
{
return(Task.FromResult(new ArgumentParseResult(Arguments[2], $"Could not select an end mode from `{context.Arguments.First}`!")));
}
context.Arguments.Index++;
if (context.Arguments.Count == 0)
{
return(Task.FromResult(new ArgumentParseResult(Arguments[3], $"You need to supply an argument for the endmode!")));
}
switch (argOut.End)
{
case EndMode.Count:
if (uint.TryParse(context.Arguments.First, out argOut.RemoveCount))
{
if (argOut.Filter == SelectFilter.All)
{
argOut.InitalCount = (int)argOut.RemoveCount;
}
else
{
argOut.InitalCount = 1000;
}
}
else
{
return(Task.FromResult(new ArgumentParseResult(Arguments[3], $"Could not parse `{context.Arguments.First}` to a valid number!")));
}
break;
case EndMode.Time:
if (!DateTimeOffset.TryParseExact(context.Arguments.First, "H:mm", CultureInfo.InvariantCulture, DateTimeStyles.AssumeUniversal, out argOut.DeleteAfter))
{
return(Task.FromResult(new ArgumentParseResult(Arguments[3], $"Could not parse `{context.Arguments.First}` to a valid date and time. Required Format: `hh:mm` UTC!")));
}
argOut.InitalCount = 1000;
break;
case EndMode.TimeRelative:
if (Macros.TryParseHumanTimeString(context.Arguments.First, out TimeSpan maxAge))
{
if (maxAge.TotalHours > MAXHOURS)
{
return(Task.FromResult(new ArgumentParseResult(Arguments[3], "Can not purge messages older than 24 hours!")));
}
else
{
argOut.DeleteAfter = DateTimeOffset.UtcNow - maxAge;
}
}
else
{
return(Task.FromResult(new ArgumentParseResult(Arguments[3], $"Could not parse `{context.Arguments.First}` to a valid timespan. Use Format `##h` or `##m`!")));
}
argOut.InitalCount = 1000;
break;
}
return(Task.FromResult(new ArgumentParseResult(argOut)));
}
