Task XPHandlerAsync(SocketMessage Message, GuildModel Config)
{
var User = Message.Author as IGuildUser;
var GetTime = XPUserList.ContainsKey(User.Id) ? XPUserList[User.Id] : DateTime.UtcNow;
var BlacklistedRoles = new List <ulong>(Config.ChatXP.ForbiddenRoles.Select(x => x));
var HasRole = (User as IGuildUser).RoleIds.Intersect(BlacklistedRoles).Any();
if (HasRole || !Config.ChatXP.IsEnabled || !(GetTime.AddSeconds(60) > DateTime.UtcNow))
{
return(Task.CompletedTask);
}
var Profile = GuildHelper.GetProfile(User.GuildId, User.Id);
int Old = Profile.ChatXP;
Profile.ChatXP += Random.Next(Message.Content.Length);
var New = Profile.ChatXP;
GuildHelper.SaveProfile(Convert.ToUInt64(Config.Id), User.Id, Profile);
if (XPUserList.ContainsKey(User.Id))
{
XPUserList.Remove(User.Id);
}
XPUserList.Add(User.Id, DateTime.UtcNow);
return(LevelUpHandlerAsync(Message, Config, Old, New));
}
public async Task SetupAsync()
{
//VARIABLES
var guild = Context.Guild;
List <Reaction> reactions = new List <Reaction>();
List <Mute> mutes = new List <Mute>();
List <UserWarning> warnings = new List <UserWarning>();
CustomAnnouncement customAnnouncement = new CustomAnnouncement();
GuildInfo guildInfo = new GuildInfo
{
ServerName = guild.Name,
CreationDate = guild.CreatedAt.ToString(),
Creator = $"{guild.Owner.Username}#{guild.Owner.Discriminator}",
CreatorId = guild.OwnerId,
BannerURL = guild.BannerUrl
};
GuildModel newGuild = new GuildModel
{
GuildID = guild.Id.ToString(),
GuildInfo = guildInfo,
Mutes = mutes,
Reactions = reactions,
UserWarnings = warnings,
CustomAnnouncement = customAnnouncement
};
//Run the InitServer method which inputs the server into the database
MongoCRUD.Instance.InitServer(newGuild);
//Reply with setup is complete if it doesnt break
await ReplyAsync("Setup complete");
}
internal Task XPHandler(SocketMessage message, GuildModel config)
{
var user = message.Author as IGuildUser;
var blacklistedRoles = new List <ulong>(config.ChatXP.XPBlockedRoles.Select(x => x));
var hasRole = (user as IGuildUser).RoleIds.Intersect(blacklistedRoles).Any();
if (hasRole || !config.ChatXP.IsEnabled)
{
return(Task.CompletedTask);
}
var profile = GuildHelper.GetProfile(user.GuildId, user.Id);
int old = 0, newer = 0;
if (!profile.LastMessage.HasValue)
{
profile.LastMessage = DateTime.UtcNow;
profile.ChatXP += Random.Next(10, 21);
}
else
{
if (DateTime.UtcNow - profile.LastMessage.Value >= TimeSpan.FromMinutes(2))
{
old = profile.ChatXP;
profile.ChatXP += Random.Next(10, 21);
profile.LastMessage = DateTime.UtcNow;
newer = profile.ChatXP;
}
}
GuildHelper.SaveProfile(Convert.ToUInt64(config.Id), user.Id, profile);
return(LevelUpHandlerAsync(message, config, old, newer));
}
public IActionResult PlayerDetails(GuildModel GuildRealmResponce)
{
AccessToken token = ApiMethods.authMethods.GetAccessToken();
ViewBag.PlayerInformation = ApiMethods.getPlayerInfo.getPlayerinfo(token, GuildRealmResponce.guildName, GuildRealmResponce.guildRealm, GuildRealmResponce.guildRegion);
return(View());
}
private async Task GuildJoin(SocketGuild guild)
{
//Creating the variables we need for the setup command
List <Reaction> reactions = new List <Reaction>();
List <Mute> mutes = new List <Mute>();
List <UserWarning> warnings = new List <UserWarning>();
CustomAnnouncement customAnnouncement = new CustomAnnouncement();
GuildInfo guildInfo = new GuildInfo
{
ServerName = guild.Name,
CreationDate = guild.CreatedAt.ToString(),
Creator = $"{guild.Owner.Username}#{guild.Owner.Discriminator}",
CreatorId = guild.OwnerId,
BannerURL = guild.BannerUrl
};
GuildModel newGuild = new GuildModel
{
GuildID = guild.Id.ToString(),
GuildInfo = guildInfo,
Mutes = mutes,
Reactions = reactions,
UserWarnings = warnings,
CustomAnnouncement = customAnnouncement
};
//Run the init server method which inputs the server into the database
MongoCRUD.Instance.InitServer(newGuild);
await Task.CompletedTask;
}
public IActionResult GuildSearchForm(GuildModel GuildRealmResponce)
{
AccessToken token = ApiMethods.authMethods.GetAccessToken();
ViewBag.MembersDictionary = ApiMethods.GetGuildMembers.getMembersDictionary(token, GuildRealmResponce.guildName, GuildRealmResponce.guildRealm, GuildRealmResponce.guildRegion);
return(View());
}
async Task WarnUserAsync(SocketUserMessage message, GuildModel config, string warning)
{
var guild = (message.Author as SocketGuildUser).Guild;
if (config.Mod.MaxWarnings == 0 || message.Author.Id == guild.OwnerId)
{
return;
}
await message.DeleteAsync();
var profile = GuildHelper.GetProfile(guild.Id, message.Author.Id);
if (profile.Warnings >= config.Mod.MaxWarnings)
{
await(message.Author as SocketGuildUser).KickAsync("Kicked By AutoMod.");
await guild.GetTextChannel(config.Mod.TextChannel).SendMessageAsync(
$"**Kick** | Case {config.Mod.Cases.Count + 1}\n**User:** {message.Author} ({message.Author.Id})\n**Reason:** Reached max warnings.\n" +
$"**Responsible Moderator:** {Client.CurrentUser}"
);
}
else
{
profile.Warnings++;
GuildHelper.SaveProfile(guild.Id, message.Author.Id, profile);
}
await message.Channel.SendMessageAsync(warning);
}
async Task WarnUserAsync(SocketUserMessage Message, GuildModel Config, string Warning)
{
var Guild = (Message.Author as SocketGuildUser).Guild;
if (Config.Mod.MaxWarnings == 0 || Message.Author.Id == Guild.OwnerId)
{
return;
}
await Message.DeleteAsync();
var Profile = GuildHelper.GetProfile(Guild.Id, Message.Author.Id);
if (Profile.Warnings >= Config.Mod.MaxWarnings)
{
await(Message.Author as SocketGuildUser).KickAsync("Kicked By AutoMod.");
await Guild.GetTextChannel(Config.Mod.TextChannel).SendMessageAsync(
$"**Kick** | Case {Config.Mod.Cases.Count + 1}\n**User:** {Message.Author} ({Message.Author.Id})\n**Reason:** Reached Max Warnings.\n" +
$"**Responsible Moderator:** {Client.CurrentUser}");
await GuildHelper.LogAsync(Guild, Message.Author, Client.CurrentUser, CaseType.Kick, Warning);
}
else
{
Profile.Warnings++;
GuildHelper.SaveProfile(Guild.Id, Message.Author.Id, Profile);
await GuildHelper.LogAsync(Guild, Message.Author, Client.CurrentUser, CaseType.Warning, Warning);
}
await Message.Channel.SendMessageAsync(Warning);
}
async Task CleverbotHandlerAsync(SocketMessage Message, GuildModel Config)
{
string UserMessage = Message.Content.ToLower().Replace("valerie", string.Empty);
if (!Message.Content.ToLower().StartsWith("valerie") || string.IsNullOrWhiteSpace(UserMessage) ||
Message.Channel.Id != Config.CleverbotWebhook.TextChannel)
{
return;
}
Response CleverResponse;
if (!CleverbotTracker.ContainsKey(Config.CleverbotWebhook.TextChannel))
{
CleverResponse = await ConfigHandler.Cookie.Cleverbot.TalkAsync(UserMessage);
CleverbotTracker.Add(Config.CleverbotWebhook.TextChannel, CleverResponse);
}
else
{
CleverbotTracker.TryGetValue(Config.CleverbotWebhook.TextChannel, out CleverResponse);
CleverResponse = await ConfigHandler.Cookie.Cleverbot.TalkAsync(UserMessage);
CleverbotTracker[Config.CleverbotWebhook.TextChannel] = CleverResponse;
}
await WebhookService.SendMessageAsync(new WebhookOptions
{
Message = CleverResponse.CleverOutput,
Name = "Cleverbot",
Webhook = Config.CleverbotWebhook
});
}
internal RestPartialGuild(RestDiscordClient client, GuildModel model) : base(client, model.Id)
{
Name = model.Name.Value;
IconHash = model.Icon.Value;
Features = model.Features.Value.ReadOnly();
IsOwner = model.Owner.Value;
Permissions = model.Permissions.Value;
}
internal Task RunTasks(SocketMessage Message, GuildModel Config)
{
XPHandlerAsync(Message, Config);
ExecuteTagAsync(Message, Config);
AFKHandlerAsync(Message, Config);
CleverbotHandlerAsync(Message, Config).ConfigureAwait(false);
ModeratorAsync(Message as SocketUserMessage, Config);
return(Task.CompletedTask);
}
public static GuildMemberModel FromDbObject(Entity.guild_members dbObject) => dbObject != null
? new GuildMemberModel
{
Id = dbObject.pk_id,
Guild = GuildModel.FromDbObject(dbObject.guild),
Player = PlayerModel.FromDbObject(dbObject.player)
}
: null;
public static async Task JoinedGuildAsync(SocketGuild Guild)
{
var CreateConfig = new GuildModel();
if (!GuildHandler.GuildConfigs.ContainsKey(Guild.Id))
{
GuildHandler.GuildConfigs.Add(Guild.Id, CreateConfig);
}
await GuildHandler.SaveAsync(GuildHandler.GuildConfigs);
}
internal static async Task HandleGuildConfigAsync(SocketGuild guild)
{
var createConfig = new GuildModel();
if (!GuildHandler.GuildConfigs.ContainsKey(guild.Id))
{
GuildHandler.GuildConfigs.Add(guild.Id, createConfig);
}
await GuildHandler.SaveAsync(GuildHandler.GuildConfigs);
}
public async Task TempBan(
CommandContext ctx, DiscordMember user, string duration,
[RemainingText] string reason = "Not provided.")
{
SilkDbContext db = DbFactory.CreateDbContext();
DiscordMember bot = ctx.Guild.CurrentMember;
DateTime now = DateTime.Now;
TimeSpan banDuration = GetTimeFromInput(duration);
BanFailureReason? banFailed = CanBan(bot, ctx.Member, user);
DiscordEmbedBuilder embed =
new DiscordEmbedBuilder().WithAuthor(bot.Username, ctx.GetBotUrl(), ctx.Client.CurrentUser.AvatarUrl);
if (banFailed is not null)
{
await SendFailureMessage(ctx, user, embed, banFailed);
}
else
{
DiscordEmbedBuilder banEmbed = new DiscordEmbedBuilder()
.WithAuthor(ctx.User.Username, ctx.User.GetUrl(), ctx.User.AvatarUrl)
.WithDescription($"You've been temporarily banned from {ctx.Guild.Name} for {duration} days.")
.AddField("Reason:", reason);
await user.SendMessageAsync(embed : banEmbed);
await ctx.Guild.BanMemberAsync(user, 0, reason);
GuildModel guild = db.Guilds.First(g => g.Id == ctx.Guild.Id);
UserModel?bannedUser = db.Users.FirstOrDefault(u => u.Id == user.Id);
string formattedBanReason = InfractionFormatHandler.ParseInfractionFormat("temporarily banned",
banDuration.TotalDays + " days", user.Mention, reason, guild.Configuration.InfractionFormat ?? defaultFormat);
UserInfractionModel infraction = CreateInfraction(formattedBanReason, ctx.User.Id, now);
if (bannedUser is null)
{
bannedUser = new UserModel
{
Infractions = new List <UserInfractionModel>()
};
db.Users.Add(bannedUser);
bannedUser.Infractions.Add(infraction);
}
if (guild.Configuration.GeneralLoggingChannel != default)
{
embed.WithDescription(formattedBanReason);
embed.WithColor(DiscordColor.Green);
await ctx.Guild.GetChannel(guild.Configuration.GeneralLoggingChannel).SendMessageAsync(embed: embed);
}
EventService.Events.Add(new TimedInfraction(user.Id, ctx.Guild.Id, DateTime.Now.Add(banDuration),
reason, e => _ = OnBanExpiration((TimedInfraction)e)));
}
}
internal async Task ModeratorAsync(SocketUserMessage message, GuildModel config)
{
if (GuildHelper.ProfanityMatch(message.Content) && config.Mod.AntiProfanity)
{
await WarnUserAsync(message, config, $"{message.Author.Mention}, refrain from using profanity. You have been warned.");
}
if (GuildHelper.InviteMatch(message.Content) && config.Mod.AntiInvite)
{
await WarnUserAsync(message, config, $"{message.Author.Mention}, invite links are not allowed. You have been warned.");
}
}
public List <PlayerModel> GetGuildMembers(string guildName)
{
var getGuildModel = GuildModel.FromDbObject(_entities.guilds.FirstOrDefault(x => x.name.Equals(guildName)));
if (getGuildModel == null)
{
throw GuildNotFoundException.FromName(guildName);
}
return(_entities.guild_members.Include("player").Where(x => x.fk_guild == getGuildModel.Id).Select(x => x.player).ToList().Select(PlayerModel.FromDbObject).ToList());
}
Task ModeratorAsync(SocketUserMessage Message, GuildModel Config)
{
if (GuildHelper.ProfanityMatch(Message.Content) && Config.Mod.AntiProfanity)
{
return(WarnUserAsync(Message, Config, $"{Message.Author.Mention}, Refrain from using profanity. You've been warned."));
}
if (GuildHelper.InviteMatch(Message.Content) && Config.Mod.AntiInvite)
{
return(WarnUserAsync(Message, Config, $"{Message.Author.Mention}, No invite links allowed. You've been warned."));
}
return(Task.CompletedTask);
}
public bool ToggleBlackList(GuildModel guild, ulong channelId)
{
if (!guild.BlackListedChannels.Contains(channelId))
{
guild.BlackListedChannels.Add(channelId);
_database.Update <GuildModel>(guild.Id, guild);
return(true);
}
guild.BlackListedChannels.Remove(channelId);
_database.Update <GuildModel>(guild.Id, guild);
return(false);
}
internal async Task AFKHandlerAsync(SocketMessage message, GuildModel config)
{
if (!message.MentionedUsers.Any(x => config.AFK.ContainsKey(x.Id)))
{
return;
}
string reason = null;
var user = message.MentionedUsers.FirstOrDefault(u => config.AFK.TryGetValue(u.Id, out reason));
if (user != null)
{
await message.Channel.SendMessageAsync($"**{user.Username} has left an AFK Message:** {reason}");
}
}
internal Task ExecuteTag(SocketMessage message, GuildModel config)
{
if (!config.Tags.Any(x => x.AutoRespond == true))
{
return(Task.CompletedTask);
}
var tags = config.Tags.Where(x => x.AutoRespond == true);
var content = tags.FirstOrDefault(x => message.Content.StartsWith(x.Name));
if (content != null)
{
return(message.Channel.SendMessageAsync(content.Content));
}
return(Task.CompletedTask);
}
Task ExecuteTagAsync(SocketMessage Message, GuildModel Config)
{
if (!Config.Tags.Any(x => x.AutoRespond == true))
{
return(Task.CompletedTask);
}
var Tags = Config.Tags.Where(x => x.AutoRespond == true);
var Content = Tags.FirstOrDefault(x => Message.Content.StartsWith(x.Name));
if (Content != null)
{
return(Message.Channel.SendMessageAsync(Content.Content));
}
return(Task.CompletedTask);
}
Task AFKHandlerAsync(SocketMessage Message, GuildModel Config)
{
if (!Message.MentionedUsers.Any(x => Config.AFK.ContainsKey(x.Id)))
{
return(Task.CompletedTask);
}
string Reason = null;
var User = Message.MentionedUsers.FirstOrDefault(u => Config.AFK.TryGetValue(u.Id, out Reason));
if (User != null)
{
return(Message.Channel.SendMessageAsync($"**{User.Username} has left an AFK Message:** {Reason}"));
}
return(Task.CompletedTask);
}
public bool UpdateValue(ulong guildId, GuildModel model)
{
if (!guildCache.ContainsKey(guildId))
{
return(false);
}
guildCache[guildId] = model;
++updateCount;
if (updateCount > 100)
{
updateCount = 0;
SaveGuilds();
}
return(true);
}
public GuildModel GetGuildModel(ulong guildId)
{
guildCache.TryGetValue(guildId, out var guildModel1);
if (guildModel1 != null)
{
return(guildModel1);
}
GuildModel guildModel2 = DBHandler.Execute <GuildModel>(DatabaseHandler.Operation.LOAD, null, guildId.ToString());
if (guildModel2 == null)
{
return(null);
}
guildCache.TryAdd(guildId, guildModel2);
return(GetGuildModel(guildId));
}
internal Task XPHandler(SocketMessage message, GuildModel config)
{ // TODO: modify
var user = message.Author as IGuildUser;
var blacklistedRoles = new List <ulong>(config.ChatXP.XPBlockedRoles.Select(x => x));
var hasRole = (user as IGuildUser).RoleIds.Intersect(blacklistedRoles).Any();
if (hasRole || !config.ChatXP.IsEnabled)
{
return(Task.CompletedTask);
}
var profile = GuildHelper.GetProfile(user.GuildId, user.Id);
int old = profile.ChatXP;
profile.ChatXP += Random.Next(message.Content.Length);
var newer = profile.ChatXP;
GuildHelper.SaveProfile(Convert.ToUInt64(config.Id), user.Id, profile);
return(LevelUpHandlerAsync(message, config, old, newer));
}
async Task LevelUpHandlerAsync(SocketMessage message, GuildModel config, int oldXp, int newXp)
{
var user = message.Author as SocketGuildUser;
int oldLevel = IntHelper.GetLevel(oldXp);
int newLevel = IntHelper.GetLevel(newXp);
if (newLevel <= oldLevel)
{
return;
}
int credits = (int)Math.Sqrt(Math.PI * newXp);
var profile = GuildHelper.GetProfile(user.Guild.Id, user.Id);
profile.Credits += credits;
GuildHelper.SaveProfile(user.Guild.Id, user.Id, profile);
if (!string.IsNullOrWhiteSpace(config.ChatXP.LevelMessage))
{
await message.Channel.SendMessageAsync(StringHelper.Replace(config.ChatXP.LevelMessage, user: user.Username, level: newLevel, credits: credits));
}
if (!config.ChatXP.LeveledRoles.Any())
{
return;
}
var role = user.Guild.GetRole(config.ChatXP.LeveledRoles.Where(x => x.Value == newLevel).FirstOrDefault().Key);
if (user.Roles.Contains(role) || !user.Guild.Roles.Contains(role))
{
return;
}
await user.AddRoleAsync(role);
foreach (var lvlRole in config.ChatXP.LeveledRoles)
{
if (lvlRole.Value < newLevel)
{
if (user.Roles.Contains(user.Guild.GetRole(lvlRole.Key)))
{
await user.RemoveRoleAsync(user.Guild.GetRole(lvlRole.Key));
}
}
}
}
async Task LevelUpHandlerAsync(SocketMessage Message, GuildModel Config, int OldXp, int NewXp)
{
var User = Message.Author as SocketGuildUser;
int OldLevel = IntHelper.GetLevel(OldXp);
int NewLevel = IntHelper.GetLevel(NewXp);
if (!(NewLevel > OldLevel))
{
return;
}
int Crystals = (int)Math.Sqrt(Math.PI * NewXp);
var Profile = GuildHelper.GetProfile(User.Guild.Id, User.Id);
Profile.Crystals += Crystals;
GuildHelper.SaveProfile(User.Guild.Id, User.Id, Profile);
if (!string.IsNullOrWhiteSpace(Config.ChatXP.LevelMessage))
{
await Message.Channel.SendMessageAsync(StringHelper.Replace(Config.ChatXP.LevelMessage, User: $"{User}", Level: NewLevel, Crystals: Crystals));
}
if (!Config.ChatXP.LevelRoles.Any())
{
return;
}
var Role = User.Guild.GetRole(Config.ChatXP.LevelRoles.Where(x => x.Value == NewLevel).FirstOrDefault().Key);
if (User.Roles.Contains(Role) || !User.Guild.Roles.Contains(Role))
{
return;
}
await User.AddRoleAsync(Role);
foreach (var lvlrole in Config.ChatXP.LevelRoles)
{
if (lvlrole.Value < NewLevel)
{
if (!User.Roles.Contains(User.Guild.GetRole(lvlrole.Key)))
{
await User.AddRoleAsync(User.Guild.GetRole(lvlrole.Key));
}
}
}
}
public async Task SetPrefix(CommandContext ctx, string prefix)
{
SilkDbContext db = _dbFactory.CreateDbContext();
(bool valid, string reason) = IsValidPrefix(prefix);
if (!valid)
{
await ctx.RespondAsync(reason);
return;
}
GuildModel guild = db.Guilds.First(g => g.Id == ctx.Guild.Id);
guild.Prefix = prefix;
_prefixCache.UpdatePrefix(ctx.Guild.Id, prefix);
await db.SaveChangesAsync();
await ctx.RespondAsync($"Done! I'll respond to `{prefix}` from now on.");
}
/// <summary>
/// The user left event
/// </summary>
/// <param name="guildModel">
/// The guild Model.
/// </param>
/// <param name="user">
/// The user.
/// </param>
/// <returns>
/// The <see cref="Task" />.
/// </returns>
public static async Task UserLeftAsync(GuildModel guildModel, SocketGuildUser user)
{
if (guildModel.Events.Goodbye.Enabled)
{
var goodbyeEmbed = new EmbedBuilder {
Title = $"{user} has left the server", Description = $"{guildModel.Events.Goodbye.Message}"
};
if (user.Guild.GetChannel(guildModel.Events.Goodbye.ChannelID) is ITextChannel GChannel)
{
try
{
await GChannel.SendMessageAsync(user.Mention, false, goodbyeEmbed.Build());
}
catch
{
// Ignored
}
}
}
}
