private async Task Client_JoinedGuildAsync(SocketGuild arg)
{
logger.LogInformation($"Joined guild {arg.Name}");
GuildConfig config = await dbContext.GuildConfigs.SingleOrDefaultAsync(c => c.GuildID == arg.Id).ConfigureAwait(false);
if (config == null)
{
config = new GuildConfig();
dbContext.GuildConfigs.Add(config);
await dbContext.SaveChangesAsync().ConfigureAwait(false);
}
}
public async Task AddSubscriptionAsync(string gameName, ulong guildID, ulong userID)
{
if (dbContext.GameSubscriptions.Any(x => x.GameName.Contains(gameName, StringComparison.OrdinalIgnoreCase) && x.GuildID == guildID && x.UserID == userID))
{
throw new ArgumentException("The user is already subscribed to that game");
}
var gameSubscription = new GameSubscription {
GuildID = guildID, UserID = userID, GameName = gameName
};
dbContext.GameSubscriptions.Add(gameSubscription);
await dbContext.SaveChangesAsync().ConfigureAwait(false);
}
public async Task <bool> AddServerAsync(IPEndPoint endpoint, ulong guildID, ulong channelID)
{
var server = new GameServer {
GameServerType = _gameServerType, ServerIP = endpoint, GuildID = guildID, ChannelID = channelID
};
bool success = await PostServerInfoAsync(server);
if (success && !_dbContext.GameServers.Contains(server))
{
_dbContext.Add(server);
await _dbContext.SaveChangesAsync();
}
return(success);
}
public Task AddSubscriptionAsync(string gameName, ulong guildID, ulong userID)
{
if (dbContext.GameSubscriptions.Any(x => x.GameName.ToUpper().Contains(gameName.ToUpper()) && x.GuildID == guildID && x.UserID == userID))
{
throw new ArgumentException("The user is already subscribed to that game");
}
var gameSubscription = new GameSubscription {
GuildID = guildID, UserID = userID, GameName = gameName
};
_ = dbContext.GameSubscriptions.Add(gameSubscription);
return(dbContext.SaveChangesAsync());
}
public async Task <GuildConfig> GetOrCreateConfigAsync(ulong guildId)
{
GuildConfig config = await _dbContext.GuildConfigs.SingleOrDefaultAsync(c => c.GuildID == guildId);
if (config == null)
{
config = new GuildConfig {
GuildID = guildId
};
_dbContext.GuildConfigs.Add(config);
await _dbContext.SaveChangesAsync();
}
return(config);
}
public async Task <bool> AddServerAsync(IPEndPoint endpoint, ulong guildID, ulong channelID)
{
var server = new GameServer {
GameServerType = gameServerType, ServerIP = endpoint, GuildID = guildID, ChannelID = channelID
};
bool success = await PostServerInfoAsync(server).ConfigureAwait(false);
if (success)
{
dbContext.Add(server);
await dbContext.SaveChangesAsync().ConfigureAwait(false);
}
return(success);
}
public async Task EnableForGuildAsync(ulong guildID, ulong channelID)
{
GuildConfig cfg = await dbContext.GuildConfigs.SingleOrDefaultAsync(g => g.GuildID == guildID).ConfigureAwait(false) ?? new GuildConfig
{
GuildID = guildID
};
cfg.BattlefieldUpdatesEnabled = true;
cfg.BattlefieldUpdatesChannel = channelID;
dbContext.GuildConfigs.Update(cfg);
await dbContext.SaveChangesAsync().ConfigureAwait(false);
await GetUpdateForGuildAsync(await GetLatestBattlefieldVUpdateAsync().ConfigureAwait(false), discordClient.GetGuild(guildID)).ConfigureAwait(false);
}
public async Task AddFeedAsync(string name, string url, ulong guildID, ulong channelID)
{
var feed = new Models.Feed
{
Name = name,
URL = url,
GuildID = guildID,
ChannelID = channelID
};
_ = dbContext.Feeds.Add(feed);
_ = await dbContext.SaveChangesAsync().ConfigureAwait(false);
await GetFeedUpdateAsync(feed, true).ConfigureAwait(false);
}
public async Task AddAndStartPollAsync(Poll poll)
{
DiscordGuild guild = await _discordClient.GetGuildAsync(poll.GuildId);
DiscordChannel channel = guild?.GetChannel(poll.ChannelId);
DiscordMessage pollMessage = await channel.GetMessageAsync(poll.MessageId);
await pollMessage.PinAsync();
await _dbContext.Polls.AddAsync(poll);
await _dbContext.SaveChangesAsync();
await StartPollAsync(poll);
}
/// <summary>
/// Add an announcement that should be broadcasted regularly based on the interval defined by the Cron Expression
/// </summary>
/// <param name="name">The unique ID of the announcement</param>
/// <param name="cronExpression">The cron expression that defines the broadcast intervall. See https://github.com/atifaziz/NCrontab/wiki/Crontab-Expression for details</param>
/// <param name="message">The message to be broadcasted</param>
/// <param name="guildID">The ID of the Guild where the message will be broadcasted</param>
/// <param name="channelID">The ID of the Channel where the message will be broadcasted</param>
public Task AddRecurringAnnouncementAsync(string name, string cronExpression, string message, ulong guildID, ulong channelID)
{
if (name.IsEmpty())
{
throw new ArgumentException("Please provide an ID");
}
// Create the announcement, add it to the list and persist it
var announcement = new Announcement {
Type = AnnouncementType.Recurring, GuildID = guildID, ChannelID = channelID, CronExpression = cronExpression, Name = name, Message = message
};
AddRecurringJob(announcement);
_ = dbContext.Announcements.Add(announcement);
return(dbContext.SaveChangesAsync());
}
/// <summary>
/// Add an reminder that should be broadcasted regularly based on the interval defined by the Cron Expression
/// </summary>
/// <param name="id">The unique ID of the reminder</param>
/// <param name="cronExpression">The cron expression that defines the broadcast intervall. See https://github.com/atifaziz/NCrontab/wiki/Crontab-Expression for details</param>
/// <param name="message">The message to be broadcasted</param>
/// <param name="guildId">The ID of the Guild where the message will be broadcasted</param>
/// <param name="channelId">The ID of the Channel where the message will be broadcasted</param>
public Task AddRecurringReminderAsync(string id, string cronExpression, string message, ulong guildId, ulong channelId)
{
if (id.IsEmpty())
{
throw new ArgumentException("Please provide an ID");
}
// Create the reminder, add it to the list and persist it
var reminder = new Reminder {
Type = ReminderType.Recurring, GuildId = guildId, ChannelId = channelId, CronExpression = cronExpression, Name = id, Message = message
};
AddRecurringJob(reminder);
_dbContext.Reminders.Add(reminder);
return(_dbContext.SaveChangesAsync());
}
public async Task AddBenzenFactAsync([Remainder] string fact)
{
fact = fact.Trim('\"').Trim();
if (fact.IsEmpty())
{
_ = await ReplyAsync("Please provide a fact!").ConfigureAwait(false);
return;
}
if (!fact.Contains(name, StringComparison.OrdinalIgnoreCase))
{
_ = await ReplyAsync("The fact must include Benzen!").ConfigureAwait(false);
return;
}
if (dbContext.BenzenFacts.Any(f => f.Fact == fact))
{
_ = await ReplyAsync("I already know this fact!").ConfigureAwait(false);
return;
}
_ = dbContext.BenzenFacts.Add(new BenzenFact(fact));
_ = await dbContext.SaveChangesAsync().ConfigureAwait(false);
_ = await ReplyAsync("Fact added").ConfigureAwait(false);
}
private async Task AddPointsToUserAsync(IUser user, int pointsToAdd)
{
// Add points to current scores and global scores
AddPointsCurrent(user, userScoresCurrent, pointsToAdd);
var currentScore = await dbContext.TriviaScores.FirstOrDefaultAsync(s => s.GuildID == guildID && s.UserID == user.Id).ConfigureAwait(false);
//pointsToAdd can be negative -> prevent less than zero points
if (currentScore == null && pointsToAdd < 0)
{
pointsToAdd = 0;
}
else if (currentScore != null && currentScore.Score + pointsToAdd < 0)
{
pointsToAdd = -1 * currentScore.Score;
}
if (currentScore == null)
{
await dbContext.AddAsync(new TriviaScore { GuildID = guildID, UserID = user.Id, Score = pointsToAdd }).ConfigureAwait(false);
}
else
{
currentScore.Score += pointsToAdd;
dbContext.Update(currentScore);
}
await dbContext.SaveChangesAsync().ConfigureAwait(false);
}
public async Task AddRoleButtonLinkAsync(ulong guildID, ulong messageID, ulong roleID, string emoteString)
{
SocketGuild guild = discordClient.GetGuild(guildID);
if (guild == null)
{
return;
}
IUserMessage msg = await GetMessageAsync(guild, messageID).ConfigureAwait(false);
if (msg == null)
{
return;
}
IEmote emote = guild.Emotes.FirstOrDefault(x => emoteString.Contains(x.Name, StringComparison.Ordinal))
?? new Emoji(emoteString) as IEmote;
if (emote == null)
{
return;
}
if (!msg.Reactions.Any(x => x.Key == emote))
{
await msg.AddReactionAsync(emote).ConfigureAwait(false);
}
bool exists = await dbContext.RoleButtonLinks
.AsQueryable()
.AnyAsync(x => x.GuildID == guildID && x.MessageID == messageID && x.RoleID == roleID && x.EmoteString == emoteString)
.ConfigureAwait(false);
if (!exists)
{
var link = new RoleButtonLink {
GuildID = guildID, MessageID = messageID, RoleID = roleID, EmoteString = emoteString
};
_ = dbContext.RoleButtonLinks.Add(link);
_ = await dbContext.SaveChangesAsync().ConfigureAwait(false);
}
else
{
throw new ArgumentException("The specified link already exists");
}
}
public async Task SetWelcomeMessageAsync([Summary("The welcome message")][Remainder] string welcomeMsg)
{
welcomeMsg = welcomeMsg.Trim('\"');
if (welcomeMsg.IsEmpty())
{
await ReplyAsync("Please provide a welcome message").ConfigureAwait(false);
return;
}
GuildConfig config = await GetOrCreatConfigAsync(Context.Guild.Id).ConfigureAwait(false);
config.WelcomeMessageText = welcomeMsg;
dbContext.GuildConfigs.Update(config);
await dbContext.SaveChangesAsync().ConfigureAwait(false);
await ReplyAndDeleteAsync("Message set").ConfigureAwait(false);
}
protected override async Task <bool> PostServerInfoAsync(GameServer discordGameServer)
{
if (discordGameServer == null)
{
return(false);
}
MineQuery query = null;
try
{
query = new MineQuery(discordGameServer.ServerIP.Address, discordGameServer.ServerIP.Port, logger);
var serverInfo = await query.GetServerInfoAsync().ConfigureAwait(false);
if (serverInfo == null)
{
return(false);
}
var guild = discordClient?.GetGuild(discordGameServer.GuildID);
var channel = guild?.GetTextChannel(discordGameServer.ChannelID);
if (guild == null || channel == null)
{
return(false);
}
var builder = new EmbedBuilder()
.WithColor(new Color(21, 26, 35))
.WithTitle($"Minecraft Server ({discordGameServer.ServerIP.Address}:{discordGameServer.ServerIP.Port})")
.WithDescription($"Motd: {serverInfo.Description.Motd}");
if (serverInfo.Players.Sample != null && serverInfo.Players.Sample.Count > 0)
{
builder.AddField($"Online Players ({serverInfo.Players.Online}/{serverInfo.Players.Max})", string.Join(", ", serverInfo.Players.Sample.Select(x => x.Name)));
}
else
{
builder.AddField("Online Players", $"{serverInfo.Players.Online}/{serverInfo.Players.Max}");
}
if (discordGameServer.GameVersion.IsEmpty())
{
discordGameServer.GameVersion = serverInfo.Version.Name;
dbContext.GameServers.Update(discordGameServer);
await dbContext.SaveChangesAsync().ConfigureAwait(false);
}
else
{
if (serverInfo.Version.Name != discordGameServer.GameVersion)
{
discordGameServer.GameVersion = serverInfo.Version.Name;
discordGameServer.LastVersionUpdate = DateTime.Now;
dbContext.GameServers.Update(discordGameServer);
await dbContext.SaveChangesAsync().ConfigureAwait(false);
}
}
string lastServerUpdate = "";
if (discordGameServer.LastVersionUpdate.HasValue)
{
lastServerUpdate = $" (Last update: {discordGameServer.LastVersionUpdate.Value})";
}
builder.WithFooter($"Server version: {serverInfo.Version.Name}{lastServerUpdate} || Last check: {DateTime.Now}");
// Generate chart every full 5 minutes (limit picture upload API calls)
string pictureUrl = "";
if (DateTime.Now.Minute % 5 == 0)
{
pictureUrl = await GenerateAndUploadChartAsync(
discordGameServer.ServerIP.ToString().Replace(".", "_").Replace(":", "_"),
serverInfo.Players.Online,
serverInfo.Players.Max).ConfigureAwait(false);
if (!pictureUrl.IsEmptyOrWhiteSpace())
{
builder.WithImageUrl(pictureUrl);
}
}
if (discordGameServer.MessageID.HasValue)
{
if (await channel.GetMessageAsync(discordGameServer.MessageID.Value).ConfigureAwait(false) is IUserMessage existingMessage && existingMessage != null)
{
await existingMessage.ModifyAsync(x =>
{
//Reuse old image url if new one is not set
if (pictureUrl.IsEmptyOrWhiteSpace() && existingMessage.Embeds.FirstOrDefault() != null && existingMessage.Embeds.First().Image.HasValue)
{
builder.WithImageUrl(existingMessage.Embeds.First().Image.Value.Url);
}
x.Embed = builder.Build();
}).ConfigureAwait(false);
}
else
{
logger.LogWarning($"Error getting updates for server {discordGameServer.ServerIP}. Original message was removed.");
await RemoveServerAsync(discordGameServer.ServerIP, discordGameServer.GuildID).ConfigureAwait(false);
await channel.SendMessageAsync($"Error getting updates for server {discordGameServer.ServerIP}. Original message was removed. Please use the proper remove command to remove the gameserver").ConfigureAwait(false);
return(false);
}
}
else
{
var message = await(channel?.SendMessageAsync("", false, builder.Build())).ConfigureAwait(false);
discordGameServer.MessageID = message.Id;
dbContext.GameServers.Update(discordGameServer);
await dbContext.SaveChangesAsync().ConfigureAwait(false);
}
}
public async Task AddFactAsync(string fact)
{
_dbContext.BenzenFacts.Add(new BenzenFact(fact));
await _dbContext.SaveChangesAsync();
}
protected override async Task <bool> PostServerInfoAsync(GameServer discordGameServer)
{
if (discordGameServer == null)
{
return(false);
}
SteamGameServer server = null;
try
{
server = new SteamGameServer(discordGameServer.ServerIP);
var serverInfo = await(server?.GetServerInfoAsync()).ConfigureAwait(false);
var playerInfo = (await(server?.GetPlayersAsync()).ConfigureAwait(false)).Where(x => !x.Name.IsEmpty()).ToList();
if (serverInfo == null || playerInfo == null)
{
return(false);
}
var guild = discordClient?.GetGuild(discordGameServer.GuildID);
var channel = guild?.GetTextChannel(discordGameServer.ChannelID);
if (guild == null || channel == null)
{
return(false);
}
var builder = new EmbedBuilder();
builder.WithColor(new Color(21, 26, 35));
builder.WithTitle($"{serverInfo.Description} Server ({discordGameServer.ServerIP.Address}:{serverInfo.Port})");
builder.WithDescription(serverInfo.Name);
builder.AddField("Online Players", $"{playerInfo.Count}/{serverInfo.MaxPlayers}");
builder.AddField("Current Map", serverInfo.Map);
if (playerInfo != null && playerInfo.Count > 0)
{
builder.AddField("Currently connected players:", string.Join(", ", playerInfo.Select(x => x.Name).Where(name => !name.IsEmpty()).OrderBy(x => x)));
}
string connectLink = $"steam://rungameid/{serverInfo.GameId}//%20+connect%20{discordGameServer.ServerIP.Address}:{serverInfo.Port}";
builder.AddField("Connect", $"[Click to connect]({connectLink})");
if (discordGameServer.GameVersion.IsEmpty())
{
discordGameServer.GameVersion = serverInfo.GameVersion;
dbContext.GameServers.Update(discordGameServer);
await dbContext.SaveChangesAsync().ConfigureAwait(false);
}
else
{
if (serverInfo.GameVersion != discordGameServer.GameVersion)
{
discordGameServer.GameVersion = serverInfo.GameVersion;
discordGameServer.LastVersionUpdate = DateTime.Now;
dbContext.GameServers.Update(discordGameServer);
await dbContext.SaveChangesAsync().ConfigureAwait(false);
}
}
string lastServerUpdate = "";
if (discordGameServer.LastVersionUpdate.HasValue)
{
lastServerUpdate = $" (Last update: {discordGameServer.LastVersionUpdate.Value})";
}
builder.AddField("Server version", $"{serverInfo.GameVersion}{lastServerUpdate}");
builder.WithFooter($"Last check: {DateTime.Now}");
if (discordGameServer.MessageID.HasValue)
{
if (await channel.GetMessageAsync(discordGameServer.MessageID.Value).ConfigureAwait(false) is IUserMessage existingMessage && existingMessage != null)
{
await existingMessage.ModifyAsync(x => x.Embed = builder.Build()).ConfigureAwait(false);
}
else
{
logger.LogWarning($"Error getting updates for server {discordGameServer.ServerIP}. Original message was removed.");
await RemoveServerAsync(discordGameServer.ServerIP, discordGameServer.GuildID).ConfigureAwait(false);
await channel.SendMessageAsync($"Error getting updates for server {discordGameServer.ServerIP}. Original message was removed. Please use the proper remove command to remove the gameserver").ConfigureAwait(false);
return(false);
}
}
else
{
discordGameServer.MessageID = (await(channel?.SendMessageAsync("", false, builder.Build())).ConfigureAwait(false)).Id;
dbContext.GameServers.Update(discordGameServer);
await dbContext.SaveChangesAsync().ConfigureAwait(false);
}
}
protected override async Task <bool> PostServerInfoAsync(GameServer discordGameServer)
{
if (discordGameServer == null)
{
return(false);
}
ServerQuery serverQuery = null;
try
{
using var udpClient = new UdpWrapper();
serverQuery = new ServerQuery(udpClient, null);
serverQuery.Connect(discordGameServer.ServerIP.ToString());
ServerInfo serverInfo = await serverQuery.GetServerInfoAsync().ConfigureAwait(false);
List <Player> players = (await serverQuery.GetPlayersAsync().ConfigureAwait(false)).Where(p => !p.Name.IsEmptyOrWhiteSpace()).ToList();
if (serverInfo == null || players == null)
{
return(false);
}
SocketGuild guild = discordClient?.GetGuild(discordGameServer.GuildID);
ITextChannel channel = guild?.GetTextChannel(discordGameServer.ChannelID);
if (guild == null || channel == null)
{
return(false);
}
string onlinePlayers = players.Count > serverInfo.MaxPlayers
? $"{serverInfo.MaxPlayers}(+{players.Count - serverInfo.MaxPlayers})/{serverInfo.MaxPlayers}"
: $"{players.Count}/{serverInfo.MaxPlayers}";
var builder = new EmbedBuilder()
.WithColor(new Color(21, 26, 35))
.WithTitle($"{serverInfo.Game} Server ({discordGameServer.ServerIP.Address}:{serverInfo.Port})")
.WithDescription(serverInfo.Name)
.AddField("Online Players", onlinePlayers)
.AddField("Current Map", serverInfo.Map);
if (players != null && players.Count > 0)
{
_ = builder.AddField("Currently connected players:", string.Join(", ", players.Select(x => x.Name).Where(name => !name.IsEmpty()).OrderBy(x => x)).TruncateTo(1023));
}
//Discord removed support for protocols other than http or https so this currently makes no sense. Leaving it here, in case they re-enable it
//string connectLink = $"steam://connect/{discordGameServer.ServerIP.Address}:{serverInfo.Port}";
//_ = builder.AddField("Connect using this link", connectLink);
if (discordGameServer.GameVersion.IsEmpty())
{
discordGameServer.GameVersion = serverInfo.Version;
_ = dbContext.GameServers.Update(discordGameServer);
_ = await dbContext.SaveChangesAsync().ConfigureAwait(false);
}
else
{
if (serverInfo.Version != discordGameServer.GameVersion)
{
discordGameServer.GameVersion = serverInfo.Version;
discordGameServer.LastVersionUpdate = DateTime.Now;
_ = dbContext.GameServers.Update(discordGameServer);
_ = await dbContext.SaveChangesAsync().ConfigureAwait(false);
}
}
string lastServerUpdate = "";
if (discordGameServer.LastVersionUpdate.HasValue)
{
lastServerUpdate = $" (Last update: {discordGameServer.LastVersionUpdate.Value})";
}
_ = builder.AddField("Server version", $"{serverInfo.Version}{lastServerUpdate}");
_ = builder.WithFooter($"Last check: {DateTime.Now}");
string chart = await GenerateHistoryChartAsync(discordGameServer, serverInfo.Players, serverInfo.MaxPlayers).ConfigureAwait(false);
if (!chart.IsEmptyOrWhiteSpace())
{
_ = builder.AddField("Player Count History", chart);
}
if (discordGameServer.MessageID.HasValue)
{
if (await channel.GetMessageAsync(discordGameServer.MessageID.Value).ConfigureAwait(false) is IUserMessage existingMessage && existingMessage != null)
{
await existingMessage.ModifyAsync(x => x.Embed = builder.Build()).ConfigureAwait(false);
}
else
{
logger.LogWarning($"Error getting updates for server {discordGameServer.ServerIP}. Original message was removed.");
await RemoveServerAsync(discordGameServer.ServerIP, discordGameServer.GuildID).ConfigureAwait(false);
_ = await channel.SendMessageAsync($"Error getting updates for server {discordGameServer.ServerIP}. Original message was removed. Please use the proper remove command to remove the gameserver").ConfigureAwait(false);
return(false);
}
}
else
{
discordGameServer.MessageID = (await(channel?.SendMessageAsync("", false, builder.Build())).ConfigureAwait(false)).Id;
_ = dbContext.GameServers.Update(discordGameServer);
_ = await dbContext.SaveChangesAsync().ConfigureAwait(false);
}
}
protected override async Task <bool> PostServerInfoAsync(GameServer discordGameServer)
{
if (discordGameServer == null)
{
return(false);
}
MineQuery query = null;
try
{
query = new MineQuery(discordGameServer.ServerIP.Address, discordGameServer.ServerIP.Port, logger);
MineQueryResult serverInfo = await query.GetServerInfoAsync().ConfigureAwait(false);
if (serverInfo == null)
{
return(false);
}
SocketGuild guild = discordClient?.GetGuild(discordGameServer.GuildID);
SocketTextChannel channel = guild?.GetTextChannel(discordGameServer.ChannelID);
if (guild == null || channel == null)
{
return(false);
}
EmbedBuilder builder = new EmbedBuilder()
.WithColor(new Color(21, 26, 35))
.WithTitle($"Minecraft Server ({discordGameServer.ServerIP.Address}:{discordGameServer.ServerIP.Port})")
.WithDescription($"Motd: {serverInfo.Description.Motd}");
_ = serverInfo.Players.Sample != null && serverInfo.Players.Sample.Count > 0
? builder.AddField($"Online Players ({serverInfo.Players.Online}/{serverInfo.Players.Max})", string.Join(", ", serverInfo.Players.Sample.Select(x => x.Name)))
: builder.AddField("Online Players", $"{serverInfo.Players.Online}/{serverInfo.Players.Max}");
if (discordGameServer.GameVersion.IsEmpty())
{
discordGameServer.GameVersion = serverInfo.Version.Name;
_ = dbContext.GameServers.Update(discordGameServer);
_ = await dbContext.SaveChangesAsync().ConfigureAwait(false);
}
else
{
if (serverInfo.Version.Name != discordGameServer.GameVersion)
{
discordGameServer.GameVersion = serverInfo.Version.Name;
discordGameServer.LastVersionUpdate = DateTime.Now;
_ = dbContext.GameServers.Update(discordGameServer);
_ = await dbContext.SaveChangesAsync().ConfigureAwait(false);
}
}
string lastServerUpdate = "";
if (discordGameServer.LastVersionUpdate.HasValue)
{
lastServerUpdate = $" (Last update: {discordGameServer.LastVersionUpdate.Value})";
}
_ = builder.WithFooter($"Server version: {serverInfo.Version.Name}{lastServerUpdate} || Last check: {DateTime.Now}");
// Generate chart every full 10 minutes
if (DateTime.Now.Minute % 10 == 0)
{
string chart = await GenerateHistoryChartAsync(discordGameServer, serverInfo.Players.Online, serverInfo.Players.Max).ConfigureAwait(false);
if (!chart.IsEmptyOrWhiteSpace())
{
_ = builder.AddField("Player Count History", chart);
}
}
if (discordGameServer.MessageID.HasValue)
{
if (await channel.GetMessageAsync(discordGameServer.MessageID.Value).ConfigureAwait(false) is IUserMessage existingMessage && existingMessage != null)
{
await existingMessage.ModifyAsync(x => x.Embed = builder.Build()).ConfigureAwait(false);
}
else
{
logger.LogWarning($"Error getting updates for server {discordGameServer.ServerIP}. Original message was removed.");
await RemoveServerAsync(discordGameServer.ServerIP, discordGameServer.GuildID).ConfigureAwait(false);
_ = await channel.SendMessageAsync($"Error getting updates for server {discordGameServer.ServerIP}. Original message was removed. Please use the proper remove command to remove the gameserver").ConfigureAwait(false);
return(false);
}
}
else
{
IUserMessage message = await(channel?.SendMessageAsync("", false, builder.Build())).ConfigureAwait(false);
discordGameServer.MessageID = message.Id;
_ = dbContext.GameServers.Update(discordGameServer);
_ = await dbContext.SaveChangesAsync().ConfigureAwait(false);
}
}