public async Task SendMessage(string message)
{
RestGuild guild = (RestGuild)await _client.GetGuildAsync(225374061386006528);
RestTextChannel channel = await guild.GetTextChannelAsync(718854497245462588);
await channel.SendMessageAsync(message);
}
public async Task GetGuildUsersAsync()
{
string response = "";
// Implementation via Guild.Users
// foreach (var x in Context.Guild.Users) { response += (x.Username + " "); };
//Implementation via REST Client directly
//RestGuild guildRest = await _clientRest.GetGuildAsync(Context.Guild.Id);
//await guildRest.GetUsersAsync().ForEachAsync(x =>
//{
// foreach (IGuildUser y in x) { Console.Write("{name} ", y.Username); };
//});
// Implementation via Websocket method that uses REST API
await Context.Guild.GetUsersAsync().ForEachAsync(x =>
{
foreach (IGuildUser y in x)
{
response += y.Username + " ";
}
;
});
// Sending response via REST for test purposes
RestGuild guildRest = await _clientRest.GetGuildAsync(Context.Guild.Id);
RestTextChannel channelRest = await guildRest.GetTextChannelAsync(Context.Channel.Id);
await channelRest.SendMessageAsync(response);
// Sending response via WebSocket
// await ReplyAsync(response);
}
public async Task AssignSingleRole(string id, string roletoadd, string classid)
{
var userid = Convert.ToUInt64(id);
var guild = await discordrest.GetGuildAsync(718945666348351570);
var trimmed = roletoadd.Trim();
if (guild.Roles.Any(tr => tr.Value.Name.Equals(trimmed)))
{
var roleid = guild.Roles.FirstOrDefault(x => x.Value.Name.ToString() == trimmed).Key;
await discordrest.AddGuildMemberRoleAsync(718945666348351570, userid, roleid, "");
var sql = $"UPDATE classes SET d_role_snowflake='{roleid}' WHERE g_class_id='{classid}'";
var cmd = new MySqlCommand(sql, conn);
cmd.ExecuteNonQuery();
}
else
{
var role = await guild.CreateRoleAsync(trimmed, Permissions.SendMessages);
var channel = await guild.CreateChannelAsync(trimmed, ChannelType.Text);
await channel.AddOverwriteAsync(role, Permissions.AccessChannels);
await channel.AddOverwriteAsync(guild.EveryoneRole, Permissions.None, Permissions.AccessChannels);
await discordrest.AddGuildMemberRoleAsync(718945666348351570, userid, role.Id, "");
var sql = $"UPDATE classes SET d_role_snowflake='{role.Id}',d_text_channel_snowflake='{channel.Id}' WHERE g_class_id='{classid}'";
var cmd = new MySqlCommand(sql, conn);
cmd.ExecuteNonQuery();
}
}
public static Task <DiscordMember> GetMember(this DiscordRestClient client, ulong guild, ulong user)
{
async Task <DiscordMember> Inner() =>
await(await client.GetGuildAsync(guild)).GetMemberAsync(user);
return(WrapDiscordCall(Inner()));
}
private async Task <(RestRole role, RestChannel channel)> CreateCourseChannelAsync(DiscordRestClient client, string courseName, string auditLogMessage)
{
var requestOptions = new RequestOptions()
{
AuditLogReason = auditLogMessage,
};
var guild = await client.GetGuildAsync(GuildId);
var channelCategory = await GetChannelCategory(client);
courseName = NormalizeCourseChannelName(courseName);
var roleName = $"member_{channelCategory.Name}_{courseName}".ToLower();
var role = await CreateRoleAsync(guild, roleName, requestOptions);
if (role == null)
{
// duplicate
throw new Exception("Cannot create a duplicate role.");
}
var channel = await CreateTextChannelAsync(guild, courseName, requestOptions, role.Id);
if (channel == null)
{
throw new Exception("Cannot create a duplicate channel.");
}
await channel.SendMessageAsync(auditLogMessage);
return(role, channel);
}
/// <summary>
/// Creates a ban infraction for the user if they do not already have one.
/// </summary>
/// <param name="guild">The guild that the user was banned from.</param>
/// <param name="user">The user who was banned.</param>
/// <returns>
/// A <see cref="Task"/> that will complete when the operation completes.
/// </returns>
private async Task TryCreateBanInfractionAsync(ISocketUser user, ISocketGuild guild)
{
if (await _moderationService.AnyInfractionsAsync(GetBanSearchCriteria(guild, user)))
{
return;
}
var restGuild = await _restClient.GetGuildAsync(guild.Id);
var auditLogs = (await restGuild.GetAuditLogsAsync(10)
.FlattenAsync())
.Where(x => x.Action == ActionType.Ban && x.Data is BanAuditLogData)
.Select(x => (Entry: x, Data: (BanAuditLogData)x.Data));
var banLog = auditLogs.FirstOrDefault(x => x.Data.Target.Id == user.Id);
var reason = string.IsNullOrWhiteSpace(banLog.Entry.Reason)
? $"Banned by {banLog.Entry.User.GetFullUsername()}."
: banLog.Entry.Reason;
var guildUser = guild.GetUser(banLog.Entry.User.Id);
await _authorizationService.OnAuthenticatedAsync(guildUser);
await _moderationService.CreateInfractionAsync(guild.Id, banLog.Entry.User.Id, InfractionType.Ban, user.Id, reason, null);
}
public DiscordAnnouncer(DiscordRestClient discordClient, ulong guildId, ulong purgeLogChannelId, string warningText)
{
_warningText = warningText;
_guild = discordClient.GetGuildAsync(guildId).Result;
_purgeChannel = _guild.GetTextChannelAsync(purgeLogChannelId).Result;
_userDict = _guild.GetUsersAsync().FlattenAsync().Result.ToDictionary(u => u.Id, u => u);
}
public async Task MigrateAsync()
{
DiscordRestClient client = null;
RestGuild guild = null;
await _cache.LoadInfoAsync(_config.GuildId).ConfigureAwait(false);
while (_cache.Info.Version != MigrationCount)
{
if (client == null)
{
client = new DiscordRestClient();
await client.LoginAsync(TokenType.Bot, _config.Token).ConfigureAwait(false);
guild = await client.GetGuildAsync(_config.GuildId);
}
uint nextVer = _cache.Info.Version + 1;
try
{
await DoMigrateAsync(client, guild, nextVer).ConfigureAwait(false);
_cache.Info.Version = nextVer;
await _cache.SaveInfoAsync().ConfigureAwait(false);
}
catch
{
await _cache.ClearAsync().ConfigureAwait(false);
throw;
}
}
}
public async Task <ActionResult <GuildLeaderboard> > GetLocalLeaderboard(ulong guildId)
{
var guild = _client.GetGuild(guildId);
if (guild == null)
{
return(NotFound("The specified guild could not be found!"));
}
var gl = new GuildLeaderboard()
{
AvatarUrl = guild.IconUrl ?? _client.CurrentUser.GetAvatarUrl(),
GuildName = guild.Name,
Ranks = new List <GuildRank>(guild.MemberCount > 100 ? 100: guild.MemberCount) // Properly set capacity already for best performance!
};
var gUsersO = await _profileRepo.GetGuildUsersSorted(guildId);
if (!gUsersO)
{
return(NotFound("Guild has no saved users!"));
}
var g = await _restClient.GetGuildAsync(guildId);
// Create dictionary for easy and fast lookups later :)
var users = (await g.GetUsersAsync().FlattenAsync()).ToDictionary(x => x.Id, x => x);
var gUsers = (~gUsersO);
for (var i = 0; i < gUsers.Count; i++)
{
var user = gUsers[i];
int rank = i + 1;
if (rank > 100)
{
break;
}
if (!users.TryGetValue(user.UserId, out var u))
{
continue;
}
gl.Ranks.Add(new GuildRank()
{
AvatarUrl = u.GetAvatarUrl() ?? u.GetDefaultAvatarUrl(),
Discrim = u.Discriminator,
Exp = user.Exp,
Name = u.Username,
Rank = rank,
UserId = u.Id.ToString()
});
}
return(Ok(gl));
}
/// <summary>
/// Tries repeatedly to get a <see cref="RestGuild"/> even if there's a common 5XX error
/// </summary>
public static async Task <RestGuild> SuperGetRestGuild(this DiscordRestClient client, ulong ID)
{
var requestOptions = new RequestOptions()
{
RetryMode = RetryMode.AlwaysRetry
};
Func <Task <RestGuild> > func = async() =>
{
return(await client.GetGuildAsync(ID, requestOptions));
};
return(await func.SuperGet());
}
private async void PageOne_Load(object sender, EventArgs e)
{
await discord.LoginAsync(TokenType.Bot, _config["token"]);
var guild = await discord.GetGuildAsync(432496922134052882);
var channels = await guild.GetTextChannelsAsync();
foreach (var channel in channels)
{
channelList.Add(channel);
boxChannels.Items.Add(channel);
}
}
protected override void CycleThink()
{
if (World.GameConfiguration.DiscordGuildID != null && World.GameConfiguration.DiscordToken != null)
{
foreach (var player in Player.GetWorldPlayers(this.World)
.Where(p => !string.IsNullOrEmpty(p.Token) && !p.AuthenticationStarted))
{
player.AuthenticationStarted = true;
Task.Run(async() =>
{
using (var drc = new DiscordRestClient())
{
try
{
await drc.LoginAsync(Discord.TokenType.Bearer, player.Token);
if (drc.CurrentUser != null)
{
var playerRoles = new List <string>();
var userId = drc.CurrentUser.Id;
await drc.LoginAsync(Discord.TokenType.Bot, World.GameConfiguration.DiscordToken);
var user = await drc.GetGuildUserAsync(World.GameConfiguration.DiscordGuildID.Value, userId);
var guild = await drc.GetGuildAsync(World.GameConfiguration.DiscordGuildID.Value);
foreach (var roleID in user.RoleIds)
{
var role = guild.Roles.FirstOrDefault(r => r.Id == roleID);
if (role != null)
{
playerRoles.Add(role.Name);
}
}
player.LoginName = user.Username;
player.LoginID = user.Id;
player.Roles = playerRoles;
player.Avatar = $"https://cdn.discordapp.com/avatars/{user.Id}/{user.AvatarId}.png?size=128";
player.OnAuthenticated();
}
}
catch (Exception) { }
}
});
}
}
}
/// <summary>
/// Creates a ban infraction for the user if they do not already have one.
/// </summary>
/// <param name="guild">The guild that the user was banned from.</param>
/// <param name="user">The user who was banned.</param>
/// <returns>
/// A <see cref="Task"/> that will complete when the operation completes.
/// </returns>
private async Task TryCreateBanInfractionAsync(ISocketUser user, ISocketGuild guild)
{
if (await _moderationService.AnyInfractionsAsync(GetBanSearchCriteria(guild, user)))
{
return;
}
var restGuild = await _restClient.GetGuildAsync(guild.Id);
var allAudits = await restGuild.GetAuditLogsAsync(10).FlattenAsync();
var banLog = allAudits
.Where(x => x.Action == ActionType.Ban && x.Data is BanAuditLogData)
.Select(x => (Entry: x, Data: (BanAuditLogData)x.Data))
.FirstOrDefault(x => x.Data.Target.Id == user.Id);
// We're in a scenario in where the guild does not have a Discord audit of the
// ban MODiX just received, if that's the case something has gone wrong and we
// need to investigate.
if (banLog.Data is null ||
banLog.Entry is null)
{
// Snapshot the most amount of information possible about this event
// to log this incident and investigate further
var mostRecentAudit = allAudits.OrderByDescending(x => x.CreatedAt).FirstOrDefault();
Log.Error("No ban audit found when handling {message} for user {userId}, in guild {guild} - " +
"the most recent audit was created at {mostRecentAuditTime}: {mostRecentAuditAction} for user: {mostRecentAuditUserId}",
nameof(UserBannedNotification),
user.Id,
guild.Id,
mostRecentAudit?.CreatedAt,
mostRecentAudit?.Action,
mostRecentAudit?.User.Id);
return;
}
var reason = string.IsNullOrWhiteSpace(banLog.Entry.Reason)
? $"Banned by {banLog.Entry.User.GetFullUsername()}."
: banLog.Entry.Reason;
var guildUser = guild.GetUser(banLog.Entry.User.Id);
await _authorizationService.OnAuthenticatedAsync(guildUser);
await _moderationService.CreateInfractionAsync(guild.Id, banLog.Entry.User.Id, InfractionType.Ban, user.Id, reason, null);
}
public TestsFixture()
{
_cache = new CachedRestClient();
_config = TestConfig.LoadFile("./config.json");
var config = new DiscordRestConfig
{
RestClientProvider = url =>
{
_cache.SetUrl(url);
return(_cache);
}
};
_client = new DiscordRestClient(config);
_client.LoginAsync(TokenType.Bot, _config.Token).Wait();
MigrateAsync().Wait();
_guild = _client.GetGuildAsync(_config.GuildId).Result;
}
/// <inheritdoc />
public async Task <GuildResult> GetGuildInformationAsync(ulong guildId)
{
IGuild guild = DiscordSocketClient.GetGuild(guildId);
if (guild != null)
{
return(new GuildResult(guild));
}
try
{
guild = await DiscordRestClient.GetGuildAsync(guildId);
}
catch (HttpException ex) when(ex.DiscordCode == 50001)
{
return(new GuildResult("Sorry, I do not have access to any guilds with that ID."));
}
return(new GuildResult(guild));
}
/// <summary>
/// Creates a ban infraction for the user if they do not already have one.
/// </summary>
/// <param name="guild">The guild that the user was banned from.</param>
/// <param name="user">The user who was banned.</param>
/// <returns>
/// A <see cref="Task"/> that will complete when the operation completes.
/// </returns>
private async Task TryCreateBanInfractionAsync(IGuild guild, IUser user)
{
if (await _moderationService.AnyInfractionsAsync(GetBanSearchCriteria(guild, user)))
{
return;
}
var restGuild = await _restClient.GetGuildAsync(guild.Id);
var auditLogs = (await restGuild.GetAuditLogsAsync(10)
.FlattenAsync())
.Where(x => x.Action == ActionType.Ban)
.Select(x => (Entry: x, Data: (BanAuditLogData)x.Data));
var banLog = auditLogs.FirstOrDefault(x => x.Data.Target.Id == user.Id);
var reason = string.IsNullOrWhiteSpace(banLog.Entry.Reason)
? $"Banned by {banLog.Entry.User.GetDisplayNameWithDiscriminator()}."
: banLog.Entry.Reason;
await _moderationService.CreateInfractionAsync(guild.Id, banLog.Entry.User.Id, InfractionType.Ban, user.Id, reason, null);
}
public async Task <ActionResult> ExternalLoginConfirmation(ExternalLoginConfirmationViewModel model, string returnUrl)
{
if (User.Identity.IsAuthenticated)
{
return(RedirectToAction("Index", "Manage"));
}
if (ModelState.IsValid)
{
// Get the information about the user from the external login provider
var info = await AuthenticationManager.GetExternalLoginInfoAsync();
if (info == null)
{
return(View("ExternalLoginFailure"));
}
var user = new ApplicationUser {
UserName = info.DefaultUserName, Email = info.DefaultUserName
};
DiscordRestClient dcli = new DiscordRestClient(new DiscordRestConfig
{
LogLevel = Discord.LogSeverity.Info
});
await dcli.LoginAsync(Discord.TokenType.Bot, ConfigHelper.Instance.DiscordBotToken);
ulong discordUserId = Convert.ToUInt64(info.ExternalIdentity.Claims.First().Value);
ulong guildId = Convert.ToUInt64(ConfigHelper.Instance.DiscordGuildID);
RestGuildUser guser = dcli.GetGuildUserAsync(guildId, discordUserId).Result;
if (guser != null)
{
RestGuild guild = dcli.GetGuildAsync(guildId).Result;
List <string> roleNames = guild.Roles.Where(x => guser.RoleIds.Contains(x.Id)).Select(x => x.Name).ToList();
var roleManager = new RoleManager <IdentityRole>(new RoleStore <IdentityRole>(new ApplicationDbContext()));
foreach (string roleName in roleNames)
{
if (!roleManager.RoleExists(roleName))
{
roleManager.Create(new IdentityRole(roleName));
}
}
var result = await UserManager.CreateAsync(user);
if (result.Succeeded)
{
await UserManager.AddToRolesAsync(user.Id, roleNames.ToArray());
result = await UserManager.AddLoginAsync(user.Id, info.Login);
if (result.Succeeded)
{
await SignInManager.SignInAsync(user, isPersistent : false, rememberBrowser : false);
return(RedirectToLocal(returnUrl));
}
}
AddErrors(result);
}
}
ViewBag.ReturnUrl = returnUrl;
return(View(model));
}
private async Task <RestCategoryChannel> GetChannelCategory(DiscordRestClient client)
{
var guild = await client.GetGuildAsync(GuildId);
return(await guild.GetChannelAsync(CategoryId) as RestCategoryChannel);
}
public static Task <DiscordGuild> GetGuild(this DiscordRestClient client, ulong id) => WrapDiscordCall(client.GetGuildAsync(id));
public async Task Assign(CommandContext ctx, string message)
{
var intakeStrings = message.Split(' ').ToList();
var classes = "";
var id = intakeStrings[0];
intakeStrings.RemoveAt(0);
foreach (var elem in intakeStrings)
{
classes = classes + elem + " ";
}
var rolestoadd = classes.Split(',');
var token = File.ReadAllText(@"token.txt");
var discord = new DiscordRestClient(new DiscordConfiguration
{
Token = token,
TokenType = TokenType.Bot,
UseInternalLogHandler = true,
LogLevel = LogLevel.Debug
});
var userid = Convert.ToUInt64(id);
var guild = await discord.GetGuildAsync(718945666348351570);
foreach (var elem in rolestoadd)
{
var trimmed = elem.Trim();
if (guild.Roles.Any(tr => tr.Value.Name.Equals(trimmed)))
{
var roleid = guild.Roles.FirstOrDefault(x => x.Value.Name.ToString() == trimmed).Key;
await discord.AddGuildMemberRoleAsync(718945666348351570, userid, roleid, "");
}
else
{
var role = await guild.CreateRoleAsync(trimmed, Permissions.SendMessages);
var channel = await guild.CreateChannelAsync(trimmed, ChannelType.Text);
var voicechannel = await guild.CreateChannelAsync(trimmed, ChannelType.Voice);
await discord.ModifyChannelAsync(channel.Id, channel.Name, 0, "", false, 718991556107042817,
null, 0, 0, "");
await discord.ModifyChannelAsync(voicechannel.Id, voicechannel.Name, 0, "", false,
718945666797404230,
64000, 0, 0, "");
await channel.AddOverwriteAsync(role, Permissions.AccessChannels);
await voicechannel.AddOverwriteAsync(role, Permissions.AccessChannels);
await channel.AddOverwriteAsync(guild.EveryoneRole, Permissions.None, Permissions.AccessChannels);
await voicechannel.AddOverwriteAsync(guild.EveryoneRole, Permissions.None,
Permissions.AccessChannels);
await discord.AddGuildMemberRoleAsync(718945666348351570, userid, role.Id, "");
}
}
}
public DiscordInactivityRetriever(DiscordRestClient discordClient, HttpClient httpClient, ulong guildId, ulong channelId, ulong idToBeg)
{
_httpClient = httpClient;
_idToBeg = idToBeg;
_purgeChannel = discordClient.GetGuildAsync(guildId).Result.GetTextChannelAsync(channelId).Result;
}
