public async Task sil(CommandContext ctx, int miktar)
{
try
{
await ctx.TriggerTypingAsync();
await ctx.Message.DeleteAsync();
DiscordChannel kanal = ctx.Channel;
int sayi = miktar;
do
{
List <DiscordMessage> messages = (await kanal.GetMessagesAsync(sayi > 100 ? 100 : sayi)).ToList();
await kanal.DeleteMessagesAsync(messages);
sayi -= 100;
} while (sayi >= 100);
DiscordMessage msg = await ctx.RespondAsync($"Son {miktar} Mesaj Başarı İle Silindi.");
await Task.Delay(TimeSpan.FromSeconds(3));
await msg.DeleteAsync();
}
catch (Exception ex)
{
Console.WriteLine("HATA : " + ex.Message);
}
}
public static async Task DeleteAsync(this IEnumerable <DiscordMessage> messageCollection)
{
if (messageCollection is null)
{
throw new ArgumentNullException(nameof(messageCollection), "Cannot be null!");
}
DiscordChannel channel = messageCollection.First().Channel;
await channel.DeleteMessagesAsync(messageCollection);
}
private async Task CleanUp(DiscordChannel channel, DiscordMessage afterMessage)
{
var messages = await channel.GetMessagesAfterAsync(afterMessage.Id);
if (messages.Count > 1)
{
await channel.DeleteMessagesAsync(messages);
}
await channel.DeleteMessageAsync(afterMessage);
}
public async Task PruneAsync(ImmutableArray <DiscordMessage> messages, DiscordChannel channel, int baseAmount)
{
if (messages.Length <= 0)
{
throw new FoxException("Uh, I've found no messages to delete. Note that they must be newer than 2 weeks!");
}
await channel.DeleteMessagesAsync(messages);
await SimpleEmbedAsync($"`{messages.Length}/{baseAmount}` messages have been deleted.");
}
public async Task CleanupAsync()
{
if (_messages.Count <= 0)
{
return;
}
if (_channel.Type == DSharpPlus.ChannelType.Text)
{
await _channel.DeleteMessagesAsync(_messages.Where(x => x != null));
}
}
/// <summary>
/// Deletes all the responses in the specific channel
/// </summary>
/// <param name="channel"></param>
/// <param name="count"></param>
/// <returns></returns>
public async Task DeleteAllResponseAsync(DiscordChannel channel, int count = 10)
{
//if (!(Redis is StackExchangeClient))
// throw new Exception("The redis client must be a StackExchangeClient to utlise the SCAN.");
//
//var key = Namespace.Combine(channel.Guild, "replies", "*");
//var redis = Redis as StackExchangeClient;
//var server = redis.GetServersEnumable().First();
//IEnumerable<DiscordMessage> deletes = server.Keys(pattern: key)
// .Select(k => redis.FetchStringAsync(key, "ResponseMsg", "0").Result)
// .Select(str => ulong.TryParse(str, out var id) ? id : 0)
// .Select(id => { try { return channel.GetMessageAsync(id).Result; } catch { return null; } })
// .Where(msg => msg != null);
var messages = await channel.GetMessagesAsync();
await channel.DeleteMessagesAsync(messages.Where(m => m.Author.Id == Bot.Discord.CurrentUser.Id).Take(count), "Cleanup");
}
public async Task Purge(CommandContext ctx, int amount = 100, DiscordChannel channel = null)
{
if (channel == null)
{
channel = ctx.Channel;
}
var messages = await channel.GetMessagesBeforeAsync(ctx.Message.Id, amount);
await channel.DeleteMessagesAsync(messages);
if (ctx.Channel.Id == channel.Id)
{
await ctx.Message.DeleteAsync();
return;
}
await ctx.RespondAsync("Channel cleared");
}
private async Task WaitForCancellationAsync()
{
while (!_cts.IsCancellationRequested)
{
if (!Ready)
{
await Task.Delay(TimeSpan.FromMilliseconds(500));
continue;
}
lock (_lockerObject)
{
Task.Run(async() =>
{
while (Ready)
{
if (DateTime.Now >= _nextStatusCheck)
{
_nextStatusCheck = DateTime.Now + Program.Config.UpdateDelay;
try
{
var request = (HttpWebRequest)WebRequest.Create(Program.Config.StatusURL);
request.ContentType = "application/json";
request.Credentials = CredentialCache.DefaultCredentials;
var res = request.GetResponse();
var serverList = new List <ServerModel>();
await using (var stream = res.GetResponseStream())
{
if (stream != null)
{
using var reader = new StreamReader(stream);
var result = await reader.ReadToEndAsync();
serverList = JsonConvert.DeserializeObject <List <ServerModel> >(result);
}
}
res.Close();
res.Dispose();
foreach (var serverModel in serverList)
{
if (await Program.ServerStatusRepository.EntryExists(Convert.ToInt32(serverModel.Id)))
{
var model = await Program.ServerStatusRepository.FindById(
Convert.ToInt32(serverModel.Id));
model.CurrentStatus.EditTime = DateTime.Now;
model.CurrentStatus.Online = serverModel.Online == "1";
model.CurrentStatus.UserCount = Convert.ToInt32(serverModel.UserCount);
model.History = new List <ServerEntryStatusHistory>
{
new ServerEntryStatusHistory
{
EntryTime = DateTime.Now, Id = Guid.NewGuid(),
Online = serverModel.Online == "1", ServerId = model.Id,
UserCount = model.CurrentStatus.UserCount
}
};
await Program.ServerStatusRepository.UpdateCurrentStatusAsync(model);
}
else
{
var model = new ServerEntry
{
CurrentStatus = new ServerEntryStatus(),
ExpRate = serverModel.EXPRate,
Id = Guid.NewGuid(),
RgbColor = "rgb(0, 0, 0)",
ServerId = Convert.ToInt32(serverModel.Id),
ServerName = serverModel.Name,
ServerType = serverModel.Type
};
model.CurrentStatus.Id = Guid.NewGuid();
model.CurrentStatus.EditTime = DateTime.Now;
model.CurrentStatus.Online = serverModel.Online == "1";
model.CurrentStatus.UserCount = Convert.ToInt32(serverModel.UserCount);
model.History = new List <ServerEntryStatusHistory>
{
new ServerEntryStatusHistory
{
EntryTime = DateTime.Now, Id = Guid.NewGuid(),
Online = serverModel.Online == "1", ServerId = model.Id,
UserCount = model.CurrentStatus.UserCount
}
};
await _serverStatusRepository.AddServerAsync(model);
}
}
}
catch (Exception e)
{
Program.Log(e);
}
}
if (DateTime.Now < _nextOutputTime)
{
await Task.Delay(500);
continue;
}
_nextOutputTime = DateTime.Now + Program.Config.OutputDelay;
try
{
var models = await _serverStatusRepository.GetAllAsync();
models = models.OrderByDescending(a => a.CurrentStatus.Online)
.ThenByDescending(a => a.CurrentStatus.UserCount != -1)
.ThenByDescending(a => a.CurrentStatus.UserCount).ToList();
var temp = "```md\r\n";
foreach (var serverEntry in models)
{
temp += Program.Config.OutputFormat
.Replace("$SERVERNAME$", serverEntry.ServerName)
.Replace("$STATUS$", serverEntry.CurrentStatus.Online ? "Online" : "Offline")
.Replace("$USERCOUNT$", $"{serverEntry.CurrentStatus.UserCount}");
if (!temp.EndsWith("\r\n"))
{
temp += "\r\n";
}
}
temp += "```";
if (_lastMessage != null)
{
await _channel.DeleteMessageAsync(_lastMessage);
}
else
{
var currentMessages = await _channel.GetMessagesAsync();
if (currentMessages != null)
{
await _channel.DeleteMessagesAsync(currentMessages);
}
}
_lastMessage = await _channel.SendMessageAsync(temp);
}
catch (Exception e)
{
Program.Log(e);
}
await Task.Delay(500);
}
});
}
await Task.Delay(-1);
}
}
/// <summary>
/// Deletes a list of <see cref="DiscordMessage" /> from the <see cref="DiscordMember" /> in the
/// <see cref="DiscordChannel" />.
/// </summary>
/// <param name="channel">Represents the <see cref="DiscordChannel" />.</param>
/// <param name="messages">Represents a list of <see cref="DiscordMessage" /> which will deleted.</param>
/// <param name="member">
/// Represents the suspect <see cref="DiscordMember" /> which will all his
/// <see cref="DiscordMessage" />s
/// </param>
/// <param name="reason">Represents the reason why those <see cref="DiscordMessage" />s has been deleted.</param>
/// <returns></returns>
public static async Task BulkMessagesFromUserAsync(this DiscordChannel channel, IEnumerable <DiscordMessage> messages, DiscordMember member, string reason = null)
{
var memberMessage = messages.Where(x => x.Author == member)
.ToList();
await channel.DeleteMessagesAsync(memberMessage, reason);
}
/// <summary>
/// Deletes a list of <see cref="DiscordMessage" /> in the <see cref="DiscordChannel" />.
/// </summary>
/// <param name="channel">Represents the <see cref="DiscordChannel" />.</param>
/// <param name="messages">Represents a list of <see cref="DiscordMessage" /> which will deleted.</param>
/// <param name="reason">Represents the reason why those <see cref="DiscordMessage" />s has been deleted.</param>
/// <returns></returns>
public static async Task BulkMessagesAsync(this DiscordChannel channel, IEnumerable <DiscordMessage> messages, string reason = null)
{
await channel.DeleteMessagesAsync(messages, reason);
}
public static async Task UpdateGuildRanking(DiscordGuild e)
{
DiscordChannel RankingChannel = RPClass.GuildRankingChannel;
if (!RPClass.Guilds.Any())
{
try
{
await RankingChannel.DeleteMessagesAsync(await RankingChannel.GetMessagesAsync(100));
}
catch {
var msgs = await RankingChannel.GetMessagesAsync(100);
foreach (var msg in msgs)
{
await msg.DeleteAsync();
}
}
return;
}
try
{
await RankingChannel.DeleteMessagesAsync(await RankingChannel.GetMessagesAsync(100));
}
catch {
var msgs = await RankingChannel.GetMessagesAsync(100);
foreach (var msg in msgs)
{
await msg.DeleteAsync();
}
}
List <string> tableStrings = new List <string>();
int positionMax = 4;
int nameMax = RPClass.Guilds.Max(x => x.Name.Length) + 2;
int fameMax = 6;
int infamyMax = 8;
int rankMax = 6;
if (nameMax < 6)
{
nameMax = 6;
}
string table = $"╔{new string('═', positionMax)}╤{new string('═', nameMax)}╤{new string('═', fameMax)}╤{new string('═', infamyMax)}╤{new string('═', rankMax)}╗\n";
table += $"║{"Pos".PadRight(positionMax)}│{" Name".PadRight(nameMax)}│{" Fame".PadRight(fameMax)}│{" Infamy".PadRight(infamyMax)}│{" Rank".PadRight(rankMax)}║\n";
table += $"╠{new string('═', positionMax)}╪{new string('═', nameMax)}╪{new string('═', fameMax)}╪{new string('═', infamyMax)}╪{new string('═', rankMax)}╣\n";
List <GuildObject.RootObject> GuildsNew = new List <GuildObject.RootObject>();
foreach (GuildObject.RootObject guild in RPClass.Guilds)
{
int xp = 0;
int fame = 0;
int infamy = 0;
UserObject.RootObject user;
if (guild.UserIDs.Count > 0)
{
foreach (ulong num in guild.UserIDs)
{
user = RPClass.Users.FirstOrDefault(x => x.UserData.UserID == num);
if (user != null)
{
xp += user.Xp;
fame += user.UserData.Fame;
infamy += user.UserData.Infamy;
}
}
xp = (xp / guild.UserIDs.Count);
GuildsNew.Add(new GuildObject.RootObject(0, guild.Name, new List <ulong>()
{
(ulong)xp, (ulong)fame, (ulong)infamy
})); // xp, fame, infamy
}
}
List <GuildObject.RootObject> SortedGuilds = GuildsNew.OrderByDescending(x => x.UserIDs[0]).ToList();
int countNum = 1;
foreach (GuildObject.RootObject guild in SortedGuilds)
{
ulong rank = guild.UserIDs[0];
RPClass.Users.Where(x => x.UserData.GuildID == guild.Id);
string GuildRank = "S1";
if (rank < 10000)
{
GuildRank = "S2";
}
if (rank < 9000)
{
GuildRank = "S3";
}
if (rank < 8000)
{
GuildRank = "A1";
}
if (rank < 7000)
{
GuildRank = "A2";
}
if (rank < 6000)
{
GuildRank = "A3";
}
if (rank < 5500)
{
GuildRank = "B1";
}
if (rank < 5000)
{
GuildRank = "B2";
}
if (rank < 4500)
{
GuildRank = "B3";
}
if (rank < 4000)
{
GuildRank = "C1";
}
if (rank < 3000)
{
GuildRank = "C2";
}
if (rank < 2500)
{
GuildRank = "C3";
}
if (rank < 2000)
{
GuildRank = "D1";
}
if (rank < 1000)
{
GuildRank = "D2";
}
if (rank < 500)
{
GuildRank = "D3";
}
table += $"║{countNum.ToString().PadRight(positionMax)}│ {guild.Name.PadRight(nameMax - 1)}│ {guild.UserIDs[1].ToString().PadRight(fameMax - 1)}│ {guild.UserIDs[2].ToString().PadRight(infamyMax - 1)}│ {GuildRank.PadRight(rankMax - 1)}║\n";
if (table.Length > 1500)
{
table += $"╚{new string('═', positionMax)}╧{new string('═', nameMax)}╧{new string('═', fameMax)}╧{new string('═', infamyMax)}╧{new string('═', rankMax)}╝";
tableStrings.Add(table);
table = "";
if (guild != SortedGuilds.Last())
{
table = $"╔{new string('═', positionMax)}╤{new string('═', nameMax)}╤{new string('═', fameMax)}╤{new string('═', infamyMax)}╤{new string('═', rankMax)}╗\n";
}
}
countNum += 1;
}
if (table != "")
{
table += $"╚{new string('═', positionMax)}╧{new string('═', nameMax)}╧{new string('═', fameMax)}╧{new string('═', infamyMax)}╧{new string('═', rankMax)}╝";
tableStrings.Add(table);
}
foreach (var tableString in tableStrings)
{
await RankingChannel.SendMessageAsync("```" + tableString + "```");
}
}
public static async Task UpdatePlayerRanking(DiscordGuild e, int type)
{
DiscordChannel RankingChannel = RPClass.HeroRankingChannel;
if (type == 2)
{
RankingChannel = RPClass.VillainRankingChannel;
}
else if (type == 3)
{
RankingChannel = RPClass.RogueRankingChannel;
}
else if (type == 4)
{
RankingChannel = RPClass.AcademyRankingChannel;
}
if (!RPClass.Users.Where(x => x.UserData.Role == type && x.Xp > 0).Any())
{
try
{
await RankingChannel.DeleteMessagesAsync(await RankingChannel.GetMessagesAsync(100));
}
catch {
var msgs = await RankingChannel.GetMessagesAsync(100);
foreach (var msg in msgs)
{
await msg.DeleteAsync();
}
}
return;
}
try
{
await RankingChannel.DeleteMessagesAsync(await RankingChannel.GetMessagesAsync(100));
}
catch {
var msgs = await RankingChannel.GetMessagesAsync(100);
foreach (var msg in msgs)
{
await msg.DeleteAsync();
}
}
List <UserObject.RootObject> SortedUsers = new List <UserObject.RootObject>();
SortedUsers = RPClass.Users.Where(x => x.UserData.Role == type).OrderByDescending(x => (x.Xp)).ToList();
int countNum = 1;
var tableData = new List <RankingRow>();
foreach (UserObject.RootObject user in SortedUsers)
{
string userGuild = "";
if (user.UserData.GuildID == 0)
{
userGuild += "N/A";
}
else
{
userGuild += RPClass.Guilds.First(x => x.Id == user.UserData.GuildID && x.UserIDs.Contains(user.UserData.UserID)).Name;
}
tableData.Add(new RankingRow(countNum.ToString(), user.UserData.Username, user.UserData.Fame.ToString(), user.UserData.Infamy.ToString(), userGuild, user.GetRank()));
countNum += 1;
}
foreach (var table in CreateRankingTable(tableData))
{
await RankingChannel.SendMessageAsync("```" + table + "```");
}
}
// Non-Command Methods
public static async Task UpdateStats(DiscordChannel c)
{
if (!RPClass.Users.Where(x => x.Xp > 0).Any())
{
try
{
await c.DeleteMessagesAsync(await c.GetMessagesAsync(100));
}
catch {
var msgs = await c.GetMessagesAsync(100);
foreach (var msg in msgs)
{
await msg.DeleteAsync();
}
}
return;
}
try
{
await c.DeleteMessagesAsync(await c.GetMessagesAsync(100));
}
catch {
var msgs = await c.GetMessagesAsync(100);
foreach (var msg in msgs)
{
await msg.DeleteAsync();
}
}
int longestName = 1;
if (RPClass.Users.Any())
{
longestName = RPClass.Users.Where(x => x.Xp > 0).Max(x => x.UserData.Username.Length) + 2;
}
int longestXP = 7;
var tables = new List <string>();
string table = $"╔{new string('═', longestName)}╤{new string('═', longestXP)}╗\n";
table += $"║{" Name".PadRight(longestName)}│{" XP".PadRight(longestXP)}║\n";
table += $"╠{new string('═', longestName)}╪{new string('═', longestXP)}╣\n";
List <UserObject.RootObject> SortedUsers = new List <UserObject.RootObject>();
SortedUsers = RPClass.Users.OrderByDescending(x => x.Xp).ToList();
foreach (UserObject.RootObject user in SortedUsers)
{
if (user.Xp > 0)
{
table += $"║ {user.UserData.Username.PadRight(longestName-1)}│ {user.Xp.ToString().PadRight(longestXP-1)}║\n";
if (table.Length > 1500)
{
table += $"╚{new string('═', longestName)}╧{new string('═', longestXP)}╝\n";
tables.Add(table);
table = "";
if (user != SortedUsers.Last())
{
table += $"╔{new string('═', longestName)}╤{new string('═', longestXP)}╗\n";
}
}
}
}
if (table != "")
{
table += $"╚{new string('═', longestName)}╧{new string('═', longestXP)}╝\n";
tables.Add(table);
}
foreach (var tableString in tables)
{
await c.SendMessageAsync("```" + tableString + "```");
}
}
public static async Task UpdateGuildRanking(DiscordGuild e)
{
if (!RPClass.Guilds.Any())
{
return;
}
DiscordChannel RankingChannel = RPClass.GuildChannel;
int longestCount = 5;
int longestName = 10;
longestName = RPClass.Guilds.Max(x => x.Name.Length) + 1;
string Count = "Pos".PadRight(longestCount) + "| ";
string Name = "Name".PadRight(longestName) + "| ";
string Rank = "Rank";
string value = $"```{Count}{Name}{Rank}\n{new string('-', $"{Count}{Name}{Rank}".Length + 4)}\n";
List <GuildObject.StatSheetObject> GuildsNew = new List <GuildObject.StatSheetObject>();
foreach (var guild in RPClass.Guilds)
{
int xp = 0;
foreach (var guildMember in RPClass.Users.Where(x => x.UserData.FactionID == guild.Id))
{
if (guildMember != null)
{
xp += guildMember.UserData.Xp;
}
}
if (xp != 0)
{
xp = (xp / RPClass.Users.Where(x => x.UserData.FactionID == guild.Id).Count());
}
GuildsNew.Add(new GuildObject.StatSheetObject(guild.Name, xp));
}
List <GuildObject.StatSheetObject> SortedGuilds = GuildsNew.OrderByDescending(x => x.Xp).ToList();
try
{
await RankingChannel.DeleteMessagesAsync(await RankingChannel.GetMessagesAsync(100));
}
catch { }
int countNum = 1;
foreach (GuildObject.StatSheetObject guild in SortedGuilds)
{
int rank = guild.Xp;
string GuildRank = "Tier 10";
if (rank < 20000)
{
GuildRank = "Tier 9";
}
if (rank < 17000)
{
GuildRank = "Tier 8";
}
if (rank < 14000)
{
GuildRank = "Tier 7";
}
if (rank < 11000)
{
GuildRank = "Tier 6";
}
if (rank < 8000)
{
GuildRank = "Tier 5";
}
if (rank < 6000)
{
GuildRank = "Tier 4";
}
if (rank < 4000)
{
GuildRank = "Tier 3";
}
if (rank < 2000)
{
GuildRank = "Tier 2";
}
if (rank < 1000)
{
GuildRank = "Tier 1";
}
if (value.Length > 1500)
{
await RankingChannel.SendMessageAsync(value + "```");
value = "```";
}
value += (countNum.ToString().PadRight(longestCount) + "| " + guild.Name.PadRight(longestName) + "| " + GuildRank + "\n");
countNum += 1;
}
await RankingChannel.SendMessageAsync(value + "```");
}
public static async Task UpdatePlayerRanking(DiscordGuild e)
{
var ocs = RPClass.Users.Where(x => x.UserData.Xp > 0);
if (!ocs.Any())
{
return;
}
var members = await e.GetAllMembersAsync();
DiscordChannel RankingChannel = RPClass.StatsChannel;
int longestName = ocs.Max(x => members.First(y => y.Id == x.UserData.UserID).DisplayName.Length) + 1;
if (longestName < 5)
{
longestName = 5;
}
int longestCount = 4;
int longestGuild = RPClass.Guilds.Select(x => x.Name.Length).DefaultIfEmpty(7).Max() + 1;
if (longestGuild < 8)
{
longestGuild = 8;
}
string Count = "Pos".PadRight(longestCount) + "| ";
string Name = "Name".PadRight(longestName) + "| ";
string Faction = "Faction".PadRight(longestGuild) + "| ";
string Rank = "Rank";
string value = "";
value += $"```{Count}{Name}{Faction}{Rank}\n{new string('-', $"{Count}{Name}{Faction}{Rank}".Length + 4)}\n";
List <UserObject.RootObject> SortedUsers = new List <UserObject.RootObject>();
SortedUsers = ocs.OrderByDescending(x => (x.UserData.Xp)).ToList();
try
{
await RankingChannel.DeleteMessagesAsync(await RankingChannel.GetMessagesAsync(100));
}
catch { }
int countNum = 1;
foreach (UserObject.RootObject user in SortedUsers)
{
string UserRank = user.UserData.GetRank();
string UserFaction = "";
if (user.UserData.FactionID == 0)
{
UserFaction += "N/A";
}
else
{
UserFaction += RPClass.Guilds.First(x => x.Id == user.UserData.FactionID).Name;
}
if (value.Length > 1500)
{
await RankingChannel.SendMessageAsync(value + "```");
value = "```";
}
value += (countNum.ToString().PadRight(longestCount) + "| " + members.First(y => y.Id == user.UserData.UserID).DisplayName.PadRight(longestName) + "| " + UserFaction.PadRight(longestGuild) + "| " + UserRank + "\n");
countNum += 1;
}
await RankingChannel.SendMessageAsync(value + "```");
}
