public UserInfo(DiscordMember member, DiscordClient client)
{
InitializeComponent();
SetupTheme();
Member = member;
mainClientReference = client;
if(Member.Avatar != null)
{
BitmapImage _userAvatar = new BitmapImage(Member.GetAvatarURL());
Icon = _userAvatar;
try
{
userAvatar.Source = _userAvatar;
}
catch (Exception) { }
}
usernameLabel.Content = Member.Username + $" (#{Member.Discriminator})";
Title = "User info for " + Member.Username;
if (member.CurrentGame != null)
userID.Content = $"Playing {member.CurrentGame}";
else
userID.Content = "";
foreach(var server in mainClientReference.GetServersList())
{
foreach(var __member in server.members)
{
if(__member.ID == member.ID)
{
ServerStub stub = new ServerStub(server);
inServers.Items.Add(stub);
}
}
}
}
internal static List <DiscordMember> GetPotentialVictims(DiscordClient client, DiscordMember newMember, bool checkUsername, bool checkNickname, List <DiscordMember> listToCheckAgainst = null)
{
var membersWithRoles = listToCheckAgainst ??
client.Guilds.SelectMany(guild => guild.Value.Members)
.Where(m => m.Roles.Any())
.OrderByDescending(m => m.Hierarchy)
.ThenByDescending(m => m.JoinedAt)
.ToList();
var newUsername = GetCanonical(newMember.Username);
var newDisplayName = GetCanonical(newMember.DisplayName);
var potentialTargets = new List <DiscordMember>();
foreach (var memberWithRole in membersWithRoles)
{
if (checkUsername && newUsername == GetCanonical(memberWithRole.Username) && newMember.Id != memberWithRole.Id)
{
potentialTargets.Add(memberWithRole);
}
else if (checkNickname && (newDisplayName == GetCanonical(memberWithRole.DisplayName) || newDisplayName == GetCanonical(memberWithRole.Username)) && newMember.Id != memberWithRole.Id)
{
potentialTargets.Add(memberWithRole);
}
}
return(potentialTargets);
}
public async Task Profile(CommandContext ctx, [RemainingText] DiscordMember user = null)
{
try
{
if (user == null)
{
user = ctx.Member;
}
SdlPlayer player;
try
{
player = await MySqlClient.RetrieveSdlPlayer(user.Id);
}
catch (Exception e)
{
Logger.Warn(e);
/*if (e is SdlAirTableException airTableException)
* await airTableException.Message;*/
throw;
}
await ctx.TriggerTypingAsync();
Font powerFont = KarlaFontFamily.CreateFont(160, FontStyle.Bold);
Font nameFont = KarlaFontFamily.CreateFont(80, FontStyle.Bold);
Font winRateFont = KarlaFontFamily.CreateFont(100, FontStyle.Bold);
Font switchCodeFont = KarlaItalicFontFamily.CreateFont(50, FontStyle.Italic);
Font classFont = KarlaFontFamily.CreateFont(180, FontStyle.Bold);
Font classNameFont = KarlaFontFamily.CreateFont(26, FontStyle.Bold);
Font roleFont = KarlaFontFamily.CreateFont(100, FontStyle.Bold);
Font placementFont = KarlaFontFamily.CreateFont(113, FontStyle.Bold);
Font ordinalFont = KarlaFontFamily.CreateFont(57, FontStyle.Bold);
WebClient webClient = new WebClient();
string avatarUrl = string.IsNullOrWhiteSpace(user.GetAvatarUrl(ImageFormat.Png)) ? user.DefaultAvatarUrl : user.GetAvatarUrl(ImageFormat.Png);
byte[] avatarBytes = await webClient.DownloadDataTaskAsync(avatarUrl);
using (Image <Rgba32> image = Image.Load(Path.Combine(Globals.AppPath, "Data", "img", "profile-template.png")))
{
using Image <Rgba32> rankImage = new Image <Rgba32>(225, 225);
using Image <Rgba32> avatarImage = Image.Load(avatarBytes);
using Image <Rgba32> roleImage = new Image <Rgba32>(455, 115);
using MemoryStream ms = new MemoryStream();
string name = player.Nickname.ToUpper();
string powerLevel = Math.Round(player.PowerLevel, 1).ToString(CultureInfo.InvariantCulture);
SizeF nameTextSize = TextMeasurer.Measure(name, new RendererOptions(nameFont));
if (nameTextSize.Width > 700)
{
float nameScalingFactor = 700 / nameTextSize.Width;
nameFont = KarlaFontFamily.CreateFont(nameFont.Size * nameScalingFactor);
}
IPathCollection nameTextGlyphs = TextBuilder.GenerateGlyphs(name,
new PointF(445, 45), new RendererOptions(nameFont));
SizeF powerLevelSize = TextMeasurer.Measure(powerLevel, new RendererOptions(powerFont));
float powerYDifference = 0;
if (powerLevelSize.Width > 480)
{
float powerScalingFactor = 480 / powerLevelSize.Width;
powerFont = KarlaFontFamily.CreateFont(powerFont.Size * powerScalingFactor, FontStyle.Bold);
powerYDifference = powerLevelSize.Height - TextMeasurer.Measure(powerLevel, new RendererOptions(powerFont)).Height;
}
IPathCollection powerTextGlyphs = TextBuilder.GenerateGlyphs(powerLevel,
new PointF(445, 110 + powerYDifference), new RendererOptions(powerFont));
IPathCollection switchCodeGlyphs = TextBuilder.GenerateGlyphs(player.SwitchFriendCode,
new PointF(420, 987), new RendererOptions(switchCodeFont));
// When centering, this is for if everything is off by the same amount.
const float offset = 0;
string splatZonesWr = player.WinRates.ContainsKey(GameMode.SplatZones) ?
$"{player.WinRates[GameMode.SplatZones]:P0}" :
"N/A";
SizeF szWrSize = TextMeasurer.Measure(splatZonesWr, new RendererOptions(winRateFont));
float szWrX = 379 + offset + (119F - szWrSize.Width / 2);
IPathCollection splatZonesGlyphs = TextBuilder.GenerateGlyphs(
splatZonesWr, new PointF(szWrX, 420), new RendererOptions(winRateFont));
string rainmakerWr = player.WinRates.ContainsKey(GameMode.Rainmaker) ?
$"{player.WinRates[GameMode.Rainmaker]:P0}" :
"N/A";
SizeF rmWrSize = TextMeasurer.Measure(rainmakerWr, new RendererOptions(winRateFont));
float rmWrX = 379 + offset + (119F - rmWrSize.Width / 2);
IPathCollection rainmakerGlyphs = TextBuilder.GenerateGlyphs(
rainmakerWr, new PointF(rmWrX, 587), new RendererOptions(winRateFont));
string towerControlWr = player.WinRates.ContainsKey(GameMode.TowerControl) ?
$"{player.WinRates[GameMode.TowerControl]:P0}" :
"N/A";
SizeF tcWrSize = TextMeasurer.Measure(towerControlWr, new RendererOptions(winRateFont));
float tcWrX = 1005 + offset + (119F - tcWrSize.Width / 2);
IPathCollection towerControlGlyphs = TextBuilder.GenerateGlyphs(
towerControlWr, new PointF(tcWrX, 420), new RendererOptions(winRateFont));
string clamBlitzWr = player.WinRates.ContainsKey(GameMode.ClamBlitz) ?
$"{player.WinRates[GameMode.ClamBlitz]:P0}" :
"N/A";
SizeF cbWrSize = TextMeasurer.Measure(clamBlitzWr, new RendererOptions(winRateFont));
float cbWrX = 1005 + offset + (119F - cbWrSize.Width / 2);
IPathCollection clamBlitzGlyphs = TextBuilder.GenerateGlyphs(
clamBlitzWr, new PointF(cbWrX, 587), new RendererOptions(winRateFont));
string overallWrText = Math.Abs(player.OverallWinRate + 1) < 0.1
? "N/A"
: $"{player.OverallWinRate:P0}";
SizeF overallWrSize = TextMeasurer.Measure(overallWrText, new RendererOptions(winRateFont));
float overallWrX = 740 + offset + (119F - overallWrSize.Width / 2);
IPathCollection overallGlyphs = TextBuilder.GenerateGlyphs(
overallWrText, new PointF(overallWrX, 755), new RendererOptions(winRateFont));
Rgba32 classColor;
string classText;
if (player.PowerLevel >= 2200)
{
classColor = new Rgba32(255, 70, 75);
classText = "1";
}
else if (player.PowerLevel >= 2000)
{
classColor = new Rgba32(255, 190, 52);
classText = "2";
}
else if (player.PowerLevel >= 1800)
{
classColor = new Rgba32(61, 255, 99);
classText = "3";
}
else
{
classColor = new Rgba32(21, 205, 227);
classText = "4";
}
SizeF classSize = TextMeasurer.Measure(classText, new RendererOptions(classFont));
float classX = 1340 + ((float)rankImage.Width / 2 - classSize.Width / 2);
IPathCollection classNameGlyphs =
TextBuilder.GenerateGlyphs("CLASS", new PointF(1414.32F, 70), new RendererOptions(classNameFont));
IPathCollection classGlyphs =
TextBuilder.GenerateGlyphs(classText, new PointF(classX, 67.57F),
new RendererOptions(classFont));
Rgba32 roleColor;
string role = player.RoleOne ?? "Flex";
switch (role.ToLower())
{
case "back":
roleColor = Rgba32.FromHex("#4BDFFA");
break;
case "front":
roleColor = Rgba32.FromHex("#EB5F5F");
break;
case "mid":
roleColor = Rgba32.FromHex("#61E87B");
break;
case "flex":
roleColor = Rgba32.RebeccaPurple;
break;
default:
roleColor = Rgba32.Black;
break;
}
role = role.ToUpper();
SizeF roleNameSize = TextMeasurer.Measure(role, new RendererOptions(roleFont));
float roleNameX = (float)roleImage.Width / 2 - roleNameSize.Width / 2;
float roleNameY = (float)roleImage.Height / 2 - roleNameSize.Height / 2 - 10;
IPathCollection roleGlyphs = TextBuilder.GenerateGlyphs(role, new PointF(roleNameX, roleNameY),
new RendererOptions(roleFont));
SdlPlayer[] players = await MySqlClient.RetrieveAllSdlPlayers();
List <SdlPlayer> orderedPlayers = players
.Where(x => ctx.Guild.Members.Any(y =>
y.Id == x.DiscordId &&
MySqlClient.CheckHasPlayedSet(x).Result&&
y.Roles.Any(z =>
z.Name.Equals("player", StringComparison.InvariantCultureIgnoreCase))))
.OrderByDescending(x => x.PowerLevel).ToList();
var playerStandings = orderedPlayers.Select(x => new { Player = x, Rank = orderedPlayers.FindLastIndex(y => y.PowerLevel == x.PowerLevel) + 1 }).ToList();
string ordinal = "";
int placement = 0;
if (playerStandings.All(x => x.Player != player))
{
await ctx.RespondAsync("Note that you will not have a standing until you play a set.");
}
else
{
placement = playerStandings.First(x => x.Player == player).Rank;
ordinal = placement.GetOrdinal();
}
SizeF placementSize =
TextMeasurer.Measure(placement == 0 ? "N/A" : placement.ToString(), new RendererOptions(placementFont));
SizeF ordinalSize =
TextMeasurer.Measure(ordinal, new RendererOptions(ordinalFont));
float standingsWidth =
placementSize.Width + ordinalSize.Width;
float placementX = 949 + (347 / 2F - standingsWidth / 2F);
IPathCollection placementGlyphs = TextBuilder.GenerateGlyphs(placement == 0 ? "N/A" : placement.ToString(),
new PointF(placementX, 140), new RendererOptions(placementFont));
float ordinalX = placementX + placementSize.Width;
float ordinalY = 140 + placementSize.Height - ordinalSize.Height - 5;
IPathCollection ordinalGlyphs = TextBuilder.GenerateGlyphs(ordinal, new PointF(ordinalX, ordinalY),
new RendererOptions(ordinalFont));
TextGraphicsOptions textGraphicsOptions = new TextGraphicsOptions(true);
rankImage.Mutate(e => e
.Fill(classColor)
.Apply(f => ApplyRoundedCorners(f, 30))
);
avatarImage.Mutate(e => e
.Resize(new Size(268, 268))
.Apply(img => ApplyRoundedCorners(img, 40))
);
roleImage.Mutate(e => e
.Fill(roleColor)
.Apply(f => ApplyRoundedCorners(f, 30))
.Fill((GraphicsOptions)textGraphicsOptions, Rgba32.White, roleGlyphs)
);
image.Mutate(e => e
.DrawImage(avatarImage, new Point(48, 32), 1)
.DrawImage(rankImage, new Point(1340, 50), 1)
.DrawImage(roleImage, new Point(1111, 755), 1)
.Fill((GraphicsOptions)textGraphicsOptions, Rgba32.Black, powerTextGlyphs)
.Fill((GraphicsOptions)textGraphicsOptions, Rgba32.Black, nameTextGlyphs)
.Fill((GraphicsOptions)textGraphicsOptions, Rgba32.Black, switchCodeGlyphs)
.Fill((GraphicsOptions)textGraphicsOptions, Rgba32.Black, splatZonesGlyphs)
.Fill((GraphicsOptions)textGraphicsOptions, Rgba32.Black, rainmakerGlyphs)
.Fill((GraphicsOptions)textGraphicsOptions, Rgba32.Black, towerControlGlyphs)
.Fill((GraphicsOptions)textGraphicsOptions, Rgba32.Black, clamBlitzGlyphs)
.Fill((GraphicsOptions)textGraphicsOptions, Rgba32.Black, overallGlyphs)
.Fill((GraphicsOptions)textGraphicsOptions, Rgba32.White, classGlyphs)
.Fill((GraphicsOptions)textGraphicsOptions, Rgba32.White, classNameGlyphs)
.Fill((GraphicsOptions)textGraphicsOptions, Rgba32.Black, placementGlyphs)
.Fill((GraphicsOptions)textGraphicsOptions, Rgba32.Black, ordinalGlyphs)
);
image.SaveAsPng(ms);
using MemoryStream memory = new MemoryStream(ms.GetBuffer());
await ctx.Channel.SendFileAsync(memory, "profile.png");
}
Configuration.Default.MemoryAllocator.ReleaseRetainedResources();
}
catch (Exception e)
{
Logger.Error(e);
throw;
}
}
private DiscordChannel GetChannelToPostNotificationIn(GuildMemberAddEventArgs e, DiscordMember bot)
{
var channel = e.Guild.Channels.FirstOrDefault(xc => xc.Name.ToLower().Contains("bot") || xc.Name.ToLower().Contains("test"));
if (channel == null)
{
channel = e.Guild.Channels.FirstOrDefault(xc => xc.PermissionsFor(bot).ToPermissionString().Contains("Send message") == true);
}
return(channel);
}
public static void DemoteLurkers(DiscordClient discord)
{
//demote lurkers
discord.MessageCreated += async e =>
{
if (e.Message.Content.ToLower().StartsWith("spirit demote"))
{
//get member permission
DiscordMember myMember = await e.Guild.GetMemberAsync(e.Message.Author.Id);
IEnumerable <DiscordRole> adminRoles = myMember.Roles;
int executePermission = 0; //if 1 execute demote
foreach (var item in adminRoles)
{
if (item.Name == "Manager" || item.Name == "Admin" || item.Name == "Moderator" || item.Name == "Owner")
{
executePermission = 1;
if (executePermission == 1)
{
break;
}
}
}
if (executePermission == 1)
{
DiscordRole guestRole = e.Guild.GetRole(354466276338434070);
DiscordRole memberRole = e.Guild.GetRole(346470543446507522);
DiscordRole lurkerRole = e.Guild.GetRole(357638353534976020);
DiscordRole inactiveRole = e.Guild.GetRole(389201764466819073);
IReadOnlyList <DiscordMember> discordMembers = e.Guild.Members; //All Members in "Guild"
List <string> eligibleToDemoteMembers = new List <string>(); //members to demote
List <string> eligibleToDemoteGuests = new List <string>(); //guests to demote
//Loop through all members in guild
try
{
foreach (var item in discordMembers)
{
IEnumerable <DiscordRole> memberRoles = item.Roles;
string authorToCheck = item.ToString();
string authorParsed = item.Username;
//Check the member role
foreach (var item2 in memberRoles)
{
if (item2.Name == "OG")
{
continue; //ignore OG
// continue;
}
if (item2.Name == "Member")
{
int commentCount14Days = SQLCode.getCommentCount14Days(authorToCheck);
if (commentCount14Days == 0)
{
if (eligibleToDemoteMembers.Count < 100)
{
eligibleToDemoteMembers.Add(authorParsed);
await e.Guild.GrantRoleAsync(item, inactiveRole, "INACTIVE: No comments in 14 days");
await e.Guild.RevokeRoleAsync(item, memberRole, "No comments in 14 days");
}
}
continue;
}
if (item2.Name == "Guest")
{
int commentCount7Days = SQLCode.getCommentCount7Days(authorToCheck);
if (commentCount7Days == 0)
{
if (eligibleToDemoteGuests.Count < 100)
{
eligibleToDemoteGuests.Add(authorParsed);
await e.Guild.GrantRoleAsync(item, lurkerRole, "LURKER: No comments in 7 days");
await e.Guild.RevokeRoleAsync(item, guestRole, "No comments in 7 days");
}
}
}
}
}
}
catch (Exception)
{
throw;
}
string responseStringGuests = "";
string responseStringMembers = "";
//respond with list of users demoted
foreach (var item in eligibleToDemoteGuests)
{
responseStringGuests += item + " ";
}
foreach (var item in eligibleToDemoteMembers)
{
responseStringMembers += item + " ";
}
int executeCommentLog = SQLCode.insertCommandComment(e.Message.Author.ToString(), "lurkers demoted:" + responseStringGuests + " Members inactive: " + responseStringMembers, e.Channel.Id.ToString(), e.Channel.ToString(), e.Message.CreationTimestamp);
if (responseStringGuests != "")
{
await e.Message.RespondAsync("I demoted these Guests..." + responseStringGuests);
}
else
{
await e.Message.RespondAsync("I found no Guests to demote! I am so happy :grin:...");
}
if (responseStringMembers != "")
{
await e.Message.RespondAsync("These Members are inactive..." + responseStringMembers);
}
else
{
await e.Message.RespondAsync("I found no Members to inactive! I am so happy :grin:...");
}
}
else //if execute permission is not 1
{
await e.Message.RespondAsync("No permission to execute");
}
}
};
}
private DiscordMessage SendActualMessage(string id, string message, DiscordMember recipient)
{
string url = Endpoints.BaseAPI + Endpoints.Channels + $"/{id}" + Endpoints.Messages;
DiscordMessage toSend = Utils.GenerateMessage(message);
try
{
var result = JObject.Parse(WebWrapper.Post(url, token, JsonConvert.SerializeObject(toSend).ToString()));
DiscordMessage d = JsonConvert.DeserializeObject<DiscordMessage>(result.ToString());
d.Recipient = recipient;
d.channel = PrivateChannels.Find(x => x.ID == result["channel_id"].ToString());
d.TypeOfChannelObject = typeof(DiscordPrivateChannel);
d.Author = Me;
return d;
}
catch (Exception ex)
{
DebugLogger.Log($"Error ocurred while sending message to user, step 2: {ex.Message}", MessageLevel.Error);
}
return null;
}
/// <summary>
/// Removes a ban on the user.
/// </summary>
/// <param name="guild">The guild to lift the ban from.</param>
/// <param name="member">The DiscordMember object of the user to lift the ban from, assuming you have it.</param>
public void RemoveBan(DiscordServer guild, DiscordMember member)
{
string url = Endpoints.BaseAPI + Endpoints.Guilds + $"/{guild.ID}" + Endpoints.Bans + $"/{member.ID}";
try
{
WebWrapper.Delete(url, token);
}
catch (Exception ex)
{
DebugLogger.Log($"Error during RemoveBan\n\tMessage: {ex.Message}\n\tStack: {ex.StackTrace}", MessageLevel.Error);
}
}
/// <summary>
/// Assigns a specified role to a member, given you have the permission.
/// </summary>
/// <param name="guild">The guild you and the user are in.</param>
/// <param name="role">The role you wish to assign them.</param>
/// <param name="member">The member you wish to assign the role to.</param>
public void AssignRoleToMember(DiscordServer guild, DiscordRole role, DiscordMember member)
{
string url = Endpoints.BaseAPI + Endpoints.Guilds + $"/{guild.ID}" + Endpoints.Members + $"/{member.ID}";
string message = JsonConvert.SerializeObject(new { roles = new string[] { role.ID } });
try
{
WebWrapper.Patch(url, token, message);
}
catch (Exception ex)
{
DebugLogger.Log($"Exception ocurred while assigning role ({role.Name}) to member ({member.Username}): "
+ ex.Message, MessageLevel.Error);
}
}
private async Task ExecuteWarn(CommandContext ctx,
DiscordMember target,
String reason,
Boolean silent,
Boolean dmMember)
{
if (!ctx.Member.HasPermission("insanitybot.moderation.warn"))
{
await ctx.RespondAsync(InsanityBot.LanguageConfig["insanitybot.error.lacking_permission"]);
return;
}
//if silent - delete the warn command
if (silent)
{
await ctx.Message.DeleteAsync();
}
//actually do something with the usedefault value
String WarnReason = reason switch
{
"usedefault" => GetFormattedString(InsanityBot.LanguageConfig["insanitybot.moderation.no_reason_given"],
ctx, target),
_ => GetFormattedString(reason, ctx, target)
};
DiscordEmbedBuilder embedBuilder = null;
DiscordEmbedBuilder moderationEmbedBuilder = new DiscordEmbedBuilder
{
Title = "Warn",
Color = DiscordColor.Yellow,
Footer = new DiscordEmbedBuilder.EmbedFooter
{
Text = "InsanityBot - ExaInsanity 2020-2021"
}
};
moderationEmbedBuilder.AddField("Moderator", ctx.Member.Mention, true)
.AddField("Member", target.Mention, true)
.AddField("Reason", WarnReason, true);
try
{
target.AddModlogEntry(ModlogEntryType.warn, WarnReason);
embedBuilder = new DiscordEmbedBuilder
{
Description = GetFormattedString(InsanityBot.LanguageConfig["insanitybot.moderation.warn.success"],
ctx, target),
Color = DiscordColor.Red,
Footer = new DiscordEmbedBuilder.EmbedFooter
{
Text = "InsanityBot - ExaInsanity 2020-2021"
}
};
_ = InsanityBot.HomeGuild.GetChannel(ToUInt64(InsanityBot.Config["insanitybot.identifiers.commands.modlog_channel_id"]))
.SendMessageAsync(embed: moderationEmbedBuilder.Build());
}
catch (Exception e)
{
embedBuilder = new DiscordEmbedBuilder
{
Description = GetFormattedString(InsanityBot.LanguageConfig["insanitybot.moderation.warn.failure"],
ctx, target),
Color = DiscordColor.Red,
Footer = new DiscordEmbedBuilder.EmbedFooter
{
Text = "InsanityBot - ExaInsanity 2020-2021"
}
};
InsanityBot.Client.Logger.LogError($"{e}: {e.Message}");
}
finally
{
if (!silent)
{
await ctx.RespondAsync(embed : embedBuilder.Build());
}
if (dmMember)
{
embedBuilder.Description = GetReason(InsanityBot.LanguageConfig["insanitybot.moderation.warn.reason"], WarnReason);
await(await target.CreateDmChannelAsync()).SendMessageAsync(embed: embedBuilder.Build());
}
}
}
}
public async Task OnExecute(CommandContext command, [RemainingText] string commandArgs)
{
// Check if the user has permission to use this command.
if (!Config.HasPermission(command.Member, "new"))
{
DiscordEmbed error = new DiscordEmbedBuilder
{
Color = DiscordColor.Red,
Description = "You do not have permission to use this command."
};
await command.RespondAsync(error);
command.Client.Logger.Log(LogLevel.Information, "User tried to use the new command but did not have permission.");
return;
}
// Check if user is blacklisted
if (Database.IsBlacklisted(command.User.Id))
{
DiscordEmbed error = new DiscordEmbedBuilder
{
Color = DiscordColor.Red,
Description = "You are banned from opening tickets."
};
await command.RespondAsync(error);
return;
}
if (Database.IsOpenTicket(command.Channel.Id))
{
DiscordEmbed error = new DiscordEmbedBuilder
{
Color = DiscordColor.Red,
Description = "You cannot use this command in a ticket channel."
};
await command.RespondAsync(error);
return;
}
DiscordChannel category = command.Guild.GetChannel(Config.ticketCategory);
DiscordChannel ticketChannel;
try
{
ticketChannel = await command.Guild.CreateChannelAsync("ticket", ChannelType.Text, category);
}
catch (Exception)
{
DiscordEmbed error = new DiscordEmbedBuilder
{
Color = DiscordColor.Red,
Description = "Error occured while creating ticket, " + command.Member.Mention +
"!\nIs the channel limit reached in the server or ticket category?"
};
await command.RespondAsync(error);
return;
}
if (ticketChannel == null)
{
DiscordEmbed error = new DiscordEmbedBuilder
{
Color = DiscordColor.Red,
Description = "Error occured while creating ticket, " + command.Member.Mention +
"!\nIs the channel limit reached in the server or ticket category?"
};
await command.RespondAsync(error);
return;
}
ulong staffID = 0;
if (Config.randomAssignment)
{
staffID = Database.GetRandomActiveStaff(0)?.userID ?? 0;
}
long id = Database.NewTicket(command.Member.Id, staffID, ticketChannel.Id);
string ticketID = id.ToString("00000");
await ticketChannel.ModifyAsync(modifiedAttributes => modifiedAttributes.Name = "ticket-" + ticketID);
await ticketChannel.AddOverwriteAsync(command.Member, Permissions.AccessChannels, Permissions.None);
await ticketChannel.SendMessageAsync("Hello, " + command.Member.Mention + "!\n" + Config.welcomeMessage);
// Refreshes the channel as changes were made to it above
ticketChannel = command.Guild.GetChannel(ticketChannel.Id);
if (staffID != 0)
{
DiscordEmbed assignmentMessage = new DiscordEmbedBuilder
{
Color = DiscordColor.Green,
Description = "Ticket was randomly assigned to <@" + staffID + ">."
};
await ticketChannel.SendMessageAsync(assignmentMessage);
if (Config.assignmentNotifications)
{
DiscordEmbed message = new DiscordEmbedBuilder
{
Color = DiscordColor.Green,
Description = "You have been randomly assigned to a newly opened support ticket: " +
ticketChannel.Mention
};
try
{
DiscordMember staffMember = await command.Guild.GetMemberAsync(staffID);
await staffMember.SendMessageAsync(message);
}
catch (NotFoundException) {}
catch (UnauthorizedException) {}
}
}
DiscordEmbed response = new DiscordEmbedBuilder
{
Color = DiscordColor.Green,
Description = "Ticket opened, " + command.Member.Mention + "!\n" + ticketChannel.Mention
};
await command.RespondAsync(response);
// Log it if the log channel exists
DiscordChannel logChannel = command.Guild.GetChannel(Config.logChannel);
if (logChannel != null)
{
DiscordEmbed logMessage = new DiscordEmbedBuilder
{
Color = DiscordColor.Green,
Description = "Ticket " + ticketChannel.Mention + " opened by " + command.Member.Mention + ".\n",
Footer = new DiscordEmbedBuilder.EmbedFooter {
Text = "Ticket " + ticketID
}
};
await logChannel.SendMessageAsync(logMessage);
}
}
public async Task ProcessPokemonSubscription(PokemonData pkmn)
{
if (!MasterFile.Instance.Pokedex.ContainsKey(pkmn.Id))
{
return;
}
// Cache the result per-guild so that geospatial stuff isn't queried for every single subscription below
Dictionary <ulong, GeofenceItem> locationCache = new Dictionary <ulong, GeofenceItem>();
GeofenceItem GetGeofence(ulong guildId)
{
if (!locationCache.TryGetValue(guildId, out var geofence))
{
geofence = _whm.GetGeofence(guildId, pkmn.Latitude, pkmn.Longitude);
locationCache.Add(guildId, geofence);
}
return(geofence);
}
var subscriptions = Manager.GetUserSubscriptionsByPokemonId(pkmn.Id);
if (subscriptions == null)
{
_logger.Warn($"Failed to get subscriptions from database table.");
return;
}
SubscriptionObject user;
PokemonSubscription subscribedPokemon;
DiscordMember member = null;
var pokemon = MasterFile.GetPokemon(pkmn.Id, pkmn.FormId);
var matchesIV = false;
var matchesLvl = false;
var matchesGender = false;
var matchesIVList = false;
for (var i = 0; i < subscriptions.Count; i++)
{
try
{
user = subscriptions[i];
if (user == null)
{
continue;
}
if (!user.Enabled)
{
continue;
}
if (!_whConfig.Instance.Servers.ContainsKey(user.GuildId))
{
continue;
}
if (!_whConfig.Instance.Servers[user.GuildId].Subscriptions.Enabled)
{
continue;
}
if (!_servers.ContainsKey(user.GuildId))
{
continue;
}
var client = _servers[user.GuildId];
try
{
member = await client.GetMemberById(user.GuildId, user.UserId);
}
catch (Exception ex)
{
_logger.Debug($"FAILED TO GET MEMBER BY ID {user.UserId}");
_logger.Error(ex);
continue;
}
if (member?.Roles == null)
{
continue;
}
if (!member.HasSupporterRole(_whConfig.Instance.Servers[user.GuildId].DonorRoleIds))
{
_logger.Debug($"User {member?.Username} ({user.UserId}) is not a supporter, skipping pokemon {pokemon.Name}...");
// Automatically disable users subscriptions if not supporter to prevent issues
//user.Enabled = false;
//user.Save(false);
continue;
}
var form = Translator.Instance.GetFormName(pkmn.FormId);
subscribedPokemon = user.Pokemon.FirstOrDefault(x =>
x.PokemonId == pkmn.Id &&
(string.IsNullOrEmpty(x.Form) || (!string.IsNullOrEmpty(x.Form) && string.Compare(x.Form, form, true) == 0))
);
// Not subscribed to Pokemon
if (subscribedPokemon == null)
{
//_logger.Debug($"User {member.Username} not subscribed to Pokemon {pokemon.Name} (Form: {form}).");
continue;
}
matchesIV = Filters.MatchesIV(pkmn.IV, subscribedPokemon.MinimumIV);
//var matchesCP = _whm.Filters.MatchesCpFilter(pkmn.CP, subscribedPokemon.MinimumCP);
matchesLvl = Filters.MatchesLvl(pkmn.Level, (uint)subscribedPokemon.MinimumLevel, (uint)subscribedPokemon.MaximumLevel);
matchesGender = Filters.MatchesGender(pkmn.Gender, subscribedPokemon.Gender);
matchesIVList = subscribedPokemon.IVList?.Contains($"{pkmn.Attack}/{pkmn.Defense}/{pkmn.Stamina}") ?? false;
if (!(
(!subscribedPokemon.HasStats && matchesIV && matchesLvl && matchesGender) ||
(subscribedPokemon.HasStats && matchesIVList)
))
{
continue;
}
var geofence = GetGeofence(user.GuildId);
if (geofence == null)
{
//_logger.Warn($"Failed to lookup city from coordinates {pkmn.Latitude},{pkmn.Longitude} {db.Pokemon[pkmn.Id].Name} {pkmn.IV}, skipping...");
continue;
}
var distanceMatches = user.DistanceM > 0 && user.DistanceM > new Coordinates(user.Latitude, user.Longitude).DistanceTo(new Coordinates(pkmn.Latitude, pkmn.Longitude));
var geofenceMatches = subscribedPokemon.Areas.Select(x => x.ToLower()).Contains(geofence.Name.ToLower());
// If set distance does not match and no geofences match, then skip Pokemon...
if (!distanceMatches && !geofenceMatches)
{
continue;
}
var embed = pkmn.GeneratePokemonMessage(user.GuildId, client, _whConfig.Instance, null, geofence.Name);
foreach (var emb in embed.Embeds)
{
_queue.Enqueue(new NotificationItem(user, member, emb, pokemon.Name, geofence.Name, pkmn));
}
Statistics.Instance.SubscriptionPokemonSent++;
Thread.Sleep(5);
}
catch (Exception ex)
{
_logger.Error(ex);
}
}
subscriptions.Clear();
subscriptions = null;
member = null;
user = null;
pokemon = null;
await Task.CompletedTask;
}
private async Task ExecuteAddRole(CommandContext ctx, DiscordMember member, Boolean silent, UInt64 role)
{
if (!ctx.Member.HasPermission("insanitybot.permissions.user.add_role"))
{
await ctx.Channel.SendMessageAsync(InsanityBot.LanguageConfig["insanitybot.error.lacking_admin_permission"]);
return;
}
if (silent)
{
await ctx.Message.DeleteAsync();
}
DiscordEmbedBuilder embedBuilder = null;
DiscordEmbedBuilder moderationEmbedBuilder = new()
{
Title = "ADMIN: Add role to user",
Color = new(0xff6347),
Footer = new()
{
Text = "InsanityBot 2020-2021"
}
};
moderationEmbedBuilder.AddField("Administrator", ctx.Member.Mention, true)
.AddField("User", member.Mention, true)
.AddField("Role ID", role.ToString(), true)
.AddField("Role", InsanityBot.HomeGuild.GetRole(role).Mention, true);
try
{
UserPermissions permissions = InsanityBot.PermissionEngine.GetUserPermissions(member.Id);
if (!permissions.AssignedRoles.Contains(role))
{
permissions.AssignedRoles = permissions.AssignedRoles.Append(role).ToArray();
}
InsanityBot.PermissionEngine.SetUserPermissions(permissions);
embedBuilder = new()
{
Color = new(0xff6347),
Footer = new()
{
Text = "InsanityBot 2020-2021"
},
Description = GetFormattedString(InsanityBot.LanguageConfig["insanitybot.permissions.role_added"],
ctx, member, InsanityBot.HomeGuild.GetRole(role))
};
InsanityBot.Client.Logger.LogInformation(new EventId(9003, "Permissions"), $"Added role {role} to {member.Username}");
}
catch (Exception e)
{
embedBuilder = new()
{
Color = new(0xff6347),
Footer = new()
{
Text = "InsanityBot 2020-2021"
},
Description = GetFormattedString(InsanityBot.LanguageConfig["insanitybot.permissions.error.could_not_add_role"],
ctx, member, InsanityBot.HomeGuild.GetRole(role))
};
InsanityBot.Client.Logger.LogCritical(new EventId(9003, "Permissions"), $"Administrative action failed: could not add " +
$"role {role} to {member.Username}. Please contact the InsanityBot team immediately.\n" +
$"Please also provide them with the following information:\n\n{e}:{e.Message}\n{e.StackTrace}");
}
finally
{
if (!silent)
{
await ctx.Channel.SendMessageAsync(embedBuilder.Build());
}
_ = InsanityBot.ModlogQueue.QueueMessage(ModlogMessageType.Administration, new DiscordMessageBuilder
{
Embed = moderationEmbedBuilder.Build()
});
}
}
}
private static DiscordEmbedBuilder MakeReportTemplate(DiscordClient client, string infraction, DiscordMessage message, ReportSeverity severity, string actionList = null)
{
var content = message.Content;
if (message.Channel.IsPrivate)
{
severity = ReportSeverity.None;
}
var needsAttention = severity > ReportSeverity.Low;
if (message.Embeds?.Any() ?? false)
{
if (!string.IsNullOrEmpty(content))
{
content += Environment.NewLine;
}
var srcEmbed = message.Embeds.First();
content += $"🔤 {srcEmbed.Title}";
if (srcEmbed.Fields?.Any() ?? false)
{
content += $"{Environment.NewLine}{srcEmbed.Description}{Environment.NewLine}+{srcEmbed.Fields.Count} fields";
}
}
if (message.Attachments?.Any() ?? false)
{
if (!string.IsNullOrEmpty(content))
{
content += Environment.NewLine;
}
content += string.Join(Environment.NewLine, message.Attachments.Select(a => "📎 " + a.FileName));
}
if (string.IsNullOrEmpty(content))
{
content = "🤔 something fishy is going on here, there was no message or attachment";
}
DiscordMember author = null;
try
{
author = client.GetMember(message.Author);
}
catch (Exception e)
{
Config.Log.Warn(e, $"Failed to get the member info for user {message.Author.Id} ({message.Author.Username})");
}
var result = new DiscordEmbedBuilder
{
Title = infraction,
Color = GetColor(severity),
}.AddField("Violator", author == null ? message.Author.Mention : GetMentionWithNickname(author), true)
.AddField("Channel", message.Channel.IsPrivate ? "Bot's DM" : message.Channel.Mention, true)
//.AddField("Time (UTC)", message.CreationTimestamp.ToString("yyyy-MM-dd HH:mm:ss"), true)
.AddField("Content of the offending item", content.Trim(EmbedPager.MaxFieldLength));
if (!string.IsNullOrEmpty(actionList))
{
result.AddField("Filter Actions", actionList, true);
}
if (needsAttention && !message.Channel.IsPrivate)
{
result.AddField("Link to the message", message.JumpLink.ToString());
}
#if DEBUG
result.WithFooter("Test bot instance");
#endif
return(result);
}
public static string FullName(DiscordMember user)
{
return(user.Username + "#" + user.Discriminator);
}
private void UserUpdateEvents(JObject message)
{
DiscordUserUpdateEventArgs e = new DiscordUserUpdateEventArgs();
e.RawJson = message;
DiscordMember newMember = JsonConvert.DeserializeObject<DiscordMember>(message["d"].ToString());
newMember.parentclient = this;
DiscordMember oldMember = new DiscordMember(this);
oldMember.parentclient = this;
//Update members
foreach (var server in ServersList)
{
for (int i = 0; i < server.members.Count; i++)
{
if (server.members[i].ID == newMember.ID)
{
server.members[i] = newMember;
oldMember = server.members[i];
}
}
}
newMember.Parent = oldMember.Parent;
if (!message["roles"].IsNullOrEmpty())
{
JArray rawRoles = JArray.Parse(message["roles"].ToString());
if (rawRoles.Count > 0)
{
foreach (var role in rawRoles.Children())
{
newMember.Roles.Add(newMember.Parent.roles.Find(x => x.id == role.Value<string>()));
}
}
else
{
newMember.Roles.Add(newMember.Parent.roles.Find(x => x.name == "@everyone"));
}
}
e.NewMember = newMember;
e.OriginalMember = oldMember;
if (UserUpdate != null)
UserUpdate(this, e);
}
public static String GetFormattedString(String value, CommandContext context, DiscordMember commandTarget)
{
return(value.Replace("{MENTION}", commandTarget.Mention)
.Replace("{USERNAME}", commandTarget.Username)
.Replace("{NICKNAME}", commandTarget.Nickname)
.Replace("{ID}", commandTarget.Id.ToString())
.Replace("{MODMENTION}", context.Member.Mention)
.Replace("{MODUSERNAME}", context.Member.Username)
.Replace("{MODNICKNAME}", context.Member.Nickname)
.Replace("{MODID}", context.Member.Id.ToString())
.Replace("{CHANNEL}", context.Channel.Mention)
.Replace("{CHANNELNAME}", context.Channel.Name));
}
public BoostEmoji(DiscordMember member)
{
GuildId = member.Guild.Id;
OwnerId = member.Id;
}
public async Task StartGame(CommandContext e)
{
await e.RespondAsync("Game started.");
Started = true;
int Total = Players.Count;
int playerNumIncrement = Total;
int Villains = Convert.ToInt32(Math.Floor((float)(Total / 4)));
int Medics = Convert.ToInt32(Math.Floor((float)(Villains / 2)));
int Spies = Convert.ToInt32(Math.Floor((float)(Villains / 2)));
int Joker = Convert.ToInt32(Math.Floor((float)(Total / 6)));
int Heroes = Total - Villains - Medics - Spies - Joker;
await e.RespondAsync("```There are " + Total + " players in this game, meaning there will be:\n" + Villains + " Villain(s),\n" + Medics + " Medic(s),\n" + Spies + " Spies,\n" + Joker + " Joker(s),\n" + Heroes + " Heroes.```");
for (int i = 0; i < Villains; i++)
{
List <UserObject> usersLeft = Players.Where(x => x.Role < 0).ToList();
int r = Program.random.Next(usersLeft.Count(x => x.Role < 0));
usersLeft[r].Role = 1;
}
for (int i = 0; i < Medics; i++)
{
List <UserObject> usersLeft = Players.Where(x => x.Role < 0).ToList();
int r = Program.random.Next(usersLeft.Count(x => x.Role < 0));
usersLeft[r].Role = 2;
}
for (int i = 0; i < Spies; i++)
{
List <UserObject> usersLeft = Players.Where(x => x.Role < 0).ToList();
int r = Program.random.Next(usersLeft.Count(x => x.Role < 0));
usersLeft[r].Role = 3;
}
for (int i = 0; i < Joker; i++)
{
List <UserObject> usersLeft = Players.Where(x => x.Role < 0).ToList();
int r = Program.random.Next(usersLeft.Count(x => x.Role < 0));
usersLeft[r].Role = 4;
}
for (int i = 0; i < Heroes; i++)
{
List <UserObject> usersLeft = Players.Where(x => x.Role < 0).ToList();
int r = Program.random.Next(usersLeft.Count(x => x.Role < 0));
usersLeft[r].Role = 5;
}
List <int> numberList = Enumerable.Range(0, Total).ToList();
for (int i = 0; i < Total; i++)
{
int rnd = numberList.PickRandom();
Players[i].PlayerNum = rnd;
numberList.Remove(rnd);
}
Players = Players.OrderBy(x => x.PlayerNum).ToList();
try
{
foreach (UserObject userData in Players)
{
DiscordMember user = await e.Guild.GetMemberAsync(userData.ID);
DiscordDmChannel dm = await user.CreateDmChannelAsync();
string roleType = userData.Role == 1 ? "Villain" : userData.Role == 2 ? "Medic" : userData.Role == 3 ? "Spy" : userData.Role == 4 ? "Joker" : userData.Role == 5 ? "Hero" : "ERROR, Please report this to Jcryer.";
if (userData.Role == 1)
{
if (Players.Count(x => x.Role == 1) > 1)
{
await dm.SendMessageAsync("Hi! your role is: Villain, and the other Villains are: ");
foreach (UserObject a in Players.FindAll(x => x.Role == 1 && x.ID != user.Id))
{
await dm.SendMessageAsync(a.Username);
}
}
else
{
await dm.SendMessageAsync("Hi! your role is: Villain.");
}
}
else
{
await dm.SendMessageAsync("Hi! Your role is: " + roleType);
}
await DisplayData(dm, false);
}
}
catch { }
}
/// <summary>
/// Kicks a specified DiscordMember from the guild that's assumed from their
/// parent property.
/// </summary>
/// <param name="member"></param>
public void KickMember(DiscordMember member)
{
string url = Endpoints.BaseAPI + Endpoints.Guilds + $"/{member.Parent.ID}" + Endpoints.Members + $"/{member.ID}";
try
{
WebWrapper.Delete(url, token);
}
catch (Exception ex)
{
DebugLogger.Log($"Error during KickMember\n\t{ex.Message}\n\t{ex.StackTrace}", MessageLevel.Error);
}
}
private async void Clear(object sender, RoutedEventArgs e)
{
try
{
if (IsDirect.IsChecked ?? false)
{
DiscordGuild server;
ulong serverId = Convert.ToUInt64(GuildId.Text);
if (MainWindow.userClient.Guilds.TryGetValue(serverId, out server))
{
ulong channelIdVal = Convert.ToUInt64(ChannelId.Text);
try
{
DiscordMember dmUser = await server.GetMemberAsync(channelIdVal);
DiscordDmChannel dm = await dmUser.CreateDmChannelAsync();
if (dm != null)
{
int msgCount;
ulong startClear;
if (!int.TryParse(ClearCount.Text, out msgCount))
{
MessageBox.Show("Неправильное кол-во ссобщений.");
}
if (!ulong.TryParse(ClearerMsgId.Text, out startClear))
{
MessageBox.Show("Неправильный ID сообщения.");
}
try
{
toClear = (await dm.GetMessagesAsync(msgCount, startClear)).Where(ex => ex.Author == MainWindow.userClient.CurrentUser).ToList();
MessageBoxResult result = MessageBox.Show($"Вы действительно хотите удалить свои {toClear.Count} сообщений в DM с \"{dmUser.Username}\" начиная с сообщения \"{toClear.Last().Content}\" и заканчивая \"{toClear.First().Content}\"?", "Ожидание подтверждения", MessageBoxButton.YesNo, MessageBoxImage.Question, MessageBoxResult.No);
if (result == MessageBoxResult.No)
{
MessageBox.Show("Удаление отменено.");
return;
}
foreach (DiscordMessage msg in toClear)
{
try
{
await dm.DeleteMessageAsync(msg);
Thread.Sleep(1300);
}
catch (Exception) { Thread.Sleep(600); }
}
}
catch (Exception)
{
MessageBox.Show("Какая-то ошибка.");
}
}
else
{
MessageBox.Show("Ошибка: неверный ID пользователя.");
}
}
catch (Exception)
{
MessageBox.Show("Ошибка: неверный ID пользователя.");
}
}
}
else
{
DiscordGuild server;
ulong serverId = Convert.ToUInt64(GuildId.Text);
if (MainWindow.userClient.Guilds.TryGetValue(serverId, out server))
{
ulong channelIdVal = Convert.ToUInt64(ChannelId.Text);
try
{
DiscordChannel channel = server.GetChannel(channelIdVal);
if (channel != null)
{
int msgCount;
ulong startClear;
if (!int.TryParse(ClearCount.Text, out msgCount))
{
MessageBox.Show("Неправильное кол-во ссобщений.");
}
if (!ulong.TryParse(ClearerMsgId.Text, out startClear))
{
MessageBox.Show("Неправильный ID сообщения.");
}
try
{
if ((OnlyMine.IsChecked ?? false) == false)
{
toClear = (await channel.GetMessagesAsync(msgCount, startClear)).ToList();
}
else
{
toClear = (await channel.GetMessagesAsync(msgCount, startClear)).Where(ex => ex.Author == MainWindow.userClient.CurrentUser).ToList();
}
MessageBoxResult result = MessageBox.Show($"Вы действительно хотите удалить {toClear.Count}{((OnlyMine.IsChecked ?? false)?" своих":"")} сообщений в канале \"{channel.Name}\" на сервере \"{server.Name}\" начиная с сообщения \"{toClear.Last().Content}\" и заканчивая \"{toClear.First().Content}\"?", "Ожидание подтверждения", MessageBoxButton.YesNo, MessageBoxImage.Question, MessageBoxResult.No);
if (result == MessageBoxResult.No)
{
MessageBox.Show("Удаление отменено.");
return;
}
foreach (DiscordMessage msg in toClear)
{
try
{
await channel.DeleteMessageAsync(msg);
Thread.Sleep(1300);
}
catch (Exception) { Thread.Sleep(600); }
}
}
catch (Exception)
{
MessageBox.Show("Какая-то ошибка.");
}
}
else
{
MessageBox.Show("Ошибка: неверный ID канала.");
}
}
catch (Exception)
{
MessageBox.Show("Ошибка: неверный ID канала.");
}
}
else
{
MessageBox.Show("Ошибка: неверный ID сервера.");
}
}
}
catch (Exception) { return; }
}
private void UserUpdateEvents(JObject message)
{
DiscordUserUpdateEventArgs e = new DiscordUserUpdateEventArgs();
e.RawJson = message;
DiscordMember newMember = JsonConvert.DeserializeObject<DiscordMember>(message["d"].ToString());
newMember.parentclient = this;
DiscordMember oldMember = new DiscordMember(this);
oldMember.parentclient = this;
//Update members
foreach (var server in ServersList)
{
foreach (var member in server.Members)
{
if (member.Value.ID == newMember.ID)
{
oldMember = member.Value;
server.AddMember(newMember);
break;
}
}
}
newMember.Parent = oldMember.Parent;
if (!message["roles"].IsNullOrEmpty())
{
JArray rawRoles = JArray.Parse(message["roles"].ToString());
if (rawRoles.Count > 0)
{
foreach (var role in rawRoles.Children())
{
newMember.Roles.Add(newMember.Parent.Roles.Find(x => x.ID == role.ToString()));
}
}
else
{
newMember.Roles.Add(newMember.Parent.Roles.Find(x => x.Name == "@everyone"));
}
}
e.NewMember = newMember;
e.OriginalMember = oldMember;
UserUpdate?.Invoke(this, e);
}
public async Task List(CommandContext ctx, [Description("Название корабля (необязательно для капитанов)")][RemainingText] string shipName = null)
{
PrivateShip ship = null;
if (string.IsNullOrEmpty(shipName))
{
ship = PrivateShip.GetOwnedShip(ctx.Member.Id);
if (ship == null)
{
await ctx.RespondAsync($"{Bot.BotSettings.ErrorEmoji} Ты не являешься капитаном. Офицеры могут использовать команду " +
$"`!p list название корабля`");
return;
}
}
else
{
ship = PrivateShip.Get(shipName);
if (ship == null)
{
await ctx.RespondAsync($"{Bot.BotSettings.ErrorEmoji} Указанный корабль не был найден!");
return;
}
}
var requesterMember = ship.GetMember(ctx.Member.Id);
if (requesterMember == null ||
(requesterMember.Role != PrivateShipMemberRole.Officer && requesterMember.Role != PrivateShipMemberRole.Captain))
{
await ctx.RespondAsync($"{Bot.BotSettings.ErrorEmoji} Ты не являешься офицером или капитаном на данном корабле");
return;
}
var members = ship.GetMembers().OrderByDescending(m => m.Role).ToList();
await ctx.Channel.TriggerTypingAsync();
var memberList = new List <string>();
foreach (var member in members)
{
DiscordMember discordMember = null;
try
{
discordMember = await ctx.Guild.GetMemberAsync(member.MemberId);
}
catch (NotFoundException)
{
continue;
}
var type = PrivateShipMember.RoleEnumToStringRu(member.Role);
memberList.Add($"{type} {discordMember.DisplayName}#{discordMember.Discriminator}." + (member.Status ? null : " Приглашён."));
}
var interactivity = ctx.Client.GetInteractivity();
var membersPagination = Utility.GeneratePagesInEmbeds(memberList, $"Список членов экипажа вашего корабля.");
if (memberList.Count() > 1)
{
await interactivity.SendPaginatedMessageAsync(ctx.Channel, ctx.User, membersPagination, timeoutoverride : TimeSpan.FromMinutes(5));
}
else
{
await ctx.RespondAsync(embed : membersPagination.First().Embed);
}
}
internal void MemberAdded(DiscordMember added)
{
if(added.Parent == Guild)
{
if(added.CurrentVoiceChannel == Channel)
{
if (MembersInChannel.Contains(added))
MembersInChannel.Remove(added);
MembersInChannel.Add(added);
VoiceDebugLogger.Log($"User {added.Username} ({added.ID}) joined the client's current connected voice channel.");
}
}
}
public async Task Kick(CommandContext ctx, [Description("Участник")] DiscordMember member, [RemainingText][Description("Название корабля (необязательно для капитанов)")] string shipName)
{
PrivateShip ship = null;
if (string.IsNullOrEmpty(shipName))
{
ship = PrivateShip.GetOwnedShip(ctx.Member.Id);
if (ship == null)
{
await ctx.RespondAsync($"{Bot.BotSettings.ErrorEmoji} Ты не являешься капитаном. Офицеры могут использовать команду " +
$"`!p kick участник название корабля`");
return;
}
}
else
{
ship = PrivateShip.Get(shipName);
if (ship == null)
{
await ctx.RespondAsync($"{Bot.BotSettings.ErrorEmoji} Указанный корабль не был найден!");
return;
}
}
var requesterMember = ship.GetMember(ctx.Member.Id);
if (requesterMember == null ||
(requesterMember.Role != PrivateShipMemberRole.Officer && requesterMember.Role != PrivateShipMemberRole.Captain))
{
await ctx.RespondAsync($"{Bot.BotSettings.ErrorEmoji} Ты не являешься офицером или капитаном на данном корабле");
return;
}
if (ctx.Member == member)
{
await ctx.RespondAsync($"{Bot.BotSettings.ErrorEmoji} Нельзя выгнать самого себя.");
return;
}
var members = ship.GetMembers();
var selected = members.Find(m => m.MemberId == member.Id);
if (selected == null)
{
await ctx.RespondAsync($"{Bot.BotSettings.ErrorEmoji} Этого участника нет на корабле.");
return;
}
ship.RemoveMember(selected.MemberId);
await ctx.RespondAsync($"{Bot.BotSettings.OkEmoji} Ты успешно выгнал участника с корабля.");
try
{
string title = requesterMember.Role == PrivateShipMemberRole.Captain ? "Капитан" : "Офицер";
if (selected.Status)
{
await ctx.Guild.GetChannel(ship.Channel).AddOverwriteAsync(member);
await member.SendMessageAsync($":right_facing_fist: {title} **{ctx.Member.DisplayName}#{ctx.Member.Discriminator}** " +
$"выгнал тебя с корабля **{ship.Name}**");
}
else
{
await member.SendMessageAsync($":right_facing_fist: {title} **{ctx.Member.DisplayName}#{ctx.Member.Discriminator}** " +
$"отменил твоё приглашение на корабль **{ship.Name}**");
}
}
catch (UnauthorizedException)
{
}
}
public async Task Ping(CommandContext ctx, [Description("Member to mention.")] DiscordMember member)
{
await ctx.RespondAsync($"{member.Mention}");
}
public void Invoke(DiscordHandler client, CommandHandler handler, CommandEventArg args)
{
using DBContext c = new DBContext();
DiscordGuildConfig dgc = args.Config;
if (dgc == null || dgc.MutedRoleId == 0)
{
args.Channel.SendMessageAsync("You need to setup your muted role first in the config");
return;
}
args.Parameters[0] = args.Parameters[0].Trim('<', '@', '!', '>');
DiscordMember member = null;
if (ulong.TryParse(args.Parameters[0], out ulong uid))
{
try
{
member = args.Guild.GetMemberAsync(uid).ConfigureAwait(false).GetAwaiter().GetResult();
}
catch (DSharpPlus.Exceptions.NotFoundException)
{
}
}
if (member == null)
{
HelpCommand.ShowHelp(args.Channel, this, "Could not find member or parse id: " + args.Parameters[0]);
return;
}
if (!long.TryParse(args.Parameters[1], out long durationM))
{
HelpCommand.ShowHelp(args.Channel, this, "Failed to parse duration: " + args.Parameters[1]);
return;
}
var drole = args.Guild.GetRole((ulong)dgc.MutedRoleId);
Mute m;
if (member.Roles.Contains(drole))
{
//Update duration if diffrent
m = c.Mute.FirstOrDefault(mu => mu.DiscordGuildId == (long)args.Guild.Id && mu.DiscordUserId == (long)uid && !mu.Unmuted);
if (m != null)
{
if (m.DurationM == durationM)
{
args.Channel.SendMessageAsync("Not updated, time is the same");
return;
}
m.DurationM = durationM;
c.Mute.Update(m);
c.SaveChanges();
args.Channel.SendMessageAsync("Updated duration");
return;
}
else
{
member.RevokeRoleAsync(drole, "invalid mute, revoking").ConfigureAwait(false).GetAwaiter().GetResult();
}
}
if (args.Parameters.Count < 3)
{
HelpCommand.ShowHelp(args.Channel, this);
return;
}
StringBuilder reasonBuilder = new StringBuilder(args.Parameters[2]);
for (int i = 3; i < args.Parameters.Count; i++)
{
reasonBuilder.Append(" " + args.Parameters[i]);
}
m = new Mute((long)uid, (long)args.Guild.Id, DateTime.UtcNow, durationM, args.ParameterString.Remove(0, args.Parameters[0].Length + args.Parameters[1].Length + 2));
member.GrantRoleAsync(drole, $"muted by {args.User.Username} for {durationM} minutes, reason: {m.Reason}");
c.Mute.Add(m);
c.SaveChanges();
args.Channel.SendMessageAsync($"Muted {member.Username} for {durationM} minutes, reason: {m.Reason}");
}
public static async void EnqueueLogProcessing(DiscordClient client, DiscordChannel channel, DiscordMessage message, DiscordMember requester = null, bool checkExternalLinks = false)
{
try
{
if (!QueueLimiter.Wait(0))
{
await channel.SendMessageAsync("Log processing is rate limited, try again a bit later").ConfigureAwait(false);
return;
}
bool parsedLog = false;
var startTime = Stopwatch.StartNew();
DiscordMessage botMsg = null;
try
{
var possibleHandlers = sourceHandlers.Select(h => h.FindHandlerAsync(message, archiveHandlers).ConfigureAwait(false).GetAwaiter().GetResult()).ToList();
var source = possibleHandlers.FirstOrDefault(h => h.source != null).source;
var fail = possibleHandlers.FirstOrDefault(h => !string.IsNullOrEmpty(h.failReason)).failReason;
if (source != null)
{
Config.Log.Debug($">>>>>>> {message.Id % 100} Parsing log '{source.FileName}' from {message.Author.Username}#{message.Author.Discriminator} ({message.Author.Id}) using {source.GetType().Name} ({source.SourceFileSize} bytes)...");
var analyzingProgressEmbed = GetAnalyzingMsgEmbed();
botMsg = await channel.SendMessageAsync(embed : analyzingProgressEmbed.AddAuthor(client, message, source)).ConfigureAwait(false);
parsedLog = true;
var timeout = new CancellationTokenSource(Config.LogParsingTimeout);
var combinedTokenSource = CancellationTokenSource.CreateLinkedTokenSource(timeout.Token, Config.Cts.Token);
var tries = 0;
LogParseState result = null;
do
{
result = await ParseLogAsync(
source,
async() => botMsg = await botMsg.UpdateOrCreateMessageAsync(channel, embed : analyzingProgressEmbed.AddAuthor(client, message, source)).ConfigureAwait(false),
combinedTokenSource.Token
).ConfigureAwait(false);
tries++;
} while (result == null && !combinedTokenSource.IsCancellationRequested && tries < 3);
if (result == null)
{
botMsg = await botMsg.UpdateOrCreateMessageAsync(channel, embed : new DiscordEmbedBuilder
{
Description = "Log analysis failed, most likely cause is a truncated/invalid log.\n" +
"Please run the game again and re-upload a new copy.",
Color = Config.Colors.LogResultFailed,
}
.AddAuthor(client, message, source)
.Build()
).ConfigureAwait(false);
}
else
{
result.ParsingTime = startTime.Elapsed;
try
{
if (result.Error == LogParseState.ErrorCode.PiracyDetected)
{
var yarr = client.GetEmoji(":piratethink:", "☠");
result.ReadBytes = 0;
if (message.Author.IsWhitelisted(client, channel.Guild))
{
var piracyWarning = await result.AsEmbedAsync(client, message, source).ConfigureAwait(false);
piracyWarning = piracyWarning.WithDescription("Please remove the log and issue warning to the original author of the log");
botMsg = await botMsg.UpdateOrCreateMessageAsync(channel, embed : piracyWarning).ConfigureAwait(false);
await client.ReportAsync(yarr + " Pirated Release (whitelisted by role)", message, result.SelectedFilter?.String, result.SelectedFilterContext, ReportSeverity.Low).ConfigureAwait(false);
}
else
{
var severity = ReportSeverity.Low;
try
{
await message.DeleteAsync("Piracy detected in log").ConfigureAwait(false);
}
catch (Exception e)
{
severity = ReportSeverity.High;
Config.Log.Warn(e, $"Unable to delete message in {channel.Name}");
}
try
{
/*
* botMsg = await botMsg.UpdateOrCreateMessageAsync(channel,
* $"{message.Author.Mention}, please read carefully:",
* embed: await result.AsEmbedAsync(client, message, source).ConfigureAwait(false)
* ).ConfigureAwait(false);
*/
botMsg = await botMsg.UpdateOrCreateMessageAsync(channel,
$"{message.Author.Mention}, please read carefully:\n" +
"🚨 **Pirated content detected** 🚨\n" +
"__You are being denied further support until you legally dump the game__.\n" +
"Please note that the RPCS3 community and its developers do not support piracy.\n" +
"Most of the issues with pirated dumps occur due to them being modified in some way " +
"that prevent them from working on RPCS3.\n" +
"If you need help obtaining valid working dump of the game you own, please read the quickstart guide at <https://rpcs3.net/quickstart>"
).ConfigureAwait(false);
}
catch (Exception e)
{
Config.Log.Error(e, "Failed to send piracy warning");
}
try
{
await client.ReportAsync(yarr + " Pirated Release", message, result.SelectedFilter?.String, result.SelectedFilterContext, severity).ConfigureAwait(false);
}
catch (Exception e)
{
Config.Log.Error(e, "Failed to send piracy report");
}
if (!(message.Channel.IsPrivate || (message.Channel.Name?.Contains("spam") ?? true)))
{
await Warnings.AddAsync(client, message, message.Author.Id, message.Author.Username, client.CurrentUser, "Pirated Release", $"{result.SelectedFilter?.String} - {result.SelectedFilterContext?.Sanitize()}");
}
}
}
else
{
if (result.SelectedFilter != null)
{
await ContentFilter.PerformFilterActions(client, message, result.SelectedFilter, FilterAction.IssueWarning | FilterAction.SendMessage, result.SelectedFilterContext).ConfigureAwait(false);
}
botMsg = await botMsg.UpdateOrCreateMessageAsync(channel,
requester == null?null : $"Analyzed log from {client.GetMember(channel.Guild, message.Author)?.GetUsernameWithNickname()} by request from {requester.Mention}:",
embed : await result.AsEmbedAsync(client, message, source).ConfigureAwait(false)
).ConfigureAwait(false);
}
}
catch (Exception e)
{
Config.Log.Error(e, "Sending log results failed");
}
}
return;
}
else if (!string.IsNullOrEmpty(fail) &&
("help".Equals(channel.Name, StringComparison.InvariantCultureIgnoreCase) || LimitedToSpamChannel.IsSpamChannel(channel)))
{
await channel.SendMessageAsync($"{message.Author.Mention} {fail}").ConfigureAwait(false);
return;
}
if (!"help".Equals(channel.Name, StringComparison.InvariantCultureIgnoreCase))
{
return;
}
var potentialLogExtension = message.Attachments.Select(a => Path.GetExtension(a.FileName).ToUpperInvariant().TrimStart('.')).FirstOrDefault();
switch (potentialLogExtension)
{
case "TXT":
{
await channel.SendMessageAsync($"{message.Author.Mention} Please upload the full RPCS3.log.gz (or RPCS3.log with a zip/rar icon) file after closing the emulator instead of copying the logs from RPCS3's interface, as it doesn't contain all the required information.").ConfigureAwait(false);
return;
}
}
if (string.IsNullOrEmpty(message.Content))
{
return;
}
var linkStart = message.Content.IndexOf("http");
if (linkStart > -1)
{
var link = message.Content.Substring(linkStart).Split(linkSeparator, 2)[0];
if (link.Contains(".log", StringComparison.InvariantCultureIgnoreCase) || link.Contains("rpcs3.zip", StringComparison.CurrentCultureIgnoreCase))
{
await channel.SendMessageAsync("If you intended to upload a log file please re-upload it directly to discord").ConfigureAwait(false);
}
}
}
finally
{
QueueLimiter.Release();
if (parsedLog)
{
Config.Log.Debug($"<<<<<<< {message.Id % 100} Finished parsing in {startTime.Elapsed}");
}
}
}
catch (Exception e)
{
Config.Log.Error(e, "Error parsing log");
}
}
public async Task S**t(CommandContext ctx)
{
int reward = 0;
Profile profile = await _profileService.GetOrCreateProfileAsync(ctx.Member.Id, ctx.Guild.Id).ConfigureAwait(false);
DiscordMember member = ctx.Guild.Members[profile.DiscordId];
Random random = new Random();
reward = random.Next(501, 4001);
int loseNum = random.Next(0, 101);
bool lose = false;
if (loseNum > 35)
{
lose = false;
}
else if (loseNum <= 35)
{
lose = true;
}
if (profile.cooldown_slut.HasValue)
{
var timeSpan = DateTime.Now - profile.cooldown_slut.Value;
if (timeSpan >= TimeSpan.FromHours(1.5))
{
await _profileService.ChangeUserGold(ctx.Member.Id, ctx.Guild.Id, reward, lose);
await _profileService.SetUserTimeSlut(ctx.Member.Id, ctx.Guild.Id, DateTime.Now);
var embedMessage = GetMessage(reward, 1, lose);
await ctx.Channel.SendMessageAsync(embed : embedMessage).ConfigureAwait(false);
return;
}
else
{
var embedMessage = new DiscordEmbedBuilder();
TimeSpan timeLeft = TimeSpan.FromHours(1.5) - timeSpan;
embedMessage.WithTitle("Too early!");
embedMessage.WithDescription("You need to wait " + timeLeft.ToString(@"hh\:mm\:ss"));
await ctx.Channel.SendMessageAsync(embed : embedMessage).ConfigureAwait(false);
return;
}
}
else
{
await _profileService.ChangeUserGold(ctx.Member.Id, ctx.Guild.Id, reward, lose);
await _profileService.SetUserTimeSlut(ctx.Member.Id, ctx.Guild.Id, DateTime.Now);
var embedMessage = GetMessage(reward, 1, lose);
await ctx.Channel.SendMessageAsync(embed : embedMessage).ConfigureAwait(false);
return;
}
}
public Witch(DiscordMember me, DiscordGuildEmoji emoji) : base(me, emoji)
{
}
/// <summary>
/// Exporting representation state
/// </summary>
/// <param name="commandContext">Command context</param>
/// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
public async Task ExportRepresentation(CommandContextContainer commandContext)
{
using (var dbFactory = RepositoryFactory.CreateInstance())
{
var guildId = dbFactory.GetRepository <GuildRepository>()
.GetQuery()
.Where(obj => obj.DiscordServerId == commandContext.Guild.Id)
.Select(obj => obj.GuildId)
.FirstOrDefault();
var entries = await dbFactory.GetRepository <AccountRepository>()
.GetQuery()
.Select(obj => new
{
obj.Name,
DiscordAccountId = obj.User
.DiscordAccounts
.Select(obj2 => obj2.Id)
.FirstOrDefault(),
obj.ApiKey
})
.ToListAsync()
.ConfigureAwait(false);
var accounts = new List <(string User, string AccountName, int Characters, int?Representation)>();
foreach (var entry in entries)
{
DiscordMember user = null;
try
{
user = await commandContext.Guild
.GetMemberAsync(entry.DiscordAccountId)
.ConfigureAwait(false);
}
catch
{
}
if (user != null)
{
var connector = new GuidWars2ApiConnector(entry.ApiKey);
await using (connector.ConfigureAwait(false))
{
var characters = await connector.GetCharactersAsync()
.ConfigureAwait(false);
accounts.Add((user.TryGetDisplayName(), entry.Name, characters?.Count ?? 0, characters?.Count(obj => obj.Guild == guildId) ?? 0));
}
}
}
var memoryStream = new MemoryStream();
await using (memoryStream.ConfigureAwait(false))
{
var writer = new StreamWriter(memoryStream);
await using (writer.ConfigureAwait(false))
{
await writer.WriteLineAsync("User;AccountName;Characters;Representation;Percentage")
.ConfigureAwait(false);
foreach (var(user, accountName, characters, representation) in accounts.OrderBy(obj => obj.User)
.ThenBy(obj => obj.AccountName))
{
await writer.WriteLineAsync($"{user};{accountName};{characters};{representation};{(characters != 0 ? representation / (double)characters : 0)}")
.ConfigureAwait(false);
}
await writer.FlushAsync()
.ConfigureAwait(false);
memoryStream.Position = 0;
await commandContext.Channel
.SendMessageAsync(new DiscordMessageBuilder().WithFile("representation.csv", memoryStream))
.ConfigureAwait(false);
}
}
}
}
public DiscordMemberCapsule(DiscordMember m)
{
Member = m;
}
public async Task BlacklistCommand(CommandContext ctx,
DiscordMember member,
[RemainingText]
String Reason = "usedefault")
{
if (!ctx.Member.HasPermission("insanitybot.moderation.blacklist"))
{
await ctx.RespondAsync(InsanityBot.LanguageConfig["insanitybot.error.lacking_permission"]);
return;
}
//actually do something with the usedefault value
String BlacklistReason = Reason switch
{
"usedefault" => GetFormattedString(InsanityBot.LanguageConfig["insanitybot.moderation.no_reason_given"],
ctx, member),
_ => GetFormattedString(Reason, ctx, member)
};
DiscordEmbedBuilder embedBuilder = null;
DiscordEmbedBuilder moderationEmbedBuilder = new DiscordEmbedBuilder
{
Title = "BLACKLIST",
Color = DiscordColor.Black,
Footer = new DiscordEmbedBuilder.EmbedFooter
{
Text = "InsanityBot - ExaInsanity 2020-2021"
}
};
moderationEmbedBuilder.AddField("Moderator", ctx.Member.Mention, true)
.AddField("Member", member.Mention, true)
.AddField("Reason", BlacklistReason, true);
try
{
member.AddModlogEntry(ModlogEntryType.blacklist, BlacklistReason);
embedBuilder = new DiscordEmbedBuilder
{
Description = GetFormattedString(InsanityBot.LanguageConfig["insanitybot.moderation.blacklist.success"],
ctx, member),
Color = DiscordColor.Red,
Footer = new DiscordEmbedBuilder.EmbedFooter
{
Text = "InsanityBot - ExaInsanity 2020-2021"
}
};
_ = member.GrantRoleAsync(InsanityBot.HomeGuild.GetRole(
ToUInt64(InsanityBot.Config["insanitybot.identifiers.moderation.blacklist_role_id"])),
BlacklistReason);
_ = InsanityBot.HomeGuild.GetChannel(ToUInt64(InsanityBot.Config["insanitybot.identifiers.commands.modlog_channel_id"]))
.SendMessageAsync(embed: moderationEmbedBuilder.Build());
}
catch (Exception e)
{
embedBuilder = new DiscordEmbedBuilder
{
Description = GetFormattedString(InsanityBot.LanguageConfig["insanitybot.moderation.blacklist.failure"],
ctx, member),
Color = DiscordColor.Red,
Footer = new DiscordEmbedBuilder.EmbedFooter
{
Text = "InsanityBot - ExaInsanity 2020-2021"
}
};
InsanityBot.Client.Logger.LogError($"{e}: {e.Message}");
}
finally
{
await ctx.RespondAsync(embed : embedBuilder.Build());
}
}
private Task SetupEvents(CancellationToken token)
{
Console.ForegroundColor = ConsoleColor.White;
return Task.Run(() =>
{
client.MessageReceived += (sender, e) =>
{
if(owner == null)
owner = client.GetServersList().Find(x => x.GetMemberByKey(config.OwnerID) != null).GetMemberByKey(config.OwnerID); //prays
if (e.Author == null)
{
string msg = $"Author had null id in message received!\nRaw JSON:\n```\n{e.RawJson}\n```\n";
msg += $"Args\nChannel: {e.Channel.Name}/{e.Channel.ID}\nMessage: {e.Message}";
try
{
owner.SlideIntoDMs(msg);
}
catch { }
}
else
{
Console.WriteLine($"[-- Message from {e.Author.Username} in #{e.Channel.Name} on {e.Channel.Parent.Name}: {e.Message.Content}");
if (doingInitialRun)
{
if (e.Message.Content.StartsWith("?authenticate"))
{
string[] split = e.Message.Content.Split(new char[] { ' ' }, 2);
if (split.Length > 1)
{
if (codeToEnter.Trim() == split[1].Trim())
{
config.OwnerID = e.Author.ID;
doingInitialRun = false;
e.Channel.SendMessage("Authentication successful! **You are now my owner, " + e.Author.Username + ".**");
CommandsManager.AddPermission(e.Author, PermissionType.Owner);
owner = e.Author;
}
}
}
}
else
{
if (e.Message.Content.Length > 0 && (e.Message.Content[0] == config.CommandPrefix))
{
string rawCommand = e.Message.Content.Substring(1);
try
{
CommandsManager.ExecuteOnMessageCommand(rawCommand, e.Channel, e.Author);
}
catch (UnauthorizedAccessException ex)
{
e.Channel.SendMessage(ex.Message);
}
catch(ModuleNotEnabledException x)
{
e.Channel.SendMessage($"{x.Message}");
}
catch (Exception ex)
{
e.Channel.SendMessage("Exception occurred while running command:\n```" + ex.Message + "\n```");
}
}
}
//Now, for fun.
//if(e.author == owner)
//{
// if (StringContainsObjectInArray(e.message.content.ToLower(), NaughtyWords))
// {
// try
// {
// var msg = client.GetMessageLog()[client.GetMessageLog().Count - 1].Value;
// if (msg.author == owner
// && client.GetLastMessageSent(e.Channel).content != null &&
// client.GetLastMessageSent(e.Channel).content != "hey now")
// {
// //if(msg.timestamp.AddMinutes(1) < DateTime.Now)
// int timebetween = (DateTime.Now.Minute - msg.timestamp.Minute);
// if ((timebetween < 1) && (timebetween > -1)) //less than one minute between his message and my vulgarity
// e.Channel.SendMessage("hey now");
// }
// }
// catch { }
// }
//}
if(e.Channel.ID == "91265608326324224") //discord-sharp on discordapi
{
if(e.Author != owner)
{
if(e.Message.Content != null && e.Message.Content.ToLower().Contains("how"))
{
if(e.Message.Content.ToLower().Contains("bot") && e.Message.Content.ToLower().Contains("tag"))
{
e.Channel.SendMessage($"<#124294271900712960>");//#api-changes
}
}
}
}
}
};
client.VoiceClientDebugMessageReceived += (sender, e) =>
{
if(e.message.Level != MessageLevel.Unecessary)
Console.WriteLine($"[{e.message.Level} {e.message.TimeStamp.ToString()}] {e.message.Message}");
};
client.VoiceClientConnected += (sender, e) =>
{
try
{
owner.SlideIntoDMs($"Voice connection complete.");
}
catch { }
//player = new AudioPlayer(client.GetVoiceClient().VoiceConfig);
//bufferedWaveProvider = new BufferedWaveProvider(waveFormat);
//bufferedWaveProvider.BufferDuration = new TimeSpan(0, 0, 50);
//volumeProvider = new VolumeWaveProvider16(bufferedWaveProvider);
//volumeProvider.Volume = 1.1f;
//outputDevice.Init(volumeProvider);
//stutterReducingTimer = new System.Timers.Timer(500);
//stutterReducingTimer.Elapsed += StutterReducingTimer_Elapsed;
//PlayAudioAsync(cancelToken);
};
client.AudioPacketReceived += (sender, e) =>
{
if(bufferedWaveProvider != null)
{
byte[] potential = new byte[4000];
int decodedFrames = client.GetVoiceClient().Decoder.DecodeFrame(e.OpusAudio, 0, e.OpusAudioLength, potential);
bufferedWaveProvider.AddSamples(potential, 0, decodedFrames);
}
};
client.GuildCreated += (sender, e) =>
{
if(owner == null)
owner = client.GetServersList().Find(x => x.GetMemberByKey(config.OwnerID) != null).GetMemberByKey(config.OwnerID);
Console.WriteLine($"Joined server {e.Server.Name} ({e.Server.ID})");
try
{
owner.SlideIntoDMs($"Joined server {e.Server.Name} ({e.Server.ID})");
}
catch { }
};
client.GuildAvailable += (sender, e) =>
{
Console.WriteLine($"Guild {e.Server.Name} became available.");
};
client.SocketClosed += (sender, e) =>
{
Console.Title = "Luigibot - Discord - Socket Closed..";
if(!actuallyExit)
{
WriteError($"\n\nSocket Closed Unexpectedly! Code: {e.Code}. Reason: {e.Reason}. Clear: {e.WasClean}.\n\n");
Console.WriteLine("Waiting 6 seconds to reconnect..");
Thread.Sleep(6 * 1000);
LetsGoAgain();
}
else
{
Console.WriteLine($"Shutting down ({e.Code}, {e.Reason}, {e.WasClean})");
}
};
client.UnknownMessageTypeReceived += (sender, e) =>
{
if (!Directory.Exists("dumps"))
Directory.CreateDirectory("dumps");
string message = $"Ahoy! An unknown message type `{e.RawJson["t"].ToString()}` was discovered with the contents: \n\n";
message += $"```\n{e.RawJson.ToString()}\n```\nIt's been dumped to `dumps/{e.RawJson["t"].ToString()}.json` for your viewing pleasure.";
string filename = $"{Environment.CurrentDirectory}{Path.DirectorySeparatorChar}dumps{Path.DirectorySeparatorChar}{e.RawJson["t"].ToString()}.json";
if(!File.Exists(filename))
{
File.WriteAllText(e.RawJson.ToString(), filename);
try
{
owner.SlideIntoDMs(message);
}
catch { }
}
};
client.TextClientDebugMessageReceived += (sender, e) =>
{
if (e.message.Level == MessageLevel.Error || e.message.Level == MessageLevel.Critical)
{
WriteError($"(Logger Error) {e.message.Message}");
try
{
owner.SlideIntoDMs($"Bot error ocurred: ({e.message.Level.ToString()})```\n{e.message.Message}\n```");
}
catch { }
}
if (e.message.Level == MessageLevel.Warning)
WriteWarning($"(Logger Warning) {e.message.Message}");
};
client.Connected += (sender, e) =>
{
Console.Title = "Luigibot - Discord - Logged in as " + e.User.Username;
Console.WriteLine("Connected as " + e.User.Username);
if (!String.IsNullOrEmpty(config.OwnerID))
{ }
else
{
doingInitialRun = true;
RandomCodeGenerator rcg = new RandomCodeGenerator();
codeToEnter = rcg.GenerateRandomCode();
Console.ForegroundColor = ConsoleColor.Cyan;
Console.WriteLine("Important: ");
Console.ForegroundColor = ConsoleColor.White;
Console.WriteLine("\tPlease authenticate yourself as owner by typing the following into any Discord server you and the bot are in: ");
Console.WriteLine($"\t{config.CommandPrefix}authenticate " + codeToEnter);
}
CommandsManager = new CommandsManager(client);
if (File.Exists("permissions.json"))
{
var permissionsDictionary = JsonConvert.DeserializeObject<Dictionary<string, PermissionType>>(File.ReadAllText("permissions.json"));
if (permissionsDictionary == null)
permissionsDictionary = new Dictionary<string, PermissionType>();
if(permissionsDictionary.Count == 0 && owner != null)
permissionsDictionary.Add(owner.ID, PermissionType.Owner);
CommandsManager.OverridePermissionsDictionary(permissionsDictionary);
}
SetupCommands();
if(config.ModulesDictionary != null)
{
CommandsManager.OverrideModulesDictionary(config.ModulesDictionary);
}
//client.UpdateCurrentGame($"DiscordSharp {typeof(DiscordClient).Assembly.GetName().Version.ToString()}");
};
if(client.SendLoginRequest() != null)
{
client.Connect();
}
}, token);
}
public ReactionsPoll(InteractivityExtension interactivity, DiscordChannel channel, DiscordMember sender, string question)
: base(interactivity, channel, sender, question)
{
}
private void MessageCreateEvents(JObject message)
{
//try
//{
string tempChannelID = message["d"]["channel_id"].ToString();
//DiscordServer foundServerChannel = ServersList.Find(x => x.channels.Find(y => y.id == tempChannelID) != null);
DiscordChannel potentialChannel = GetDiscordChannelByID(message["d"]["channel_id"].ToString());
if (potentialChannel == null) //private message create
{
if (message["d"]["author"]["id"].ToString() != Me.ID)
{
var foundPM = PrivateChannels.Find(x => x.ID == message["d"]["channel_id"].ToString());
DiscordPrivateMessageEventArgs dpmea = new DiscordPrivateMessageEventArgs();
dpmea.Channel = foundPM;
dpmea.Message = message["d"]["content"].ToString();
DiscordMember tempMember = new DiscordMember(this);
tempMember.Username = message["d"]["author"]["username"].ToString();
tempMember.ID = message["d"]["author"]["id"].ToString();
dpmea.Author = tempMember;
tempMember.parentclient = this;
dpmea.RawJson = message;
if (PrivateMessageReceived != null)
PrivateMessageReceived(this, dpmea);
}
else
{
//if (DebugMessageReceived != null)
// DebugMessageReceived(this, new DiscordDebugMessagesEventArgs { message = "Ignoring MESSAGE_CREATE for private channel for message sent from this client." });
}
}
else
{
DiscordMessageEventArgs dmea = new DiscordMessageEventArgs();
dmea.RawJson = message;
dmea.Channel = potentialChannel;
dmea.MessageText = message["d"]["content"].ToString();
DiscordMember tempMember = null;
tempMember = potentialChannel.Parent.GetMemberByKey(message["d"]["author"]["id"].ToString());
if (tempMember == null)
{
tempMember = JsonConvert.DeserializeObject<DiscordMember>(message["author"].ToString());
tempMember.parentclient = this;
tempMember.Parent = potentialChannel.Parent;
potentialChannel.Parent.AddMember(tempMember);
}
dmea.Author = tempMember;
DiscordMessage m = new DiscordMessage();
m.Author = dmea.Author;
m.channel = dmea.Channel;
m.TypeOfChannelObject = dmea.Channel.GetType();
m.Content = dmea.MessageText;
m.ID = message["d"]["id"].ToString();
m.RawJson = message;
m.timestamp = DateTime.Now;
dmea.Message = m;
if (!message["d"]["attachments"].IsNullOrEmpty())
{
List<DiscordAttachment> tempList = new List<DiscordAttachment>();
foreach (var attachment in message["d"]["attachments"])
{
tempList.Add(JsonConvert.DeserializeObject<DiscordAttachment>(attachment.ToString()));
}
m.Attachments = tempList.ToArray();
}
if (!message["d"]["mentions"].IsNullOrEmpty())
{
JArray mentionsAsArray = JArray.Parse(message["d"]["mentions"].ToString());
foreach (var mention in mentionsAsArray)
{
string id = mention["id"].ToString();
if (id.Equals(Me.ID))
{
if (MentionReceived != null)
MentionReceived(this, dmea);
}
}
}
KeyValuePair<string, DiscordMessage> toAdd = new KeyValuePair<string, DiscordMessage>(message["d"]["id"].ToString(), m);
MessageLog.Add(message["d"]["id"].ToString(), m);
if (MessageReceived != null)
MessageReceived(this, dmea);
}
//}
//catch (Exception ex)
//{
// DebugLogger.Log("Error ocurred during MessageCreateEvents: " + ex.Message, MessageLevel.Error);
//}
}
public async Task Kick(CommandContext ctx, DiscordMember user, bool noPenalty = false)
{
Lobby joinedLobby = Matchmaker.Lobbies.FirstOrDefault(e => e.Players.Any(f => f.DiscordId == user.Id));
if (joinedLobby != null)
{
joinedLobby.RemovePlayer(joinedLobby.Players.FirstOrDefault(e => e.DiscordId == user.Id));
await ctx.RespondAsync($"{user.Mention} has been kicked from lobby #{joinedLobby.LobbyNumber}.");
if (joinedLobby.Players.Count == 0)
{
joinedLobby.Close();
await ctx.RespondAsync($"Lobby #{joinedLobby.LobbyNumber} has been disbanded.");
}
}
else
{
Set joinedSet = Matchmaker.Sets.FirstOrDefault(e => e.AllPlayers.Any(f => f.DiscordId == user.Id));
decimal points = await MatchModule.ReportScores(joinedSet, true);
if (joinedSet == null)
{
return;
}
if (!noPenalty)
{
string penaltyDir = Directory.CreateDirectory(Path.Combine(Globals.AppPath, "Penalties")).FullName;
string penaltyFile = Path.Combine(penaltyDir, $"{user.Id}.penalty");
Record record;
if (File.Exists(penaltyFile))
{
record = JsonConvert.DeserializeObject <Record>(File.ReadAllText(penaltyFile));
}
else
{
record = new Record
{
AllInfractions = new List <Infraction>()
};
}
// await AirTableClient.PenalizePlayer(user.Id, (int) (10 + points / 2), "Was kicked from a set.");
record.AllInfractions.Add(new Infraction
{
Penalty = (int)(10 + points / 2),
Notes = "Was kicked from a set.",
TimeOfOffense = DateTime.Now
});
File.WriteAllText(penaltyFile, JsonConvert.SerializeObject(record, Formatting.Indented));
}
if (joinedSet.AlphaTeam.Players.Any(e => e.DiscordId == user.Id))
{
joinedSet.AlphaTeam.RemovePlayer(
joinedSet.AlphaTeam.Players.First(e => e.DiscordId == user.Id));
}
else if (joinedSet.BravoTeam.Players.Any(e => e.DiscordId == user.Id))
{
joinedSet.BravoTeam.RemovePlayer(
joinedSet.BravoTeam.Players.First(e => e.DiscordId == user.Id));
}
else if (joinedSet.DraftPlayers.Any(e => e.DiscordId == user.Id))
{
joinedSet.DraftPlayers.Remove(
joinedSet.DraftPlayers.First(e => e.DiscordId == user.Id));
}
List <DiscordMember> remainingUsers =
ctx.Guild.Members.Where(x => joinedSet.AllPlayers.Any(y => y.DiscordId == x.Id)).ToList();
await ctx.RespondAsync(
$"{user.Mention} was kicked from the set. " +
$"Beginning removal of access to this channel in 30 seconds. " +
$"Rate limiting may cause the full process to take up to two minutes.",
embed : joinedSet.GetScoreEmbedBuilder(points, 0).Build());
#region RemovedForBug
/*Lobby movedLobby = Matchmaker.Lobbies.First(e => !e.Players.Any());
*
* if (movedLobby == null)
* {
* // TODO Not sure what to do if all lobbies are filled.
* return;
* }
*
* foreach (SdlPlayer joinedSetPlayer in joinedSet.AllPlayers)
* {
* movedLobby.AddPlayer(joinedSetPlayer, true);
* }*/
#endregion
joinedSet.Close();
await Task.Delay(TimeSpan.FromSeconds(30));
List <DiscordRole> roleRemovalList = CommandHelper.DraftRoleIds.Select(e => ctx.Guild.GetRole(e)).ToList();
await user.RemoveRolesAsync(roleRemovalList.Where(x => user.Roles.Select(xr => xr.Id).Contains(x.Id)));
foreach (DiscordMember member in remainingUsers)
{
await member.RemoveRolesAsync(roleRemovalList.Where(x => member.Roles.Any(f => f.Id == x.Id)));
}
#region AlsoRemoved
/*await ((ITextChannel)ctx.Client.GetChannel(572536965833162753))
* .SendMessageAsync($"{8 - movedLobby.Players.Count} players needed to begin.",
* embed: movedLobby.GetEmbedBuilder().Build());*/
#endregion
}
}
/// <summary>
/// Assigns the specified roles to a member, given you have the permission.
/// </summary>
/// <param name="guild">The guild you and the user are in.</param>
/// <param name="roles">The roles you wish to assign them.</param>
/// <param name="member">The member you wish to assign the role to.</param>
public void AssignRoleToMember(DiscordServer guild, List<DiscordRole> roles, DiscordMember member)
{
string url = Endpoints.BaseAPI + Endpoints.Guilds + $"/{guild.ID}" + Endpoints.Members + $"/{member.ID}";
List<string> rolesAsIds = new List<string>();
roles.ForEach(x => rolesAsIds.Add(x.ID));
string message = JsonConvert.SerializeObject(new { roles = rolesAsIds.ToArray() });
try
{
WebWrapper.Patch(url, token, message);
}
catch (Exception ex)
{
DebugLogger.Log($"Exception ocurred while assigning {roles.Count} role(s) to member ({member.Username}): "
+ ex.Message, MessageLevel.Error);
}
}
public LuigibotDiscordMember(DiscordMember member)
{
RawMember = member;
}
/// <summary>
/// Bans a specified DiscordMember from the guild that's assumed from their
/// parent property.
/// </summary>
/// <param name="member"></param>
/// <param name="serverOverride"></param>
/// <param name="days"></param>
/// <returns></returns>
public DiscordMember BanMember(DiscordMember member, DiscordServer serverOverride, int days = 0)
{
string url = Endpoints.BaseAPI + Endpoints.Guilds + $"/{serverOverride.ID}" + Endpoints.Bans + $"/{member.ID}";
url += $"?delete-message-days={days}";
try
{
WebWrapper.Put(url, token);
return member;
}
catch (Exception ex)
{
DebugLogger.Log($"Error during BanMember\n\t{ex.Message}\n\t{ex.StackTrace}", MessageLevel.Error);
return null;
}
}
// This doesn't do anything by itself (DiscordMember.SendMessageAsync doesn't take a mentions argument)
// It's just here for consistency so we don't use the standard SendMessageAsync method >.>
public static Task <DiscordMessage> SendMessageFixedAsync(this DiscordMember member, string content = null,
DiscordEmbed embed = null) =>
member.SendMessageAsync(content, embed: embed);
private void GuildMemberRemoveEvents(JObject message)
{
DiscordGuildMemberRemovedEventArgs e = new DiscordGuildMemberRemovedEventArgs();
DiscordMember removed = new DiscordMember(this);
removed.parentclient = this;
List<DiscordMember> membersToRemove = new List<DiscordMember>();
foreach (var server in ServersList)
{
if (server.ID != message["d"]["guild_id"].ToString())
continue;
foreach (var member in server.Members)
{
if (member.Value.ID == message["d"]["user"]["id"].ToString())
{
removed = member.Value;
membersToRemove.Add(removed);
RemovedMembers.Add(removed);
}
}
}
foreach (var member in membersToRemove)
{
foreach (var server in ServersList)
{
try
{
server.RemoveMember(member.ID);
}
catch { } //oh, you mean useless?
}
}
e.MemberRemoved = removed;
e.Server = ServersList.Find(x => x.ID == message["d"]["guild_id"].ToString());
e.RawJson = message;
if (UserRemovedFromServer != null)
UserRemovedFromServer(this, e);
}
public async Task Info(CommandContext context, DiscordUser user = null)
{
if (user == null)
{
user = context.User;
}
var builder = new MaterialEmbedBuilder(context.Client);
builder.WithTitle($"{user.Username} / {await context.GetStringAsync("GeneralTerms_Information")}", user.AvatarUrl);
builder.AddSection(null, await context.GetStringAsync("User_Info_Identification"),
new MaterialEmbedListTile(
"pencil",
await context.GetStringAsync("User_Info_Username"),
user.Username
),
new MaterialEmbedListTile(
"pound",
await context.GetStringAsync("User_Info_Discriminator"),
user.Discriminator.ToString()
),
new MaterialEmbedListTile(
"id",
await context.GetStringAsync("User_Info_Id"),
user.Id.ToString()
)
);
builder.AddSection(null, await context.GetStringAsync("GeneralTerms_General"),
new MaterialEmbedListTile(
"calendar-plus",
await context.GetStringAsync("User_Info_UserSince_Title"),
string.Format(await context.GetStringAsync("User_Info_UserSince_Value"), user.CreationTimestamp.ToString())
),
new MaterialEmbedListTile(
user.IsBot,
await context.GetStringAsync("User_Info_IsBot")
),
user.Verified.HasValue ? new MaterialEmbedListTile(
user.Verified.Value,
await context.GetStringAsync("User_Info_IsVerified")
) : null
);
bool isMember = context.Guild.Members.Any(m => m.Value.Id == user.Id);
if (isMember)
{
DiscordMember member = await context.Guild.GetMemberAsync(user.Id);
builder.AddSection(null, await context.GetStringAsync("User_Info_MemberInformation"), !string.IsNullOrWhiteSpace(member.Nickname) ?
new MaterialEmbedListTile(
"pencil",
await context.GetStringAsync("User_Info_Nickname"),
member.Nickname
) : null,
new MaterialEmbedListTile(
"calendar-plus",
await context.GetStringAsync("User_Info_MemberSince_Title"),
string.Format(await context.GetStringAsync("User_Info_MemberSince_Value"), member.JoinedAt.ToString())
),
new MaterialEmbedListTile(
member.IsOwner,
await context.GetStringAsync("User_Info_IsOwner")
)
);
}
builder.AddSection(null, await context.GetStringAsync("GeneralTerms_BotRelated"),
new MaterialEmbedListTile(
await user.IsQuotingEnabledAsync(),
await context.GetStringAsync("User_Info_Quoting")
),
new MaterialEmbedListTile(
await user.GetDelayDeletingAsync(),
await context.GetStringAsync("User_Info_DelayDelete")
)
);
if (user.IsCurrent)
{
builder.WithFooter(await context.GetStringAsync("User_Info_ThatsMe"));
}
await context.RespondAsync(embed : builder.Build());
}
/// <summary>
/// Sends a private message to the given user.
/// </summary>
/// <param name="message">The message text to send them.</param>
/// <param name="member">The member you want to send this to.</param>
/// <returns></returns>
public DiscordMessage SendMessageToUser(string message, DiscordMember member)
{
string url = Endpoints.BaseAPI + Endpoints.Users + $"/{Me.ID}" + Endpoints.Channels;
string initMessage = "{\"recipient_id\":" + member.ID + "}";
try
{
var result = JObject.Parse(WebWrapper.Post(url, token, initMessage));
if (result != null)
{
DiscordMember recipient = ServersList.Find(
x => x.GetMemberByKey(result["recipient"]["id"].ToString()) != null).Members[result["recipient"]["id"].ToString()];
return SendActualMessage(result["id"].ToString(), message, recipient);
}
}
catch (Exception ex)
{
DebugLogger.Log($"Error ocurred while sending message to user, step 1: {ex.Message}", MessageLevel.Error);
}
return null;
}
public Task MemberAsync(CommandContext ctx, DiscordMember mbr = null) => ctx.RespondAsync(embed: new DiscordEmbedBuilder().WithDescription(mbr?.Mention ?? "<null>"));
public static void Main(string[] args)
{
Console.CancelKeyPress += (sender, e) =>
{
quitEvent.Set();
e.Cancel = true;
};
Console.WriteLine("\t\t\tDiscordSharp Tester");
client.ClientPrivateInformation = new DiscordUserInformation();
#if DEBUG
client.WriteLatestReady = true;
#endif
if (File.Exists("credentials.txt"))
{
using (StreamReader sr = new StreamReader("credentials.txt"))
{
client.ClientPrivateInformation.email = sr.ReadLine();
client.ClientPrivateInformation.password = sr.ReadLine();
}
}
else
{
Console.Write("Please enter your email: ");
string email = Console.ReadLine();
client.ClientPrivateInformation.email = email;
Console.Write("Now, your password (visible): ");
string pass = Console.ReadLine();
client.ClientPrivateInformation.password = pass;
}
Console.WriteLine("Attempting login..");
var worker = new Thread(() =>
{
client.VoiceClientConnected += (sender, e) =>
{
owner.SlideIntoDMs("Voice client connection complete.");
};
client.TextClientDebugMessageReceived += (sender, e) =>
{
if (e.message.Level == MessageLevel.Error || e.message.Level == MessageLevel.Error || e.message.Level == MessageLevel.Warning)
{
WriteDebug(e.message, "Text Client");
if (client.GetServersList() != null)
{
DiscordMember onwer = client.GetServersList().Find(x => x.members.Find(y => y.Username == "Axiom") != null).members.Find(x => x.Username == "Axiom");
if (onwer != null)
if (!e.message.Message.Contains("Setting current game"))
onwer.SendMessage($"**LOGGING**\n```\n[Text Client: {e.message.Level}]: {e.message.Message}\n```");
}
}
};
client.VoiceClientDebugMessageReceived += (sender, e) =>
{
WriteDebug(e.message, "Voice Debug");
};
client.RoleDeleted += (sender, e) =>
{
Console.WriteLine($"Role '{e.DeletedRole.name}' deleted.");
};
client.UnknownMessageTypeReceived += (sender, e) =>
{
using (var sw = new StreamWriter(e.RawJson["t"].ToString() + ".txt"))
{
sw.WriteLine(e.RawJson);
}
client.SendMessageToUser("Heya, a new message type, '" + e.RawJson["t"].ToString() + "', has popped up!", client.GetServersList().Find(x => x.members.Find(y => y.Username == "Axiom") != null).members.Find(x => x.Username == "Axiom"));
};
client.AudioPacketReceived += (sender, e) =>
{
//client.EchoPacket(e.Packet);
};
client.VoiceStateUpdate += (sender, e) =>
{
Console.WriteLine("***Voice State Update*** User: "******"Server Created: " + e.server.name);
};
client.MessageEdited += (sender, e) =>
{
Console.WriteLine(e.message);
//if (e.author.user.username == "Axiom")
// client.SendMessageToChannel("What the f**k, <@" + e.author.user.id + "> you can't event type your message right. (\"" + e.MessageEdited.content + "\")", e.Channel);
};
client.ChannelCreated += (sender, e) =>
{
var parentServer = client.GetServersList().Find(x => x.channels.Find(y => y.ID == e.ChannelCreated.ID) != null);
if (parentServer != null)
Console.WriteLine("Channel {0} created in {1}!", e.ChannelCreated.Name, parentServer.name);
};
client.PrivateChannelDeleted += (sender, e) =>
{
Console.WriteLine("Private channel deleted with " + e.PrivateChannelDeleted.recipient.Username);
};
client.PrivateChannelCreated += (sender, e) =>
{
Console.WriteLine("Private channel started with {0}", e.ChannelCreated.recipient.Username);
};
client.PrivateMessageReceived += (sender, e) =>
{
client.SendMessageToUser("Pong!", e.author);
};
client.MentionReceived += (sender, e) =>
{
string rawMessage = e.message.content;
string whatToSend = $"I received a mention from @{e.author.Username} in #{e.Channel.Name} in {e.Channel.parent.name}. It said: \n```\n{rawMessage}\n```";
if (rawMessage.Contains($"{client.Me.ID}"))
whatToSend += $"Where `<@{client.Me.ID}>` is my user being mentioned.";
DiscordMember owner = client.GetServersList().Find(x => x.members.Find(y => y.Username == "Axiom") != null).members.Find(x => x.Username == "Axiom");
client.SendMessageToUser(whatToSend, owner);
};
client.MessageReceived += (sender, e) =>
{
DiscordServer fromServer = client.GetServersList().Find(x => x.channels.Find(y => y.ID == e.Channel.ID) != null);
Console.WriteLine("[- Message from {0} in {1} on {2}: {3}", e.author.Username, e.Channel.Name, fromServer.name, e.message.content);
if (e.message.content.StartsWith("?typemonkey"))
{
client.SimulateTyping(e.Channel);
}
else if(e.message.content.StartsWith("?unban"))
{
string[] split = e.message.content.Split(new char[] { ' ' }, 2);
if(split.Length > 1)
{
DiscordMember meInServer = e.Channel.parent.members.Find(x => x.ID == client.Me.ID);
bool hasPermission = false;
foreach(var role in meInServer.Roles)
{
if (role.permissions.HasPermission(DiscordSpecialPermissions.BanMembers) || role.permissions.HasPermission(DiscordSpecialPermissions.ManageServer))
{
hasPermission = true;
break;
}
}
if(hasPermission)
client.RemoveBan(e.Channel.parent, split[1]);
else
e.Channel.SendMessage("No permission to do so!");
}
}
else if(e.message.content.StartsWith("?getbans"))
{
var banList = client.GetBans(e.Channel.parent);
if (banList == null)
{
e.Channel.SendMessage("No permission!");
return;
}
if(banList.Count > 0)
{
string msg = $"**{banList.Count}** bans in this server.";
msg += "\n```";
for(int i = 0; i < banList.Count; i++)
{
if (i > 5)
break;
msg += $"\n* {banList[i].Username} ({banList[i].ID})";
}
msg += "\n```";
e.Channel.SendMessage(msg);
}
else
{
e.Channel.SendMessage("No bans in this server!");
}
}
else if(e.message.content.StartsWith("?ban"))
{
string[] split = e.message.content.Split(new char[] { ' ' }, 2);
if(split.Length > 1)
{
//<@09380598340598>
string id = split[1].Trim(new char[] { '<', '@', '>' });
DiscordMember toBan = e.Channel.parent.members.Find(x => x.ID == id);
if (toBan != null)
{
if (client.BanMember(toBan) != null)
e.Channel.SendMessage($"**{toBan.Username}** will be missed.");
else
e.Channel.SendMessage("No permission!");
}
else
e.Channel.SendMessage("Ban who?");
}
else
e.Channel.SendMessage("Ban who?");
}
else if(e.message.content.StartsWith("?stop"))
{
if(client.ConnectedToVoice())
{
client.GetVoiceClient().ClearVoiceQueue();
}
}
else if (e.message.content.StartsWith("?editlast"))
{
string[] split = e.message.content.Split(new char[] { ' ' }, 2);
if (split.Length > 1)
{
DiscordMessage toEdit = client.GetLastMessageSent(e.Channel);
if (toEdit != null)
{
client.EditMessage(toEdit.id, split[1], e.Channel);
}
}
}
else if (e.message.content.StartsWith("?testjoinvoice"))
{
if (e.author.Username != "Axiom")
return;
string[] split = e.message.content.Split(new char[] { ' ' }, 2);
if (split.Length > 1)
{
DiscordChannel voiceToJoin = e.Channel.parent.channels.Find(x => x.Name.ToLower() == split[1].ToLower() && x.Type == ChannelType.Voice);
if (voiceToJoin != null)
client.ConnectToVoiceChannel(voiceToJoin);
}
}
else if (e.message.content.StartsWith("?disconnect"))
{
client.DisconnectFromVoice();
}
else if (e.message.content.StartsWith("?newguild"))
{
string[] split = e.message.content.Split(new char[] { ' ' }, 2);
if (split.Length > 1)
{
DiscordServer created = client.CreateGuild(split[1]);
DiscordChannel channel = created.channels.Find(x => x.Type == ChannelType.Text);
client.ChangeChannelTopic("Created with DiscordSharp test bot", channel);
client.SendMessageToChannel($"Join: {client.MakeInviteURLFromCode(client.CreateInvite(channel))}", e.Channel);
}
}
else if (e.message.content.StartsWith("?notify"))
{
string[] split = e.message.content.Split(new char[] { ' ' }, 2);
}
else if(e.message.content.StartsWith("?channeltype"))
{
e.Channel.SendMessage(e.Channel.Type.ToString());
}
else if (e.message.content.StartsWith("?whereami"))
{
DiscordServer server = client.GetServersList().Find(x => x.channels.Find(y => y.ID == e.Channel.ID) != null);
string owner = "";
foreach (var member in server.members)
if (member.ID == server.owner.ID)
owner = member.Username;
string whereami = String.Format("I am currently in *#{0}* ({1}) on server *{2}* ({3}) owned by @{4}. The channel's topic is: {5}", e.Channel.Name, e.Channel.ID, server.name, server.id, owner, e.Channel.Topic);
client.SendMessageToChannel(whereami, e.Channel);
}
else if (e.message.content.StartsWith("?makeroll"))
{
DiscordMember me = e.Channel.parent.members.Find(x => x.ID == client.Me.ID);
DiscordServer inServer = e.Channel.parent;
foreach (var role in me.Roles)
{
if (role.permissions.HasPermission(DiscordSpecialPermissions.ManageRoles))
{
DiscordRole madeRole = client.CreateRole(inServer);
DiscordRole newRole = madeRole.Copy();
newRole.name = "DiscordSharp Test Roll";
newRole.color = new DiscordSharp.Color("0xFF0000");
newRole.permissions.SetPermission(DiscordSpecialPermissions.ManageRoles);
client.EditRole(inServer, newRole);
client.SendMessageToChannel("Created test roll successfully?", e.Channel);
return;
}
}
client.SendMessageToChannel("Can't create role: no permission.", e.Channel);
}
else if (e.message.content.StartsWith("?getroles"))
{
string[] split = e.message.content.Split(new char[] { ' ' }, 2);
//?getroles <@10394803598>
if (split.Length > 1)
{
Regex r = new Regex(@"(?<=<)([^>]+)(?=>)");
string userToGetRoles = r.Match(split[1]).Value;
userToGetRoles = userToGetRoles.Trim('@'); //lol
DiscordMember foundMember = e.Channel.parent.members.Find(x => x.ID == userToGetRoles);
if (foundMember != null)
{
string whatToSend = "Found roles for user **" + foundMember.Username + "**:\n```";
for (int i = 0; i < foundMember.Roles.Count; i++)
{
if (i > 0)
whatToSend += "\n";
whatToSend += $"* {foundMember.Roles[i].name}: id={foundMember.Roles[i].id} color=0x{foundMember.Roles[i].color.ToString()}, (R: {foundMember.Roles[i].color.R} G: {foundMember.Roles[i].color.G} B: {foundMember.Roles[i].color.B}) permissions={foundMember.Roles[i].permissions.GetRawPermissions()}";
string tempPermissions = "";
foreach (var permissions in foundMember.Roles[i].permissions.GetAllPermissions())
{
tempPermissions += " " + permissions.ToString();
}
whatToSend += "\n\n Friendly Permissions: " + tempPermissions;
}
whatToSend += "\n```";
client.SendMessageToChannel(whatToSend, e.Channel);
}
else
{
client.SendMessageToChannel("User with id `" + userToGetRoles + "` not found.", e.Channel);
}
}
}
else if (e.message.content.StartsWith("?test_game"))
{
string[] split = e.message.content.Split(new char[] { ' ' }, 2);
if (split.Length > 0)
{
client.UpdateCurrentGame(split[1]);
}
}
else if (e.message.content.StartsWith("?gtfo"))
{
string[] split = e.message.content.Split(new char[] { ' ' }, 2);
if (split.Length > 1)
{
DiscordServer curServer = client.GetServersList().Find(x => x.channels.Find(y => y.ID == split[1]) != null);
if (curServer != null)
{
client.SendMessageToChannel("Leaving server " + curServer.name, e.Channel);
client.LeaveServer(curServer.id);
}
}
else
{
DiscordServer curServer = client.GetServersList().Find(x => x.channels.Find(y => y.ID == e.Channel.ID) != null);
if (curServer != null)
{
//client.SendMessageToChannel("Bye!", e.Channel);
client.LeaveServer(e.Channel.parent.id);
}
}
}
else if (e.message.content.StartsWith("?everyone"))
{
//DiscordServer server = client.GetServersList().Find(x => x.channels.Find(y => y.id == e.Channel.id) != null);
//string[] split = e.message.content.Split(new char[] { ' ' }, 2);
//if (split.Length > 1)
//{
// string message = "";
// foreach (var user in server.members)
// {
// if (user.ID == client.Me.ID)
// continue;
// if (user.user.username == "Blank")
// continue;
// message += "@" + user.user.username + " ";
// }
// message += ": " + split[1];
// client.SendMessageToChannel(message, e.Channel);
//}
}
else if (e.message.content.StartsWith("?lastfm"))
{
#if __MONOCS__
client.SendMessageToChannel("Sorry, not on Mono :(", e.Channel);
#else
string[] split = e.message.content.Split(new char[] { ' ' }, 2);
if (split.Length > 1)
{
using (var lllfclient = new LastfmClient(lastfmAuthentication))
{
try
{
var recentScrobbles = lllfclient.User.GetRecentScrobbles(split[1], null, 1, 1);
LastTrack lastTrack = recentScrobbles.Result.Content[0];
client.SendMessageToChannel(string.Format("*{0}* last listened to _{1}_ by _{2}_", split[1], lastTrack.Name, lastTrack.ArtistName), e.Channel);
}
catch
{
client.SendMessageToChannel(string.Format("User _*{0}*_ not found!", split[1]), e.Channel);
}
}
}
else
client.SendMessageToChannel("Who??", e.Channel);
#endif
}
else if (e.message.content.StartsWith("?assignrole"))
{
DiscordServer server = e.Channel.parent;
DiscordMember me = server.members.Find(x => x.ID == client.Me.ID);
bool hasPermission = false;
me.Roles.ForEach(r =>
{
if (r.permissions.HasPermission(DiscordSpecialPermissions.ManageRoles))
hasPermission = true;
});
if (hasPermission)
{
string[] split = e.message.content.Split(new char[] { ' ' }, 2);
if (split.Length > 0)
{
DiscordRole toAssign = server.roles.Find(x => x.name.ToLower().Trim() == split[1].ToLower().Trim());
if (toAssign != null)
{
client.AssignRoleToMember(server, toAssign, server.members.Find(x => x.Username == "Axiom"));
}
else
{
client.SendMessageToChannel($"Role '{split[1]}' not found!", e.Channel);
}
}
}
else
{
client.SendMessageToChannel("Cannot assign role: no permission.", e.Channel);
}
}
else if (e.message.content.StartsWith("?rename"))
{
string[] split = e.message.content.Split(new char[] { ' ' }, 2);
if (split.Length > 0)
{
//client.ChangeBotUsername(split[1]);
DiscordUserInformation newUserInfo = client.ClientPrivateInformation;
newUserInfo.username = split[1].ToString();
client.ChangeClientInformation(newUserInfo);
}
}
else if (e.message.content.StartsWith("?changepic"))
{
string[] split = e.message.content.Split(new char[] { ' ' }, 2);
if (split.Length > 0)
{
Regex linkParser = new Regex(@"\b(?:https?://|www\.)\S+\b", RegexOptions.Compiled | RegexOptions.IgnoreCase);
string rawString = $"{split[1]}";
if (linkParser.Matches(rawString).Count > 0)
{
string url = linkParser.Matches(rawString)[0].ToString();
using (WebClient wc = new WebClient())
{
byte[] data = wc.DownloadData(url);
using (MemoryStream mem = new MemoryStream(data))
{
using (var image = System.Drawing.Image.FromStream(mem))
{
client.ChangeClientAvatar(new Bitmap(image));
}
}
}
}
}
}
else if (e.message.content.StartsWith("?changeguildpic"))
{
DiscordServer current = e.Channel.parent;
DiscordMember me = current.members.Find(x => x.ID == client.Me.ID);
foreach (var role in me.Roles)
{
if (role.permissions.HasPermission(DiscordSpecialPermissions.ManageServer))
{
string[] split = e.message.content.Split(new char[] { ' ' }, 2);
if (split.Length > 0)
{
Regex linkParser = new Regex(@"\b(?:https?://|www\.)\S+\b", RegexOptions.Compiled | RegexOptions.IgnoreCase);
string rawString = $"{split[1]}";
if (linkParser.Matches(rawString).Count > 0)
{
string url = linkParser.Matches(rawString)[0].ToString();
using (WebClient wc = new WebClient())
{
byte[] data = wc.DownloadData(url);
using (MemoryStream mem = new MemoryStream(data))
{
using (var image = System.Drawing.Image.FromStream(mem))
{
client.ChangeGuildIcon(new Bitmap(image), current);
}
}
}
}
}
return;
}
}
client.SendMessageToChannel("Unable to change pic: No permission.", e.Channel);
}
else if(e.message.content.StartsWith("?servericon"))
{
if(e.Channel.parent.IconURL != null)
{
e.Channel.SendMessage(e.Channel.parent.IconURL);
}
}
else if(e.message.content.StartsWith("?whois"))
{
string[] split = e.message.content.Split(new char[] { ' ' }, 2);
if(split.Length > 1)
{
string justID = split[1].Trim(new char []{ '<', '>', '@' });
DiscordMember memberToCheck = e.Channel.parent.members.Find(x => x.ID == justID.Trim());
if(memberToCheck != null)
{
string msg = $"User info for {memberToCheck.Username}\n```\nID: {memberToCheck.ID}\nStatus: {memberToCheck.Status}\n";
if (memberToCheck.CurrentGame != null)
msg += $"\nCurrent Game: {memberToCheck.CurrentGame}";
msg += "\n```";
e.Channel.SendMessage(msg);
}
else
{
e.Channel.SendMessage("Couldn't find user with ID `" + justID + "`!");
}
}
}
else if (e.message.content.StartsWith("?deletelast"))
{
//client.DeleteMessage(client.GetLastMessageSent(e.Channel).id);
}
else if (e.message.content.StartsWith("?testdmdelete"))
{
var msg = client.SendMessageToUser("lmao you suck", client.GetServersList()[0].members.Find(x => x.Username == "Axiom"));
client.DeleteMessage(msg);
}
else if (e.message.content.StartsWith("?prune"))
{
string[] split = e.message.content.Split(new char[] { ' ' }, 2);
if (split.Length > 0)
{
client.DeleteMultipleMessagesInChannel(e.Channel, int.Parse(split[1]));
}
else
{
client.SendMessageToChannel("Prune what?", e.Channel);
}
}
else if (e.message.content.StartsWith("?quoththeraven"))
client.SendMessageToChannel("nevermore", e.Channel);
else if (e.message.content.StartsWith("?quote"))
client.SendMessageToChannel("Luigibot does what Reta don't.", e.Channel);
else if (e.message.content.StartsWith("?selfdestruct"))
{
if (e.author.Username == "Axiom")
client.SendMessageToChannel("restaroni in pepparoni", e.Channel);
Environment.Exit(0);
}
else if (e.message.content.Contains("?checkchannelperm"))
{
DiscordChannel channel = e.Channel;
string toSend = $"Channel Permission Overrides for #{channel.Name}\n\n```";
foreach (var over in channel.PermissionOverrides)
{
toSend += $"* Type: {over.type}\n";
if (over.type == DiscordPermissionOverride.OverrideType.member)
toSend += $" Member: {over.id} ({channel.parent.members.Find(x => x.ID == over.id).Username})\n";
else
toSend += $" Role: {over.id} ({channel.parent.roles.Find(x => x.id == over.id).name})\n";
toSend += $" Allowed: {over.GetAllowedRawPermissions()}\n";
toSend += $" Friendly:";
foreach (var allowed in over.GetAllAllowedPermissions())
{
toSend += " " + allowed.ToString();
}
toSend += $"\n Denied: {over.GetDeniedRawPermissions()}\n";
toSend += $" Friendly:";
foreach (var denied in over.GetAllDeniedPermissions())
{
toSend += " " + denied.ToString();
}
toSend += "\n\n";
}
toSend += "```";
client.SendMessageToChannel(toSend, channel);
}
else if (e.message.content.StartsWith("?createchannel"))
{
if (e.author.Username == "Axiom")
{
string[] split = e.message.content.Split(new char[] { ' ' }, 2);
if (split.Length > 0)
{
client.CreateChannel(client.GetServerChannelIsIn(e.Channel), split[1], false);
}
}
}
else if (e.message.content.StartsWith("?deletechannel"))
{
if (e.author.Username == "Axiom")
{
client.DeleteChannel(e.Channel);
}
}
else if (e.message.content.StartsWith("?changetopic"))
{
if (e.author.Username == "Axiom")
{
string[] split = e.message.content.Split(new char[] { ' ' }, 2);
if (split.Length > 0)
client.ChangeChannelTopic(split[1], e.Channel);
}
}
else if (e.message.content.StartsWith("?join"))
{
if (e.author.Username == "Axiom")
{
string[] split = e.message.content.Split(new char[] { ' ' }, 2);
if (split.Length > 0)
{
string substring = split[1].Substring(split[1].LastIndexOf('/') + 1);
//client.SendMessageToChannel(substring, e.Channel);
client.AcceptInvite(substring);
}
}
}
else if(e.message.content.StartsWith("?testvoice"))
{
if (!client.ConnectedToVoice())
return;
string[] split = e.message.content.Split(new char[] { ' ' }, 2);
if(split.Length > 1)
{
if(File.Exists(split[1]))
{
VoiceStuffs(client.GetVoiceClient(), split[1]);
}
}
}
else if (e.message.content.StartsWith("?statusof"))
{
string[] split = e.message.content.Split(new char[] { ' ' }, 2);
if(split.Length > 1)
{
string id = split[1].Trim(new char[] { '<', '@', '>' });
DiscordMember member = e.Channel.parent.members.Find(x => x.ID == id);
if(member != null)
{
string msg = $"Status of **{member.Username}**";
msg += $"\n```\nStatus: " + member.Status.ToString();
if (member.CurrentGame != null)
msg += "\nPlaying: " + member.CurrentGame;
msg += "\n```";
e.Channel.SendMessage(msg);
}
}
}
else if (e.message.content.StartsWith("?playing"))
{
DiscordMember member = e.Channel.parent.members.Find(x => x.Username == "Axiom");
using (var lllfclient = new LastfmClient(lastfmAuthentication))
{
try
{
client.SimulateTyping(e.Channel);
var recentScrobbles = lllfclient.User.GetRecentScrobbles("mrmiketheripper", null, 1, 1);
LastTrack lastTrack = recentScrobbles.Result.Content[0];
if (lastTrack.TimePlayed != null) //means the track is still playing
{
var localTime = lastTrack.TimePlayed.Value.DateTime.ToLocalTime();
if (DateTime.Now.Subtract(localTime) > (lastTrack.Duration == null ? new TimeSpan(0, 10, 0) : lastTrack.Duration))
e.Channel.SendMessage($"<@{member.ID}> last played: **{lastTrack.Name}** by *{lastTrack.ArtistName}*. It was scrobbled at: {localTime} EST (-5).");
else
e.Channel.SendMessage($"<@{member.ID}> is now playing: **{lastTrack.Name}** by *{lastTrack.ArtistName}*.");
}
else
e.Channel.SendMessage($"<@{member.ID}> is now playing: **{lastTrack.Name}** by *{lastTrack.ArtistName}*.");
if (e.message.content.Contains("art"))
{
client.SimulateTyping(e.Channel);
using (WebClient wc = new WebClient())
{
Image downloaded = Image.FromStream(new MemoryStream(wc.DownloadData(lastTrack.Images.Medium.AbsoluteUri)));
if (downloaded != null)
{
downloaded.Save("temp.png");
client.AttachFile(e.Channel, "", "temp.png");
File.Delete("temp.png");
}
}
}
}
catch (Exception ex)
{
string whatToSend = $"Couldn't get Last.fm recent scrobbles for you! Exception:\n```{ex.Message}\n{ex.StackTrace}\n```\n";
client.SendMessageToUser(whatToSend, client.GetServersList().Find(x => x.members.Find(y => y.Username == "Axiom") != null).members.Find(x => x.Username == "Axiom"));
}
}
}
};
client.Connected += (sender, e) =>
{
Console.WriteLine("Connected! User: "******"credentials.txt"))
{
sw.WriteLine(client.ClientPrivateInformation.email);
sw.WriteLine(client.ClientPrivateInformation.password);
sw.Flush();
}
using (var lllfclient = new LastfmClient(lastfmAuthentication))
{
try
{
var recentScrobbles = lllfclient.User.GetRecentScrobbles("mrmiketheripper", null, 1, 1);
LastTrack lastTrack = recentScrobbles.Result.Content[0];
string newGame = $"{lastTrack.Name} by {lastTrack.ArtistName}";
if (newGame != client.GetCurrentGame)
client.UpdateCurrentGame(newGame);
}
catch (Exception ex)
{
string whatToSend = $"Couldn't get Last.fm recent scrobbles for you! Exception:\n```{ex.Message}\n{ex.StackTrace}\n```\n";
client.SendMessageToUser(whatToSend, client.GetServersList().Find(x => x.members.Find(y => y.Username == "Axiom") != null).members.Find(x => x.Username == "Axiom"));
}
}
owner = client.GetServersList().Find(x => x.members.Find(y => y.Username == "Axiom") != null).members.Find(x => x.Username == "Axiom");
};
client.SocketClosed += (sender, e) =>
{
Console.WriteLine("Closed ({0}): {1}", e.Code, e.Reason);
};
//ConnectStuff();
//while (true) ;
if (client.SendLoginRequest() != null)
{
Console.WriteLine("Logged in!");
client.Connect();
Console.WriteLine($"Connected to {client.CurrentGatewayURL}");
client.UpdateCurrentGame("development testing");
}
});
worker.Start();
System.Timers.Timer lastfmUpdateTimer = new System.Timers.Timer(25 * 1000); //check last.fm every 25 seconds
lastfmUpdateTimer.Elapsed += (sender, e) =>
{
using (var lllfclient = new LastfmClient(lastfmAuthentication))
{
try
{
var recentScrobbles = lllfclient.User.GetRecentScrobbles("mrmiketheripper", null, 1, 1);
LastTrack lastTrack = recentScrobbles.Result.Content[0];
if (lastTrack.TimePlayed != null)
{
var localTime = lastTrack.TimePlayed.Value.DateTime.ToLocalTime();
if (DateTime.Now.Subtract(localTime) > new TimeSpan(0, 15, 0))
{
if (client.GetCurrentGame != "")
if (client.GetCurrentGame == null)
client.UpdateCurrentGame("");
}
}
else
{
string newGame = $"{lastTrack.Name} by {lastTrack.ArtistName}";
if (newGame != client.GetCurrentGame)
client.UpdateCurrentGame(newGame);
}
}
catch (Exception ex)
{
string whatToSend = $"Couldn't get Last.fm recent scrobbles for you! Exception:\n```{ex.Message}\n{ex.StackTrace}\n```\n";
client.SendMessageToUser(whatToSend, client.GetServersList().Find(x => x.members.Find(y => y.Username == "Axiom") != null).members.Find(x => x.Username == "Axiom"));
}
}
};
lastfmUpdateTimer.Start();
InputCheck();
//System.Windows.Forms.Application.Run();
/**
Since this is a test app and people actually do read my code...
I'd like to say one thing:
If you're not going to be doing any input accepting **INSIDE OF THE CONSOLE** you don't have to setup
a seperate thread for the client and accept input on main. This is why I've only commented out
the System.Windows.Forms.Application.Run(); part instead of removing it.
If you're not accepting input, you can just run client on the main thread and run that
System.Windows.Forms.Application.Run(); snippet and this will keep the app alive, with no CPU
hit!
*/
if (client.GetTextClientLogger.LogCount > 0)
{
client.GetTextClientLogger.Save($"log-{DateTime.Now.Month}-{DateTime.Now.Day}-{DateTime.Now.Year} {DateTime.Now.Hour} {DateTime.Now.Minute}.log");
Console.WriteLine("Wrote log.");
}
if (client.GetLastVoiceClientLogger != null && client.GetLastVoiceClientLogger.LogCount > 0)
{
client.GetLastVoiceClientLogger.Save($"voicelog-{DateTime.Now.Month}-{DateTime.Now.Day}-{DateTime.Now.Year} {DateTime.Now.Hour} {DateTime.Now.Minute}.log");
Console.WriteLine("Wrote voice log");
}
quitEvent.WaitOne();
client.Dispose();
}
#pragma warning restore 4014 //stupid await warnings
#region Websocket Opcode Events/other misc events
internal void MemberRemoved(DiscordMember removed)
{
if (MembersInChannel.Contains(removed))
{
MembersInChannel.Remove(removed);
VoiceDebugLogger.Log($"User {removed.Username} ({removed.ID}) left the client's current connected voice channel.");
}
}
