Task Client_GuildMemberAdded(DiscordClient client, GuildMemberAddEventArgs e)
{
_ = Task.Run(async() =>
{
using var scope = ServiceScopeFactory.CreateScope();
var dbContext = scope.ServiceProvider.GetService <InciteDbContext>();
var user = dbContext.Users
.Include(x => x.Memberships)
.ThenInclude(x => x.Guild)
.FirstOrDefault(x => x.DiscordId == e.Member.Id);
Member member = user?.Memberships
.FirstOrDefault(x => x.Guild.DiscordId == e.Guild.Id);
if (member == null)
{
member = new Member()
{
Guild = await dbContext.Guilds.FirstAsync(x => x.DiscordId == e.Guild.Id),
User = user ?? new User()
{
DiscordId = e.Member.Id
}
};
dbContext.Members.Add(member);
await dbContext.SaveChangesAsync();
}
});
return(Task.CompletedTask);
}
private Task MemberAddedHandler(DiscordClient s, GuildMemberAddEventArgs e)
{
// automatically add scrubs role to new users to pacify my OCD
e.Member.GrantRoleAsync(e.Guild.GetRole(310980088122441728));
return(Task.CompletedTask);
}
private static async Task Discord_GuildMemberAdded(GuildMemberAddEventArgs e)
{
var channel = await e.Member.CreateDmChannelAsync();
await channel.SendMessageAsync("Welcome to the Insanity Network Discord! Please be sure to read <#693561317352669254> and <#693561343084593222>!");
if (!File.Exists($"./data/{e.Member.Id}/modlog.xml"))
{
Serializer.CreateNew(e.Member.Id, e.Member.Username);
}
FileStream writer = new FileStream("./data/experience.xml", FileMode.Open);
XmlSerializer serializer = new XmlSerializer(typeof(List <ExperiencePacket>));
List <ExperiencePacket> packets = (List <ExperiencePacket>)serializer.Deserialize(writer);
packets.Add(new ExperiencePacket
{
Level = 0,
Experience = 0,
UserID = e.Member.Id
});
packets = packets.OrderByDescending(xm => xm.Level).ThenByDescending(xm => xm.Experience).ToList();
writer.SetLength(0);
writer.Flush();
serializer.Serialize(writer, packets);
writer.Close();
}
private async Task BloonsideEmbed(DiscordClient dClient, GuildMemberAddEventArgs args)
{
DiscordChannel sbgChannel = await this.dClient.GetChannelAsync(SBGChannels.Bloonside);
// If guild isn't SBG, just ignore this user join event.
if (args.Guild.Id != Variables.Guilds.SBG)
{
return;
}
DiscordEmbedBuilder embed = this.BuildEmbed(args.Member);
using IServiceScope scope = this.provider.CreateScope();
using AnalyticsContext db = scope.ServiceProvider.GetRequiredService <AnalyticsContext>();
List <UserEvent> userEvents = await db.UserEvents
.Where(u => u.UserId == args.Member.Id)
.OrderByDescending(u => u.Timestamp)
.Take(10)
.ToListAsync();
embed.AddField(
"Events",
string.Join(
"\n",
userEvents.Select(u => $"{DiscordEmoji.FromGuildEmote(this.dClient, this.eventEmotes[u.Event])} {u.Event.ToString().PadRight(8, '\u2000')} - {u.Timestamp.ToString("ddd, dd MMM yyyy, hh:mm:ss tt", CultureInfo.InvariantCulture)}")));
// Post embed to #bloonside
await sbgChannel.SendMessageAsync(embed);
}
private async Task OnMemberAdded(DiscordClient sender, GuildMemberAddEventArgs e)
{
ConfigJson config = await GetConfig();
DiscordMember daryl = await e.Guild.GetMemberAsync(229594828889915392);
foreach (DSharpPlus.Entities.DiscordInvite discordInvite in await e.Guild.GetInvitesAsync())
{
Console.WriteLine(discordInvite.Code + " => " + discordInvite.Inviter.Username);
if (discordInvite.Uses == invitesCount[discordInvite.Code])
{
continue;
}
DiscordRole role = e.Guild.GetRole(config.InviteRole[discordInvite.Code]);
try
{
await e.Member.GrantRoleAsync(role);
}
catch (Exception exception)
{
await daryl.SendMessageAsync($"Failed to grant {role.Name} to {e.Member.Username} \n Error: {exception.Message}");
invitesCount[discordInvite.Code] = discordInvite.Uses;
return;
}
invitesCount[discordInvite.Code] = discordInvite.Uses;
await daryl.SendMessageAsync($"Granted {role.Name} to {e.Member.Username}");
return;
}
await daryl.SendMessageAsync($"Failed to grant any roles to {e.Member.Username}");
}
internal static async Task Main(DiscordClient Bot, GuildMemberAddEventArgs MemberObjects)
{
Log.Debug("GuildMemberAddEvent " + "Start...");
GetLanguage Get_Language;
string GuildLanguageString = Database.DatabaseMethods.GuildConfigMethods.LanguageFind(MemberObjects.Guild.Id);
if (GuildLanguageString == null)
{
Get_Language = new GetLanguage(Database.Enums.Language.ja_JP);
}
else
{
if (Enum.TryParse(GuildLanguageString, true, out Database.Enums.Language GuildLanguage))
{
Get_Language = new GetLanguage(GuildLanguage);
}
else
{
Get_Language = new GetLanguage(Database.Enums.Language.ja_JP);
}
}
await Fork(Bot, MemberObjects, Get_Language).ConfigureAwait(false);
Log.Debug("GuildMemberAddEvent " + "End...");
}
public async Task MemberAdd(GuildMemberAddEventArgs e)
{
await GreetUser(e);
await connection.OpenAsync();
try
{
MySqlCommand cmd = new MySqlCommand
{
Connection = connection,
CommandText = $"INSERT INTO `guilds.users` (`userID`, `userName`, `userDiscriminator`, `Birthdate`, `changeDate`) VALUES (?, ?, ?, NULL, CURRENT_TIMESTAMP) ON DUPLICATE KEY UPDATE userName=userName"
};
cmd.Parameters.Add("userID", MySqlDbType.Int64).Value = e.Member.Id;
cmd.Parameters.Add("userName", MySqlDbType.VarChar).Value = e.Member.Username;
cmd.Parameters.Add("userDiscriminator", MySqlDbType.VarChar).Value = e.Member.Discriminator;
await cmd.ExecuteNonQueryAsync();
GuildsList[e.Guild.Id].GuildMembers.Add(e.Member.Id, new Members
{
UserName = e.Member.Username,
UserDiscriminator = e.Member.Discriminator,
BdaySent = false
});
await LogActionNoMsg(e.Guild, "MemberAdd", "Fired on member join", $"User {e.Member.Username} joined", DiscordColor.Yellow);
}
catch (Exception ex)
{
Console.WriteLine("Error: " + ex);
Console.WriteLine(ex.StackTrace);
}
await connection.CloseAsync();
}
public static async Task NewMember(DiscordClient y, GuildMemberAddEventArgs e)
{
try
{
var data = new Global().GetDBRecords(e.Guild.Id);
if (e.Member.IsBot)
{
var m = e.Member;
var p = Convert.ToUInt64(data.BotAutoRole);
var c = e.Member.Guild.GetRole(p);
await m.GrantRoleAsync(c);
}
else if (e.Member.IsBot == false)
{
var p = Convert.ToUInt64(data.Autorole);
var c = e.Member.Guild.GetRole(p);
var m = e.Member;
await m.GrantRoleAsync(c);
}
}
catch (Exception exception)
{
Console.WriteLine(exception);
throw;
}
}
private async Task OnGuildMemberAdded(DiscordClient dClient, GuildMemberAddEventArgs args)
{
if (args.Guild.Id != Guilds.SBG || args.Member.IsBot)
{
return;
}
IServiceScope scope = this.scopeFactory.CreateScope();
BloonContext db = scope.ServiceProvider.GetRequiredService <BloonContext>();
List <ulong> roleIds = await db.RoleMembers.AsNoTracking()
.Where(r => r.MemberId == args.Member.Id)
.Select(r => r.RoleId)
.ToListAsync();
List <string> addedRoleNames = new List <string>();
for (int i = 0; i < roleIds.Count; i++)
{
if (args.Guild.Roles.TryGetValue(roleIds[i], out DiscordRole role) && role.Position < args.Guild.CurrentMember.Hierarchy)
{
addedRoleNames.Add(role.Name);
await args.Member.GrantRoleAsync(role);
}
}
if (addedRoleNames.Count == 0)
{
return;
}
await args.Guild.GetChannel(SBGChannels.Bloonside)
.SendMessageAsync($"Granted **{string.Join(", ", addedRoleNames)}** to **{args.Member.Username}**.");
}
private async Task OnGuildMemberAdded(GuildMemberAddEventArgs e)
{
if (GuildMemberAdded != null)
{
await GuildMemberAdded(e);
}
}
public async Task OnMemberJoinedAsync(DiscordClient _, GuildMemberAddEventArgs e)
{
GuildConfig config = await _configRepository.FindOrCreateConfigAsync(e.Member.Guild.Id);
if (config.JoinLogChannel is not 0)
{
_logger.LogDebug("Fetching Joinlog record for user {userId} in guild {guildId}.", e.Member.Id, e.Guild.Id);
TrustlistUser user = await _client.LookupUserAsync(e.Member.Id);
TrustlistEntry entry = user?.GetLatestMaxEntry();
byte maxEscalation = user?.GetMaxEscalationLevel() ?? 0;
DiscordEmbed entryEmbed = Utilities.BuildUserRecordEmbed(user, e.Member);
if (maxEscalation is 0 && config.SuppressJoinlogCleanRecords)
{
_logger.LogDebug("Suppressed clean record for user {userId} in guild {guildId}.", e.Member.Id, e.Guild.Id);
}
else
{
DiscordChannel joinLog = e.Guild.GetChannel(config.JoinLogChannel);
await joinLog.SendMessageAsync($"User **{e.Member.GetFullUsername()}** ({e.Member.Mention}) has joined the server.", entryEmbed);
}
if (maxEscalation >= 3 && config.AutoBanBlacklisted)
{
await e.Member.BanAsync(0, $"[SocialGuard] \n{entry.EscalationNote}");
await e.Guild.GetChannel(config.BanLogChannel is not 0?config.BanLogChannel : config.JoinLogChannel)
.SendMessageAsync($"User **{e.Member.GetFullUsername()}** ({e.Member.Mention}) banned on server join.", entryEmbed);
}
}
public static Task Guild_Member_Added(GuildMemberAddEventArgs e)
{
e.Member.GrantRoleAsync(e.Guild.Roles[2]); // TEST
e.Member.SendMessageAsync($"Welcome to {e.Guild.Name} {e.Member.Mention}. For now you are but a fledgling potato, but soon you may ascend. I am PotatoBot, guardian of this land. Fear my wrath.");
return(Task.CompletedTask);
}
private async Task Discord_GuildMemberAdded(GuildMemberAddEventArgs e)
{
if (e.Guild == RPClass.RPGuild)
{
DiscordEmbedBuilder b = new DiscordEmbedBuilder()
.AddField($"Welcome, {e.Member.Username}!",
$@"Welcome to the Heroes & Villains Discord Server, {e.Member.Mention}!
First things first, please read the <#511221485004783618> to see how we run things here.
Once you've done that, then head over to <#463498007514710016> to get some help for your OC and ask for an approval channel.
To learn more about the lore and the Server, then browse through <#366574305418543105> or head over to our Wiki and have a look through the pages!
https://roleplay-heroes-and-villains.wikia.com/wiki/Role-Play:_Heroes_and_Villains_Wiki
We hope you enjoy your stay!")
.WithFooter("Heroes & Villains Discord Server").WithColor(DiscordColor.CornflowerBlue);
await e.Member.SendMessageAsync("", embed : b);
await e.Guild.Channels.First(x => x.Id == 312918289988976653).SendMessageAsync("", embed: b);
DiscordEmbedBuilder c = new DiscordEmbedBuilder
{
Title = "Member Joined",
Color = DiscordColor.Green
}
.AddField("Member", e.Member.DisplayName + "#" + e.Member.Discriminator + " (" + e.Member.Id + ")", true)
.AddField("Timestamp", e.Member.JoinedAt.ToString(), true);
await e.Guild.GetChannel(392429153909080065).SendMessageAsync(embed: c);
}
}
public static async Task OnGuildMemberAdded(DiscordClient client, GuildMemberAddEventArgs e)
{
if (e.Guild.Id != Config.serverID)
{
return;
}
// Check if user has registered their Github account
if (!Database.TryGetSponsor(e.Member.Id, out Database.SponsorEntry sponsorEntry))
{
return;
}
// Check if user is active sponsor
List <Github.Sponsor> sponsors = await Github.GetSponsors();
Github.Sponsor sponsor = sponsors.FirstOrDefault(s => s.sponsor.id == sponsorEntry.githubID);
if (sponsor == null)
{
return;
}
// Check if tier is registered in the config
if (!Config.TryGetTierRole(sponsor.dollarAmount, out ulong roleID))
{
return;
}
// Assign role
DiscordRole role = e.Guild.GetRole(roleID);
Logger.Log(LogID.Discord, Utils.FullName(e.Member) + " (" + e.Member.Id + ") were given back the role '" + role.Name + "' on rejoin. ");
await e.Member.GrantRoleAsync(role);
}
private static async Task DenyUserProcess(DiscordClient Bot, GuildMemberAddEventArgs MemberObjects, GetLanguage Get_Language)
{
await MemberObjects.Member.SendMessageAsync(Get_Language.Language_Data.PermissionDenied);
await MemberObjects.Member.RemoveAsync(Get_Language.Language_Data.NotAccessed);
ulong Guild_ChannelID = Database.DatabaseMethods.GuildConfigMethods.LogChannelFind(MemberObjects.Guild.Id);
if (Guild_ChannelID != 0)
{
DiscordChannel GuildLogChannel = MemberObjects.Guild.GetChannel(Guild_ChannelID);
DiscordEmbed LogChannelEmbed = new DiscordEmbedBuilder()
.WithTitle(Get_Language.Language_Data.AccessDenied)
.WithDescription(
string.Format(
Get_Language.Language_Data.Bot_BanDescription,
MemberObjects.Member.Username + "#" + MemberObjects.Member.Discriminator,
MemberObjects.Member.Id
)
)
.WithColor(new DiscordColor(0xFF4B00))
.WithTimestamp(DateTime.Now)
.WithFooter(
string.Format("{0} Bot", Bot.CurrentUser.Username)
)
.WithAuthor(Get_Language.Language_Data.NotAccessed);
await GuildLogChannel.SendMessageAsync(LogChannelEmbed);
}
else
{
Log.Warning("Could not send from log channel");
}
Log.Debug($"{MemberObjects.Member.Username + "#" + MemberObjects.Member.Discriminator} is not allowed join");
}
private async Task Client_GuildMemberAdded(GuildMemberAddEventArgs e)
{
_logger.Trace($"FilterBot::Client_GuildMemberAdded [Guild={e.Guild.Name}, Username={e.Member.Username}]");
if (_config.NotifyNewMemberJoined)
{
var channel = await _client.GetChannel(_config.CommandsChannelId);
if (channel == null)
{
_logger.Error($"Failed to find channel with id {_config.CommandsChannelId}.");
return;
}
await channel.SendMessageAsync($"Everyone let's welcome {e.Member.Mention} to the server! We've been waiting for you!");
}
if (_config.AssignNewMembersCityRoles)
{
_client.AssignMemberRoles(e.Member, _config.CityRoles);
}
if (_config.SendWelcomeMessage)
{
await _client.SendWelcomeMessage(e.Member, _config.WelcomeMessage);
}
}
private static async Task Fork(DiscordClient Bot, GuildMemberAddEventArgs MemberObjects, GetLanguage Get_Language)
{
if (!Database.DatabaseMethods.GuildConfigMethods.WhitelistFind(MemberObjects.Guild.Id))
{
Log.Info("Whitelist Disabled");
return;
}
if (MemberObjects.Member.IsBot)
{
await BotProcess(Bot, MemberObjects, Get_Language).ConfigureAwait(false);
return;
}
if (Database.DatabaseMethods.AllowUsersMethods.AllowUserFind(MemberObjects.Guild.Id, MemberObjects.Member.Id, out AllowUsers DBAllowUserID))
{
await AllowUserProcess(Bot, MemberObjects, Get_Language, DBAllowUserID).ConfigureAwait(false);
return;
}
else // if DBAllowUserID is null, processes will not be executed from here. And kick.
{
await DenyUserProcess(Bot, MemberObjects, Get_Language).ConfigureAwait(false);
return;
}
}
private Task _discordClient_UserJoined(DiscordClient sender, GuildMemberAddEventArgs e)
{
_ = Task.Run(async() =>
{
// Haven't set the config
if (_config.JoinLogChannel == default)
{
return;
}
_joinLogChannel ??= _discordClient.FindChannel(_config.JoinLogChannel);
// Invalid channel ID
if (_joinLogChannel == null)
{
return;
}
var accountAge = DateTimeOffset.UtcNow - e.Member.CreationTimestamp.UtcDateTime;
var userJoinedMessage = await _joinLogChannel.SendMessageAsync(
$"{e.Member.Mention} {Formatter.Sanitize(e.Member.Username.RemoveControlChars())}#{e.Member.Discriminator} joined, account was created {accountAge.ToPrettyFormat()} ago");
await WarnIfNewAccountAsync(userJoinedMessage, accountAge);
await WarnIfDuplicatedNewAccountAsync(e.Member);
});
return(Task.CompletedTask);
}
private Task GuildMemberAdded(GuildMemberAddEventArgs e)
{
var joinedLeftEventId = _redis.StringGet($"{e.Guild.Id}:Logs:JoinedLeftEvent");
var guild = e.Guild;
var member = e.Member;
if (!string.IsNullOrWhiteSpace(joinedLeftEventId))
{
var logChannel = guild.GetChannel((ulong)joinedLeftEventId);
var avatarUrl = member.AvatarUrl;
var title = ":inbox_tray: Member joined";
var description = new StringBuilder().AppendLine($"Username: `{member.GetUsertag()}`").AppendLine($"User identity: `{member.Id}`").AppendLine($"Registered: {member.CreatedAtLongDateTimeString().Result}").ToString();
var footer = new DiscordEmbedBuilder.EmbedFooter
{
Text = $"Member Id: {member.Id}"
};
logChannel.SendEmbedMessageAsync(title, description, DiscordColor.SpringGreen, thumbnailUrl: avatarUrl, footer: footer, timestamp: DateTimeOffset.UtcNow);
}
_logger.Information($"'{e.Member.GetUsertag()}' ({e.Member.Id}) has joined the guild '{e.Guild.Name}' ({e.Guild.Id}).");
return(Task.CompletedTask);
}
public static async Task Welcome_Member(object Client, GuildMemberAddEventArgs e)
{
_ = Task.Run(async() =>
{
var WelcomeSettings = DB.DBLists.ServerWelcomeSettings.FirstOrDefault(w => w.Server_ID == e.Guild.Id);
var JoinRole = (from rr in DB.DBLists.RankRoles
where rr.Server_ID == e.Guild.Id
where rr.Server_Rank == 0
select rr).FirstOrDefault();
if (WelcomeSettings.Channel_ID != 0 && !WelcomeSettings.HasScreening)
{
DiscordChannel WelcomeChannel = e.Guild.GetChannel(Convert.ToUInt64(WelcomeSettings.Channel_ID));
if (WelcomeSettings.Welcome_Message != null)
{
string msg = WelcomeSettings.Welcome_Message;
msg = msg.Replace("$Mention", $"{e.Member.Mention}");
await WelcomeChannel.SendMessageAsync(msg);
if (JoinRole != null)
{
DiscordRole role = e.Guild.GetRole(Convert.ToUInt64(JoinRole.Role_ID));
await e.Member.GrantRoleAsync(role);
}
}
}
});
await Task.Delay(1);
}
public async Task HandleMemberJoinAsync(GuildMemberAddEventArgs e, AntifloodSettings settings)
{
if (!this.guildFloodUsers.ContainsKey(e.Guild.Id) && !this.TryAddGuildToWatch(e.Guild.Id))
{
throw new ConcurrentOperationException("Failed to add guild to antiflood watch list!");
}
if (!this.guildFloodUsers[e.Guild.Id].Add(e.Member))
{
throw new ConcurrentOperationException("Failed to add member to antiflood watch list!");
}
if (this.guildFloodUsers[e.Guild.Id].Count >= settings.Sensitivity)
{
foreach (DiscordMember m in this.guildFloodUsers[e.Guild.Id])
{
await this.PunishMemberAsync(e.Guild, m, settings.Action);
await Task.Delay(TimeSpan.FromMilliseconds(100));
}
this.guildFloodUsers[e.Guild.Id].Clear();
return;
}
await Task.Delay(TimeSpan.FromSeconds(settings.Cooldown));
if (this.guildFloodUsers.ContainsKey(e.Guild.Id) && !this.guildFloodUsers[e.Guild.Id].TryRemove(e.Member))
{
throw new ConcurrentOperationException("Failed to remove member from antiflood watch list!");
}
}
public async Task AddJoinUser(GuildMemberAddEventArgs e)
{
try
{
var guildId = GetGuildIdByUid(e.Guild.Id);
await connection.OpenAsync();
MySqlCommand cmd = new MySqlCommand();
cmd.Connection = connection;
cmd.CommandText = $"INSERT INTO `guilds.users` (discordId, discordName, guildId, notes) "
+ $" values (?, ?, ?, 'auto add') "
+ $" ON DUPLICATE KEY UPDATE discordId=discordId";
cmd.Parameters.Add("discordId", MySqlDbType.VarChar).Value = Convert.ToString(e.Member.Id);
cmd.Parameters.Add("discordName", MySqlDbType.VarChar).Value = Convert.ToString(e.Member.Username);
cmd.Parameters.Add("guildId", MySqlDbType.Int16).Value = guildId;
await cmd.ExecuteNonQueryAsync();
await connection.CloseAsync();
}
catch (Exception ey)
{
Console.WriteLine("Error: " + ey);
Console.WriteLine(ey.StackTrace);
}
Console.WriteLine("UserAdd done!");
}
internal async Task OnMemberAdded(DiscordClient client, GuildMemberAddEventArgs e)
{
if (!Database.TryGetOpenTickets(e.Member.Id, out List <Database.Ticket> ownTickets))
{
return;
}
foreach (Database.Ticket ticket in ownTickets)
{
try
{
DiscordChannel channel = await client.GetChannelAsync(ticket.channelID);
if (channel?.GuildId == e.Guild.Id)
{
await channel.AddOverwriteAsync(e.Member, Permissions.AccessChannels, Permissions.None);
DiscordEmbed message = new DiscordEmbedBuilder()
.WithColor(DiscordColor.Green)
.WithDescription("User '" + e.Member.Username + "#" + e.Member.Discriminator + "' has rejoined the server, and has been re-added to the ticket.");
await channel.SendMessageAsync(message);
}
}
catch (Exception) { }
}
}
public static async Task <string> ReplaceValues(string message, GuildMemberAddEventArgs e)
{
return(await ReplaceValues(message,
e.Member.Username,
e.Guild.Name,
e.Guild.MemberCount.ToString()));
}
/// <summary>
/// Triggered when an user join a guild
/// </summary>
private static async Task GuildMemberAdded(GuildMemberAddEventArgs e)
{
var welcome = Guilds[e.Guild.Id].Welcome;
if (welcome.Channel == null)
{
return;
}
var channel = e.Guild.GetChannel(ulong.Parse(welcome.Channel));
if (channel == null)
{
return;
}
var embed = new DiscordEmbedBuilder()
.WithTitle(string.Format(welcome.Header, e.Member.Username))
.WithDescription(welcome.Body)
.WithColor(new DiscordColor(welcome.Color))
.WithThumbnailUrl(e.Member.AvatarUrl)
.Build();
await channel.SendMessageAsync(embed : embed, content : welcome.Mention?e.Member.Mention : null);
}
private async Task StartMember(GuildMemberAddEventArgs e)
{
var p = GameBuilder.CreatePerms(Permissions.AccessChannels, Permissions.UseVoice, Permissions.Speak);
await Global.Game.DiscordChannels[GameChannel.BotVoice].AddOverwriteAsync(e.Member, p);
Game.WriteDebug($"D : {e.Member.Username}");
}
public async Task AddUserJoinedEventAsync(GuildMemberAddEventArgs args)
{
UserEvent userEvent = new UserEvent()
{
UserId = args.Member.Id,
Username = args.Member.Username,
Nickname = args.Member.Nickname,
Discriminator = args.Member.Discriminator,
AvatarId = args.Member.AvatarHash.ToString(),
AccountCreated = args.Member.CreationTimestamp.UtcDateTime,
Bot = args.Member.IsBot,
Event = Event.Joined,
Timestamp = DateTime.Now,
};
try
{
using IServiceScope scope = this.scopeFactory.CreateScope();
using AnalyticsContext db = scope.ServiceProvider.GetRequiredService <AnalyticsContext>();
db.UserEvents.Add(userEvent);
await db.SaveChangesAsync();
}
catch (Exception e)
{
Log.Error(e, $"Failed to add new user event {userEvent.Username}#{userEvent.Discriminator} | {userEvent.UserId}");
return;
}
}
private async Task OnMemberAdded(GuildMemberAddEventArgs e)
{
var guild = e.Guild;
ulong tylerServer = 380871056757358592;
ulong gabeTeamServer = 736434039866785900;
ulong testServer = 714663062254256218;
if (guild.Id == tylerServer)
{
var roles = Client.Guilds.Values.FirstOrDefault(x => x.Name == "Tyler's Streaming Discord").Roles.Values;
var memberRole = roles.First(x => x.Name == "Viewers");
await e.Member.GrantRoleAsync(memberRole);
}
else if (guild.Id == gabeTeamServer)
{
var roles = Client.Guilds.Values.FirstOrDefault(x => x.Name == "Destiny Gods").Roles.Values;
var memberRole = roles.First(x => x.Name == "shittas");
await e.Member.GrantRoleAsync(memberRole);
}
else if (guild.Id == testServer)
{
var roles = Client.Guilds.Values.FirstOrDefault(x => x.Name == "Bot Testing").Roles.Values;
var memberRole = roles.First(x => x.Name == "Member");
await e.Member.GrantRoleAsync(memberRole);
}
}
private async Task Discord_GuildMemberAdded(GuildMemberAddEventArgs e)
{
if (e.Guild == RPClass.RPGuild)
{
DiscordEmbedBuilder b = new DiscordEmbedBuilder
{
Title = "Welcome!"
}
.AddField("Welcome to the Prometheus RP Server, " + e.Member.Username + "!", @"
Please read " + e.Guild.Channels.First(x => x.Id == 473596208565190659).Mention + @" then go for " + e.Guild.Channels.First(x => x.Id == 472503660174245908).Mention + @", followed by " + e.Guild.Channels.First(x => x.Id == 471840372717387787).Mention + @".
Then, once you have decided the character(and filled out the template), ask for an approval mod to give you a channel. If you have any questions ask in " + e.Guild.Channels.First(x => x.Id == 472512797096542236).Mention + @".
Hope you enjoy your time here " + e.Member.Mention + "!");
await e.Member.SendMessageAsync("", embed : b);
await RPClass.GeneralChannel.SendMessageAsync("", embed : b);
DiscordEmbedBuilder c = new DiscordEmbedBuilder
{
Title = "Member Joined",
Color = DiscordColor.Green
}
.AddField("Member", e.Member.DisplayName + "#" + e.Member.Discriminator + " (" + e.Member.Id + ")", true)
.AddField("Timestamp", e.Member.JoinedAt.ToString(), true);
await RPClass.LogChannel.SendMessageAsync(embed : c);
}
}
private Task NewMember(GuildMemberAddEventArgs e)
{
if (e.Client != Client)
{
var json = "";
if (!File.Exists("member.json"))
{
using (StreamWriter file = File.CreateText("member.json"))
{
JsonSerializer serializer = new JsonSerializer();
//serialize object directly into file stream
serializer.Serialize(file, @"{}");
}
}
using (var fs = File.OpenRead("member.json"))
using (var sr = new StreamReader(fs, new UTF8Encoding(false)))
json = sr.ReadToEnd();
// next, let's load the values from that file
// to our client's configuration
//var cfgjson = JsonConvert.DeserializeObject<ConfigMAL>(json);
var cfgjson = JsonConvert.DeserializeObject <List <ulong> >(json);
cfgjson.Add(e.Client.CurrentUser.Id);
using (StreamWriter file = File.CreateText("member.json"))
{
JsonSerializer serializer = new JsonSerializer();
//serialize object directly into file stream
serializer.Serialize(file, cfgjson);
}
}
return(Task.CompletedTask);
}
