public ActionResult Add(long playerId, string from)
{
var blacklistEntryToRemove = new BlacklistEntry(playerId, from);
_blacklistEntryAdder.Add("ns2", blacklistEntryToRemove);
TempData["Success"] = string.Format("{0} blacklisted from {1}.", playerId, from);
return(RedirectToAction("Manage"));
}
public async Task Check(CommandContext ctx)
{
await ctx.RespondAsync(
$"{Bot.BotSettings.OkEmoji} Запущена проверка всех зарегистрированных аккаунтов. Она может занять некоторое время.");
await ctx.TriggerTypingAsync();
var blacklist = BlacklistEntry.GetAll();
var message = "**Следующие учётные записи были добавлены в чёрный список:**\n";
/*
* Algorythm:
* 1) Get all BL entries
* 2) For each BL entry:
* 2.1) Get all accounts with the same IP.
* 2.2) If is not the same account, then add to banlist
*/
foreach (var entry in blacklist)
{
var webUser = WebUser.GetByDiscordId(entry.DiscordId);
if (webUser == null)
{
continue;
}
foreach (var ip in webUser.Ips)
{
var sameIp = WebUser.GetUsersByIp(ip);
foreach (var sameIpUser in sameIp)
{
if (!BlacklistEntry.IsBlacklisted(sameIpUser.UserId))
{
string id = RandomString.NextString(6);
BlacklistEntry.Create(id, sameIpUser.UserId, sameIpUser.Username, sameIpUser.LastXbox,
DateTime.Now, ctx.Client.CurrentUser.Id, "Автоматическая блокировка системой защиты",
"");
message +=
$"• {sameIpUser.Username} ({sameIpUser.UserId}) - совпадение по IP c баном {entry.Id} ({webUser.Username})\n";
try
{
var member = await ctx.Guild.GetMemberAsync(sameIpUser.UserId);
await member.RevokeRoleAsync(ctx.Guild.GetRole(Bot.BotSettings.FleetCodexRole));
}
catch
{
}
}
}
}
}
await ctx.RespondAsync(message);
}
public void SaveBlacklistEntry(BlacklistEntry BlacklistEntry)
{
if (BlacklistEntry.Id == 0)
{
context.BlacklistEntries.Add(BlacklistEntry);
}
else
{
var editMe = context.BlacklistEntries.Find(BlacklistEntry.Id);
if (editMe != null)
{
// dbEntry.Name = BlacklistEntry.Name;
// dbEntry.Message = BlacklistEntry.Message;
// dbEntry.TimeStamp = BlacklistEntry.TimeStamp;
}
}
context.SaveChanges();
}
public static string TogglePlayerBlacklist(Player creator, Player receiver)
{
IBlacklistEntryRepository repo = new EFBlacklistEntryRepository();
var entry = repo.BlacklistEntries.FirstOrDefault(e => e.CreatorMembershipId == creator.MembershipId && e.TargetMembershipId == receiver.MembershipId);
if (entry != null)
{
repo.DeleteBlacklistEntry(entry.Id);
return(receiver.GetFullName() + " has been REMOVED from your blacklist.");
}
else
{
var newentry = new BlacklistEntry
{
CreatorMembershipId = creator.MembershipId,
TargetMembershipId = receiver.MembershipId,
Timestamp = DateTime.UtcNow,
BlacklistLevel = 1
};
repo.SaveBlacklistEntry(newentry);
return(receiver.GetFullName() + " has been ADDED to your blacklist.");
}
}
private Task InitCommands()
{
Command <TUser> newCommand = null;
// !global
newCommand = new Command <TUser>("global");
newCommand.Type = CommandType.Standard;
newCommand.Description = "Display all teh numbers.";
newCommand.RequiredPermissions = PermissionType.OwnerOnly;
newCommand.OnExecute += async e => {
StringBuilder shards = new StringBuilder();
GlobalContext dbContext = GlobalContext.Create(this.DbConfig.GetDbConnectionString());
Shard globalCount = new Shard();
foreach (Shard shard in dbContext.Shards)
{
globalCount.ServerCount += shard.ServerCount;
globalCount.UserCount += shard.UserCount;
globalCount.MemoryUsed += shard.MemoryUsed;
globalCount.ThreadsActive += shard.ThreadsActive;
globalCount.MessagesTotal += shard.MessagesTotal;
globalCount.MessagesPerMinute += shard.MessagesPerMinute;
globalCount.OperationsRan += shard.OperationsRan;
globalCount.OperationsActive += shard.OperationsActive;
globalCount.Disconnects += shard.Disconnects;
shards.AppendLine(shard.GetStatsString());
}
string message = "Server Status: <http://status.botwinder.info>\n\n" +
$"Global Servers: `{globalCount.ServerCount}`\n" +
$"Global Members `{globalCount.UserCount}`\n" +
$"Global Allocated data Memory: `{globalCount.MemoryUsed} MB`\n" +
$"Global Threads: `{globalCount.ThreadsActive}`\n" +
$"Global Messages received: `{globalCount.MessagesTotal}`\n" +
$"Global Messages per minute: `{globalCount.MessagesPerMinute}`\n" +
$"Global Operations ran: `{globalCount.OperationsRan}`\n" +
$"Global Operations active: `{globalCount.OperationsActive}`\n" +
$"Global Disconnects: `{globalCount.Disconnects}`\n" +
$"\n**Shards: `{dbContext.Shards.Count()}`**\n\n" +
$"{shards.ToString()}";
await SendMessageToChannel(e.Channel, message);
};
this.Commands.Add(newCommand.Id, newCommand);
// !getServer
newCommand = new Command <TUser>("getServer");
newCommand.Type = CommandType.Standard;
newCommand.Description = "Display some info about specific server with id/name, or owners id/username.";
newCommand.RequiredPermissions = PermissionType.OwnerOnly;
newCommand.OnExecute += async e => {
if (string.IsNullOrEmpty(e.TrimmedMessage))
{
await SendMessageToChannel(e.Channel, "Requires parameters.");
return;
}
guid id;
guid.TryParse(e.TrimmedMessage, out id);
StringBuilder response = new StringBuilder();
IEnumerable <ServerStats> foundServers = null;
if (!(foundServers = ServerContext.Create(this.DbConfig.GetDbConnectionString()).ServerStats.Where(s =>
s.ServerId == id || s.OwnerId == id ||
s.ServerName.ToLower().Contains($"{e.TrimmedMessage.ToLower()}") ||
s.OwnerName.ToLower().Contains($"{e.TrimmedMessage.ToLower()}")
)).Any())
{
await SendMessageToChannel(e.Channel, "Server not found.");
return;
}
if (foundServers.Count() > 5)
{
response.AppendLine("__**Found more than 5 servers!**__\n");
}
foreach (ServerStats server in foundServers.Take(5))
{
response.AppendLine(server.ToString());
response.AppendLine();
}
await SendMessageToChannel(e.Channel, response.ToString());
};
this.Commands.Add(newCommand.Id, newCommand);
// !getInvite
newCommand = new Command <TUser>("getInvite");
newCommand.Type = CommandType.Standard;
newCommand.Description = "Get an invite url with serverid.";
newCommand.RequiredPermissions = PermissionType.OwnerOnly;
newCommand.OnExecute += async e => {
guid id;
ServerConfig foundServer = null;
if (string.IsNullOrEmpty(e.TrimmedMessage) ||
!guid.TryParse(e.TrimmedMessage, out id) ||
(foundServer = ServerContext.Create(this.DbConfig.GetDbConnectionString()).ServerConfigurations.FirstOrDefault(s => s.ServerId == id)) == null)
{
await SendMessageToChannel(e.Channel, "Server not found.");
return;
}
if (string.IsNullOrEmpty(foundServer.InviteUrl))
{
await SendMessageToChannel(e.Channel, "I don't have permissions to create this InviteUrl.");
return;
}
await SendMessageToChannel(e.Channel, foundServer.InviteUrl);
};
this.Commands.Add(newCommand.Id, newCommand);
// !maintenance
newCommand = new Command <TUser>("maintenance");
newCommand.Type = CommandType.Standard;
newCommand.Description = "Performe maintenance";
newCommand.RequiredPermissions = PermissionType.OwnerOnly;
newCommand.OnExecute += async e => {
await SendMessageToChannel(e.Channel, "Okay, this may take a while...");
await LogMaintenanceAndExit();
};
this.Commands.Add(newCommand.Id, newCommand);
// !restart
newCommand = new Command <TUser>("restart");
newCommand.Type = CommandType.Standard;
newCommand.Description = "Shut down the bot.";
newCommand.RequiredPermissions = PermissionType.OwnerOnly;
newCommand.OnExecute += async e => {
await SendMessageToChannel(e.Channel, "bai");
await Task.Delay(1000);
Environment.Exit(0);
};
this.Commands.Add(newCommand.Id, newCommand);
this.Commands.Add("shutdown", newCommand.CreateAlias("shutdown"));
// !getExceptions
newCommand = new Command <TUser>("getExceptions");
newCommand.Type = CommandType.Standard;
newCommand.Description = "Get a list of exceptions.";
newCommand.RequiredPermissions = PermissionType.OwnerOnly;
newCommand.OnExecute += async e => {
StringBuilder response = new StringBuilder();
if (string.IsNullOrEmpty(e.TrimmedMessage) || !int.TryParse(e.TrimmedMessage, out int n) || n <= 0)
{
n = 5;
}
GlobalContext dbContext = GlobalContext.Create(this.DbConfig.GetDbConnectionString());
foreach (ExceptionEntry exception in dbContext.Exceptions.Skip(Math.Max(0, dbContext.Exceptions.Count() - n)))
{
response.AppendLine(exception.GetMessage());
}
string responseString = response.ToString();
if (string.IsNullOrWhiteSpace(responseString))
{
responseString = "I did not record any errors :stuck_out_tongue:";
}
await SendMessageToChannel(e.Channel, responseString);
};
this.Commands.Add(newCommand.Id, newCommand);
// !getException
newCommand = new Command <TUser>("getException");
newCommand.Type = CommandType.Standard;
newCommand.Description = "Get an exception stack for specific ID.";
newCommand.RequiredPermissions = PermissionType.OwnerOnly;
newCommand.OnExecute += async e => {
string responseString = "I couldn't find that exception.";
ExceptionEntry exception = null;
GlobalContext dbContext = GlobalContext.Create(this.DbConfig.GetDbConnectionString());
if (!string.IsNullOrEmpty(e.TrimmedMessage) && int.TryParse(e.TrimmedMessage, out int id) && (exception = dbContext.Exceptions.FirstOrDefault(ex => ex.Id == id)) != null)
{
responseString = exception.GetStack();
}
await SendMessageToChannel(e.Channel, responseString);
};
this.Commands.Add(newCommand.Id, newCommand);
// !blacklist
newCommand = new Command <TUser>("blacklist");
newCommand.Type = CommandType.Standard;
newCommand.Description = "Add or remove an ID to or from the blacklist.";
newCommand.RequiredPermissions = PermissionType.OwnerOnly;
newCommand.OnExecute += async e => {
guid id = 0;
string responseString = "Invalid parameters.";
if (e.MessageArgs == null || e.MessageArgs.Length < 2 || !guid.TryParse(e.MessageArgs[1], out id))
{
if (!e.Message.MentionedUsers.Any())
{
await SendMessageToChannel(e.Channel, responseString);
return;
}
id = e.Message.MentionedUsers.First().Id;
}
GlobalContext dbContext = GlobalContext.Create(this.DbConfig.GetDbConnectionString());
ServerStats server = ServerContext.Create(this.DbConfig.GetDbConnectionString()).ServerStats
.FirstOrDefault(s => s.ServerId == id || s.OwnerId == id);
switch (e.MessageArgs[0])
{
case "add":
if (dbContext.Blacklist.Any(b => b.Id == id))
{
responseString = "That ID is already blacklisted.";
break;
}
dbContext.Blacklist.Add(new BlacklistEntry()
{
Id = id
});
dbContext.SaveChanges();
responseString = server == null ? "Done." : server.ServerId == id ?
$"I'll be leaving `{server.OwnerName}`'s server `{server.ServerName}` shortly." :
$"All of `{server.OwnerName}`'s servers are now blacklisted.";
break;
case "remove":
BlacklistEntry entry = dbContext.Blacklist.FirstOrDefault(b => b.Id == id);
if (entry == null)
{
responseString = "That ID was not blacklisted.";
break;
}
dbContext.Blacklist.Remove(entry);
dbContext.SaveChanges();
responseString = server == null ? "Done." : server.ServerId == id ?
$"Entry for `{server.OwnerName}`'s server `{server.ServerName}` was removed from the balcklist." :
$"Entries for all `{server.OwnerName}`'s servers were removed from the blacklist.";
break;
default:
responseString = "Invalid keyword.";
break;
}
await SendMessageToChannel(e.Channel, responseString);
};
this.Commands.Add(newCommand.Id, newCommand);
// !subscriber
newCommand = new Command <TUser>("subscriber");
newCommand.Type = CommandType.Standard;
newCommand.Description = "Add or remove an ID to or from the subscribers, use with optional bonus or premium parameter.";
newCommand.RequiredPermissions = PermissionType.OwnerOnly;
newCommand.OnExecute += async e => {
guid id = 0;
string responseString = "Invalid parameters.";
if (e.MessageArgs == null || e.MessageArgs.Length < 2 ||
!guid.TryParse(e.MessageArgs[1], out id))
{
if (!e.Message.MentionedUsers.Any())
{
await SendMessageToChannel(e.Channel, responseString);
return;
}
id = e.Message.MentionedUsers.First().Id;
}
GlobalContext dbContext = GlobalContext.Create(this.DbConfig.GetDbConnectionString());
Subscriber subscriber = dbContext.Subscribers.FirstOrDefault(s => s.UserId == id);
switch (e.MessageArgs[0]) //Nope - mentioned users above mean that there is a parameter.
{
case "add":
if (subscriber == null)
{
dbContext.Subscribers.Add(subscriber = new Subscriber()
{
UserId = id
});
}
for (int i = 2; i < e.MessageArgs.Length; i++)
{
subscriber.HasBonus = subscriber.HasBonus || e.MessageArgs[i] == "bonus";
subscriber.IsPremium = subscriber.IsPremium || e.MessageArgs[i] == "premium";
}
dbContext.SaveChanges();
responseString = "Done.";
break;
case "remove":
if (subscriber == null)
{
responseString = "That ID was not a subscriber.";
break;
}
responseString = "Done.";
if (e.MessageArgs.Length < 3)
{
dbContext.Subscribers.Remove(subscriber);
break;
}
for (int i = 2; i < e.MessageArgs.Length; i++)
{
subscriber.HasBonus = subscriber.HasBonus && e.MessageArgs[i] != "bonus";
subscriber.IsPremium = subscriber.IsPremium && e.MessageArgs[i] != "premium";
}
dbContext.SaveChanges();
break;
default:
responseString = "Invalid keyword.";
break;
}
await SendMessageToChannel(e.Channel, responseString);
};
this.Commands.Add(newCommand.Id, newCommand);
// !partner
newCommand = new Command <TUser>("partner");
newCommand.Type = CommandType.Standard;
newCommand.Description = "Add or remove an ID to or from the partners, use with optional premium parameter.";
newCommand.RequiredPermissions = PermissionType.OwnerOnly;
newCommand.OnExecute += async e => {
guid id = 0;
string responseString = "Invalid parameters.";
if (e.MessageArgs == null || e.MessageArgs.Length < 2 ||
!guid.TryParse(e.MessageArgs[1], out id))
{
if (!e.Message.MentionedUsers.Any())
{
await SendMessageToChannel(e.Channel, responseString);
return;
}
id = e.Message.MentionedUsers.First().Id;
}
GlobalContext dbContext = GlobalContext.Create(this.DbConfig.GetDbConnectionString());
PartneredServer partner = dbContext.PartneredServers.FirstOrDefault(s => s.ServerId == id);
switch (e.MessageArgs[0]) //Nope - mentioned users above mean that there is a parameter.
{
case "add":
if (partner == null)
{
dbContext.PartneredServers.Add(partner = new PartneredServer()
{
ServerId = id
});
}
if (e.MessageArgs.Length > 2)
{
partner.IsPremium = partner.IsPremium || e.MessageArgs[2] == "premium";
}
dbContext.SaveChanges();
responseString = "Done.";
break;
case "remove":
if (partner == null)
{
responseString = "That ID was not a partner.";
break;
}
responseString = "Done.";
if (e.MessageArgs.Length < 3)
{
dbContext.PartneredServers.Remove(partner);
break;
}
if (e.MessageArgs.Length > 2)
{
partner.IsPremium = partner.IsPremium && e.MessageArgs[2] != "premium";
}
dbContext.SaveChanges();
break;
default:
responseString = "Invalid keyword.";
break;
}
await SendMessageToChannel(e.Channel, responseString);
};
this.Commands.Add(newCommand.Id, newCommand);
// !operations
newCommand = new Command <TUser>("operations");
newCommand.Type = CommandType.Standard;
newCommand.Description = "Display info about all queued or running operations on your server.";
newCommand.RequiredPermissions = PermissionType.ServerOwner | PermissionType.Admin;
newCommand.OnExecute += async e => {
StringBuilder response = new StringBuilder();
bool allOperations = IsGlobalAdmin(e.Message.Author.Id);
response.AppendLine($"Total operations in the queue: `{this.CurrentOperations.Count}`");
if (allOperations)
{
response.AppendLine($"Currently allocated data Memory: `{(GC.GetTotalMemory(false) / 1000000f):#0.00} MB`");
}
response.AppendLine();
lock (this.OperationsLock)
{
foreach (Operation <TUser> op in this.CurrentOperations)
{
if (!allOperations && op.CommandArgs.Server.Id != e.Server.Id)
{
continue;
}
response.AppendLine(op.ToString());
if (allOperations)
{
response.AppendLine($"Server: `{op.CommandArgs.Server.Guild.Name}`\n" +
$"ServerID: `{op.CommandArgs.Server.Id}`\n" +
$"Allocated DataMemory: `{op.AllocatedMemoryStarted:#0.00} MB`\n");
}
}
}
string responseString = response.ToString();
if (string.IsNullOrEmpty(responseString))
{
responseString = "There are no operations running.";
}
await SendMessageToChannel(e.Channel, responseString);
};
this.Commands.Add(newCommand.Id, newCommand);
// !cancel
newCommand = new Command <TUser>("cancel");
newCommand.Type = CommandType.Standard;
newCommand.Description = "Cancel queued or running operation - use in the same channel, and with the name of the command as parameter. (nuke, archive, etc...)";
newCommand.RequiredPermissions = PermissionType.ServerOwner | PermissionType.Admin;
newCommand.OnExecute += async e => {
string responseString = "Operation not found.";
Operation <TUser> operation = null;
if (!string.IsNullOrEmpty(e.TrimmedMessage) &&
(operation = this.CurrentOperations.FirstOrDefault(
op => op.CommandArgs.Channel.Id == e.Channel.Id &&
op.CommandArgs.Command.Id == e.TrimmedMessage)) != null)
{
responseString = "Operation canceled:\n\n" + operation.ToString();
}
await SendMessageToChannel(e.Channel, responseString);
};
this.Commands.Add(newCommand.Id, newCommand);
// !say
newCommand = new Command <TUser>("say");
newCommand.Type = CommandType.Standard;
newCommand.Description = "Make the bot say something!";
newCommand.RequiredPermissions = PermissionType.SubModerator;
newCommand.DeleteRequest = true;
newCommand.IsBonusCommand = true;
newCommand.OnExecute += async e => {
if (string.IsNullOrWhiteSpace(e.TrimmedMessage))
{
return;
}
await SendMessageToChannel(e.Channel, e.TrimmedMessage);
};
this.Commands.Add(newCommand.Id, newCommand);
// !ping
newCommand = new Command <TUser>("ping");
newCommand.Type = CommandType.Standard;
newCommand.Description = "Measure how long does it take to receive a message and handle it as a command.";
newCommand.RequiredPermissions = PermissionType.Everyone;
newCommand.OnExecute += async e => {
TimeSpan time = DateTime.UtcNow - Utils.GetTimeFromId(e.Message.Id);
string responseString = "`" + time.TotalMilliseconds.ToString("#00") + "`ms";
await SendMessageToChannel(e.Channel, responseString);
};
this.Commands.Add(newCommand.Id, newCommand);
// !help
newCommand = new Command <TUser>("help");
newCommand.Type = CommandType.Standard;
newCommand.Description = "PMs a list of Custom Commands for the server if used without a parameter. Use with a parameter to search for specific commands.";
newCommand.RequiredPermissions = PermissionType.Everyone;
newCommand.OnExecute += async e => {
StringBuilder response = new StringBuilder("Please refer to the website documentation for the full list of features and commands: <http://botwinder.info/docs>\n\n");
StringBuilder commandStrings = new StringBuilder();
bool isSpecific = !string.IsNullOrWhiteSpace(e.TrimmedMessage);
string prefix = e.Server.Config.CommandPrefix;
List <string> includedCommandIds = new List <string>();
int count = 0;
void AddCustomAlias(string commandId)
{
List <CustomAlias> aliases = e.Server.CustomAliases.Values.Where(a => a.CommandId == commandId).ToList();
int aliasCount = aliases.Count;
if (aliasCount > 0)
{
commandStrings.Append(aliasCount == 1 ? " **-** Custom Alias: " : " **-** Custom Aliases: ");
for (int i = 0; i < aliasCount; i++)
{
commandStrings.Append((i == 0 ? "`" : i == aliasCount - 1 ? " and `" : ", `") +
prefix + aliases[i].Alias + "`");
}
}
commandStrings.AppendLine();
}
void AddCommand(Command <TUser> cmd)
{
commandStrings.AppendLine($"\n```diff\n{(cmd.CanExecute(this, e.Server, e.Channel, e.Message.Author as SocketGuildUser) ? "+" : "-")}" +
$" {prefix}{cmd.Id}```" +
$" **-** {cmd.Description}");
if (cmd.Aliases != null && cmd.Aliases.Any())
{
int aliasCount = cmd.Aliases.Count;
commandStrings.Append(aliasCount == 1 ? " **-** Alias: " : " **-** Aliases: ");
for (int i = 0; i < aliasCount; i++)
{
commandStrings.Append((i == 0 ? "`" : i == aliasCount - 1 ? " and `" : ", `") +
prefix + cmd.Aliases[i] + "`");
}
commandStrings.AppendLine();
}
AddCustomAlias(cmd.Id);
}
void AddCustomCommand(CustomCommand cmd)
{
commandStrings.AppendLine($"\n```diff\n{(cmd.CanExecute(this, e.Server, e.Channel, e.Message.Author as SocketGuildUser) ? "+" : "-")}" +
$" {prefix}{cmd.CommandId}```" +
$" **-** {cmd.Description}");
AddCustomAlias(cmd.CommandId);
}
if (isSpecific)
{
string expression = e.TrimmedMessage.Replace(" ", "|") + ")\\w*";
if (e.MessageArgs.Length > 1)
{
expression += "(" + expression;
}
Regex regex = new Regex($"\\w*({expression}", RegexOptions.IgnoreCase, TimeSpan.FromMilliseconds(10f));
foreach (Command <TUser> cmd in e.Server.Commands.Values)
{
if (!cmd.IsHidden &&
cmd.RequiredPermissions != PermissionType.OwnerOnly &&
regex.Match(cmd.Id).Success)
{
Command <TUser> command = cmd;
if (cmd.IsAlias && e.Server.Commands.ContainsKey(cmd.ParentId))
{
command = e.Server.Commands[cmd.ParentId];
}
if (includedCommandIds.Contains(command.Id))
{
continue;
}
if (++count > 5)
{
break;
}
AddCommand(cmd);
}
}
foreach (CustomCommand cmd in e.Server.CustomCommands.Values)
{
if (regex.Match(cmd.CommandId).Success) //Chances are that it's gonna fail more often.
{
if (includedCommandIds.Contains(cmd.CommandId))
{
continue;
}
if (++count > 5)
{
break;
}
AddCustomCommand(cmd);
}
}
foreach (CustomAlias alias in e.Server.CustomAliases.Values)
{
if (regex.Match(alias.Alias).Success) //Chances are that it's gonna fail more often.
{
if (includedCommandIds.Contains(alias.CommandId))
{
continue;
}
if (++count > 5)
{
break;
}
if (e.Server.Commands.ContainsKey(alias.CommandId))
{
AddCommand(e.Server.Commands[alias.CommandId]);
}
else if (e.Server.CustomCommands.ContainsKey(alias.CommandId))
{
AddCustomCommand(e.Server.CustomCommands[alias.CommandId]);
}
}
}
if (count == 0)
{
response.AppendLine("I did not find any commands matching your search expression.");
}
else
{
if (count > 5)
{
response.AppendLine("I found too many commands matching your search expression. **Here are the first five:**");
}
response.Append(commandStrings.ToString());
}
}
else //Not specific - PM CustomCommands.
{
foreach (CustomCommand cmd in e.Server.CustomCommands.Values)
{
if (includedCommandIds.Contains(cmd.CommandId))
{
continue;
}
if (++count > 5)
{
break;
}
AddCustomCommand(cmd);
}
response.AppendLine("I've PMed you the Custom Commands for this server.");
await e.Message.Author.SendMessageSafe(commandStrings.ToString());
}
await SendMessageToChannel(e.Channel, response.ToString());
};
this.Commands.Add(newCommand.Id, newCommand);
/*
* // !command
* newCommand = new Command<TUser>("command");
* newCommand.Type = CommandType.Standard;
* newCommand.Description = "";
* newCommand.RequiredPermissions = PermissionType.OwnerOnly;
* newCommand.OnExecute += async e => {
* string responseString = "";
* await SendMessageToChannel(e.Channel, responseString);
* };
* this.Commands.Add(newCommand.Id, newCommand);
*
*/
return(Task.CompletedTask);
}
public static async Task ClientOnMessageReactionAdded(DiscordClient client, MessageReactionAddEventArgs e)
{
var discordUser = await client.GetUserAsync(e.User.Id);
if (discordUser.IsBot)
{
return;
}
//Проверка если сообщение с принятием правил сообщества
if (e.Message.Id == Bot.BotSettings.CodexMessageId && e.Emoji.GetDiscordName() == ":white_check_mark:")
{
//При надобности добавить кулдаун
/*if (EmojiCooldowns.ContainsKey(e.User)) // проверка на кулдаун
* if ((EmojiCooldowns[e.User] - DateTime.Now).Seconds > 0) return;
*
* // если проверка успешно пройдена, добавим пользователя
* // в словарь кулдаунов
* EmojiCooldowns[e.User] = DateTime.Now.AddSeconds(Bot.BotSettings.FastCooldown);*/
//Проверка на purge
var hasPurge = false;
ReportSQL validPurge = null;
foreach (var purge in ReportSQL.GetForUser(discordUser.Id, ReportType.CodexPurge))
{
if (purge.ReportEnd > DateTime.Now)
{
validPurge = purge;
hasPurge = true;
break;
}
}
if (hasPurge)
{
var moderator = await e.Channel.Guild.GetMemberAsync(validPurge.Moderator);
try
{
await(await e.Guild.GetMemberAsync(discordUser.Id)).SendMessageAsync(
"**Возможность принять правила заблокирована**\n" +
$"**Снятие через:** {Utility.FormatTimespan(DateTime.Now - validPurge.ReportEnd)}\n" +
$"**Модератор:** {moderator.Username}#{moderator.Discriminator}\n" +
$"**Причина:** {validPurge.Reason}\n");
}
catch (UnauthorizedException)
{
//user can block the bot
}
return;
}
//Выдаем роль правил
var member = await e.Guild.GetMemberAsync(discordUser.Id);
//Проверка времени входа на сервер.
if (member.JoinedAt > DateTime.Now.AddMinutes(-10))
{
try
{
await member.SendMessageAsync(
$"{Bot.BotSettings.ErrorEmoji} Для принятия правил вы должны находиться на сервере минимум " +
$"**{Utility.FormatTimespan(TimeSpan.FromMinutes(10))}**.");
await e.Message.DeleteReactionAsync(DiscordEmoji.FromName(client, ":white_check_mark:"), member);
}
catch (UnauthorizedException) { }
return;
}
if (!member.Roles.Contains(e.Channel.Guild.GetRole(Bot.BotSettings.CodexRole)))
{
//Выдаем роль правил
await member.GrantRoleAsync(e.Channel.Guild.GetRole(Bot.BotSettings.CodexRole));
//Убираем роль блокировки правил
await member.RevokeRoleAsync(e.Channel.Guild.GetRole(Bot.BotSettings.PurgeCodexRole));
client.Logger.LogInformation(BotLoggerEvents.Event, $"Пользователь {discordUser.Username}#{discordUser.Discriminator} ({discordUser.Id}) подтвердил прочтение правил через реакцию.");
}
return;
}
//Проверка если сообщение с принятием правил рейда
if (e.Message.Id == Bot.BotSettings.FleetCodexMessageId && e.Emoji.GetDiscordName() == ":white_check_mark:")
{
//Проверка на purge
var hasPurge = false;
ReportSQL validPurge = null;
foreach (var purge in ReportSQL.GetForUser(discordUser.Id, ReportType.FleetPurge))
{
if (purge.ReportEnd > DateTime.Now)
{
validPurge = purge;
hasPurge = true;
break;
}
}
if (hasPurge)
{
var moderator = await e.Channel.Guild.GetMemberAsync(validPurge.Moderator);
try
{
await(await e.Guild.GetMemberAsync(discordUser.Id)).SendMessageAsync(
"**Возможность принять правила заблокирована**\n" +
$"**Снятие через:** {Utility.FormatTimespan(DateTime.Now - validPurge.ReportEnd)}\n" +
$"**Модератор:** {moderator.Username}#{moderator.Discriminator}\n" +
$"**Причина:** {validPurge.Reason}\n");
}
catch (UnauthorizedException)
{
//user can block the bot
}
return;
} //Удаляем блокировку если истекла
var member = await e.Guild.GetMemberAsync(discordUser.Id);
//Проверка времени входа на сервер.
if (member.JoinedAt > DateTime.Now.AddDays(-Bot.BotSettings.FleetDateOffset))
{
await member.SendMessageAsync(
$"{Bot.BotSettings.ErrorEmoji} Для получения доступа к рейдам вы должны находиться на сервере " +
$"**{Utility.FormatTimespan(TimeSpan.FromDays(Bot.BotSettings.FleetDateOffset))}**.");
await e.Message.DeleteReactionAsync(DiscordEmoji.FromName(client, ":white_check_mark:"), member);
return;
}
var voiceTime = VoiceListener.GetUpdatedVoiceTime(e.User.Id);
//Проверка на время проведенное в голосовых каналах
if (voiceTime < TimeSpan.FromHours(Bot.BotSettings.FleetVoiceTimeOffset))
{
await member.SendMessageAsync(
$"{Bot.BotSettings.ErrorEmoji} Для получения доступа к рейдам вы должны провести " +
$"**{Utility.FormatTimespan(TimeSpan.FromHours(Bot.BotSettings.FleetVoiceTimeOffset))}** в голосовых каналах. " +
$"Ваше время: **{Utility.FormatTimespan(voiceTime)}**");
await e.Message.DeleteReactionAsync(DiscordEmoji.FromName(client, ":white_check_mark:"), member);
return;
}
//Проверка на регистрацию и привязку Xbox
var webUser = WebUser.GetByDiscordId(member.Id);
if (webUser == null)
{
await member.SendMessageAsync(
$"{Bot.BotSettings.ErrorEmoji} Для получения доступа к рейдам вам нужно авторизоваться с помощью Discord на сайте {Bot.BotSettings.WebURL}login.");
await e.Message.DeleteReactionAsync(DiscordEmoji.FromName(client, ":white_check_mark:"), member);
return;
}
if (webUser.LastXbox == "")
{
await member.SendMessageAsync($"{Bot.BotSettings.ErrorEmoji} Для получения доступа к рейдам вы должны привязать Xbox к своему аккаунту, затем перейдите по ссылке " +
$"{Bot.BotSettings.WebURL}xbox - это обновит базу данных.");
await e.Message.DeleteReactionAsync(DiscordEmoji.FromName(client, ":white_check_mark:"), member);
return;
}
// Проверка ЧС
if (BlacklistEntry.IsBlacklisted(member.Id) || BlacklistEntry.IsBlacklistedXbox(webUser.LastXbox))
{
await member.SendMessageAsync(
$"{Bot.BotSettings.ErrorEmoji} Вы находитесь в чёрном списке рейдов и вам навсегда ограничен доступ к ним.");
return;
}
//Выдаем роль правил рейда
if (!member.Roles.Any(x => x.Id == Bot.BotSettings.FleetCodexRole))
{
await member.GrantRoleAsync(e.Channel.Guild.GetRole(Bot.BotSettings.FleetCodexRole));
await e.Guild.GetChannel(Bot.BotSettings.FleetLogChannel)
.SendMessageAsync($"{DiscordEmoji.FromName(client, ":new:")} Пользователь **{e.User.Username}#{e.User.Discriminator}** ({e.User.Id}) получил роль рейда. **Xbox:** {webUser.LastXbox}.");
client.Logger.LogInformation(BotLoggerEvents.Event, $"Пользователь {discordUser.Username}#{discordUser.Discriminator} ({discordUser.Id}) подтвердил прочтение правил рейда.");
}
return;
}
//Проверка на сообщение эмиссарства
if (e.Message.Id == Bot.BotSettings.EmissaryMessageId)
{
await e.Message.DeleteReactionAsync(e.Emoji, discordUser);
if (EmojiCooldowns.ContainsKey(discordUser)) // проверка на кулдаун
{
if ((EmojiCooldowns[discordUser] - DateTime.Now).Seconds > 0)
{
return;
}
}
// если проверка успешно пройдена, добавим пользователя
// в словарь кулдаунов
EmojiCooldowns[discordUser] = DateTime.Now.AddSeconds(Bot.BotSettings.FastCooldown);
//Проверка у пользователя уже существующих ролей эмисарства и их удаление
var member = await e.Guild.GetMemberAsync(discordUser.Id);
member.Roles.Where(x => x.Id == Bot.BotSettings.EmissaryGoldhoadersRole ||
x.Id == Bot.BotSettings.EmissaryTradingCompanyRole ||
x.Id == Bot.BotSettings.EmissaryOrderOfSoulsRole ||
x.Id == Bot.BotSettings.EmissaryAthenaRole ||
x.Id == Bot.BotSettings.EmissaryReaperBonesRole ||
x.Id == Bot.BotSettings.HuntersRole).ToList()
.ForEach(async x => await member.RevokeRoleAsync(x));
//Выдаем роль в зависимости от реакции
switch (e.Emoji.GetDiscordName())
{
case ":moneybag:":
await member.GrantRoleAsync(e.Channel.Guild.GetRole(Bot.BotSettings.EmissaryGoldhoadersRole));
break;
case ":pig:":
await member.GrantRoleAsync(e.Channel.Guild.GetRole(Bot.BotSettings.EmissaryTradingCompanyRole));
break;
case ":skull:":
await member.GrantRoleAsync(e.Channel.Guild.GetRole(Bot.BotSettings.EmissaryOrderOfSoulsRole));
break;
case ":gem:":
await member.GrantRoleAsync(e.Channel.Guild.GetRole(Bot.BotSettings.EmissaryAthenaRole));
break;
case ":skull_crossbones:":
await member.GrantRoleAsync(e.Channel.Guild.GetRole(Bot.BotSettings.EmissaryReaperBonesRole));
break;
case ":fish:":
await member.GrantRoleAsync(e.Channel.Guild.GetRole(Bot.BotSettings.HuntersRole));
break;
default:
break;
}
//Отправка в лог
client.Logger.LogInformation(BotLoggerEvents.Event, $"{discordUser.Username}#{discordUser.Discriminator} получил новую роль эмиссарства.");
return;
}
if (e.Message.Channel != null)
{
//Проверка на голосование
if (e.Message.Channel.Id == Bot.BotSettings.VotesChannel)
{
var vote = Vote.GetByMessageId(e.Message.Id);
await e.Message.DeleteReactionAsync(e.Emoji, discordUser);
// Проверка на окончание голосования
if (DateTime.Now > vote.End)
{
return;
}
// Проверка на предыдущий голос
if (vote.Voters.ContainsKey(discordUser.Id))
{
return;
}
if (e.Emoji.GetDiscordName() == ":white_check_mark:")
{
vote.Voters.Add(discordUser.Id, true);
++vote.Yes;
}
else
{
vote.Voters.Add(discordUser.Id, false);
++vote.No;
}
var total = vote.Voters.Count;
var author = await e.Guild.GetMemberAsync(vote.Author);
var embed = Utility.GenerateVoteEmbed(
author,
DiscordColor.Yellow,
vote.Topic,
vote.End,
vote.Voters.Count,
vote.Yes,
vote.No,
vote.Id);
Vote.Save(Bot.BotSettings.VotesXML);
await e.Message.ModifyAsync(embed : embed);
await(await e.Guild.GetMemberAsync(discordUser.Id)).SendMessageAsync($"{Bot.BotSettings.OkEmoji} Спасибо, ваш голос учтён!");
}
// Private ship confirmation message
if (e.Channel.Id == Bot.BotSettings.PrivateRequestsChannel)
{
var ship = PrivateShip.GetByRequest(e.Message.Id);
if (ship != null && ship.Channel == 0)
{
if (e.Emoji == DiscordEmoji.FromName(client, ":white_check_mark:"))
{
var channel = await e.Guild.CreateChannelAsync($"☠{ship.Name}☠", ChannelType.Voice,
e.Guild.GetChannel(Bot.BotSettings.PrivateCategory), bitrate : Bot.BotSettings.Bitrate);
await channel.AddOverwriteAsync(e.Guild.GetRole(Bot.BotSettings.CodexRole),
Permissions.AccessChannels);
await channel.AddOverwriteAsync(e.Guild.EveryoneRole, Permissions.None, Permissions.UseVoice);
ship.Channel = channel.Id;
ship.CreatedAt = DateTime.Now;
ship.LastUsed = DateTime.Now;
var captain = (from member in ship.GetMembers()
where member.Role == PrivateShipMemberRole.Captain
select member).First();
var captainMember = await e.Guild.GetMemberAsync(captain.MemberId);
await channel.AddOverwriteAsync(captainMember, Permissions.UseVoice);
captain.Status = true;
await e.Channel.SendMessageAsync(
$"{Bot.BotSettings.OkEmoji} Администратор {e.User.Mention} подтвердил запрос на создание " +
$"корабля **{ship.Name}**.");
try
{
await captainMember.SendMessageAsync(
$"{Bot.BotSettings.OkEmoji} Администратор **{e.User.Username}#{e.User.Discriminator}** " +
$"подтвердил твой запрос на создание корабля **{ship.Name}**.");
}
catch (UnauthorizedException)
{
}
}
else if (e.Emoji == DiscordEmoji.FromName(client, ":no_entry:"))
{
var captain = (from member in ship.GetMembers()
where member.Role == PrivateShipMemberRole.Captain
select member).First();
var captainMember = await e.Guild.GetMemberAsync(captain.MemberId);
PrivateShip.Delete(ship.Name);
await e.Channel.SendMessageAsync(
$"{Bot.BotSettings.OkEmoji} Администратор {e.User.Mention} отклонил запрос на создание " +
$"корабля **{ship.Name}**.");
try
{
await captainMember.SendMessageAsync(
$"{Bot.BotSettings.ErrorEmoji} Администратор **{e.User.Username}#{e.User.Discriminator}** " +
$"отклонил твой запрос на создание корабля **{ship.Name}**.");
}
catch (UnauthorizedException)
{
}
}
await e.Message.DeleteAllReactionsAsync();
}
}
}
}
protected bool Equals(BlacklistEntry other)
{
return(PlayerId == other.PlayerId && string.Equals(From, other.From));
}
public async Task Remove(CommandContext ctx, string id)
{
BlacklistEntry.Remove(id);
await ctx.RespondAsync($"{Bot.BotSettings.OkEmoji} Успешно удалена запись!");
}
public async Task Add(CommandContext ctx)
{
var embed = new DiscordEmbedBuilder();
embed.Description = "**Добавление записи в чёрный список**\n";
embed.WithAuthor(ctx.Member.Username + "#" + ctx.Member.Discriminator, iconUrl: ctx.Member.AvatarUrl);
embed.Color = DiscordColor.Orange;
embed.WithFooter(
"Отправьте ID пользователя. Если неизвестно, отправьте `нет`, для отмены отправьте `отмена`");
var status = await ctx.RespondAsync(embed : embed.Build());
var interactivity = ctx.Client.GetInteractivity();
// запрашиваем ID пользователя
var userId =
await interactivity.WaitForMessageAsync(m => m.Author.Id == ctx.Member.Id, TimeSpan.FromMinutes(1));
if (userId.Result == null || userId.Result.Content.ToLower().Contains("отмена"))
{
await ctx.Message.DeleteAsync();
await status.DeleteAsync();
if (userId.Result != null)
{
await userId.Result.DeleteAsync();
}
return;
}
DiscordUser user = null;
// ищем пользователя
if (userId.Result.Content != "нет")
{
try
{
user = await ctx.Client.GetUserAsync(Convert.ToUInt64(userId.Result.Content));
}
catch
{
await status.DeleteAsync();
await ctx.RespondAsync($"{Bot.BotSettings.ErrorEmoji} Не удалось найти данного пользователя!");
return;
}
}
await userId.Result.DeleteAsync();
if (user == null)
{
embed.AddField("Пользователь", "Неизвестен");
}
else
{
embed.AddField("Пользователь", user.Username + "#" + user.Discriminator, true);
embed.AddField("ID", user.Id.ToString(), true);
embed.WithThumbnail(user.AvatarUrl);
}
embed.WithFooter("Отправьте Xbox пользователя. Если неизвестно, отправьте `нет`, для отмены отправьте `отмена`");
status = await status.ModifyAsync(embed : embed.Build());
// запрашиваем xbox пользователя
var xbox =
await interactivity.WaitForMessageAsync(m => m.Author.Id == ctx.Member.Id, TimeSpan.FromMinutes(1));
if (xbox.Result == null || xbox.Result.Content.ToLower().Contains("отмена"))
{
await ctx.Message.DeleteAsync();
await status.DeleteAsync();
if (xbox.Result != null)
{
await xbox.Result.DeleteAsync();
}
return;
}
var xboxSql = "";
if (xbox.Result.Content.ToLower().Contains("нет"))
{
embed.AddField("Xbox", "Неизвестен", false);
}
else
{
embed.AddField("Xbox", xbox.Result.Content, false);
xboxSql = xbox.Result.Content;
}
embed.WithFooter("Отправьте причину добавления в чёрный список, для отмены отправьте `отмена`");
await xbox.Result.DeleteAsync();
status = await status.ModifyAsync(embed : embed.Build());
// запрашиваем причину
var reason =
await interactivity.WaitForMessageAsync(m => m.Author.Id == ctx.Member.Id, TimeSpan.FromMinutes(1));
if (reason.Result == null || reason.Result.Content.ToLower().Contains("отмена"))
{
await ctx.Message.DeleteAsync();
await status.DeleteAsync();
if (reason.Result != null)
{
await reason.Result.DeleteAsync();
}
return;
}
var reasonSql = reason.Result.Content;
embed.AddField("Причина", reason.Result.Content, false);
embed.WithFooter(
"Отправьте дополнительную информацию (например, ссылки на доказательства), иначе отправьте `нет` или для отмены отправьте `отмена`");
await reason.Result.DeleteAsync();
status = await status.ModifyAsync(embed : embed.Build());
// запрашиваем допольнительную информацию
var additional =
await interactivity.WaitForMessageAsync(m => m.Author.Id == ctx.Member.Id, TimeSpan.FromMinutes(1));
if (additional.Result == null || additional.Result.Content.ToLower().Contains("отмена"))
{
await ctx.Message.DeleteAsync();
await status.DeleteAsync();
if (additional.Result != null)
{
await additional.Result.DeleteAsync();
}
return;
}
var additionalSql = "";
if (additional.Result.Content == "нет")
{
embed.AddField("Дополнительно", "Не указано", false);
}
else
{
embed.AddField("Дополнительно", additional.Result.Content, false);
additionalSql = additional.Result.Content;
}
var id = RandomString.NextString(6);
embed.WithFooter("Готово! ID записи: " + id);
embed.Color = DiscordColor.SpringGreen;
await additional.Result.DeleteAsync();
status = await status.ModifyAsync(embed : embed.Build());
var userIdSql = user == null ? 0 : user.Id;
var usernameSql = user == null ? "" : user.Username + "#" + user.Discriminator;
var entry =
BlacklistEntry.Create(id, userIdSql, usernameSql, xboxSql, DateTime.Now, ctx.Member.Id, reasonSql, additionalSql);
try
{
var member = await ctx.Guild.GetMemberAsync(userIdSql);
await member.RevokeRoleAsync(ctx.Guild.GetRole(Bot.BotSettings.FleetCodexRole));
}
catch
{
}
await ctx.Guild.GetChannel(Bot.BotSettings.ModlogChannel).SendMessageAsync(
"**Добавление записи в ЧС**\n\n" +
$"**Модератор:** {ctx.Member}\n" +
$"**Дата:** {DateTime.Now}\n" +
$"**ID:** {id}\n" +
$"**Пользователь:** {usernameSql} ({userIdSql})\n" +
$"**Xbox:** {xboxSql}\n" +
$"**Причина:** {reasonSql}\n" +
$"**Дополнительно:** {additionalSql}\n");
}
