private async Task MessageCreated(MessageCreateEventArgs args)
{
await Task.Yield();
if (args.Channel.IsPrivate)
{
return;
}
var tasks = new List <Task>();
using (var db = new LiteDatabase("Data.db"))
{
var guilds = db.GetCollection <Guild>();
var guild = guilds.FindOne(x => x.Id == args.Guild.Id);
if (guild.HandleUsers)
{
}
if (guild.NightWatchEnabled)
{
tasks.Add(NightWatch.NightWatchMessage(args));
}
}
await Task.WhenAll(tasks);
}
protected string[] GetParameters(DiscordClient sender, MessageCreateEventArgs e)
{
string c = e.Message.Content;
List <string> possibleArgs = new List <string>();
Regex regx = new Regex(@"\b[\w']*\b", RegexOptions.IgnoreCase);
MatchCollection matches = regx.Matches(c);
foreach (var item in matches)
{
if (item.ToString() != "")
{
possibleArgs.Add(item.ToString());
}
}
possibleArgs.RemoveAt(0);
foreach (var item in possibleArgs)
{
Console.WriteLine(item);
}
return(possibleArgs.ToArray());
}
Task NewMessage(DiscordClient discordClient, MessageCreateEventArgs messageCreateArgs)
{
using (var scope = Services.CreateScope())
{
var dbContext = scope.ServiceProvider.GetRequiredService <CoreDatabaseContext>();
if (messageCreateArgs.Guild != null && dbContext.GetGuildFor(messageCreateArgs.Guild.Id) is null)
{
var discordGuild = messageCreateArgs.Guild;
Log.LogInformation("Registering guild: {GuildID}", discordGuild.Id);
dbContext.Add(new Guild(discordGuild.Name, discordGuild.Id.ToString()));
dbContext.SaveChanges();
}
var new_event = new DiscordMessageCreatedEvent(messageCreateArgs, dbContext);
//_commandExecutor.ProcessMessage(new_event);
_eventBus.PostEvent(new_event);
}
return(Task.CompletedTask);
}
public static async Task SendPings(MessageCreateEventArgs e)
{
DiscordChannel channel = await Program.GetDiscordClient.GetChannelAsync(Settings.Default.ping_channel_id).ConfigureAwait(false); //get channel from channel id
if (!string.IsNullOrWhiteSpace(e.Message.Content) && e.Message.ChannelId != Settings.Default.ping_channel_id)
{
string message = e.Message.Content.ToLower(CultureInfo.CreateSpecificCulture("en-GB"));
HashSet <ulong> pinged_users = GetPingedUsers(message);
string mentions = string.Empty;
DiscordMember member;
foreach (ulong user in pinged_users) // loop and get mention strings
{
if (user != e.Message.Author.Id)
{
member = e.Guild.Members.Where(mem => mem.Id.Equals(user)).FirstOrDefault();
if (member != null)
{
mentions += member.Mention + " ";
}
}
}
if (!string.IsNullOrWhiteSpace(mentions))
{
string author_nickname = ((DiscordMember)e.Message.Author).DisplayName;
if (author_nickname == null)
{
author_nickname = e.Message.Author.Username;
}
StringBuilder stringBuilder = new StringBuilder();
stringBuilder.Append(mentions + "at " + e.Message.Channel.Mention + "\n" + "<" + author_nickname + "> " + e.Message.Content);
await Program.GetDiscordClient.SendMessageAsync(channel, stringBuilder.ToString()).ConfigureAwait(false);
}
}
}
private static async Task ClientOnMessageCreated(DiscordClient sender, MessageCreateEventArgs e)
{
await Task.Yield();
var db = new NameBadgeContext();
if (!db.NameBadges.Any(x => x.UserId == e.Author.Id && x.GuildId == e.Guild.Id))
{
return;
}
var badge = db.NameBadges.Single(x => x.UserId == e.Author.Id && x.GuildId == e.Guild.Id);
if (!badge.IsHoisted)
{
await e.Guild.GetRole(badge.RoleId).ModifyAsync(hoist: true);
badge.IsHoisted = true;
}
badge.LastInteraction = DateTime.UtcNow;
await db.SaveChangesAsync();
}
private static void InvokeAnalyzer(MessageCreateEventArgs e, DiscordGuildConfig dgc)
{
try
{
using DBContext c = new DBContext();
string[] lines = e.Message.Content.Split('\n');
string stageLine = lines.FirstOrDefault(l => l.StartsWith("Stage -", StringComparison.CurrentCultureIgnoreCase));
if (!string.IsNullOrEmpty(stageLine))
{
int stageIndex = stageLine.IndexOf("-", StringComparison.CurrentCultureIgnoreCase);
string stage = stageLine.Remove(0, stageIndex + 1).TrimStart(' ').Trim(' ');
string mpLink = lines.FirstOrDefault(l => l.StartsWith("MP link:", StringComparison.CurrentCultureIgnoreCase)).Split(' ')[2].Trim('>').Trim('<');
if (!string.IsNullOrEmpty(mpLink))
{
var history = OsuHistoryEndPoint.GetData.FromUrl(mpLink, null);
var warmupMaps = c.WarmupBeatmaps.Where(wb => wb.DiscordGuildId == dgc.GuildId);
var result = SkyBot.Analyzer.OsuAnalyzer.CreateStatistic(history, e.Guild, (int)(history.CurrentGameId ?? 0), dgc.AnalyzeWarmupMatches, stage, true, beatmapsToIgnore: warmupMaps.Select(wm => wm.BeatmapId).ToArray());
var embed = SkyBot.Analyzer.OsuAnalyzer.GetMatchResultEmbed(result.MatchId);
e.Channel.SendMessageAsync(embed: embed);
}
}
}
catch (Exception ex)
{
Logger.Log(ex, LogLevel.Error);
throw;
}
}
private Task Client_CommandHandler(DiscordClient client, MessageCreateEventArgs e)
{
var cmdPrefix = "";
using (var fs = File.OpenRead("config.json"))
using (var sr = new StreamReader(fs, new UTF8Encoding(false)))
cmdPrefix = JsonConvert.DeserializeObject <ConfigJson>(sr.ReadToEnd()).CommandPrefix;
var cnext = client.GetCommandsNext();
var msg = e.Message;
var cmdStart = msg.GetStringPrefixLength(cmdPrefix);
if (cmdStart == -1)
{
return(Task.CompletedTask);
}
var prefix = msg.Content.Substring(0, cmdStart);
var cmdString = msg.Content.Substring(cmdStart);
var command = cnext.FindCommand(cmdString, out var args);
if (command == null)
{
return(Task.CompletedTask);
}
var ctx = cnext.CreateContext(msg, prefix, command, args);
Task.Run(async() => await cnext.ExecuteCommandAsync(ctx));
Console.WriteLine($"{BotEventId}, {e.Author.Username} successfully executed '{e.Message.Content}'");
return(Task.CompletedTask);
}
private static Task OnDiscordClientOnMessageCreatedAsync(MessageCreateEventArgs e)
{
switch (e.Channel.Type)
{
case ChannelType.Private:
{
var message = MessageLog(e, "DM"); // If channel is private then make the message type DM
File.AppendAllText(Path, message); // writes the message to the file
} break;
case ChannelType.Text:
{
var message = MessageLog(e, $"{e.Guild.Name}"); // if channel is Text(Normal Channel) print the channel name
File.AppendAllText(Path, message); // writes the message to the file
} break;
default:
{
var message = MessageLog(e, $"{e.Channel.Type}"); // if channel is not private or text just print the channel type
File.AppendAllText(Path, message); // writes the message to the file
} break;
}
return(Task.CompletedTask);
}
private async Task <bool> ScanForUrlShortenersAsync(MessageCreateEventArgs e)
{
var match = LinkfilterMatcherCollection.UrlShortenerRegex.Check(e.Message);
if (!match.Success)
{
return(false);
}
try {
await e.Message.DeleteAsync("_gf: URL shortener linkfilter");
await this.LogLinkfilterMatchAsync(e, "URL shortener website matched");
await(e.Author as DiscordMember).SendMessageAsync(
$"Your message:\n{Formatter.BlockCode(e.Message.Content)}was automatically removed from " +
$"{Formatter.Bold(e.Guild.Name)} because it is suspected to contain a link to a link shortener website: {Formatter.InlineCode(match.Matched)} (possible origin: {LinkfilterMatcherCollection.UrlShorteners[match.Matched]})" +
$"If you think this is a false detection, please report."
);
} catch (UnauthorizedException) {
}
return(true);
}
public static async Task DiscordClient_MessageCreated(MessageCreateEventArgs e)
{
if (!await e.Author.GetDelayDeletingAsync())
{
return;
}
MatchCollection matches = Regex.Matches(e.Message.Content, DelayDeleteRegex);
if (matches.Count == 1)
{
if (int.TryParse(matches[0].Value.Substring(1), out int seconds))
{
if (!e.Channel.PermissionsFor(await e.Guild.GetMemberAsync(e.Client.CurrentUser.Id)).HasFlag(Permissions.ManageMessages))
{
await e.Message.CreateReactionAsync(DiscordEmoji.FromName(e.Client, ":no_entry_sign:"));
return;
}
await e.Message.CreateReactionAsync(DiscordEmoji.FromName(e.Client, ":wastebasket:"));
await Task.Delay(seconds * 1000);
await e.Message.DeleteAsync();
}
else
{
await e.Message.CreateReactionAsync(DiscordEmoji.FromName(e.Client, ":x:"));
}
}
else if (matches.Count > 1)
{
await e.Message.CreateReactionAsync(DiscordEmoji.FromName(e.Client, ":question:"));
}
}
public static async Task MessageFilterEventHandlerAsync(KioskAppShard shard, MessageCreateEventArgs e)
{
if (e.Author.IsBot || e.Channel.IsPrivate || string.IsNullOrWhiteSpace(e.Message?.Content))
{
return;
}
if (shard.SharedData.BlockedChannels.Contains(e.Channel.Id))
{
return;
}
CachedGuildConfig gcfg = shard.SharedData.GetGuildConfig(e.Guild.Id);
if (gcfg.LinkfilterSettings.Enabled)
{
if (await shard.CNext.Services.GetService <LinkfilterService>().HandleNewMessageAsync(e, gcfg.LinkfilterSettings))
{
return;
}
}
if (!shard.SharedData.MessageContainsFilter(e.Guild.Id, e.Message.Content))
{
return;
}
if (!e.Channel.PermissionsFor(e.Guild.CurrentMember).HasFlag(Permissions.ManageMessages))
{
return;
}
await e.Message.DeleteAsync("_gf: Filter hit");
await e.Channel.SendMessageAsync($"{e.Author.Mention} said: {FormatterExtensions.Spoiler(Formatter.BlockCode(Formatter.Strip(e.Message.Content)))}");
}
public static async Task OnMessageCreated(DiscordClient _, MessageCreateEventArgs args)
{
if (DefaultHandlerFilter.IsFluff(args.Message))
{
return;
}
/*
* (╯°□°）╯︵ ┻━┻
* (ノ ゜Д゜)ノ ︵ ┻━┻
* (ノಠ益ಠ)ノ彡┻━┻
* (ﾉಥ益ಥ）ﾉ ┻━┻
* (ﾉಥДಥ)ﾉ︵┻━┻･/
* (ノ^_^)ノ┻━┻
* (/¯◡ ‿ ◡)/¯ ~ ┻━┻
*
* this might look the same, but only because of the font choice
*
* ┻━┻
* ┻━┻
*/
try
{
var content = args.Message.Content;
if (!(content.Contains("┻━┻") ||
content.Contains("┻━┻")))
{
return;
}
var tableIdx = content.IndexOf("┻━┻");
if (tableIdx < 0)
{
tableIdx = content.IndexOf("┻━┻");
}
var faceIdx = content[..tableIdx].LastIndexOfAny(OpenParen);
private async Task EditCommand(MessageCreateEventArgs e, ParsedCommand cmd)
{
if (cmd.CommandParts.Length == 1)
{
await SendError(e, "What do you want me to edit?");
return;
}
try
{
OperationParameters opParams = OperationParameters.Parse(cmd.CommandParts);
bool success = await _ops.UpdateOperation(cmd.OperationId, opParams);
if (!success)
{
await SendOperationErrorMessage(e, cmd.OperationId);
}
}
catch (OpBotInvalidValueException ex)
{
await SendError(e, $"That is an invalid edit command\n\n.{ex.Message}");
}
}
private async Task ClientOnMessageCreated(MessageCreateEventArgs e)
{
if (e.Author.IsBot)
{
return;
}
if (UsersEco.Users.Exists(u => u.Id == e.Author.Id))
{
var user = UsersEco.Users.Find(u => u.Id == e.Author.Id);
if (user.Time > DateTime.Now)
{
return;
}
AddCookieToUser(e.Author);
}
else
{
AddCookieToUser(e.Author);
}
await SaveEcoModule();
}
private async Task CreateCommand(MessageCreateEventArgs e, ParsedCommand cmd)
{
try
{
OperationParameters opParams = OperationParameters.ParseWithDefault(cmd.CommandParts);
Operation newOperation = new Operation()
{
Size = opParams.Size,
Mode = opParams.Mode,
Date = DateHelper.GetDateForNextOccuranceOfDay(opParams.Day) + opParams.Time,
Side = opParams.Side,
};
newOperation.OperationName = opParams.OperationCode == "GF" ? GroupFinder.OperationOn(newOperation.Date) : opParams.OperationCode;
DiscordMessage newOpMessage = await e.Channel.SendMessageAsync("Creating event...");
newOperation.MessageId = newOpMessage.Id;
string text = _ops.Add(newOperation).GetOperationMessageText();
await newOpMessage.ModifyAsync(text);
await PinMessage(e, newOpMessage);
await _repository.SaveAsync(_ops);
SendAlerts(e, newOperation);
}
catch (OperationException ex)
{
await SendError(e, ex.Message);
}
catch (OpBotInvalidValueException opEx)
{
await SendError(e, $"I don't understand part of that create command.\n\n{opEx.Message}\n\nSo meat bag, try again and get it right this time or you will be terminated as an undesirable {DiscordText.StuckOutTongue}.");
}
}
public CompactResponse(ServerContext context, GuildSettings settings, MessageCreateEventArgs e) : base(context, settings, e)
{
}
public MessageResponse(ServerContext context, GuildSettings settings, MessageCreateEventArgs e) : base(context, settings)
{
source = e.Message;
response = null;
}
public static async Task OnMessageCreated(MessageCreateEventArgs args)
{
if (args.Author.IsBot)
{
return;
}
if (string.IsNullOrEmpty(args.Message.Content) || args.Message.Content.StartsWith(Config.CommandPrefix))
{
return;
}
var lastBotMessages = await args.Channel.GetMessagesBeforeAsync(args.Message.Id, 20, DateTime.UtcNow.AddSeconds(-30)).ConfigureAwait(false);
foreach (var msg in lastBotMessages)
{
if (BotShutupHandler.NeedToSilence(msg))
{
return;
}
}
lastBotMessages = await args.Channel.GetMessagesBeforeAsync(args.Message.Id, Config.ProductCodeLookupHistoryThrottle).ConfigureAwait(false);
StringBuilder previousRepliesBuilder = null;
foreach (var msg in lastBotMessages)
{
if (msg.Author.IsCurrent)
{
previousRepliesBuilder = previousRepliesBuilder ?? new StringBuilder();
previousRepliesBuilder.AppendLine(msg.Content);
var embeds = msg.Embeds;
if (embeds?.Count > 0)
{
foreach (var embed in embeds)
{
previousRepliesBuilder.AppendLine(embed.Title).AppendLine(embed.Description);
}
}
}
}
var previousReplies = previousRepliesBuilder?.ToString() ?? "";
var codesToLookup = GetProductIds(args.Message.Content)
.Where(c => !previousReplies.Contains(c, StringComparison.InvariantCultureIgnoreCase))
.Take(args.Channel.IsPrivate ? 50 : 5)
.ToList();
if (codesToLookup.Count == 0)
{
return;
}
await args.Channel.TriggerTypingAsync().ConfigureAwait(false);
var results = new List <(string code, Task <DiscordEmbed> task)>(codesToLookup.Count);
foreach (var code in codesToLookup)
{
results.Add((code, args.Client.LookupGameInfoAsync(code)));
}
var formattedResults = new List <DiscordEmbed>(results.Count);
foreach (var result in results)
{
try
{
formattedResults.Add(await result.task.ConfigureAwait(false));
}
catch (Exception e)
{
Config.Log.Warn(e, $"Couldn't get product code info for {result.code}");
}
}
// get only results with unique titles
formattedResults = formattedResults.GroupBy(e => e.Title).Select(g => g.First()).ToList();
DiscordEmoji sqvat = null;
foreach (var result in formattedResults)
{
try
{
if (!args.Channel.IsPrivate &&
args.Message.Author.Id == 197163728867688448 && (
result.Title.Contains("africa", StringComparison.InvariantCultureIgnoreCase) ||
result.Title.Contains("afrika", StringComparison.InvariantCultureIgnoreCase)
))
{
sqvat = sqvat ?? DiscordEmoji.FromName(args.Client, ":sqvat:");
await args.Message.ReactWithAsync(args.Client, sqvat, "How about no (๑•ิཬ•ั๑)").ConfigureAwait(false);
continue;
}
await args.Channel.SendMessageAsync(embed : result).ConfigureAwait(false);
}
catch (Exception e)
{
Config.Log.Warn(e, $"Couldn't post result for {result.Title}");
}
}
}
public static async Task OnMessageCreated(DiscordClient c, MessageCreateEventArgs args)
{
if (DefaultHandlerFilter.IsFluff(args?.Message))
{
return;
}
#if !DEBUG
if (!(args.Channel.Id == Config.BotGeneralChannelId ||
args.Channel.Name.Equals("help", StringComparison.InvariantCultureIgnoreCase)))
{
return;
}
if (CooldownBuckets.TryGetValue(args.Channel.Id, out var lastCheck) &&
DateTime.UtcNow - lastCheck < CooldownThreshold)
{
return;
}
if (args.Author.IsSmartlisted(c, args.Guild))
{
return;
}
#endif
var matches = GameNameStatusMention1.Matches(args.Message.Content);
if (!matches.Any())
{
return;
}
var gameTitle = matches.Select(m => m.Groups["game_title_1"].Value)
.Concat(matches.Select(m => m.Groups["game_title_2"].Value))
.Concat(matches.Select(m => m.Groups["game_title_3"].Value))
.FirstOrDefault(t => !string.IsNullOrEmpty(t));
if (string.IsNullOrEmpty(gameTitle) || gameTitle.Length < 2)
{
return;
}
gameTitle = CompatList.FixGameTitleSearch(gameTitle);
if (gameTitle.Length < 4)
{
return;
}
if (ProductCodeLookup.ProductCode.IsMatch(args.Message.Content))
{
return;
}
var(_, info) = await LookupGameAsync(args.Channel, args.Message, gameTitle).ConfigureAwait(false);
if (string.IsNullOrEmpty(info?.Status))
{
return;
}
gameTitle = info.Title?.StripMarks();
if (string.IsNullOrEmpty(gameTitle))
{
return;
}
var botSpamChannel = await c.GetChannelAsync(Config.BotSpamId).ConfigureAwait(false);
var status = info.Status.ToLowerInvariant();
string msg;
if (status == "unknown")
{
msg = $"{args.Message.Author.Mention} {gameTitle} status is {status}";
}
else
{
if (status != "playable")
{
status += " (not playable)";
}
msg = $"{args.Message.Author.Mention} {gameTitle} is {status}";
if (!string.IsNullOrEmpty(info.Date))
{
msg += $" since {info.ToUpdated()}";
}
}
msg += $"\nfor more results please use compatibility list (<https://rpcs3.net/compatibility>) or `{Config.CommandPrefix}c` command in {botSpamChannel.Mention} (`!c {gameTitle.Sanitize()}`)";
await args.Channel.SendMessageAsync(msg).ConfigureAwait(false);
CooldownBuckets[args.Channel.Id] = DateTime.UtcNow;
}
public override bool CanExecute(MessageCreateEventArgs e)
{
return(!(e.Channel is DiscordDmChannel));
}
public static async Task GrimToolsCalcHandler(MessageCreateEventArgs e)
{
if (e.Author.IsBot)
{
return;
}
var match = new Regex(@"(?<=(http://)?(www.)?grimtools.com/calc/)[a-zA-Z0-9]{8}(?!>)").Match(e.Message.Content);
if (!match.Success)
{
return;
}
var url = $"http://www.grimtools.com/calc/{match.Value}";
var calc = await GrimToolsCalc.GetGrimToolsCalcAsync(url);
var masteryCombo = calc.GetMasteryCombination();
var embed = new DiscordEmbedBuilder
{
Url = url,
ThumbnailUrl = masteryCombo.GetAttribute <MasteryInfoAttribute>().ImageUrl,
Title = $"Level {calc.Data.Info.Level} " +
$"{Regex.Replace(masteryCombo.ToString(), @"(\B[A-Z])", " $1")}",
Description = $"`Physique` {((calc.Data.Info.Physique - 50) / 8).ToString()}\n" +
$"`Cunning` {((calc.Data.Info.Cunning - 50) / 8).ToString()}\n" +
$"`Spirit` {((calc.Data.Info.Spirit - 50) / 8).ToString()}"
};
foreach (var mastery in calc.Data.Masteries.OrderByDescending(m => m.Value))
{
embed.AddField(mastery.Key.ToString(), mastery.Value.ToString(), true);
}
var sb = new StringBuilder();
var sortedSkills = calc.Data.Skills.OrderByDescending(s => s.Value).ToList();
for (int i = 0; i < 10 && i < sortedSkills.Count; i++)
{
try
{
var skillEmoji = EnumExtensions.GetValueFromDescription <SkillEmoji>(sortedSkills[i].Key);
sb.Append(DiscordEmoji.FromGuildEmote(Program.Client, (ulong)skillEmoji).ToString());
}
catch (ArgumentException)
{
sortedSkills.RemoveAt(i);
i--;
}
}
if (sb.Length > 0)
{
embed.AddField("Top Skill(s)", sb.ToString());
}
embed.WithFooter($"Game version: {calc.GameVersion}");
embed.WithColor(new DiscordColor(masteryCombo.GetAttribute <MasteryInfoAttribute>().Color));
await e.Message.RespondAsync("", false, embed.Build());
}
public static async Task OnMessage(MessageCreateEventArgs e)
{
await Task.FromResult(0); // Пока типа пусто
}
public abstract Task OnAccepted(MessageCreateEventArgs e);
public abstract Task <bool> IsAccepted(MessageCreateEventArgs e);
public override async Task <bool> IsAccepted(MessageCreateEventArgs e)
{
return(e.Message.Content.ToLower().StartsWith(prefix));
}
public MessageValueProvider(object value)
{
this.value = value as MessageCreateEventArgs;
}
private async Task <Task> Client_MessageCreatedAsync(MessageCreateEventArgs e)
{
return(await AsyncMessageEvent(e));
}
public async Task HandleMessageAsync(DiscordClient client, MessageCreateEventArgs args)
{
try
{
if (args.Message.Author.Username == _configuration.BotUsername || args.Message.Content.StartsWith(_configuration.CommandPrefix))
{
return;
}
//Analize all the possible emojis in the message
foreach (Match match in _regex.Matches(args.Message.Content))
{
//The emojis have the format <:emoji_name:emoji_id>, so I strip the emoji_name
string[] parts = match.Value.Split(':');
string emoji = $":{parts[1]}:";
try
{
var emojiObj = DiscordEmoji.FromName(client, emoji);
}
catch (ArgumentException)
{
_logger.LogInformation($"{args.Message.Author.Username} wrote an emoji not present on this server: {emoji}. Ignoring...");
continue;
}
_logger.LogInformation($"{args.Message.Author.Username} wrote {emoji}");
//Add all the possible emojis to the database
await _database.InsertEmojiAsync(new LogEmoji
{
EmojiId = emoji,
Username = args.Message.Author.Username,
MessageTimestamp = TimeZoneInfo.ConvertTimeFromUtc(args.Message.Timestamp.UtcDateTime, TZConvert.GetTimeZoneInfo("Romance Standard Time")),
IsReaction = false
});
}
string message = args.Message.Content.Replace("?", "").Replace("!", "").Replace(".", "").Replace("¡", "").Replace("¿", "").Replace("\"", "").Replace("'", "").Replace(")", "").TrimEnd().ToLowerInvariant();
if (message.EndsWith("gado") && !message.EndsWith("colgado"))
{
await args.Message.RespondAsync($"{args.Message.Author.Mention} el que tengo aquí colgado");
}
else if (message.EndsWith("gada") && !message.EndsWith("colgada"))
{
await args.Message.RespondAsync($"{args.Message.Author.Mention} la que tengo aquí colgada");
}
else if (message.EndsWith("gados") && !message.EndsWith("colgados"))
{
await args.Message.RespondAsync($"{args.Message.Author.Mention} los que tengo aquí colgados");
}
else if (message.EndsWith("gadas") && !message.EndsWith("colgadas"))
{
await args.Message.RespondAsync($"{args.Message.Author.Mention} las que tengo aquí colgadas");
}
else if (message.EndsWith(" concurso"))
{
await args.Message.RespondAsync($"{args.Message.Author.Mention} el de levantar mi polla a pulso");
}
double randomValue = _random.NextDouble();
if (randomValue < 0.00001)
{
var messageObj = await args.Message.RespondAsync($"{args.Message.Author.Mention} hijo de puta");
await Task.Delay(1000);
await messageObj.ModifyAsync($"{args.Message.Author.Mention} ~~hijo de puta~~ perdón");
}
}
catch (Exception e)
{
await args.Message.RespondAsync(e.Message);
}
}
public static async Task onMsgCreated(MessageCreateEventArgs args)
{
if (!autoEmbedderEnabled)
{
return;
}
if (args.Author != MainWindow.userClient.CurrentUser)
{
return;
}
DiscordMessage msg = args.Message;
if (msg.Content == null)
{
return;
}
if (msg.Content.Length < 1)
{
return;
}
DiscordEmbedBuilder embedBuilder = new DiscordEmbedBuilder();
embedBuilder.Title = $"Сообщение в {DateTime.Now.ToString()} от {(msg.Channel.IsPrivate ? msg.Author.Username : (((DiscordMember)msg.Author).Nickname!=null ? ((DiscordMember)msg.Author).Nickname : msg.Author.Username))}";
embedBuilder.Description = msg.Content;
if (msg.Attachments != null && msg.Attachments.Count > 0)
{
DiscordAttachment img = msg.Attachments[0];
if (img.FileName.EndsWith(".jpg", true, CultureInfo.InvariantCulture) ||
img.FileName.EndsWith(".png", true, CultureInfo.InvariantCulture) ||
img.FileName.EndsWith(".bmp", true, CultureInfo.InvariantCulture))
{
string url = img.Url;
embedBuilder.ImageUrl = url;
}
else
{
string url = img.Url;
embedBuilder.Url = url;
}
}
Random random = new Random();
DiscordColor randColor;
switch (random.Next(0, 7))
{
case 0: randColor = DiscordColor.Red; break;
case 1: randColor = DiscordColor.Green; break;
case 2: randColor = DiscordColor.Blue; break;
case 3: randColor = DiscordColor.Yellow; break;
case 4: randColor = DiscordColor.Cyan; break;
case 5: randColor = DiscordColor.Violet; break;
case 6: randColor = DiscordColor.Azure; break;
case 7: randColor = DiscordColor.Blurple; break;
default: randColor = new DiscordColor(); break;
}
embedBuilder.Color = randColor;
embedBuilder.ThumbnailUrl = msg.Author.AvatarUrl;
if (autoEmbedderMode == 0)
{
await msg.ModifyAsync(content : "", embed : embedBuilder.Build());
}
else
{
await msg.Channel.SendMessageAsync(embed : embedBuilder.Build());
await msg.Channel.DeleteMessageAsync(msg);
}
}
public async Task <bool> HasRequiredPropertyAsync(MessageCreateEventArgs e, List <string> propertyMatches)
{
var userData = await GetUserData(e.Author.Username);
return(propertyMatches.All(rp => userData.derivedProperties.Any(dp => dp.name == rp)));
}
private void PushConnectOnMessageCreating(object aSender, MessageCreateEventArgs anArgs)
{
var lDevice = anArgs.Device as WindowsPhonePushDeviceInfo;
if (lDevice != null)
{
var lMessage = new MPNSToastMessage();
lMessage.Text1 = anArgs.MessageData.Title;
lMessage.Text2 = anArgs.MessageData.Text;
lMessage.NotificationURI = lDevice.NotificationURI.ToString();
anArgs.Message = lMessage;
}
}