public async Task <bool> JudgeAsync(MummyContext sourceContext, ReactionData parameter)
{
var reactions = await sourceContext.Message.GetReactionsAsync(parameter.Emoji);
bool ok = reactions.Any(x => x.Id == sourceContext.User.Id);
return(ok);
}
public PaginatedMessageCallback(InteractiveService interactive, MummyContext sourceContext, PaginatedMessage pager, ICriterion <ReactionData> criterion = null)
{
Interactive = interactive;
Context = sourceContext;
Criterion = criterion ?? new EmptyCriterion <ReactionData>();
_pager = pager;
pages = _pager.Pages.Count;
}
public async Task <IUserMessage> SendPaginatedMessageAsync(MummyContext context,
PaginatedMessage pager,
ICriterion <ReactionData> criterion = null)
{
var callback = new PaginatedMessageCallback(this, context, pager, criterion);
await callback.DisplayAsync().ConfigureAwait(false);
return(callback.Message);
}
public override async ValueTask <CheckResult> CheckAsync(MummyContext context)
{
if ((await context.Client.GetCurrentApplicationAsync()).Owner.Id == context.User.Id)
{
return(CheckResult.Successful);
}
else
{
return(CheckResult.Unsuccessful("Only my owner can run this command"));
}
}
public async Task <bool> JudgeAsync(MummyContext sourceContext, T parameter)
{
foreach (var criterion in _critiera)
{
var result = await criterion.JudgeAsync(sourceContext, parameter).ConfigureAwait(false);
if (!result)
{
return(false);
}
}
return(true);
}
public async Task <IUserMessage> ReplyAndDeleteAsync(MummyContext context,
string content, bool isTTS = false,
LocalEmbed embed = null,
TimeSpan?timeout = null
)
{
timeout ??= _defaultTimeout;
var message = await context.Channel.SendMessageAsync(content, isTTS, embed).ConfigureAwait(false);
_ = Task.Delay(timeout.Value)
.ContinueWith(_ => message.DeleteAsync().ConfigureAwait(false))
.ConfigureAwait(false);
return(message);
}
public Task <CachedUserMessage> NextMessageAsync(MummyContext context,
bool fromSourceUser = true,
bool inSourceChannel = true,
TimeSpan?timeout = null,
CancellationToken token = default)
{
var criterion = new Criteria <CachedUserMessage>();
if (fromSourceUser)
{
criterion.AddCriterion(new EnsureSourceUserCriterion());
}
if (inSourceChannel)
{
criterion.AddCriterion(new EnsureSourceChannelCriterion());
}
return(NextMessageAsync(context, criterion, timeout, token));
}
public override ValueTask <CheckResult> CheckAsync(MummyContext context)
{
CachedMember user = null;
switch (_target)
{
case PermissionTarget.User:
user = context.User;
break;
case PermissionTarget.Bot:
user = context.Guild.CurrentMember;
break;
}
var failedGuildPerms = _guildPerms.Where(guildPerm => !user.Permissions.Has(guildPerm)).ToArray();
var channelPerms = context.User.GetPermissionsFor(context.Channel);
var failedChannelPerms = _channelPerms.Where(channelPerm => !channelPerms.Has(channelPerm)).ToArray();
if (failedGuildPerms.Length == 0 && failedChannelPerms.Length == 0)
{
return(CheckResult.Successful);
}
var sb = new StringBuilder();
foreach (var guildPerm in failedGuildPerms)
{
sb.AppendLine(guildPerm.ToString());
}
foreach (var channelPerm in failedChannelPerms)
{
sb.AppendLine(channelPerm.ToString());
}
var u = context.User;
var target = _target == PermissionTarget.User ? "You" : "I";
return(CheckResult.Unsuccessful($"{target} lack permissions for {sb}"));
}
public override ValueTask <CheckResult> CheckAsync(object argument, MummyContext context)
{
var lenght = argument.ToString().Length;
if (lenght == 6)
{
return(CheckResult.Successful);
}
else
{
if (lenght < 6)
{
return(CheckResult.Unsuccessful($"the code provide was to SHORT and it required to be 6 chars long exactly. (code provided was {lenght} char long)"));
}
else
{
return(CheckResult.Unsuccessful($"the code provide was to LONG and it required to be 6 chars long exactly. (code provided was {lenght} char long)"));
}
}
}
public async Task <CachedUserMessage> NextMessageAsync(MummyContext context,
ICriterion <CachedUserMessage> criterion,
TimeSpan?timeout = null,
CancellationToken token = default)
{
timeout ??= _defaultTimeout;
var eventTrigger = new TaskCompletionSource <CachedUserMessage>();
var cancelTrigger = new TaskCompletionSource <bool>();
token.Register(() => cancelTrigger.SetResult(true));
async Task Handler(MessageReceivedEventArgs e)
{
var message = e.Message as CachedUserMessage;
var result = await criterion.JudgeAsync(context, message).ConfigureAwait(false);
if (result)
{
eventTrigger.SetResult(message);
}
}
context.Client.MessageReceived += Handler;
var trigger = eventTrigger.Task;
var cancel = cancelTrigger.Task;
var delay = Task.Delay(timeout.Value);
var task = await Task.WhenAny(trigger, delay, cancel).ConfigureAwait(false);
context.Client.MessageReceived -= Handler;
if (task == trigger)
{
return(await trigger.ConfigureAwait(false));
}
else
{
return(null);
}
}
public LocationNSViewComponent(MummyContext ctx)
{
context = ctx;
}
public abstract ValueTask <TypeParserResult <T> > ParseAsync(Parameter parameter, string value, MummyContext context);
public Task <bool> JudgeAsync(MummyContext sourceContext, CachedUserMessage parameter)
{
bool ok = int.TryParse(parameter.Content, out _);
return(Task.FromResult(ok));
}
public abstract ValueTask <CheckResult> CheckAsync(object argument, MummyContext context);
public override async ValueTask <TypeParserResult <Module> > ParseAsync(Parameter parameter, string value, MummyContext context)
{
CommandService commandService = context.ServiceProvider.GetRequiredService <CommandService>();
var module = commandService.GetAllModules().FirstOrDefault(m => m.Name.Contains(value, StringComparison.CurrentCultureIgnoreCase));
if (module == null)
{
return(new TypeParserResult <Module>("Could not find a module with that name"));
}
else
{
var result = await module.RunChecksAsync(context);
if (result.IsSuccessful)
{
return(new TypeParserResult <Module>(module));
}
else
{
return(new TypeParserResult <Module>("you failed some checks and therefor i wont show you this module ;)"));
}
}
}
public BurialsController(MummyContext ctx, UserManager <IWantMyMummyUser> tempUser, IWantMyMummyContext con)
{
_context = ctx;
userManager = tempUser;
wantContext = con;
}
public override ValueTask <CheckResult> CheckAsync(MummyContext context)
{
throw new NotImplementedException();
}
public override ValueTask <TypeParserResult <TimeSpan> > ParseAsync(Parameter parameter, string value, MummyContext context)
{
MatchCollection matches = TimeSpanRegex.Matches(value);
if (matches.Count == 0)
{
return(TypeParserResult <TimeSpan> .Unsuccessful("no matches idk"));
}
var result = new TimeSpan();
bool weeks = false, days = false, hours = false, minutes = false, seconds = false;
for (var m = 0; m < matches.Count; m++)
{
Match match = matches[m];
if (!uint.TryParse(match.Groups[1].Value, out uint amount))
{
continue;
}
switch (match.Groups[2].Value[0])
{
case 'w':
if (!weeks)
{
result = result.Add(TimeSpan.FromDays(amount * 7));
weeks = true;
}
continue;
case 'd':
if (!days)
{
result = result.Add(TimeSpan.FromDays(amount));
days = true;
}
continue;
case 'h':
if (!hours)
{
result = result.Add(TimeSpan.FromHours(amount));
hours = true;
}
continue;
case 'm':
if (!minutes)
{
result = result.Add(TimeSpan.FromMinutes(amount));
minutes = true;
}
continue;
case 's':
if (!seconds)
{
result = result.Add(TimeSpan.FromSeconds(amount));
seconds = true;
}
continue;
}
}
return(TypeParserResult <TimeSpan> .Successful(result));
}
public override ValueTask <TypeParserResult <bool> > ParseAsync(Parameter parameter, string value, MummyContext context)
{
if (value.Equals("on", StringComparison.CurrentCultureIgnoreCase))
{
return(TypeParserResult <bool> .Successful(true));
}
else if (value.Equals("off", StringComparison.CurrentCultureIgnoreCase))
{
return(TypeParserResult <bool> .Successful(false));
}
else
{
return(TypeParserResult <bool> .Unsuccessful($"could not parse {parameter.Name} as on/off"));
}
}
public Task <bool> JudgeAsync(MummyContext sourceContext, IMessage parameter)
{
var ok = sourceContext.User.Id == parameter.Author.Id;
return(Task.FromResult(ok));
}
public abstract ValueTask <CheckResult> CheckAsync(MummyContext context);
public RoslynContext(MummyContext context, IServiceProvider services)
{
Context = context;
Services = services;
}
public RackSamplesController(MummyContext context, IWantMyMummyContext con, UserManager <IWantMyMummyUser> tempUser)
{
_context = context;
mummyContext = con;
userManager = tempUser;
}
public override ValueTask <TypeParserResult <DateTimeOffset> > ParseAsync(Parameter parameter, string value, MummyContext context)
{
DateTimeOffset dateTimeOffset = new DateTimeOffset(DateTime.MinValue, TimeSpan.Zero);
if (!value.EndsWith("dmy", StringComparison.CurrentCultureIgnoreCase) && !value.EndsWith("mdy", StringComparison.CurrentCultureIgnoreCase))
{
return(TypeParserResult <DateTimeOffset> .Unsuccessful("failed to parse expected mdy or dmy"));
}
if (value.EndsWith("dmy", StringComparison.CurrentCultureIgnoreCase))
{
var time = value.Substring(0, value.IndexOf("dmy"));
if (!DateTimeOffset.TryParse(time, CultureInfo.CurrentCulture, styles: DateTimeStyles.AssumeUniversal, out dateTimeOffset))
{
return(TypeParserResult <DateTimeOffset> .Unsuccessful("failed to parse time (something doesnt look right in the time part)"));
}
}
if (value.EndsWith("mdy", StringComparison.CurrentCultureIgnoreCase))
{
var time = value.Substring(0, value.IndexOf("mdy"));
if (!DateTimeOffset.TryParse(time, CultureInfo.CreateSpecificCulture("en-US"), DateTimeStyles.AssumeUniversal, out dateTimeOffset))
{
return(TypeParserResult <DateTimeOffset> .Unsuccessful("failed to parse time (something doesnt look right in the time part)"));
}
}
if (dateTimeOffset != new DateTimeOffset(DateTime.MinValue, TimeSpan.Zero))
{
return(TypeParserResult <DateTimeOffset> .Successful(dateTimeOffset));
}
return(TypeParserResult <DateTimeOffset> .Unsuccessful("something went badly wrong and i entirely failed to parse your time"));
}
private async Task HandleReceivedMessageAsync(CachedUserMessage message)
{
if (message.Author.IsBot)
{
return;
}
if (!(message.Channel is CachedTextChannel textChannel) ||
!textChannel.Guild.CurrentMember.GetPermissionsFor(textChannel).Has(Permission.SendMessages))
{
return;
}
if (CommandUtilities.HasAnyPrefix(message.Content, Prefixes, StringComparison.CurrentCulture, out var prefix, out var output) ||
CommandUtilities.HasPrefix(message.Content, $"<@{Client.CurrentUser.Id}>", StringComparison.Ordinal, out output) ||
CommandUtilities.HasPrefix(message.Content, $"<@!{Client.CurrentUser.Id}>", StringComparison.Ordinal, out output))
{
if (string.IsNullOrWhiteSpace(output))
{
return;
}
try
{
if (prefix is null)
{
prefix = Client.CurrentUser.Mention;
}
var ctx = MummyContext.Create(Client, message, Services, prefix);
ActiveTimings[ctx.UserId] = Stopwatch.StartNew();
var r = await Commands.ExecuteAsync(output, ctx);
ActiveTimings[ctx.UserId].Stop();
ActiveTimings.Remove(ctx.UserId, out var st);
if (r.IsSuccessful)
{
LogService.LogInformation($"command: {ctx.Command.Name} has successful finished execution in {st.ElapsedMilliseconds}ms.", LogSource.MessagesService, ctx.GuildId);
}
else
{
switch (r)
{
case ExecutionFailedResult executionfailed:
{
LogService.LogError(executionfailed.ToString(), LogSource.MessagesService, ctx.GuildId, executionfailed.Exception);
break;
}
case ArgumentParseFailedResult parsefailed:
{
var eb = new LocalEmbedBuilder();
eb.WithAuthor(ctx.User);
eb.WithTitle("ArmgumentParseFailure");
eb.AddField(parsefailed.Reason, parsefailed.RawArguments);
await ctx.Channel.SendMessageAsync(embed : eb.Build());
break;
}
case ArgumentParserResult parseresult:
{
LogService.LogCritical("dunno argumentparse", LogSource.MessagesService, ctx.GuildId);
await ctx.Channel.SendMessageAsync("a error has occoured and not been handled this error will be resolved shortly. (hopefully)");
break;
}
case ChecksFailedResult checksfailed:
{
var eb = new LocalEmbedBuilder();
eb.WithAuthor(ctx.User);
eb.WithTitle($"{checksfailed.FailedChecks.Count} checks have failed");
foreach (var(Check, Result) in checksfailed.FailedChecks)
{
eb.AddField((Check as MummyCheckBase).Name, Result.Reason, true);
}
await ctx.Channel.SendMessageAsync(embed : eb.Build());
break;
}
case CommandDisabledResult disabled:
{
var eb = new LocalEmbedBuilder();
eb.WithAuthor(ctx.User);
await ctx.Channel.SendMessageAsync();
eb.WithTitle($"{disabled.Command} is currently diabled");
await ctx.Channel.SendMessageAsync(embed : eb.Build());
break;
}
case CommandNotFoundResult notfound:
{
var eb = new LocalEmbedBuilder();
eb.WithAuthor(ctx.User);
eb.WithTitle($"command with name {notfound.Reason}");
await ctx.Channel.SendMessageAsync(embed : eb.Build());
break;
}
case CommandOnCooldownResult oncooldown:
{
var eb = new LocalEmbedBuilder();
eb.WithAuthor(ctx.User);
eb.WithTitle($"{oncooldown.Command.Name} is currently on cooldown");
foreach (var(cooldown, retryafter) in oncooldown.Cooldowns)
{
int index = cooldown.ToString().LastIndexOf('.');
var bucketype = (CooldownBucketType)cooldown.BucketType;
eb.AddField(cooldown.ToString().Substring(index + 1), $"is only allowed to be run {cooldown.Amount} per {cooldown.Per.Humanize()} and it forced per {bucketype}, currently locked for {retryafter.TotalMinutes} Minutes", true);
}
await ctx.Channel.SendMessageAsync(embed : eb.Build());
break;
}
case OverloadsFailedResult overloadsFailed:
{
var eb = new LocalEmbedBuilder();
eb.WithAuthor(ctx.User);
eb.WithDescription(overloadsFailed.Reason);
foreach (var(command, overloadResult) in overloadsFailed.FailedOverloads)
{
eb.AddField($"{command.Name} {string.Join(' ', command.Parameters.Select(x => x.Name))}", overloadResult.Reason);
}
await ctx.Channel.SendMessageAsync(embed : eb.Build());
break;
}
case ParameterChecksFailedResult paramcheckfailed:
{
var eb = new LocalEmbedBuilder();
eb.WithAuthor(ctx.User);
eb.WithTitle($"checks on {paramcheckfailed.Parameter} have failed with provided argument: {paramcheckfailed.Argument}");
foreach (var(Check, Result) in paramcheckfailed.FailedChecks)
{
var index = Check.ToString().LastIndexOf('.');
var name = Check.ToString().Substring(index + 1);
eb.AddField(name, Result.Reason);
}
break;
}
case TypeParseFailedResult typeParseFailed:
{
var eb = new LocalEmbedBuilder();
eb.WithAuthor(ctx.User);
eb.AddField(typeParseFailed.Parameter.Name, typeParseFailed.Reason);
await ctx.Channel.SendMessageAsync(embed : eb.Build());
break;
}
}
}
}
catch (Exception ex)
{
LogService.LogError("Issue with message service", LogSource.MessagesService, exception: ex);
}
}
}
public override ValueTask <TypeParserResult <Color> > ParseAsync(Parameter parameter, string value, MummyContext context)
{
if (value.StartsWith("0x", StringComparison.CurrentCultureIgnoreCase) ||
value.StartsWith("&H", StringComparison.CurrentCultureIgnoreCase))
{
value = value.Substring(2);
}
if (value.StartsWith("#", StringComparison.CurrentCultureIgnoreCase))
{
value = value.Substring(1);
}
Color color;
if (int.TryParse(value, NumberStyles.HexNumber, CultureInfo.CurrentCulture, out var hex))
{
color = new Color(hex);
return(TypeParserResult <Color> .Successful(color));
}
else if (IsRGB(value, out (int red, int green, int blue)rgb))
{
color = new Color(rgb.red, rgb.green, rgb.blue);
return(TypeParserResult <Color> .Successful(color));
}
else
{
return(TypeParserResult <Color> .Unsuccessful("Could not parse color"));
}
}
public BurialQuadrantsController(MummyContext context, IWantMyMummyContext con, UserManager <IWantMyMummyUser> tempUser)
{
_context = context;
mummyContext = con;
userManager = tempUser;
}
public Task <bool> JudgeAsync(MummyContext sourceContext, T parameter) => Task.FromResult(true);
