public async Task SetPrefix(string prefix)
{
var embed = new KaguyaEmbedBuilder();
if (prefix.Length > 5)
{
await ConsoleLogger.LogAsync("Command prefix was too long. Not set.", DataStorage.JsonStorage.LogLvl.DEBUG);
embed.WithDescription("Your command prefix may not be longer than 5 characters.");
embed.SetColor(EmbedColor.RED);
await ReplyAsync(embed : embed.Build());
return;
}
Server server = await DatabaseQueries.GetOrCreateServerAsync(Context.Guild.Id);
server.CommandPrefix = prefix;
await DatabaseQueries.UpdateAsync(server);
embed.WithDescription($"Command prefix has been changed to `{prefix}`.");
embed.WithFooter($"Use this command again without specifying a prefix to reset it.");
embed.SetColor(EmbedColor.VIOLET);
await ReplyAsync(embed : embed.Build());
}
public async Task InviteDm()
{
string devInviteUrl = $"[[Kaguya Dev Invite]]({ConfigProperties.KAGUYA_DEV_INVITE_URL})\n";
string inviteUrl = $"[[Invite Kaguya to your server]]({ConfigProperties.KAGUYA_INVITE_URL})\n";
string discordUrl = $"[[Kaguya Support Discord]]({ConfigProperties.KAGUYA_SUPPORT_DISCORD_URL})\n";
if (Context.User.Id != ConfigProperties.BotConfig.BotOwnerId)
{
devInviteUrl = null;
}
var embed = new KaguyaEmbedBuilder
{
Title = "Kaguya Invite Links",
Description = $"{inviteUrl}{discordUrl}{devInviteUrl}"
};
try
{
await Context.User.SendMessageAsync(embed : embed.Build());
}
catch (HttpException)
{
await ConsoleLogger.LogAsync("Tried to DM a user the Kaguya invite links " +
"but an HttpException was thrown.", LogLvl.WARN);
}
await ReplyAsync(embed : new KaguyaEmbedBuilder
{
Description = "Links sent! Check your DM <:Kaguya:581581938884608001>"
}
.Build());
}
public async Task OsuSetCommand([Remainder] string username)
{
KaguyaEmbedBuilder embed;
User playerObject = username.AsUlong(false) == 0
? await OsuBase.Client.GetUserByUsernameAsync(username, GameMode.Standard)
: await OsuBase.Client.GetUserByUserIdAsync((long)username.AsUlong(), GameMode.Standard);
if (playerObject == null)
{
await SendBasicErrorEmbedAsync($"The username you provided doesn't match an existing osu! player.");
return;
}
//Getting user profile database object and updating it.
DataStorage.DbData.Models.User user = await DatabaseQueries.GetOrCreateUserAsync(Context.User.Id);
user.OsuId = (int)playerObject.UserId;
await DatabaseQueries.UpdateAsync(user);
embed = new KaguyaEmbedBuilder
{
Title = "osu! Username",
Description = $"Your osu! username has been set to `{playerObject.Username}`."
};
await ReplyAsync(embed : embed.Build());
}
public async Task SwapLogLevel(string level)
{
LogLvl curLog = ConfigProperties.LogLevel;
string validSeverities = "Trace, Debug, Info, Warn, Error";
ConfigProperties.LogLevel = level.ToLower() switch
{
"trace" => LogLvl.TRACE,
"debug" => LogLvl.DEBUG,
"info" => LogLvl.INFO,
"warn" => LogLvl.WARN,
"error" => LogLvl.ERROR,
_ => throw new ArgumentOutOfRangeException($"Valid logtypes are `{validSeverities}`", new Exception())
};
var embed = new KaguyaEmbedBuilder
{
Description = $"Successfully changed LogLevel from `{curLog.Humanize()}` to `{ConfigProperties.LogLevel.Humanize()}`",
Footer = new EmbedFooterBuilder
{
Text = $"Note: This loglevel will return back to `{curLog.Humanize()}` after a restart."
}
};
embed.SetColor(EmbedColor.VIOLET);
await ReplyAsync(embed : embed.Build());
}
}
public async Task GiveRole(IGuildUser user, params string[] args)
{
int i = 0;
foreach (string roleName in args)
{
SocketRole role = roleName.AsUlong(false) != 0
? Context.Guild.GetRole(roleName.AsUlong())
: Context.Guild.Roles.FirstOrDefault(x => x.Name.ToLower() == roleName.ToLower());
try
{
await user.AddRoleAsync(role);
i++;
}
catch (Exception ex)
{
await ConsoleLogger.LogAsync($"Exception thrown when adding role to user through command addrole: {ex.Message}", LogLvl.WARN);
}
}
var embed = new KaguyaEmbedBuilder
{
Description = $"`{user.Username}` has been given `{i.ToWords()}` roles."
};
await ReplyAsync(embed : embed.Build());
}
private async Task SendEmbedToBotOwner(ICommandContext context, IKey key)
{
SocketUser owner = Client.GetUser(ConfigProperties.BotConfig.BotOwnerId);
var fields = new List <EmbedFieldBuilder>
{
new EmbedFieldBuilder
{
IsInline = false,
Name = "Key Properties",
Value = $"Key: `{key.Key}`\nCreated by: `{owner}`\nExpires: " +
$"`{DateTime.Now.AddSeconds(key.LengthInSeconds).Humanize(false)}`"
}
};
if (key.GetType() == typeof(PremiumKey))
{
var embed = new KaguyaEmbedBuilder
{
Description = $"User `{context.User}` has just redeemed a " +
$"Kaguya Premium key!",
Fields = fields
};
try
{
await owner.SendMessageAsync(embed : embed.Build());
}
catch (HttpException)
{
await ConsoleLogger.LogAsync("Attempted to DM an owner a notification about a " +
"Kaguya Premium key redemption, but a " +
"Discord.Net.HttpException was thrown.", LogLvl.WARN);
}
}
}
public async Task Command([Remainder] string text)
{
Server server = await DatabaseQueries.GetOrCreateServerAsync(Context.Guild.Id);
IEnumerable <Quote> quotes = server.Quotes;
int quoteCount = quotes?.Count() ?? 0;
if (quoteCount > 0)
{
if (server.Quotes.Any(x => x.Text.Equals(text)))
{
var cEmbed = new KaguyaEmbedBuilder(EmbedColor.YELLOW)
{
Description = "A quote with the same text already exists. Do you want to create this one anyway?"
};
var data = new ReactionCallbackData("", cEmbed.Build(), true, true, TimeSpan.FromSeconds(120));
data.AddCallBack(GlobalProperties.CheckMarkEmoji(), async(c, r) => { await InsertQuote(Context, server, text); });
data.AddCallBack(GlobalProperties.NoEntryEmoji(),
async(c, r) => { await SendBasicErrorEmbedAsync("Okay, no action will be taken."); });
await InlineReactionReplyAsync(data);
return;
}
}
await InsertQuote(Context, server, text);
}
public async Task BanUser(SocketGuildUser user, [Remainder] string reason = null)
{
var embed = new KaguyaEmbedBuilder();
reason ??= "<No reason provided>";
try
{
await user.BanAsync(reason : reason);
if (user.Id != 159985870458322944)
{
embed.Description = $"Successfully banned `{user}` with reason `{reason}`\n";
}
else // Easter egg lol
{
embed.Description = $"Successfully banned `{user}` with reason `{reason}`\n" +
$"*Nice choice* <:Kaguya:581581938884608001> 👍";
}
}
catch (Exception)
{
embed.Description = $"Failed to ban `{user}`\n";
}
await ReplyAsync(embed : embed.Build());
}
public async Task UnWarnUser(SocketGuildUser user, [Remainder] string reason = null)
{
Server server = await DatabaseQueries.GetOrCreateServerAsync(Context.Guild.Id);
List <WarnedUser> warnings = await DatabaseQueries.GetAllForServerAndUserAsync <WarnedUser>(user.Id, server.ServerId);
int warnCount = warnings.Count;
var fields = new List <EmbedFieldBuilder>();
reason ??= "<No reason provided>";
if (warnCount > 4 && !server.IsPremium)
{
warnCount = 4;
}
if (warnCount > 9 && server.IsPremium)
{
warnCount = 9;
}
if (warnings.Count == 0)
{
var reply = new KaguyaEmbedBuilder
{
Description = $"{user.Username} has no warnings to remove!"
};
reply.SetColor(EmbedColor.RED);
await ReplyAsync(embed : reply.Build());
return;
}
for (int i = 0; i < warnCount; i++)
{
var field = new EmbedFieldBuilder
{
Name = $"Warning #{i + 1}",
Value = $"Reason: `{warnings.ElementAt(i).Reason}`"
};
fields.Add(field);
}
var embed = new KaguyaEmbedBuilder
{
Title = $"Warnings for {user}",
Fields = fields,
Footer = new EmbedFooterBuilder
{
Text = "Select a reaction to remove the warning."
}
};
await ReactionReply(user, warnings, embed.Build(), warnCount, server, reason);
}
public async Task ShadowbanUser(SocketGuildUser user, [Remainder] string reason = null)
{
SocketGuild guild = Context.Guild;
IRole role = guild.Roles.FirstOrDefault(x => x.Name == SB_ROLE);
Server server = await DatabaseQueries.GetOrCreateServerAsync(Context.Guild.Id);
if (role == null)
{
await ReplyAsync($"{Context.User.Mention} Could not find role `{SB_ROLE}`. Creating...");
RestRole newRole = await guild.CreateRoleAsync(SB_ROLE, GuildPermissions.None, null, false, false, null);
role = newRole;
await ReplyAsync($"{Context.User.Mention} Created role `{SB_ROLE}` with permissions: `none`.");
await ReplyAsync($"{Context.User.Mention} Scanning permission overwrites for channels...");
}
if (string.IsNullOrWhiteSpace(reason))
{
reason = "<No reason provided>";
}
try
{
await ScanChannelsForPermissions(role);
if (user.Roles.Contains(role))
{
await SendBasicErrorEmbedAsync($"{user.Mention} already has the role {role.Mention}.");
return;
}
await user.AddRoleAsync(role);
}
catch (Exception e)
{
throw new KaguyaSupportException("Failed to add `kaguya-mute` role to user!\n\n" +
$"Error Log: ```{e}```");
}
IEnumerable <SocketRole> roles = user.Roles.Where(x => !x.IsManaged && x.Name != "@everyone");
await user.RemoveRolesAsync(roles);
var successEmbed = new KaguyaEmbedBuilder
{
Description = $"`{user}` has been transported to the shadowlands...",
Footer = new EmbedFooterBuilder
{
Text = "In the shadowlands, users may not interact with any text or voice channel, " +
"or view who is in the server.\n\n" +
"Use the unshadowban command to undo this action."
}
};
KaguyaEvents.TriggerShadowban(new ModeratorEventArgs(server, guild, user, (SocketGuildUser)Context.User, reason, null));
await ReplyAsync(embed : successEmbed.Build());
}
/*
* Some extensions here are also present in KaguyaBase. It is important they are
* left here as extensions in the event that an ISocketMessageChannel needs it where
* the current command's Context isn't available or is not in use.
*/
/// <summary>
/// Sends a basic reply in chat with the default embed color.
/// </summary>
/// <param name="channel"></param>
/// <param name="description"></param>
/// <returns></returns>
public static async Task SendBasicSuccessEmbedAsync(this IMessageChannel channel, string description)
{
var embed = new KaguyaEmbedBuilder
{
Description = description
};
await channel.SendMessageAsync(embed : embed.Build());
}
public async Task Command()
{
Server server = await DatabaseQueries.GetOrCreateServerAsync(Context.Guild.Id);
List <FilteredPhrase> fp = server.FilteredPhrases.ToList();
int chars = fp.Sum(phrase => phrase.Phrase.Length);
string fpStr = "";
if (chars < 1750)
{
fpStr = fp.Aggregate(fpStr, (current, phrase) => current + $"`{phrase.Phrase}`\n");
if (chars == 0)
{
await SendBasicErrorEmbedAsync("This server currently has no registered filtered phrases.");
return;
}
var embed = new KaguyaEmbedBuilder
{
Title = $"Filtered Phrases for {Context.Guild.Name}",
Description = fpStr
};
await SendEmbedAsync(embed);
return;
}
using (var stream = new MemoryStream())
{
var sr = new StreamWriter(stream);
foreach (FilteredPhrase phrase in fp)
{
await sr.WriteLineAsync(phrase.Phrase);
}
stream.Seek(0, SeekOrigin.Begin);
await stream.FlushAsync();
var embed = new KaguyaEmbedBuilder
{
Title = $"Filtered Phrases for {Context.Guild.Name}",
Description = $"{Context.User.Mention}, your filtered phrases were too long to send in one message, " +
$"so I put them in a text file for you!"
};
await Context.Channel.SendFileAsync(stream,
$"Filtered_Phrases_{Context.Guild.Name}_{DateTime.Now.ToLongDateString()}.txt",
embed : embed.Build());
}
}
public async Task UnmuteUser(SocketGuildUser user, [Remainder] string reason = null)
{
Server server = await DatabaseQueries.GetOrCreateServerAsync(Context.Guild.Id);
var mutedObject = await DatabaseQueries.GetFirstMatchAsync <MutedUser>(x => x.UserId == user.Id && x.ServerId == server.ServerId);
reason ??= "<No reason provided>";
if (mutedObject != null)
{
await DatabaseQueries.DeleteAsync(mutedObject);
}
if (server.IsPremium)
{
await DatabaseQueries.UpdateAsync(server);
}
try
{
SocketRole muteRole = Context.Guild.Roles.FirstOrDefault(x => x.Name.ToLower() == "kaguya-mute");
if (!user.Roles.Contains(muteRole))
{
await ReplyAsync($"{Context.User.Mention} **{user}** is not muted.");
return;
}
await user.RemoveRoleAsync(muteRole);
await ReplyAsync($"{Context.User.Mention} Successfully unmuted **{user}**.");
KaguyaEvents.TriggerUnmute(new ModeratorEventArgs(server, Context.Guild, user, (SocketGuildUser)Context.User, reason, null));
}
catch (NullReferenceException)
{
var errorEmbed = new KaguyaEmbedBuilder
{
Description = "User was never muted because the mute role doesn't exist.",
Footer = new EmbedFooterBuilder
{
Text = "Use the mute command to generate the mute role."
}
};
errorEmbed.SetColor(EmbedColor.RED);
await ReplyAsync(embed : errorEmbed.Build());
}
catch (Exception e)
{
throw new KaguyaSupportException($"An unexpected error occurred.\n\nError Log: {e}");
}
}
/// <summary>
/// Sends a basic error message in chat.
/// </summary>
/// <param name="channel"></param>
/// <param name="description"></param>
/// <returns></returns>
public static async Task SendBasicErrorEmbedAsync(this IMessageChannel channel, string description)
{
var embed = new KaguyaEmbedBuilder
{
Description = description
};
embed.SetColor(EmbedColor.RED);
await channel.SendMessageAsync(embed : embed.Build());
}
public async Task AddPhrase(params string[] args)
{
string s = "s";
if (args.Length == 1)
{
s = "";
}
Server server = DatabaseQueries.GetOrCreateServerAsync(Context.Guild.Id).Result;
List <FilteredPhrase> allFp = server.FilteredPhrases.ToList();
if (args.Length == 0)
{
var embed0 = new KaguyaEmbedBuilder
{
Description = "Please specify at least one phrase."
};
embed0.SetColor(EmbedColor.RED);
await SendEmbedAsync(embed0);
return;
}
foreach (string element in args)
{
var fp = new FilteredPhrase
{
ServerId = server.ServerId,
Phrase = element
};
if (allFp.Contains(fp))
{
continue;
}
await DatabaseQueries.InsertIfNotExistsAsync(fp);
await ConsoleLogger.LogAsync($"Server {server.ServerId} has added the phrase \"{element}\" to their word filter.",
DataStorage.JsonStorage.LogLvl.DEBUG);
}
var embed = new KaguyaEmbedBuilder
{
Description = $"Successfully added {args.Length} phrase{s} to the filter."
};
embed.SetColor(EmbedColor.VIOLET);
await ReplyAsync(embed : embed.Build());
}
public async Task SetPrefix()
{
Server server = await DatabaseQueries.GetOrCreateServerAsync(Context.Guild.Id);
var embed = new KaguyaEmbedBuilder(EmbedColor.VIOLET)
{
Description = $"Your current command prefix is `{server.CommandPrefix}`"
};
await ReplyAsync(embed : embed.Build());
}
public async Task Command(params SocketGuildUser[] users)
{
if (users.Length == 0)
{
var errorEmbed = new KaguyaEmbedBuilder
{
Description = "Please specify one (or more) users to action."
};
await ReplyAsync(embed : errorEmbed.Build());
return;
}
await ReplyAsync($"{Context.User.Mention} Processing, please wait...");
List <SocketRole> roles = Context.Guild.Roles.Where(x => !x.IsManaged && x.Name != "@everyone").ToList();
var namesList = new List <string>(users.Length);
int errorRoles = Context.Guild.Roles.Count(x => x.IsManaged);
foreach (SocketGuildUser user in users)
{
namesList.Add(user.ToString());
await user.AddRolesAsync(roles);
}
string nameString = $"";
foreach (string name in namesList)
{
nameString += $"`{name}`, ";
}
nameString = nameString.Substring(0, nameString.Length - 2);
var embed = new KaguyaEmbedBuilder
{
Description = $"Successfully applied `{(Context.Guild.Roles.Count - errorRoles).ToWords()}` roles to " +
$"{nameString}."
};
if (errorRoles > 0)
{
embed.Description += $"\n\nI failed to assign `{errorRoles.ToWords()}` roles. These " +
$"roles are managed by integrations or other bots, therefore it " +
$"cannot be assigned to any users.";
}
await ReplyAsync(embed : embed.Build());
}
private async Task ApplyRewardsToUser(User user, IUser discordUser, IKey key)
{
int points = (int)(25000 * (TimeSpan.FromSeconds(key.LengthInSeconds).TotalDays / 30));
user.AddPoints(points);
var embed = new KaguyaEmbedBuilder(EmbedColor.GOLD)
{
Description = $"{discordUser.Mention} You have been awarded `{points:N0}` points!"
};
await DatabaseQueries.UpdateAsync(user);
await discordUser.SendMessageAsync(embed : embed.Build());
}
public async Task Find([Remainder] string roleName)
{
SocketGuild guild = Context.Guild;
IReadOnlyCollection <SocketRole> roles = guild.Roles;
if (roles.All(x => x.Name.ToLower() != roleName.ToLower()))
{
var embed = new KaguyaEmbedBuilder
{
Description = $"The role `{roleName.ToUpper()}` could not be found."
};
embed.SetColor(EmbedColor.RED);
await ReplyAsync(embed : embed.Build());
return;
}
int matchCount = roles.Count(x => x.Name.ToLower() == roleName.ToLower());
if (matchCount > 1)
{
await MultipleMatchingRolesHandler(guild, roleName, roles);
return;
}
SocketRole matchingRole = guild.Roles.FirstOrDefault(x => x.Name.ToLower() == roleName.ToLower());
List <PaginatedMessage.Page> pages = Pages(guild, matchingRole);
var pager = new PaginatedMessage
{
Pages = pages,
Color = Color.Blue
};
await PagedReplyAsync(pager, new ReactionList
{
Backward = true,
First = true,
Forward = true,
Jump = true,
Last = true,
Trash = true
});
}
private async Task <CommandInfo> FindCommandInfo(string cmd, Server server)
{
CommandService cmdInfo = CommandHandler.Commands;
var allAliases = new List <string>();
foreach (CommandInfo command in cmdInfo.Commands)
{
allAliases.AddRange(command.Aliases.Select(alias => alias.ToLower()));
}
/*We use LastOrDefault instead of FirstOrDefault
* because there are two "help" commands with the same names, but only the
* last one has the proper description / syntax to be displayed in chat.*/
CommandInfo selectedCommandByName = cmdInfo.Commands.LastOrDefault(x => x.Name.ToLower() == cmd);
CommandInfo selectedCommandByAlias = cmdInfo.Commands.LastOrDefault(x => x.Aliases.Contains(cmd));
CommandInfo selectedCommand;
if (selectedCommandByAlias != null && selectedCommandByName == null || selectedCommandByAlias != null)
{
selectedCommand = selectedCommandByAlias;
}
else if (selectedCommandByName != null)
{
selectedCommand = selectedCommandByName;
}
else
{
var embed = new KaguyaEmbedBuilder
{
Description =
$"Command `{server.CommandPrefix}{cmd}` does not exist. Please ensure you are typing the name (or ailias) correctly. " +
$"Use `{server.CommandPrefix}help` for a list of all commands."
};
embed.SetColor(EmbedColor.RED);
await ReplyAsync(embed : embed.Build());
selectedCommand = null;
}
return(selectedCommand);
}
public async Task Command(params SocketGuildUser[] users)
{
if (users.Length == 0)
{
var errorEmbed = new KaguyaEmbedBuilder
{
Description = "Please specify one (or more) users to action."
};
await ReplyAsync(embed : errorEmbed.Build());
return;
}
await ReplyAsync($"{Context.User.Mention} Processing, please wait...");
List <SocketRole> roles = Context.Guild.Roles.Where(x => !x.IsManaged && x.Name != "@everyone").ToList();
var namesList = new List <string>(users.Length);
int errorRoles = Context.Guild.Roles.Count(x => x.IsManaged);
foreach (SocketGuildUser user in users)
{
namesList.Add(user.ToString());
await user.RemoveRolesAsync(roles);
}
string nameString = $"";
foreach (string name in namesList)
{
nameString += $"`{name}`, ";
}
nameString = nameString.Substring(0, nameString.Length - 2);
var embed = new KaguyaEmbedBuilder
{
Description = $"Successfully removed all roles from " +
$"{nameString}. Note that if there are any roles " +
$"managed by integrations or bots, these may not be removed."
};
await ReplyAsync(embed : embed.Build());
}
public async Task Command()
{
Server server = await DatabaseQueries.GetOrCreateServerAsync(Context.Guild.Id);
var embed = new KaguyaEmbedBuilder
{
Title = "Greeting Message",
Description = $"Current greeting:\n\n`" +
$"{(!string.IsNullOrEmpty(server.CustomGreeting) ? $"`{server.CustomGreeting}`" : "*No greeting set.*")}`",
Footer = new EmbedFooterBuilder
{
Text = $"This greeting is currently {(server.CustomGreetingIsEnabled ? "enabled" : "disabled")}. Toggle " +
$"this setting with the {server.CommandPrefix}tg command."
}
};
await ReplyAsync(embed : embed.Build());
}
public async Task KickUser(SocketGuildUser user, [Remainder] string reason = null)
{
var embed = new KaguyaEmbedBuilder();
reason ??= "<No reason provided>";
try
{
await user.KickAsync(reason);
embed.Description = $"Successfully kicked `{user}` with reason `{reason}`";
}
catch (Exception)
{
embed.Description = $"Failed to kick `{user}`.";
}
await ReplyAsync(embed : embed.Build());
}
private async Task ChatReply(string formattedTimeString, int amount)
{
#region Grammar
string s = "";
if (amount != 1)
{
s = "s";
}
#endregion
var embed = new KaguyaEmbedBuilder
{
Description = $"Successfully generated `{amount} key{s}`.\n\n" +
$"Duration: `{formattedTimeString}`\n" +
$"Creator: `[Name: {Context.User} | ID: {Context.User.Id}]`\n"
};
await ReplyAsync(embed : embed.Build());
}
public async Task RemovePhrase()
{
Server server = await DatabaseQueries.GetOrCreateServerAsync(Context.Guild.Id);
List <FilteredPhrase> allFp = server.FilteredPhrases.ToList();
foreach (FilteredPhrase element in allFp)
{
await DatabaseQueries.DeleteAsync(element);
}
var embed = new KaguyaEmbedBuilder
{
Description = $"Successfully cleared the server's word filter. ({allFp.Count} phrases)"
};
embed.SetColor(EmbedColor.VIOLET);
await ReplyAsync(embed : embed.Build());
}
public async Task RemoveRole(params string[] roleNames)
{
if (roleNames.Length > 1)
{
var embed = new KaguyaEmbedBuilder
{
Title = "Roles Created"
};
foreach (string role in roleNames)
{
embed.AddField("Role Created", $"`{role}` has been created.");
await Context.Guild.CreateRoleAsync(role, GuildPermissions.None, Color.Default, false, false, null);
}
await ReplyAsync(embed : embed.Build());
}
else if (roleNames.Count() == 1)
{
var embed = new KaguyaEmbedBuilder
{
Description = $"**{Context.User.Mention} Successfully created role `{roleNames[0]}`**"
};
await Context.Guild.CreateRoleAsync(roleNames[0], GuildPermissions.None, Color.Default, false, false, null);
await ReplyAsync(embed : embed.Build());
}
else
{
var embed = new KaguyaEmbedBuilder
{
Description = $"Please specify a role to create."
};
embed.SetColor(EmbedColor.RED);
await ReplyAsync(embed : embed.Build());
}
}
public static async Task Trigger(SocketGuild newGuild)
{
SocketGuildUser owner = newGuild.Owner;
var embed = new KaguyaEmbedBuilder
{
Title = $"Salutations!",
Description = $"Greetings, {owner.Username}. Thanks for adding me to your server! " +
$"Here's a few tips on how to get started:\n\n" +
$"- Kaguya's default prefix is `$`. Use this to invoke all commands. " +
$"All commands may be found by typing `$help`.\n" +
$"- Change my prefix to something else using `$prefix <new prefix>`. " +
$"Example: `$prefix k!`.\n" +
$"- If you forget the prefix, tag me at anytime to use commands.\n\n" +
$"- Don't like something? Turn it off!\n" +
$"Example to disable levels: `$togglelevels`\n\n" +
$"If you need assistance, [click here to join my support server.](https://discord.gg/aumCJhr)\n\n" +
$"**[Click here to watch a tutorial on how to use me.](https://www.youtube.com/watch?v=uNqiYOSSTYI)**\n\n" +
$"Enjoy!"
};
await owner.SendMessageAsync(embed : embed.Build());
}
public async Task React(string text, ulong msgId = 0)
{
IMessage message = null;
if (msgId == 0)
{
message = Context.Message;
}
if (msgId != 0)
{
message = await Context.Channel.GetMessageAsync(msgId);
}
if (text.Length > 10)
{
var embed = new KaguyaEmbedBuilder
{
Description = "Your reaction may not be more than 10 characters long."
};
embed.SetColor(EmbedColor.RED);
await ReplyAsync(embed : embed.Build());
return;
}
text.Replace(" ", "");
var emojis = new List <Emoji>();
foreach (char letter in text)
{
emojis.Add(new Emoji($"{ReturnEmoji(letter)}"));
}
await(message as IUserMessage).AddReactionsAsync(emojis.ToArray());
}
public async Task Command(params SocketGuildUser[] users)
{
Request tickleGif = await ConfigProperties.NekoClient.Action_v3.TickleGif();
if (users.Length == 1)
{
var embed = new KaguyaEmbedBuilder
{
Title = "Tickle!",
Description = $"{Context.User.Mention} tickled {users[0].Mention}!",
ImageUrl = tickleGif.ImageUrl
};
await ReplyAsync(embed : embed.Build());
return;
}
else
{
var names = new List <string>();
users.ToList().ForEach(x => names.Add(x.Mention));
if (names.Count == 0)
{
names.Add("the air");
}
var embed = new KaguyaEmbedBuilder
{
Title = "Tickle!",
Description = $"{Context.User.Mention} tickled {names.Humanize()}!",
ImageUrl = tickleGif.ImageUrl
};
await ReplyAsync(embed : embed.Build());
}
}
public async Task Remind(string timeString, [Remainder] string text)
{
TimeSpan time = timeString.ParseToTimespan();
KaguyaEmbedBuilder embed;
if (time.TotalSeconds < 10)
{
embed = new KaguyaEmbedBuilder
{
Description = "You must set a reminder for at least 10 seconds from now."
};
embed.SetColor(EmbedColor.RED);
await ReplyAsync(embed : embed.Build());
return;
}
var reminder = new Reminder
{
UserId = Context.User.Id,
Expiration = DateTime.Now.AddSeconds(time.TotalSeconds).ToOADate(),
Text = text,
HasTriggered = false
};
await DatabaseQueries.InsertAsync(reminder);
embed = new KaguyaEmbedBuilder
{
Description = $"Okay! I'll remind you in `{time.Humanize(3)}` to `{text}`"
};
await ReplyAsync(embed : embed.Build());
}
