private async Task OnPresenceUpdated(PresenceUpdateEventArgs e)
{
if (PresenceUpdated != null)
{
await PresenceUpdated(e);
}
}
private Task Discord_PresenceUpdate(PresenceUpdateEventArgs e)
{
//if (e.User != null)
// this.Discord.DebugLogger.LogMessage(LogLevel.Unnecessary, "DSPlus Test", $"{e.User.Username}#{e.User.Discriminator} ({e.UserID}): {e.Status ?? "<unknown>"} playing {e.Game ?? "<nothing>"}", DateTime.Now);
return(Task.Delay(0));
}
private async Task PresenceUpdatedHandler(DiscordClient s, PresenceUpdateEventArgs e)
{
var _streamerrole = s.GetGuildAsync(Settings.GetSection("discord").GetValue <ulong>("guild")).Result
.GetRole(Settings.GetSection("discord").GetValue <ulong>("streamer"));
var _liverole = s.GetGuildAsync(Settings.GetSection("discord").GetValue <ulong>("guild")).Result
.GetRole(Settings.GetSection("discord").GetValue <ulong>("live"));
var _memberUser = s.GetGuildAsync(Settings.GetSection("discord").GetValue <ulong>("guild")).Result.GetMemberAsync(e.User.Id).Result;
var womp = s.GetGuildAsync(Settings.GetSection("discord").GetValue <ulong>("guild")).Result
.GetMemberAsync(Settings.GetSection("discord").GetValue <ulong>("womp")).Result;
if (e.Activity.ActivityType == ActivityType.Streaming && e.User.Id == womp.Id)
{
await StreamAnnouncement(s);
}
if (e.Activity.ActivityType == ActivityType.Streaming)
{
e.Activity.ActivityType = ActivityType.Custom;
await _memberUser.GrantRoleAsync(_streamerrole);
await _memberUser.GrantRoleAsync(_liverole);
}
else
{
await _memberUser.RevokeRoleAsync(_liverole);
}
}
public static async Task PresenceUpdated(PresenceUpdateEventArgs e, DiscordClient client, Dictionary <DiscordMember, DateTime> gameStartedDictionary)
{
if (Komobase.IsSubscribed(e.Member.Username))
{
//if just started playing
if (e.Game != null && e.Game.Name != null && !gameStartedDictionary.ContainsKey(e.Member) && (e.PresenceBefore.Game == null || e.PresenceBefore.Game.Name == string.Empty))
{
gameStartedDictionary.Add(e.Member, DateTime.Now);
}
//if ended
else if (e.Game == null || e.Game.Name == null || e.Game.Name == string.Empty)
{
if (gameStartedDictionary.ContainsKey(e.Member))
{
DiscordDmChannel dm = await client.CreateDmAsync(e.Member);
await client.SendMessageAsync(dm, "No! Ennyit függtél most: " +
GetTimeLapsedString(DateTime.Now, gameStartedDictionary[e.Member]),
false, null);
gameStartedDictionary.Remove(e.Member);
}
}
}
}
private static async Task Discord_PresenceUpdated(PresenceUpdateEventArgs e)
{
#if DEBUG
var ch = await DiscordClient.GetDefaultChannelAsync();
await ch.SendMessageAsync("PresenceUpdated");
#endif
}
private async Task Notify(DiscordClient sender, PresenceUpdateEventArgs e)
{
if (_notifyChannel == null)
{
return;
}
var member = await DefaultGuild.GetMemberAsync(e.User.Id);
if (member == null || !member.Roles.Any((role) => role.Id == streamerRoleId))
{
return;
}
var pres = e.UserAfter.Presence;
var actTypeAfter = pres.Activity.ActivityType;
string content;
StreamerInfo info;
bool isInList = streamersInfo.TryGetValue(member.Id, out info);
if (actTypeAfter == ActivityType.Streaming && !_currentlyStreaming.Contains(member.Id)) //If start streaming
{
_currentlyStreaming.Add(member.Id);
content = isInList && !string.IsNullOrEmpty(info.StartPhrase) ? info.StartPhrase : defaultStartPhrase;
var imageUrl = isInList && !string.IsNullOrEmpty(info.ImageUrl) ? info.ImageUrl : defaultImageUrl;
var actInfo = pres.Activity.RichPresence;
content = content.Replace("name", $"**{member.Username}**", StringComparison.OrdinalIgnoreCase);
content = content.Replace("game", $"**{actInfo.State}**", StringComparison.OrdinalIgnoreCase);
var embedBuilder = new DiscordEmbedBuilder();
embedBuilder.SetAuthor(member);
embedBuilder.SetTitle(actInfo.Details);
embedBuilder.AddField("Игра", actInfo.State);
embedBuilder.AddField("Ссылка", pres.Activity.StreamUrl);
try
{
embedBuilder.WithImageUrl(imageUrl);
}
catch (Exception ex)
{
Console.WriteLine("Не удалось установить картинку для пользователя " + member.Username + " Причина: " + ex.Message);
}
await _notifyChannel.SendMessageAsync(content, embed : embedBuilder.Build());
}
else if (actTypeAfter != ActivityType.Streaming && _currentlyStreaming.Contains(member.Id)) // If end streaming
{
_currentlyStreaming.Remove(member.Id);
content = isInList && !string.IsNullOrEmpty(info.EndPhrase) ? info.EndPhrase : defaultEndPhrase;
content = content.Replace("name", $"**{member.Username}**");
await _notifyChannel.SendMessageAsync(content);
}
}
public static async Task PresenceUpdated(ModCoreShard bot, PresenceUpdateEventArgs e)
{
// TODO fix me
var db = bot.SharedData.ModCore.CreateGlobalContext();
var loggers = db.GuildConfig.Where(x => x.GetSettings().LogUpdates).Select(x => x.GuildId);
var guilds = bot?.Parent?.Shards?.SelectMany(x => x.Client?.Guilds?.Where(y => y.Value.GetGuildSettings(db)?.LogUpdates ?? false));
if (guilds != null)
{
foreach (var g in guilds.Select(x => x.Value))
{
if (await IsInGuild(e.UserAfter, g))
{
var gst = g.GetGuildSettings(db);
var log = g.GetChannel(gst.UpdateChannel);
var embed = new DiscordEmbedBuilder()
.WithTitle("User Updated:")
.WithDescription($"{e.UserAfter.Username}#{e.UserAfter.Discriminator}");
if (e.UserAfter.Username != e.UserBefore.Username)
{
embed.AddField("Changed username", $"{e.UserBefore.Username} to {e.UserAfter.Username}");
}
if (e.UserAfter.Discriminator != e.UserBefore.Discriminator)
{
embed.AddField("Changed discriminator", $"{e.UserBefore.Discriminator} to {e.UserAfter.Discriminator}");
}
if (e.UserAfter.AvatarUrl != e.UserBefore.AvatarUrl)
{
embed.AddField("Changed avatar", $"[Old Avatar]({e.UserBefore.AvatarUrl})" +
$"\nNote: this link may 404 later due to cache invalidation");
}
if (e.UserAfter.IsBot != e.UserBefore.IsBot)
{
embed.AddField("Magically transformed between bot form and human form",
$"Wait, what the f**k this isn't possible");
}
// TODO ModCore color scheme
embed.WithColor(new DiscordColor("#089FDF"));
embed.WithThumbnail(e.UserAfter.AvatarUrl);
if (embed.Fields.Count > 0)
{
await log.SendMessageAsync(embed : embed);
}
}
}
}
}
public static Task PresenceUpdated(PresenceUpdateEventArgs e)
{
if (PresenceUpdatedBool)
{
if (!e.Member.IsBot && e.Member != e.Client.CurrentUser)
{
if (PUlastUserId != e.Member.Id)
{
PUlastUserId = e.Member.Id;
PUlastUserStatus = e.Member.Presence.Status;
}
else if (PUlastUserStatus != e.Member.Presence.Status)
{
PUlastUserId = e.Member.Id;
PUlastUserStatus = e.Member.Presence.Status;
}
else
{
return(Task.CompletedTask); // try to prevent multiple guild update
}
Console.ForegroundColor = ConsoleColor.DarkYellow;
Logger.Write($"[Updated] ");
Console.ForegroundColor = ConsoleColor.White;
Logger.Write($"[Status] ");
Console.ForegroundColor = ConsoleColor.Green;
Logger.Write($"[{DateTime.Now}] ");
Console.ForegroundColor = ConsoleColor.Yellow;
Logger.Write($"{e.Member.Username}#{e.Member.Discriminator} ({e.Member.Id}) | ");
switch (e.Member.Presence.Status)
{
case UserStatus.Online:
Console.ForegroundColor = ConsoleColor.Green;
Logger.WriteLine($"{e.Status}");
break;
case UserStatus.DoNotDisturb:
Console.ForegroundColor = ConsoleColor.Red;
Logger.WriteLine($"{e.Status}");
break;
case UserStatus.Idle:
Console.ForegroundColor = ConsoleColor.DarkYellow;
Logger.WriteLine($"{e.Status}");
break;
case UserStatus.Offline:
Console.ForegroundColor = ConsoleColor.Gray;
Logger.WriteLine($"{e.Status}");
break;
}
}
}
return(Task.CompletedTask);
}
private async Task Client_PresenceUpdated(PresenceUpdateEventArgs e)
{
try
{
if (!cfgJson.ServerId.Contains(e.Guild.Id) || e.Game == null)
{
return;
}
using (var db = new LiteDatabase($"filename={cfgJson.ServerId.FirstOrDefault(x => x == e.Guild.Id)}.db; journal=false;"))
{
var dbUsers = db.GetCollection <UserModel>("Users");
var dbUser = dbUsers.FindOne(x => x.Id == e.Member.Id);
if (dbUser == null)
{
var userModel = new UserModel
{
Id = e.Member.Id,
rrIsEnabled = true
};
dbUsers.Insert(userModel);
dbUser = dbUsers.FindOne(x => x.Id == e.Member.Id);
}
if (!dbUser.rrIsEnabled)
{
return;
}
}
var userRoles = e.Roles.ToList();
var userGame = e.Game.Name.ToLower();
foreach (var game in cfgJson.GamesDictionary)
{
if (userRoles.Exists(x => x.Name == game.Key))
{
continue;
}
if (game.Value.Exists(x => userGame.Contains(x)))
{
var nonGrantedRole = targetRoles[e.Guild.Id].Find(x => x.Name == game.Key);
if (nonGrantedRole != null)
{
await e.Member.GrantRoleAsync(nonGrantedRole);
e.Client.DebugLogger.LogMessage(LogLevel.Info, "002", $"Пользователь {e.Member.Username} получил роль {nonGrantedRole.Name}", DateTime.Now);
}
break;
}
}
}
catch (Exception ex)
{
e.Client.DebugLogger.LogMessage(LogLevel.Error, "002", $"Exception occured: {ex.GetType()}: {ex.Message}", DateTime.Now);
}
return;
}
private Task Discord_PresenceUpdated(PresenceUpdateEventArgs e)
{
if (e.User != null && e.PresenceBefore?.Status != e.Status)
{
if (App.Discord.Relationships.TryGetValue(e.User.Id, out var rel) && rel?.RelationshipType == DiscordRelationshipType.Friend)
{
SortRelationship(rel, true);
}
}
return(Task.CompletedTask);
}
private static async Task Discord_PresenceUpdated(DiscordClient sender, PresenceUpdateEventArgs e)
{
if (e.User.Id == ToStalk)
{
var guild = await sender.GetGuildAsync(750409700750786632);
for (var i = 0; i < 3; i++)
{
await guild.GetChannel(770439341620330497).SendMessageAsync(
$"{e.User.Username}'s activity has changed! ({e.PresenceBefore.Status} => {e.PresenceAfter.Status})");
}
ToStalk = 0;
}
}
private static void HeatherReaction(PresenceUpdateEventArgs e)
{
var random = new Random();
if (random.Next(5) == 1)
{
if (e.User.Id == DiscordIDs.Hangry)
{
if (!e.PresenceBefore.IsOnline() && e.PresenceAfter.IsOnline())
{
e.PresenceAfter.Guild.GetDefaultChannel().SendMessageAsync("Wait, is that a Hangry... Walrus??");
}
}
}
}
private async Task OnPresenceUpdated(DiscordClient sender, PresenceUpdateEventArgs e)
{
var voiceChannel = await FindVoiceChannelAsync(e.User);
if (voiceChannel is null)
{
return;
}
if (e.PresenceBefore.Activities.Count == e.PresenceAfter.Activities.Count)
{
return;
}
await _autoVoiceService.UpdateNameAsync(voiceChannel);
}
private Task Discord_PresenceUpdate(PresenceUpdateEventArgs e)
{
var user = RPClass.StatusList.FirstOrDefault(x => x.UserID == e.User.Id);
if (user == null)
{
RPClass.StatusList.Add(new StatusObject.RootObject(e.User.Id));
user = RPClass.StatusList.Last();
}
if (e.PresenceAfter != null)
{
user.AddStatus(DateTime.Now, e.PresenceAfter.Status);
RPClass.SaveData(7);
}
return(Task.Delay(0));
}
private void GameplayStopEvent(PresenceUpdateEventArgs presenceUpdate)
{
Console.WriteLine($"Game Stopped: {presenceUpdate.PresenceBefore.Game.Name} by {presenceUpdate.Member.DisplayName}");
var a = new {
UserId = presenceUpdate.Member.Id,
GuildId = presenceUpdate.Guild.Id,
Status = "GameStart",
Timestamp_UTC = DateTime.UtcNow,
Game = new PublicDiscordGame {
Id = presenceUpdate.PresenceBefore.Game.ApplicationId,
Name = presenceUpdate.PresenceBefore.Game.Name,
Hash = StaticHelpers.GameNameToHash(presenceUpdate.PresenceBefore.Game.Name)
}
};
Console.WriteLine(JsonConvert.SerializeObject(a, Formatting.Indented));
}
private Task ManageNowStreamingUsers(DiscordClient dClient, PresenceUpdateEventArgs args)
{
Task.Run(async() =>
{
// Ignore non-SBG events
if (args.PresenceAfter.Guild.Id != Variables.Guilds.SBG)
{
return;
}
DiscordRole streaming = args.PresenceAfter.Guild.GetRole(SBGRoles.NowStreaming);
DiscordMember member = await args.PresenceAfter.Guild.GetMemberAsync(args.UserAfter.Id);
bool wasStreaming = args.PresenceBefore?.Activities.Any(a => a.StreamUrl != null) ?? false;
DiscordActivity stream = args.PresenceAfter.Activities.Where(a => a.StreamUrl != null).FirstOrDefault();
// User Started Streaming Intruder
if (!wasStreaming && stream != null)
{
SearchStreams search = await this.twitchAPI.V5.Search.SearchStreamsAsync(stream.StreamUrl.Replace("https://www.twitch.tv/", string.Empty, StringComparison.Ordinal));
foreach (Stream searchStream in search.Streams)
{
if (searchStream.Game == "Intruder")
{
await this.activityManager.SetStreamAsync(args.UserAfter.Id, searchStream.Channel.Name.Capitalize(), searchStream.Channel.Url);
await member.GrantRoleAsync(streaming);
break;
}
}
}
// User Stopped Streaming Intruder
else if (wasStreaming && stream == null && member.Roles.Contains(streaming))
{
if (this.activityManager.IsStreamOwner(args.UserAfter.Id))
{
await this.activityManager.ClearStreamAsync();
}
await member.RevokeRoleAsync(streaming);
}
});
return(Task.CompletedTask);
}
private Task ManageNowPlayingAsync(DiscordClient dClient, PresenceUpdateEventArgs args)
{
_ = Task.Run(async() =>
{
// Ignore non-SBG events
if (args.PresenceAfter.Guild.Id != Variables.Guilds.SBG)
{
return;
}
bool wasPlaying = args.PresenceBefore?.Activities.Any(a => a.Name == "Intruder") ?? false;
bool nowPlaying = args.PresenceAfter.Activities.Any(a => a.Name == "Intruder");
if ((!wasPlaying && !nowPlaying) || (wasPlaying && nowPlaying))
{
return;
}
DiscordRole nowPlayingRole = args.PresenceAfter.Guild.GetRole(SBGRoles.NowPlaying);
DiscordMember member = await args.PresenceAfter.Guild.GetMemberAsync(args.UserAfter.Id);
// User started playing Intruder
if (!wasPlaying && nowPlaying)
{
await member.GrantRoleAsync(nowPlayingRole);
using IServiceScope scope = this.scopeFactory.CreateScope();
using BloonContext db = scope.ServiceProvider.GetRequiredService <BloonContext>();
LTPJoin join = db.LTPJoins.Where(l => l.UserId == args.UserAfter.Id).FirstOrDefault();
if (join != null)
{
join.Timestamp = DateTime.UtcNow;
await db.SaveChangesAsync();
}
}
// User stopped playing Intruder
else if (wasPlaying && (!nowPlaying || args.PresenceAfter.Status == UserStatus.Invisible || args.PresenceAfter.Status == UserStatus.Offline))
{
await member.RevokeRoleAsync(nowPlayingRole);
}
});
return(Task.CompletedTask);
}
private void GenericPresenceChangeEvent(PresenceUpdateEventArgs presenceUpdate)
{
var presenceEvent = new PublicPresenceEvent {
User = new PublicDiscordUser {
Id = presenceUpdate.Member.Id,
Discriminator = int.Parse(presenceUpdate.Member.Discriminator),
//GuildId = presenceUpdate.Member.Guild.Id,
Username = presenceUpdate.Member.Username
},
Time_UTC = DateTime.UtcNow,
PreviousState = presenceUpdate.PresenceBefore != null
? presenceUpdate.PresenceBefore.Status.ToString().ToLower() // To lower because the below Status gets the string value of the enum. Why doesn't PresenceBefore do the same? Yes.
: "unknown",
NewState = presenceUpdate.Status
};
Console.WriteLine($"Presence change event for a registered user, {presenceUpdate.Member.DisplayName} in {presenceUpdate.Guild.Name} was {presenceEvent.PreviousState} now {presenceEvent.NewState}");
}
public static async Task PresenceUpdated(PresenceUpdateEventArgs e, DiscordClient client)
{
if (!e.Member.IsBot)
{
try
{
using (KomoBaseAccess kba = new KomoBaseAccess())
{
bool subStatus = kba.SubStatus(e.Member.Username);
bool isStopped = (e.Game == null || e.Game.Name == null || e.Game.Name == string.Empty) && gameStartedDictionary.ContainsKey(e.Member);
int points = 0;
string msg = string.Empty;
//add points
if (isStopped)
{
msg = GetTimeLapsedString(DateTime.Now, gameStartedDictionary[e.Member], out points);
kba.AddPoints(e.Member.Username, points);
}
//if just started playing
if (e.Game != null && e.Game.Name != null && !gameStartedDictionary.ContainsKey(e.Member) && (e.PresenceBefore.Game == null || e.PresenceBefore.Game.Name == string.Empty))
{
gameStartedDictionary.Add(e.Member, DateTime.Now);
}
//if ended
else if (isStopped)
{
gameStartedDictionary.Remove(e.Member);
}
if (subStatus == true && isStopped)
{
DiscordDmChannel dm = await client.CreateDmAsync(e.Member);
await client.SendMessageAsync(dm, "No! Ennyit függtél most: " +
msg,
false, null);
}
}
}
catch (Exception ex) { logger.Error(DateTime.UtcNow.ToString() + ": " + ex.Message); }
}
}
private async Task _discordClient_PresenceUpdated(PresenceUpdateEventArgs e)
{
try {
if (e.PresenceBefore?.Game == null && e.Game == null)
{
GenericPresenceChangeEvent(e);
}
else if (e.PresenceBefore.Game != null && e.Game == null)
{
GameplayStopEvent(e);
}
else if (e.PresenceBefore.Game == null && e.Game != null)
{
GameplayStartEvent(e);
}
await Task.Run(() => { });
} catch (Exception ee) {
throw;
}
}
private static async Task WingerdSistersReaction(PresenceUpdateEventArgs e)
{
var wingerdSisters = new List <ulong>()
{
DiscordIDs.Scrub, DiscordIDs.Rachael, DiscordIDs.Rebekah
};
if (wingerdSisters.Contains(e.User.Id))
{
var guildMembers = await e.PresenceAfter.Guild.GetAllMembersAsync();
var onlineMembers = guildMembers.Where(x => x.Presence.IsOnline() || x.Presence.Status == UserStatus.Idle).Select(x => x.Id);
var allSistersOnline = wingerdSisters.All(onlineMembers.Contains);
if (allSistersOnline)
{
await e.PresenceAfter.Guild.GetDefaultChannel().SendMessageAsync("Woah! It's all the Wingerd sisters in one place!");
}
}
}
private Task Client_PresenceUpdated(PresenceUpdateEventArgs e)
{
if (e.PresenceAfter.Activity.ActivityType == ActivityType.Playing && !string.IsNullOrWhiteSpace(e.PresenceAfter.Activity.Name))
{
//playing a game
}
else if (e.PresenceAfter.Activity.ActivityType == ActivityType.ListeningTo)
{
Client.DebugLogger.Info(string.Format("{0} is now listening to {1} by {2}", e.User.Username, e.PresenceAfter.Activity.RichPresence.Details, e.PresenceAfter.Activity.RichPresence.State));
//listening to a song
}
else if (e.PresenceAfter.Status == UserStatus.Online && e.PresenceBefore.Status == UserStatus.Offline)
{
Client.DebugLogger.Info(string.Format("{0} is now online", e.User.Username));
}
else if (e.PresenceAfter.Status == UserStatus.Offline && e.PresenceBefore.Status == UserStatus.Online)
{
Client.DebugLogger.Info(string.Format("{0} is now offline", e.User.Username));
}
return(Task.CompletedTask);
}
}//end MainAsync
private async Task Client_PresenceUpdated(PresenceUpdateEventArgs e)
{
ulong channel = 0;
if (e.Member.Presence.Game != null)
{
if (e.Member.Presence.Game.StreamType == GameStreamType.Twitch)
{
{
//Stream detected! Search if channel is recorded
var guild = e.Guild.Id.ToString();
var jsonData = File.ReadAllText("streamchannel.json");
dynamic sc = JsonConvert.DeserializeObject(jsonData);
bool found = false;
int c = sc.SChannel.Count;
for (int counter = 0; counter < c; counter++)
{
if (sc.SChannel[counter].guildID == guild)
{
found = true;
channel = Convert.ToUInt64(sc.SChannel[counter].channelID.ToString());
}
} // end for
if (found == true)
{
await e.Guild.GetChannel(channel).SendMessageAsync($"@everyone, {e.Member.DisplayName} is now streaming! Why don't you come over and watch?\n\nLink: {e.Member.Presence.Game.Url}");
}
}
}
}
await Task.CompletedTask;
}
private Task Discord_PresenceUpdated(DiscordClient client, PresenceUpdateEventArgs e)
{
client.Logger.LogInformation(TestBotEventId, "Presence updated: '{0}'", e.Activity.Name);
return(Task.CompletedTask);
}
public static async Task Stream_Notification(object Client, PresenceUpdateEventArgs e)
{
_ = Task.Run(async() =>
{
if (e.User != null)
{
DiscordGuild guild = e.User.Presence.Guild;
DB.StreamNotifications StreamNotification = DB.DBLists.StreamNotifications.FirstOrDefault(w => w.Server_ID == guild.Id);
DiscordChannel channel = guild.GetChannel(Convert.ToUInt64(StreamNotification.Channel_ID));
if (Program.ServerIdList.Contains(guild.Id))
{
LiveStreamer streamer = new()
{
User = e.User,
Time = DateTime.Now,
Guild = guild
};
int ItemIndex;
try
{
ItemIndex = LiveStreamerList.FindIndex(a => a.User.Id == e.User.Id &&
a.Guild.Id == e.User.Presence.Guild.Id);
}
catch (Exception)
{
ItemIndex = -1;
}
if (ItemIndex >= 0 &&
e.User.Presence.Activities.FirstOrDefault(w => w.Name.ToLower() == "twitch" || w.Name.ToLower() == "youtube") == null)
{
//removes user from list
if (LiveStreamerList[ItemIndex].Time.AddHours(StreamCheckDelay) < DateTime.Now &&
e.User.Presence.Activities.FirstOrDefault(w => w.Name.ToLower() == "twitch" || w.Name.ToLower() == "youtube") == LiveStreamerList[ItemIndex].User.Presence.Activities.FirstOrDefault(w => w.Name.ToLower() == "twitch" || w.Name.ToLower() == "youtube"))
{
LiveStreamerList.RemoveAt(ItemIndex);
}
}
else if (ItemIndex == -1 &&
e.User.Presence.Activities.FirstOrDefault(w => w.Name.ToLower() == "twitch" || w.Name.ToLower() == "youtube") != null &&
e.User.Presence.Activities.FirstOrDefault(w => w.Name.ToLower() == "twitch" || w.Name.ToLower() == "youtube").ActivityType.Equals(ActivityType.Streaming))
{
DiscordMember StreamMember = await guild.GetMemberAsync(e.User.Id);
bool role = false, game = false;
string gameTitle = e.User.Presence.Activities.FirstOrDefault(w => w.Name.ToLower() == "twitch" || w.Name.ToLower() == "youtube").RichPresence.State;
string streamTitle = e.User.Presence.Activities.FirstOrDefault(w => w.Name.ToLower() == "twitch" || w.Name.ToLower() == "youtube").RichPresence.Details;
string streamURL = e.User.Presence.Activities.FirstOrDefault(w => w.Name.ToLower() == "twitch" || w.Name.ToLower() == "youtube").StreamUrl;
if (StreamNotification.Roles_ID != null)
{
foreach (DiscordRole urole in StreamMember.Roles)
{
foreach (decimal roleid in StreamNotification.Roles_ID)
{
if (urole.Id == roleid)
{
role = true;
break;
}
}
}
}
else if (StreamNotification.Roles_ID == null)
{
role = true;
}
if (StreamNotification.Games != null)
{
foreach (string ugame in StreamNotification.Games)
{
try
{
if (gameTitle == ugame)
{
game = true;
break;
}
}
catch { game = false; }
}
}
else if (StreamNotification.Games == null)
{
game = true;
}
if (game && role)
{
DiscordEmbedBuilder embed = new()
{
Color = new DiscordColor(0x6441A5),
Author = new DiscordEmbedBuilder.EmbedAuthor
{
IconUrl = e.User.AvatarUrl,
Name = "STREAM",
Url = streamURL
},
Description = $"**Streamer:**\n {e.User.Mention}\n\n" +
$"**Game:**\n{gameTitle}\n\n" +
$"**Stream title:**\n{streamTitle}\n\n" +
$"**Stream Link:**\n{streamURL}",
Thumbnail = new DiscordEmbedBuilder.EmbedThumbnail
{
Url = e.User.AvatarUrl
},
Title = $"Check out {e.User.Username} is now Streaming!"
};
await channel.SendMessageAsync(embed: embed);
//adds user to list
LiveStreamerList.Add(streamer);
}
}
}
}
});
await Task.Delay(1);
}
private Task Discord_PresenceUpdate(PresenceUpdateEventArgs e)
{
return(Task.Delay(0));
}
private async Task UserPresenceUpdated(DiscordClient client, PresenceUpdateEventArgs e)
{
bool streamStatusChanged = false;
bool startedStreaming = false;
var activitiesBefore = e.PresenceBefore?.Activities;
var activitiesAfter = e.PresenceAfter?.Activities;
//check if status changed
if (activitiesBefore?.FirstOrDefault(activity =>
activity.ActivityType == ActivityType.Streaming) != null)
{
if (activitiesAfter?.FirstOrDefault(activity =>
activity.ActivityType == ActivityType.Streaming) == null)
{
streamStatusChanged = true;
}
}
else if (activitiesAfter?.FirstOrDefault(activity =>
activity.ActivityType == ActivityType.Streaming) != null)
{
if (activitiesBefore?.FirstOrDefault(activity =>
activity.ActivityType == ActivityType.Streaming) == null)
{
streamStatusChanged = true;
startedStreaming = true;
}
}
if (!streamStatusChanged)
{
return;
}
//get all configured guilds
var filteredGuilds = ShimakazeBot.Client.Guilds.Where(guild => {
return(ShimakazeBot.StreamingEnabledGuilds.ContainsKey(guild.Value.Id) ||
guild.Value.Roles.FirstOrDefault(role =>
role.Value.Name == "Now Streaming"
).Value != null);
});
//filter ones for member and check perms
string missingPerms = "";
filteredGuilds = filteredGuilds.Where(guild =>
{
if (guild.Value.Members.ContainsKey(e.User.Id))
{
if (Utils.MemberHasPermissions(
guild.Value.Members[ShimakazeBot.Client.CurrentUser.Id],
Permissions.ManageRoles))
{
return(true);
}
else
{
missingPerms += $"{guild.Value.Name} (**{guild.Value.Id}**) - ";
}
}
return(false);
});
if (missingPerms.Length > 0)
{
ShimakazeBot.SendToDebugRoom("Shima is missing manage role perms for streaming in:" +
$"\n{missingPerms}");
return;
}
//apply per guild
foreach (var guild in filteredGuilds)
{
var role = ShimakazeBot.StreamingEnabledGuilds.ContainsKey(guild.Key) ?
guild.Value.Roles[ShimakazeBot.StreamingEnabledGuilds[guild.Key]] :
guild.Value.Roles.FirstOrDefault(guildRole =>
guildRole.Value.Name == "Now Streaming"
).Value;
try
{
if (startedStreaming)
{
await guild.Value.Members[e.User.Id].GrantRoleAsync(role);
}
else
{
await guild.Value.Members[e.User.Id].RevokeRoleAsync(role);
}
}
//if role is too high
catch
{
ShimakazeBot.SendToDebugRoom($"Shima couldn't reach the streaming role {role.Name} " +
$"in {guild.Value.Name} (**{guild.Value.Id}**)");
}
}
}
private Task OnPresenceUpdated(DiscordClient sender, PresenceUpdateEventArgs e)
{
PresenceReactions.ReactToPresenceChanges(e);
return(Task.CompletedTask);
}
private Task Client_PresenceUpdated(PresenceUpdateEventArgs e)
{
e.Client.DebugLogger.LogMessage(LogLevel.Info, "BotApp", e.ToString(), DateTime.Now);
return(Task.CompletedTask);
}
internal static async void ReactToPresenceChanges(PresenceUpdateEventArgs e)
{
HeatherReaction(e);
await WingerdSistersReaction(e);
}
