private async Task Module_UserLeft(IDiscordUser arg)
{
if (await IsEnabled(arg.Guild.Id))
{
await MeruUtils.TryAsync(async() =>
{
await UserLeaveGuild(arg.Guild, arg);
});
}
}
private async Task Client_UserUpdated(IDiscordUser oldUser, IDiscordUser newUser)
{
using (var scope = MikiApp.Instance.Services.CreateScope())
{
if (oldUser.AvatarId != newUser.AvatarId)
{
await Utils.SyncAvatarAsync(newUser, scope.ServiceProvider.GetService <IExtendedCacheClient>(), scope.ServiceProvider.GetService <MikiDbContext>());
}
}
}
public async Task <List <EventMessageObject> > GetMessageAsync(
DbContext db, IDiscordGuild guild, EventMessageType type, IDiscordUser user)
{
var channels = (await guild.GetChannelsAsync()).ToList();
var channelIds = channels.Select(x => (long)x.Id);
IDiscordGuildUser owner = await guild.GetOwnerAsync();
var ownerMention = owner.Mention;
var ownerName = owner.Username;
List <EventMessageObject> output = new List <EventMessageObject>();
short t = (short)type;
var messageObjects = await db.Set <EventMessage>()
.Where(x => channelIds.Contains(x.ChannelId) && t == x.EventType)
.ToListAsync();
foreach (var c in messageObjects)
{
if (c == null)
{
continue;
}
if (string.IsNullOrEmpty(c.Message))
{
continue;
}
string modifiedMessage = c.Message;
modifiedMessage = modifiedMessage.Replace("-um", user.Mention);
modifiedMessage = modifiedMessage.Replace("-uc", guild.MemberCount.ToString());
modifiedMessage = modifiedMessage.Replace("-u", user.Username);
modifiedMessage = modifiedMessage.Replace("-now", DateTime.Now.ToShortDateString());
modifiedMessage = modifiedMessage.Replace("-s", guild.Name);
modifiedMessage = modifiedMessage.Replace("-om", ownerMention);
modifiedMessage = modifiedMessage.Replace("-o", ownerName);
modifiedMessage = modifiedMessage.Replace("-cc", channels.Count().ToString());
modifiedMessage = modifiedMessage.Replace("-vc", channels.Count().ToString());
output.Add(new EventMessageObject
{
Message = modifiedMessage,
DestinationChannel = channels.FirstOrDefault(
x => (long)x.Id == c.ChannelId) as IDiscordTextChannel
});
}
return(output);
}
public async Task AchievementsAsync(EventContext e)
{
using (var context = new MikiContext())
{
long id = (long)e.Author.Id;
ArgObject arg = e.Arguments.FirstOrDefault();
if (arg != null)
{
IDiscordUser user = await arg.TakeUntilEnd()
.GetUserAsync(e.Guild);
if (user != null)
{
id = (long)user.Id;
}
}
IDiscordUser discordUser = await e.Guild.GetUserAsync(id.FromDbLong());
User u = await User.GetAsync(context, discordUser);
List <Achievement> achievements = await context.Achievements
.Where(x => x.Id == id)
.ToListAsync();
EmbedBuilder embed = Utils.Embed
.SetAuthor($"{u.Name} | " + "Achievements", discordUser.GetAvatarUrl(), "https://miki.ai/profiles/ID/achievements");
embed.SetColor(255, 255, 255);
StringBuilder leftBuilder = new StringBuilder();
int totalScore = 0;
foreach (var a in achievements)
{
BaseAchievement metadata = AchievementManager.Instance.GetContainerById(a.Name).Achievements[a.Rank];
leftBuilder.AppendLine(metadata.Icon + " | `" + metadata.Name.PadRight(15) + $"{metadata.Points.ToString().PadLeft(3)} pts` | 📅 {a.UnlockedAt.ToShortDateString()}");
totalScore += metadata.Points;
}
if (string.IsNullOrEmpty(leftBuilder.ToString()))
{
embed.AddInlineField("Total Pts: " + totalScore, "None, yet.");
}
else
{
embed.AddInlineField("Total Pts: " + totalScore, leftBuilder.ToString());
}
embed.ToEmbed().QueueToChannel(e.Channel);
}
}
public async Task GuildInfoAsync(EventContext e)
{
IDiscordEmbed embed = Utils.Embed;
Locale l = Locale.GetEntity(e.Channel.Id.ToDbLong());
embed.SetAuthor(e.Guild.Name, e.Guild.AvatarUrl, e.Guild.AvatarUrl);
IDiscordUser owner = await e.Guild.GetOwnerAsync();
embed.AddInlineField(
"👑" + l.GetString("miki_module_general_guildinfo_owned_by"),
owner.Username + "#" + owner.Discriminator);
embed.AddInlineField(
"👉" + l.GetString("miki_label_prefix"),
await PrefixInstance.Default.GetForGuildAsync(e.Guild.Id));
embed.AddInlineField(
"📺" + l.GetString("miki_module_general_guildinfo_channels"),
(await e.Guild.GetChannelCountAsync()).ToString());
embed.AddInlineField(
"🔊" + l.GetString("miki_module_general_guildinfo_voicechannels"),
(await e.Guild.GetVoiceChannelCountAsync()).ToString());
embed.AddInlineField(
"🙎" + l.GetString("miki_module_general_guildinfo_users"),
(await e.Guild.GetUserCountAsync()).ToString());
embed.AddInlineField(
"🤖" + l.GetString("term_shard"),
Bot.instance.Client.GetShardIdFor((e.Guild as IProxy <IGuild>).ToNativeObject()));
List <string> roleNames = new List <string>();
foreach (IDiscordRole r in e.Guild.Roles)
{
roleNames.Add($"`{r.Name}`");
}
embed.AddInlineField(
"#⃣" + l.GetString("miki_module_general_guildinfo_roles_count"),
e.Guild.Roles.Count.ToString());
string roles = string.Join(", ", roleNames);
if (roles.Length <= 1000)
{
embed.AddInlineField(
"📜" + l.GetString("miki_module_general_guildinfo_roles"),
roles);
}
await embed.QueueToChannel(e.Channel);
}
public async Task EditExpAsync(EventContext e)
{
ArgObject arg = e.Arguments.FirstOrDefault();
if (arg == null)
{
throw new ArgumentException();
}
IDiscordUser target = await arg.GetUserAsync(e.Guild);
}
private async Task Module_UserLeft(IDiscordUser arg)
{
if (await IsEnabled(arg.Guild.Id))
{
try
{
await UserLeaveGuild(arg.Guild, arg);
}
catch { }
}
}
public static async Task SendPM(IDiscordUser user, string message, DatabaseSettingId settingId = DatabaseSettingId.PERSONALMESSAGE)
{
if (CanSendNotification(user.Id, settingId))
{
RuntimeEmbed e = new RuntimeEmbed(new Discord.EmbedBuilder());
e.Title = "NOTIFICATION";
e.Description = message;
await e.QueueToUser(user);
}
}
public async Task FavouritePastaList(EventContext e, bool lovedPastas = true)
{
Locale locale = Locale.GetEntity(e.Channel.Id.ToDbLong());
IDiscordUser targetUser = e.Author;
float totalPerPage = 25f;
int page = 0;
if (e.message.MentionedUserIds.Count() >= 1)
{
targetUser = await e.Guild.GetUserAsync(e.message.MentionedUserIds.First());
string[] args = e.arguments.Split(' ');
int.TryParse((args.Count() > 1 ? args[1] : "0"), out page);
}
else
{
int.TryParse(e.arguments, out page);
}
using (MikiContext context = new MikiContext())
{
long authorId = targetUser.Id.ToDbLong();
IEnumerable <PastaVote> pastaVotes = context.Votes.Where(x => x.__UserId == authorId && x.PositiveVote == lovedPastas);
int maxPage = (int)Math.Ceiling(pastaVotes.Count() / totalPerPage);
page = page > maxPage - 1 ? maxPage - 1 : page;
if (pastaVotes.Count() <= 0)
{
string loveString = (lovedPastas ? locale.GetString("miki_module_pasta_loved") : locale.GetString("miki_module_pasta_hated"));
string errorString = locale.GetString("miki_module_pasta_favlist_self_none", loveString);
if (e.message.MentionedUserIds.Count() >= 1)
{
errorString = locale.GetString("miki_module_pasta_favlist_mention_none", loveString);
}
await Utils.ErrorEmbed(e, errorString).SendToChannel(e.Channel.Id);
return;
}
IDiscordEmbed embed = Utils.Embed;
List <PastaVote> neededPastas = pastaVotes.Skip((int)totalPerPage * page).Take((int)totalPerPage).ToList();
string resultString = "";
neededPastas.ForEach(x => { resultString += "`" + x.Id + "` "; });
string useName = string.IsNullOrEmpty(e.Author.Nickname) ? e.Author.Username : e.Author.Nickname;
embed.SetTitle($"{( lovedPastas ? locale.GetString( "miki_module_pasta_loved_header" ) : locale.GetString( "miki_module_pasta_hated_header" ) )} - {useName}");
embed.SetDescription(resultString);
embed.SetFooter(locale.GetString("page_index", page + 1, Math.Ceiling(pastaVotes.Count() / totalPerPage)), "");
await embed.SendToChannel(e.Channel);
}
}
public async Task BanUserAsync(CommandContext e)
{
if (e.Arguments.Take(out string user))
{
IDiscordUser u = await DiscordExtensions.GetUserAsync(user, e.Guild);
var context = e.GetService <MikiDbContext>();
await(await User.GetAsync(context, u.Id.ToDbLong(), u.Username))
.BanAsync(context);
}
}
/// <summary>
/// Unlocks the achievement and if not yet added to the database, It'll add it to the database.
/// </summary>
/// <param name="context">sql context</param>
/// <param name="id">user id</param>
/// <param name="r">rank set to (optional)</param>
/// <returns></returns>
internal async Task UnlockAsync(IDiscordChannel channel, IDiscordUser user, int r = 0)
{
long userid = user.Id.ToDbLong();
if (await UnlockIsValid(userid, r))
{
await AchievementManager.Instance.CallAchievementUnlockEventAsync(this, user, channel);
Notification.SendAchievement(this, channel, user);
}
}
private async Task OnLevelUpAchievementsAsync(
IDiscordUser user, IDiscordTextChannel channel, int level)
{
var achievements = achievementService.GetAchievement(AchievementIds.LevellingId);
int achievementToUnlock = -1;
if (level >= 3 && level < 5)
{
achievementToUnlock = 0;
}
else if (level >= 5 && level < 10)
{
achievementToUnlock = 1;
}
else if (level >= 10 && level < 20)
{
achievementToUnlock = 2;
}
else if (level >= 20 && level < 30)
{
achievementToUnlock = 3;
}
else if (level >= 30 && level < 50)
{
achievementToUnlock = 4;
}
else if (level >= 50 && level < 100)
{
achievementToUnlock = 5;
}
else if (level >= 100 && level < 150)
{
achievementToUnlock = 6;
}
else if (level >= 150)
{
achievementToUnlock = 7;
}
if (achievementToUnlock != -1)
{
if (app is MikiBotApp botApp)
{
using var context = await botApp.CreateFromUserChannelAsync(user, channel);
await achievementService.UnlockAsync(
context,
achievements,
user.Id,
achievementToUnlock);
}
}
}
/// <inheritdoc />
public async Task <IDiscordGuildUser> GetSelfAsync()
{
IDiscordUser user = await client.GetSelfAsync()
.ConfigureAwait(false);
if (user == null)
{
throw new InvalidOperationException("Could not find self user");
}
return(await GetMemberAsync(user.Id));
}
/// <summary>
/// Creates and returns the User regardless of business errors.
/// </summary>
public static async Task <User> GetOrCreateUserAsync(
this IUserService service, IDiscordUser user)
{
try
{
return(await service.GetUserAsync((long)user.Id));
}
catch (EntityNullException <User> )
{
return(await service.CreateUserAsync((long)user.Id, user.Username));
}
}
public async Task BanUserAsync(EventContext e)
{
if (e.Arguments.Take(out string user))
{
IDiscordUser u = await DiscordExtensions.GetUserAsync(user, e.Guild);
using (var context = new MikiContext())
{
await(await User.GetAsync(context, u.Id.ToDbLong(), u.Username)).BanAsync();
}
}
}
public static async Task <BankAccount> GetAsync(MikiContext context, IDiscordUser user, IDiscordGuild guild)
{
if (await Global.RedisClient.ExistsAsync($"bankaccount:{guild.Id}:{user.Id}"))
{
return(context.BankAccounts.Attach(await Global.RedisClient.GetAsync <BankAccount>($"bankaccount:{guild.Id}:{user.Id}")).Entity);
}
BankAccount account = await context.BankAccounts.FindAsync(guild.Id.ToString(), user.Id.ToDbLong());
await Global.RedisClient.AddAsync <BankAccount>($"bankaccount:{guild.Id}:{user.Id}", account);
return(account);
}
public async Task GiveMekosAsync(EventContext e)
{
IDiscordUser user = null;
if (e.Arguments.Take(out string userName))
{
user = await DiscordExtensions.GetUserAsync(userName, e.Guild);
if (user == null)
{
await e.ErrorEmbedResource("give_error_no_mention")
.ToEmbed().QueueToChannelAsync(e.Channel);
return;
}
if (!e.Arguments.Take(out int amount))
{
await e.ErrorEmbedResource("give_error_amount_unparsable")
.ToEmbed().QueueToChannelAsync(e.Channel);
return;
}
using (MikiContext context = new MikiContext())
{
User sender = await DatabaseHelpers.GetUserAsync(context, e.Author);
User receiver = await DatabaseHelpers.GetUserAsync(context, user);
if (amount <= sender.Currency)
{
sender.RemoveCurrency(amount);
await receiver.AddCurrencyAsync(amount);
await new EmbedBuilder()
{
Title = "🔸 transaction",
Description = e.Locale.GetString("give_description", sender.Name, receiver.Name, amount.ToFormattedString()),
Color = new Color(255, 140, 0),
}.ToEmbed().QueueToChannelAsync(e.Channel);
await context.SaveChangesAsync();
}
else
{
await e.ErrorEmbedResource("user_error_insufficient_mekos")
.ToEmbed().QueueToChannelAsync(e.Channel);
}
}
}
}
private async Task Module_UserUpdated(IDiscordUser arg1, IDiscordUser arg2)
{
if (arg1.Guild != null)
{
if (await IsEnabled(arg1.Guild.Id))
{
try {
await UserUpdated(arg1, arg2);
}
catch { }
}
}
}
private async Task Module_UserUpdated(IDiscordUser arg1, IDiscordUser arg2)
{
if (arg1.Guild != null)
{
if (await IsEnabled(arg1.Guild.Id))
{
await MeruUtils.TryAsync(async() =>
{
await UserUpdated(arg1, arg2);
});
}
}
}
public async Task MarryAsync(EventContext e)
{
Locale locale = Locale.GetEntity(e.Channel.Id);
if (e.message.MentionedUserIds.Count == 0)
{
await e.Channel.SendMessage(locale.GetString("miki_module_accounts_marry_error_no_mention"));
return;
}
using (MikiContext context = new MikiContext())
{
User mentionedPerson = await context.Users.FindAsync(e.message.MentionedUserIds.First().ToDbLong());
User currentUser = await context.Users.FindAsync(e.Author.Id.ToDbLong());
IDiscordUser user = await e.Guild.GetUserAsync(e.message.MentionedUserIds.First());
if (currentUser == null || mentionedPerson == null)
{
await Utils.ErrorEmbed(locale, "miki_module_accounts_marry_error_null").SendToChannel(e.Channel);
return;
}
if (mentionedPerson.Id == currentUser.Id)
{
await Utils.ErrorEmbed(locale, locale.GetString("miki_module_accounts_marry_error_null")).SendToChannel(e.Channel);
return;
}
if (await Marriage.ExistsAsync(context, mentionedPerson.Id, currentUser.Id))
{
await Utils.ErrorEmbed(locale, locale.GetString("miki_module_accounts_marry_error_exists")).SendToChannel(e.Channel);
return;
}
if (await Marriage.ProposeAsync(context, currentUser.Id, mentionedPerson.Id))
{
await e.Channel.SendMessage(
$"💍 " +
locale.GetString("miki_module_accounts_marry_text", $"**{e.Author.Username}**", $"**{user.Username}**") +
" 💍\n\n⛪ " + user.Username + " " +
locale.GetString("miki_module_accounts_marry_text2") +
$" ⛪\n\n✅ **>acceptmarriage [@{locale.GetString("miki_terms_mention")}]**\n❌ **>declinemarriage [@{locale.GetString("miki_terms_mention")}]**");
}
}
}
public async Task AchievementsAsync(CommandContext e)
{
var context = e.GetService <MikiDbContext>();
long id = (long)e.Author.Id;
if (e.Arguments.Take(out string arg))
{
IDiscordUser user = await DiscordExtensions.GetUserAsync(arg, e.Guild);
if (user != null)
{
id = (long)user.Id;
}
}
IDiscordUser discordUser = await e.Guild.GetMemberAsync(id.FromDbLong());
User u = await User.GetAsync(context, discordUser.Id, discordUser.Username);
List <Achievement> achievements = await context.Achievements
.Where(x => x.UserId == id)
.ToListAsync();
EmbedBuilder embed = new EmbedBuilder()
.SetAuthor($"{u.Name} | " + "Achievements", discordUser.GetAvatarUrl(), "https://miki.ai/profiles/ID/achievements");
embed.SetColor(255, 255, 255);
StringBuilder leftBuilder = new StringBuilder();
int totalScore = 0;
foreach (var a in achievements)
{
IAchievement metadata = AchievementManager.Instance.GetContainerById(a.Name).Achievements[a.Rank];
leftBuilder.AppendLine(metadata.Icon + " | `" + metadata.Name.PadRight(15) + $"{metadata.Points.ToString().PadLeft(3)} pts` | 📅 {a.UnlockedAt.ToShortDateString()}");
totalScore += metadata.Points;
}
if (string.IsNullOrEmpty(leftBuilder.ToString()))
{
embed.AddInlineField("Total Pts: " + totalScore.ToFormattedString(), "None, yet.");
}
else
{
embed.AddInlineField("Total Pts: " + totalScore.ToFormattedString(), leftBuilder.ToString());
}
await embed.ToEmbed().QueueToChannelAsync(e.Channel);
}
private async Task Module_UserJoined(IDiscordUser arg)
{
if (await IsEnabled(arg.Guild.Id))
{
try
{
await UserJoinGuild(arg.Guild, arg);
}
catch (Exception e)
{
Log.ErrorAt("userjoin", e.Message + "\n" + e.StackTrace);
}
}
}
public static async Task <User> GetAsync(MikiContext context, IDiscordUser u)
{
long id = u.Id.ToDbLong();
User user = null;
user = await context.Users.FindAsync(id);
if (user == null)
{
return(await CreateAsync(u));
}
return(user);
}
public int AddReminder(IDiscordUser user, string reminder, TimeSpan atTime, bool repeated = false)
{
if (reminders.TryGetValue(user.Id, out ReminderContainer container))
{
return(container.CreateNewReminder(user, reminder, atTime, repeated));
}
else
{
ReminderContainer rc = new ReminderContainer();
rc.Id = user.Id;
reminders.Add(user.Id, rc);
return(rc.CreateNewReminder(user, reminder, atTime, repeated));
}
}
public ReminderInstance CancelReminder(IDiscordUser user, int reminderId)
{
if (reminders.TryGetValue(user.Id, out ReminderContainer container))
{
var instance = container.GetReminder(reminderId);
if (instance != null)
{
instance.Cancel();
return(instance);
}
return(null);
}
return(null);
}
private List <PermissionGroup> GetDefaultPermissions(IDiscordUser user)
{
var groups = new List <PermissionGroup>
{
PermissionGroup.User
};
if (_options.Developers.Contains(user.Id))
{
groups.Add(PermissionGroup.Developer);
}
return(groups);
}
public static async Task <User> GetAsync(MikiContext context, IDiscordUser u)
{
long id = u.Id.ToDbLong();
return(await context.Users.Where(x => x.Id == u.Id.ToDbLong())
.Include(x => x.Achievements)
.Include(x => x.CommandsUsed)
.Include(x => x.Marriages)
.ThenInclude(x => x.Marriage)
.Include(x => x.LocalExperience)
.Include(x => x.Pastas)
.Include(x => x.Connections)
.FirstOrDefaultAsync()
?? Create(context, u));
}
public async Task RunTask(IDiscordUser user)
{
await Task.Delay((int)Length.TotalMilliseconds);
cancellationToken.Token.ThrowIfCancellationRequested();
CreateReminderEmbed(Text)
.QueueToUser(user);
if (RepeatReminder)
{
parent.CreateNewReminder(user, Text, Length, RepeatReminder);
}
parent.RemoveReminder(ReminderId);
}
public async Task KickAsync(EventContext e)
{
List <string> arg = e.arguments.Split(' ').ToList();
IDiscordUser bannedUser = null;
Locale locale = Locale.GetEntity(e.Channel.Id.ToDbLong());
if (e.message.MentionedUserIds.Count > 0)
{
bannedUser = await e.Guild.GetUserAsync(e.message.MentionedUserIds.First());
}
else
{
bannedUser = await e.Guild.GetUserAsync(ulong.Parse(e.arguments.Split(' ')[0]));
}
arg.RemoveAt(0);
string reason = string.Join(" ", arg);
IDiscordEmbed embed = Utils.Embed;
embed.Title = locale.GetString("miki_module_admin_kick_header");
embed.Description = locale.GetString("miki_module_admin_kick_description", new object[] { e.Guild.Name });
if (!string.IsNullOrWhiteSpace(reason))
{
embed.AddField(f =>
{
f.Name = locale.GetString("miki_module_admin_kick_reason");
f.Value = reason;
f.IsInline = true;
});
}
embed.AddField(f =>
{
f.Name = locale.GetString("miki_module_admin_kick_by");
f.Value = e.Author.Username + "#" + e.Author.Discriminator;
f.IsInline = true;
});
embed.Color = new Color(1, 1, 0);
await bannedUser.SendMessage(embed);
await bannedUser.Kick();
}
// TODO: clean this | also, completely re-write this
public async Task SendOption(string message, IDiscordUser user, params Option[] reactionEmoji)
{
IDiscordMessage e = await SendMessage(message);
IMessage msg = (e as IProxy <IMessage>).ToNativeObject();
int output = -1;
for (int i = 0; i < reactionEmoji.Length; i++)
{
await(msg as IUserMessage).AddReactionAsync(reactionEmoji[i].emoji);
}
Func <Cacheable <IUserMessage, ulong>, ISocketMessageChannel, SocketReaction, Task> socketReaction = new Func <Cacheable <IUserMessage, ulong>, ISocketMessageChannel, SocketReaction, Task>(
async(cachableMessage, channel, reaction) =>
{
IUserMessage m = await cachableMessage.GetOrDownloadAsync();
if (m.Id == msg.Id && reaction.User.Value.Id == user.Id)
{
for (int i = 0; i < reactionEmoji.Length; i++)
{
if (reactionEmoji[i].emoji == reaction.Emoji.Name)
{
output = i;
}
}
}
});
Bot.instance.Client.ReactionAdded += socketReaction;
int timeTaken = 0;
while (output == -1 || timeTaken > 10000)
{
await Task.Delay(100);
timeTaken += 100;
}
Bot.instance.Client.ReactionAdded -= socketReaction;
if (output != -1)
{
await reactionEmoji[output].output();
}
}
