public static async Task AcceptRules(object Client, GuildMemberUpdateEventArgs e)
{
_ = Task.Run(async() =>
{
if (e.PendingBefore.Value && !e.PendingAfter.Value)
{
var WelcomeSettings = DB.DBLists.ServerWelcomeSettings.FirstOrDefault(w => w.Server_ID == e.Guild.Id);
var JoinRole = (from rr in DB.DBLists.RankRoles
where rr.Server_ID == e.Guild.Id
where rr.Server_Rank == 0
select rr).FirstOrDefault();
if (WelcomeSettings.Channel_ID != 0 && WelcomeSettings.HasScreening)
{
DiscordChannel WelcomeChannel = e.Guild.GetChannel(Convert.ToUInt64(WelcomeSettings.Channel_ID));
if (WelcomeSettings.Welcome_Message != null)
{
string msg = WelcomeSettings.Welcome_Message;
msg = msg.Replace("$Mention", $"{e.Member.Mention}");
await WelcomeChannel.SendMessageAsync(msg);
if (JoinRole != null)
{
DiscordRole role = e.Guild.GetRole(Convert.ToUInt64(JoinRole.Role_ID));
await e.Member.GrantRoleAsync(role);
}
}
}
}
});
await Task.Delay(1);
}
private async Task OnGuildMemberUpdated(GuildMemberUpdateEventArgs e)
{
if (GuildMemberUpdated != null)
{
await GuildMemberUpdated(e);
}
}
private static async Task DiscordOnGuildMemberUpdated(GuildMemberUpdateEventArgs e)
{
try
{
var col = db.GetCollection <LockedDiscordUser>("LockedDiscordUsers");
if (col.Exists(q => q.UserId == e.Member.Id))
{
try
{
var thing = col.FindOne(q => q.guildID == e.Guild.Id && q.UserId == e.Member.Id);
if (thing.nickToLockTo != e.NicknameAfter)
{
await e.Member.ModifyAsync(x => x.Nickname = thing.nickToLockTo);
}
}
catch (Exception b)
{
_logger.Error(b);
}
}
}
catch (Exception j)
{
_logger.Error(j);
}
}
private async Task Client_GuildMemberUpdated(GuildMemberUpdateEventArgs e)
{
var bot = await e.Guild.GetMemberAsync(258902871720984577);
var channel = e.Guild.Channels.FirstOrDefault(c => c.PermissionsFor(bot).ToPermissionString().Contains("Send message") == true);
if (e.NicknameAfter == null && e.NicknameBefore == null || e.NicknameBefore == e.NicknameAfter)
{
if (e.RolesAfter.Count > e.RolesBefore.Count)
{
foreach (var role in e.RolesAfter)
{
if (!e.RolesBefore.Contains(role))
{
await channel.SendMessageAsync($"User `{ e.Member.Username }` has been assigned a role, `{ role.Name }`.");
}
}
}
else
{
foreach (var role in e.RolesBefore)
{
if (!e.RolesAfter.Contains(role))
{
await channel.SendMessageAsync($"User `{ e.Member.Username }` has been removed a role, `{ role.Name }`.");
}
}
}
}
else
{
await channel.SendMessageAsync($"User `{ e.Member.Username }` changed his nickname, from `{ e.NicknameBefore ?? e.Member.Username }` to `{ e.NicknameAfter ?? e.Member.Username }`");
}
}
public DiscordEvent(GuildMemberUpdateEventArgs e)
{
Guild = e.Guild;
HasUser = true;
User = e.User;
}
public static async Task OnMemberUpdated(GuildMemberUpdateEventArgs args)
{
if (args.NicknameBefore == args.NicknameAfter)
{
return;
}
var potentialTargets = GetPotentialVictims(args.Client, args.Member, false, true);
if (!potentialTargets.Any())
{
return;
}
if (await IsFlashmobAsync(args.Client, potentialTargets).ConfigureAwait(false))
{
return;
}
await args.Client.ReportAsync("🕵️ Potential user impersonation",
$"Member {args.Member.GetMentionWithNickname()} has changed their __display name__ from " +
$"**{(args.NicknameBefore ?? args.Member.Username).Sanitize()}** to " +
$"**{args.Member.DisplayName.Sanitize()}**",
potentialTargets,
ReportSeverity.Medium);
}
public static async Task MemberUpdated(ModCoreShard bot, GuildMemberUpdateEventArgs e)
{
var db = bot.SharedData.ModCore.CreateGlobalContext();
var gst = e.Guild.GetGuildSettings(db);
if (gst == null)
{
return;
}
if (gst.LogUpdates)
{
var log = e.Guild.GetChannel(gst.UpdateChannel);
var embed = new DiscordEmbedBuilder()
.WithTitle("Member Updated:")
.WithDescription($"{e.Member.Username}#{e.Member.Discriminator}");
// TODO ModCore color scheme
embed.WithColor(new DiscordColor("#089FDF"));
embed.WithThumbnail(e.Member.AvatarUrl);
if (e.NicknameAfter != e.NicknameBefore)
{
var after = e.Member.Username;
var before = e.Member.Username;
if (!string.IsNullOrEmpty(e.NicknameAfter))
{
after = e.NicknameAfter;
}
if (!string.IsNullOrEmpty(e.NicknameBefore))
{
before = e.NicknameBefore;
}
embed.AddField("Nickname update", $"{before} to {after}");
}
if (e.RolesAfter != e.RolesBefore)
{
var added = e.RolesAfter.Where(x => !e.RolesBefore.Contains(x));
var removed = e.RolesBefore.Where(x => !e.RolesAfter.Contains(x));
if (added.Count() > 0)
{
embed.AddField("Added roles", string.Join(", ", added.Select(x => x.Name)));
}
if (removed.Count() > 0)
{
embed.AddField("Removed roles", string.Join(", ", removed.Select(x => x.Name)));
}
}
await log.SendMessageAsync(embed : embed);
}
}
private async Task ClientGuildMemberUpdated(GuildMemberUpdateEventArgs e)
{
if (e.Member.Id == 450771319479599114)
{
await(await e.Guild.GetMemberAsync(450771319479599114)).ModifyAsync(
nickname: "Sabrina");
}
}
public async ValueTask OnGuildMemberUpdate(GuildMemberUpdateEventArgs packet)
{
var updatedPacket = await UpdateGuildMemberCacheAsync(packet);
var member = new DiscordGuildUser(updatedPacket, Client);
await EventHandler.OnGuildMemberUpdate(member);
}
internal static Task MemberUpdated(DiscordClient _1, GuildMemberUpdateEventArgs e)
{
_ = Task.Run(async() =>
{
if (e.Guild.Id != 699555747591094344)
{
return;
}
DiscordEmbedBuilder embed = new DiscordEmbedBuilder()
.WithTimestamp(DateTime.Now);
if (e.NicknameAfter != e.NicknameBefore)
{
embed.WithDescription($":information_source: {e.Member.Mention} ({e.Member.Id}) changed their nickname:")
.WithThumbnail(e.Member.AvatarUrl)
.AddField("Before", e.NicknameBefore is null ? e.Member.Username : e.NicknameBefore, true)
.AddField("After", e.NicknameAfter is null ? e.Member.Username : e.NicknameAfter, true)
.WithColor(DiscordColor.Blurple);
}
else if (e.RolesAfter.Count > e.RolesBefore.Count)
{
string description = $"<:add:930501217187156018> {e.Member.Mention} ({e.Member.Id}) was granted additional roles:";
foreach (var item in e.RolesAfter)
{
if (!e.RolesBefore.Contains(item))
{
description += Environment.NewLine + item.Mention;
}
}
embed.WithDescription(description)
.WithThumbnail(e.Member.AvatarUrl)
.WithColor(DiscordColor.Green);
}
else if (e.RolesAfter.Count < e.RolesBefore.Count)
{
string description = $"<:remove:930501216889360425> {e.Member.Mention} ({e.Member.Id}) was revoked some roles:";
foreach (var item in e.RolesBefore)
{
if (!e.RolesAfter.Contains(item))
{
description += Environment.NewLine + item.Name;
}
}
embed.WithDescription(description)
.WithThumbnail(e.Member.AvatarUrl)
.WithColor(DiscordColor.Red);
}
if (!(embed.Description is null))
{
await DiscordObjectService.Instance.LogsChannel.SendMessageAsync(new DiscordMessageBuilder().WithEmbed(embed).WithAllowedMentions(Mentions.None));
}
});
return(Task.CompletedTask);
}
Task GuildMemberUpdated(GuildMemberUpdateEventArgs args)
{
var players = Games.Values.SelectMany(_ => _.InitialPlayers.Where(_ => _.Id == args.Member.Id));
foreach (var player in players)
{
player.Nickname = args.NicknameAfter;
}
return(Task.CompletedTask);
}
public static async Task OnMemberUpdate(GuildMemberUpdateEventArgs e)
{
if (Game.Players.ContainsKey(e.Member) && !Game.PlayersToKick.Contains(e.Member))
{
if (e.RolesAfter.ToList().Contains(Config.RoleBad))
{
await Game.AddToPlayersToKick(e.Member);
}
}
await Task.FromResult(0); // Пока типа пусто
}
private DiscordChannel GetChannelToPostNotificationIn(GuildMemberUpdateEventArgs e, DiscordMember bot)
{
var channel = e.Guild.Channels.FirstOrDefault(xc => xc.Name.ToLower().Contains("bot") || xc.Name.ToLower().Contains("test"));
if (channel == null)
{
channel = e.Guild.Channels.FirstOrDefault(xc => xc.PermissionsFor(bot).ToPermissionString().Contains("Send message") == true);
}
return(channel);
}
private async Task OnGuildMemberUpdate(GuildMemberUpdateEventArgs updateEventArgs)
{
var member = await cacheHandler.Members.GetAsync(
updateEventArgs.GuildId, updateEventArgs.User.Id)
?? new DiscordGuildMemberPacket();
member.User = updateEventArgs.User;
member.Roles = updateEventArgs.RoleIds.ToList();
member.Nickname = updateEventArgs.Nickname;
await cacheHandler.Members.EditAsync(member);
}
/// <summary>
/// Fired when a guild member is updated.
/// </summary>
/// <param name="sender">The discord client.</param>
/// <param name="args">The event args.</param>
public static async Task OnUpdateAsync(DiscordClient sender, GuildMemberUpdateEventArgs args)
{
if (args.PendingBefore.HasValue && args.PendingBefore == true)
{
if (args.PendingAfter.HasValue && args.PendingAfter == false)
{
ulong member_role_id = 483280207927574528;
var member_role = args.Guild.GetRole(member_role_id);
await args.Member.GrantRoleAsync(member_role);
}
}
await Task.FromResult(true);
}
private async Task GuildMemberUpdated(DiscordClient c, GuildMemberUpdateEventArgs e)
{
Task.Run(async() =>
{
var before = string.IsNullOrWhiteSpace(e.NicknameBefore) ? e.Member.Username : e.NicknameBefore;
var after = string.IsNullOrWhiteSpace(e.NicknameAfter) ? e.Member.Username : e.NicknameAfter;
if (before != after)
{
await logService.GuildLogger(c, e.Guild, e, LogType.Nickname).ConfigureAwait(true);
this.logger.Information($"'{e.Member.GetUsertag()}' ({e.Member.Id}) has changed there nickname from '{before}' to '{after}' on '{e.Guild.Name}' ({e.Guild.Id}).");
}
});
}
private async Task MemberUpdated_Handler(GuildMemberUpdateEventArgs e)
{
bool isDead = e.RolesAfter.Any(r => r.Name == "Dead" && !e.RolesBefore.Any(b => r.Name == b.Name));
if (isDead)
{
await e.Member.SetMuteAsync(true);
e.Client.DebugLogger.LogMessage(LogLevel.Info, "SinestroBot", e.Member.Username, DateTime.Now);
}
else if (!e.RolesAfter.Any(r => r.Name == "Dead"))
{
await e.Member.SetMuteAsync(false);
}
}
private async Task OnGuildMemberUpdate(GuildMemberUpdateEventArgs arg)
{
try
{
DiscordGuildPacket guild = await _discordClient.GetGuildAsync(arg.GuildId);
if (guild.Members == null)
{
guild.Members = new List <DiscordGuildMemberPacket>();
}
int index = guild.Members.FindIndex(x => x.UserId == arg.User.Id);
DiscordGuildMemberPacket packet;
if (index == -1)
{
packet = new DiscordGuildMemberPacket
{
User = arg.User,
Roles = arg.RoleIds.ToList(),
Nickname = arg.Nickname,
UserId = arg.User.Id,
GuildId = arg.GuildId,
};
guild.Members.Add(packet);
}
else
{
guild.Members[index].Nickname = arg.Nickname;
guild.Members[index].Roles = arg.RoleIds.ToList();
guild.Members[index].User = arg.User;
packet = guild.Members[index];
}
var cache = _cacheClient.Get;
await cache.UpsertAsync($"discord:guild:{arg.GuildId}:user:{arg.User.Id}", packet);
await cache.UpsertAsync($"discord:guild:{arg.GuildId}", guild);
}
catch (Exception e)
{
Log.Trace(e.ToString());
}
}
/// <summary>
/// Call when a Discord Client gets updated. Used to combat nickname-rename shenanigans by Obe
/// </summary>
/// <param name="e">The Event Args.</param>
/// <returns>The <see cref="Task"/>.</returns>
private async Task ClientGuildMemberUpdated(GuildMemberUpdateEventArgs e)
{
if (e.Guild.Permissions == null || !e.Guild.Permissions.Value.HasFlag(Permissions.ManageNicknames))
{
return;
}
if (e.Member.Id == 450771319479599114)
{
await(await e.Guild.GetMemberAsync(450771319479599114)).ModifyAsync(e => e.Nickname = "Sabrina");
}
if (e.Member.Id == 249216025931939841)
{
await(await e.Guild.GetMemberAsync(249216025931939841)).ModifyAsync(e => e.Nickname = "Salem");
}
}
public static async Task OnMemberUpdate(ModCoreShard shard, GuildMemberUpdateEventArgs ea)
{
using (var db = shard.Database.CreateContext())
{
var cfg = ea.Guild.GetGuildSettings(db);
if (cfg == null || !cfg.RoleState.Enable)
{
return;
}
var rs = cfg.RoleState;
var gld = ea.Guild;
var roleids = db.RolestateRoles.SingleOrDefault(xs => xs.GuildId == (long)ea.Guild.Id && xs.MemberId == (long)ea.Member.Id);
if (roleids == null)
{
roleids = new DatabaseRolestateRoles
{
GuildId = (long)ea.Guild.Id,
MemberId = (long)ea.Member.Id
};
}
roleids.RoleIds = ea.RolesAfter
.Select(xr => xr.Id)
.Except(rs.IgnoredRoleIds)
.Select(xid => (long)xid)
.ToArray();
db.RolestateRoles.Update(roleids);
var nick = db.RolestateNicks.SingleOrDefault(xs => xs.GuildId == (long)ea.Guild.Id && xs.MemberId == (long)ea.Member.Id);
if (nick == null)
{
nick = new DatabaseRolestateNick
{
GuildId = (long)ea.Guild.Id,
MemberId = (long)ea.Member.Id,
};
}
nick.Nickname = ea.NicknameAfter;
db.RolestateNicks.Update(nick);
await db.SaveChangesAsync();
}
}
public static async Task OnMemberUpdated(GuildMemberUpdateEventArgs args)
{
try
{
var name = args.Member.DisplayName;
if (NeedsRename(name))
{
await args.Client.ReportAsync("🔣 Potential display name issue",
$"Member {args.Member.GetMentionWithNickname()} has changed their __display name__ and is now shown as **{name.Sanitize()}**\nSuggestion to rename: **{StripZalgo(name).Sanitize()}**",
null,
ReportSeverity.Medium);
}
}
catch (Exception e)
{
Config.Log.Error(e);
}
}
private async Task ClientOnGuildMemberUpdated(GuildMemberUpdateEventArgs args)
{
await Task.Yield();
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.NightWatchEnabled)
{
tasks.Add(NightWatch.NightWatchUserChange(args));
}
}
await Task.WhenAll(tasks);
}
public static async Task NightWatchUserChange(GuildMemberUpdateEventArgs args)
{
if (string.IsNullOrWhiteSpace(args.NicknameAfter))
{
return;
}
if (InviteRegex.Matches(args.NicknameAfter).Count > 0)
{
await args.Member.RemoveAsync("nightwatch");
return;
}
if (InviteRegex.Matches(args.Member.Username).Count > 0)
{
await args.Member.RemoveAsync("nightwatch");
}
}
private Task GuildMemberUpdated(GuildMemberUpdateEventArgs e)
{
var before = string.IsNullOrWhiteSpace(e.NicknameBefore) ? e.Member.Username : e.NicknameBefore;
var after = string.IsNullOrWhiteSpace(e.NicknameAfter) ? e.Member.Username : e.NicknameAfter;
if (before == after)
{
return(Task.CompletedTask);
}
var nicknameEventId = _redis.StringGet($"{e.Guild.Id}:Logs:NicknameEvent");
if (!string.IsNullOrWhiteSpace(nicknameEventId))
{
var channel = e.Guild.GetChannel((ulong)nicknameEventId);
var avatarUrl = e.Member.AvatarUrl;
const string title = ":memo: Nickname changed";
var description = new StringBuilder().AppendLine($"Mention: {e.Member.Mention}").AppendLine($"Username: {Formatter.InlineCode(e.Member.GetUsertag())}").AppendLine($"Identity: {Formatter.InlineCode($"{e.Member.Id}")}").ToString();
var fields = new List <EmbedField>
{
new EmbedField
{
Inline = false,
Name = "Before",
Value = before
},
new EmbedField
{
Inline = false,
Name = "After",
Value = after
}
};
channel.SendEmbedMessageAsync(title, description, DiscordColor.CornflowerBlue, fields: fields, thumbnailUrl: avatarUrl, timestamp: DateTimeOffset.UtcNow);
}
_logger.Information($"'{e.Member.GetUsertag()}' ({e.Member.Id}) has changed there nickname from '{before}' to '{after}' on '{e.Guild.Name}' ({e.Guild.Id}).");
return(Task.CompletedTask);
}
public async Task <Task> Guild_Member_Updated(GuildMemberUpdateEventArgs e)
{
// Quickly work out the sum of all role positions the user has
int totalPosBefore = 0, totalPosAfter = 0;
foreach (var role in e.RolesBefore)
{
totalPosBefore += role.Position;
}
foreach (var role in e.RolesAfter)
{
totalPosAfter += role.Position;
}
// Announce to all text channels in the server
e.Client.DebugLogger.LogMessage(LogLevel.Info, "PotatoBot", $"Member_Updated: {e.Member.Username}: Role position total {totalPosBefore} -> {totalPosAfter}", DateTime.Now);
foreach (var channel in e.Guild.Channels)
{
if (channel.Name == "announcements")
{
if (channel.Type == ChannelType.Text)
{
if (totalPosBefore < totalPosAfter)
{
// Promoted
await channel.TriggerTypingAsync();
await channel.SendMessageAsync($"Congratulations {e.Member.Mention} on your ascention. May you travel far young potato.");
}
else if (totalPosBefore > totalPosAfter)
{
// Demoted
await channel.TriggerTypingAsync();
await channel.SendMessageAsync($"Shame on you {e.Member.Mention}. You have fallen from grace. May the potato Gods have mercy on you...");
}
}
}
}
return(Task.CompletedTask);
}
private async Task Client_GuildMemberUpdated(GuildMemberUpdateEventArgs e)
{
var bot = await e.Guild.GetMemberAsync(258902871720984577);
var channel = GetChannelToPostNotificationIn(e, bot);
if (e.NicknameAfter == null && e.NicknameBefore == null || e.NicknameBefore == e.NicknameAfter)
{
if (e.RolesAfter.Count > e.RolesBefore.Count)
{
foreach (var role in e.RolesAfter)
{
if (!e.RolesBefore.Contains(role))
{
var embed = new DiscordEmbedBuilder().WithColor(DiscordColor.Green)
.WithAuthor(e.Member.Username, e.Member.AvatarUrl, e.Member.AvatarUrl)
.AddField("Role Assigned", $"`{ role.Name }`, Role Id: { role.Id }")
.AddField("Role Permissions", role.Permissions.ToPermissionString());
await channel.SendMessageAsync(embed : embed);
}
}
}
else
{
foreach (var role in e.RolesBefore)
{
if (!e.RolesAfter.Contains(role))
{
var embed = new DiscordEmbedBuilder().WithColor(DiscordColor.Red)
.WithAuthor(e.Member.Username, e.Member.AvatarUrl, e.Member.AvatarUrl)
.AddField("Role Removed", $"`{ role.Name }`, Role Id: { role.Id }")
.AddField("Role Permissions", role.Permissions.ToPermissionString());
await channel.SendMessageAsync(embed : embed);
}
}
}
}
else
{
await channel.SendMessageAsync($"User `{ e.Member.Username }` changed his nickname, from `{ e.NicknameBefore ?? e.Member.Username }` to `{ e.NicknameAfter ?? e.Member.Username }`");
}
}
private async Task OnGuildMemberUpdatedAsync(DiscordClient sender, GuildMemberUpdateEventArgs e)
{
using var scope = _serviceProvider.CreateScope();
var context = scope.ServiceProvider.GetRequiredService <ApplicationDbContext>();
var user = await context.Users.FindAsync((long)e.Member.Id);
if (user is not null && user.UserName != e.Member.DisplayName)
{
user.UserName = e.Member.DisplayName;
user.NormalizedUserName = user.UserName.Normalize().ToUpper();
await context.SaveChangesAsync();
}
if (scope is IAsyncDisposable asyncDisposable)
{
await asyncDisposable.DisposeAsync();
}
}
private async Task Client_GuildMemberUpdated(GuildMemberUpdateEventArgs e)
{
if (!_whConfig.Instance.Servers.ContainsKey(e.Guild.Id))
{
return;
}
var server = _whConfig.Instance.Servers[e.Guild.Id];
if (!server.EnableCities)
{
return;
}
if (!server.AutoRemoveCityRoles)
{
return;
}
var hasBefore = e.RolesBefore.FirstOrDefault(x => server.DonorRoleIds.Contains(x.Id)) != null;
var hasAfter = e.RolesAfter.FirstOrDefault(x => server.DonorRoleIds.Contains(x.Id)) != null;
// Check if donor role was removed
if (hasBefore && !hasAfter)
{
_logger.Info($"Member {e.Member.Username} ({e.Member.Id}) donor role removed, removing any city roles...");
// If so, remove all city/geofence/area roles
foreach (var roleName in server.CityRoles)
{
var role = e.Guild.GetRoleFromName(roleName);
if (role == null)
{
_logger.Debug($"Failed to get role by name {roleName}");
continue;
}
await e.Member.RevokeRoleAsync(role, "No longer a supporter/donor");
}
_logger.Info($"All city roles removed from member {e.Member.Username} ({e.Member.Id})");
}
}
public async Task MemberUpdate(GuildMemberUpdateEventArgs e)
{
string nickNameBefore = null;
if (e.NicknameBefore != e.NicknameAfter)
{
if (e.NicknameBefore == null)
{
nickNameBefore = "the default Username";
}
else
{
nickNameBefore = e.NicknameBefore;
}
await LogActionNoMsg(e.Guild, "MemberUpdate", "Fired when guild members get updated", $"User {e.Member.Username} updated. Nickname change from *'{e.NicknameBefore}'* to **'{e.NicknameAfter}'**", DiscordColor.Orange);
}
else if (e.RolesBefore != e.RolesAfter)
{
//await LogActionNoMsg(e.Guild, "MemberUpdate", "Fired when guild members get updated", $"User {e.Member.Username} updated. Role change from {e.RolesBefore.ToString()} to {e.RolesAfter.ToString()}", DiscordColor.Green);
}
}
private static Task DiscordClient_GuildMemberUpdated(DiscordClient client, GuildMemberUpdateEventArgs e)
{
_ = Task.Run(async() =>
{
GuildConfig config = await _guildService.GetOrCreateConfigAsync(e.Guild.Id);
if (config == null || !config.StreamAnnouncementsEnabled || config.ConfirmedStreamerIds == null || !config.ConfirmedStreamerIds.Contains(e.Member.Id))
{
// Streaming announcements has to be enabled for the guild and the streamer must first opt in to have it announced
return;
}
if (e.Member.Presence.Activity.ActivityType == ActivityType.Streaming)
{
DiscordChannel channel = e.Guild.GetDefaultChannel();
if (config?.DefaultChannelId != null)
{
channel = e.Guild.GetChannel(config.WelcomeMessageChannelId) ?? channel;
}
await(channel?.SendMessageAsync($"{e.Member.DisplayName} has started streaming. Watch it [here]({e.Member.Presence.Activity.StreamUrl}) "));
}
});
return(Task.CompletedTask);
}
