public async Task StartAsync(IDiscordChannel channel)
{
message = await Root.Build().SendToChannel(channel);
(Root as BaseItem).SetMenu(this);
(Root as BaseItem).SetParent(null);
await Root.SelectAsync();
}
public static void QueueMessageAsync(this IDiscordChannel channel, string message)
=> MessageBucket.Add(new MessageBucketArgs()
{
properties = new MessageArgs()
{
content = message
},
channel = channel
});
private void SendNotADonatorError(IDiscordChannel channel)
{
new EmbedBuilder()
{
Title = "Sorry!",
Description = "... but you haven't donated yet, please support us with a small donation to unlock these commands!",
}.AddField("Already donated?", "Make sure to join the Miki Support server and claim your donator status!")
.AddField("Where do I donate?", "You can find our patreon at https://patreon.com/mikibot")
.ToEmbed().QueueToChannel(channel);
}
public static void QueueToChannel(this DiscordEmbed embed, IDiscordChannel channel)
{
MessageBucket.Add(new MessageBucketArgs()
{
properties = new MessageArgs()
{
embed = embed
},
channel = channel
});
}
/// <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);
}
}
public bool HasPermissions(IDiscordChannel channel, params DiscordGuildPermission[] permissions)
{
foreach (DiscordGuildPermission p in permissions)
{
GuildPermission newP = (GuildPermission)Enum.Parse(typeof(DiscordGuildPermission), p.ToString());
if (!(user as IGuildUser).GuildPermissions.Has(newP))
{
return(false);
}
}
return(true);
}
private async Task Client_JoinedGuild(IDiscordGuild arg)
{
using (var scope = MikiApp.Instance.Services.CreateScope())
{
var context = scope.ServiceProvider.GetService <DbContext>();
IDiscordChannel defaultChannel = await arg.GetDefaultChannelAsync();
if (defaultChannel != null)
{
LocaleInstance i = await Locale.GetLanguageInstanceAsync(context, defaultChannel.Id);
(defaultChannel as IDiscordTextChannel).QueueMessage(i.GetString("miki_join_message"));
}
List <string> allArgs = new List <string>();
List <object> allParams = new List <object>();
List <object> allExpParams = new List <object>();
try
{
var members = await arg.GetMembersAsync();
for (int i = 0; i < members.Length; i++)
{
allArgs.Add($"(@p{i * 2}, @p{i * 2 + 1})");
allParams.Add(members.ElementAt(i).Id.ToDbLong());
allParams.Add(members.ElementAt(i).Username);
allExpParams.Add(arg.Id.ToDbLong());
allExpParams.Add(members.ElementAt(i).Id.ToDbLong());
}
await context.Database.ExecuteSqlCommandAsync(
$"INSERT INTO dbo.\"Users\" (\"Id\", \"Name\") VALUES {string.Join(",", allArgs)} ON CONFLICT DO NOTHING", allParams);
await context.Database.ExecuteSqlCommandAsync(
$"INSERT INTO dbo.\"LocalExperience\" (\"ServerId\", \"UserId\") VALUES {string.Join(",", allArgs)} ON CONFLICT DO NOTHING", allExpParams);
await context.SaveChangesAsync();
}
catch (Exception e)
{
Log.Error(e.ToString());
}
DogStatsd.Increment("guilds.joined");
}
}
private async Task Client_JoinedGuild(IDiscordGuild arg)
{
IDiscordChannel defaultChannel = await arg.GetDefaultChannelAsync();
if (defaultChannel != null)
{
using (var context = new MikiContext())
{
LocaleInstance i = await Locale.GetLanguageInstanceAsync(context, defaultChannel.Id);
(defaultChannel as IDiscordTextChannel).QueueMessage(i.GetString("miki_join_message"));
}
}
//List<string> allArgs = new List<string>();
//List<object> allParams = new List<object>();
//List<object> allExpParams = new List<object>();
//try
//{
// for (int i = 0; i < arg.Members.Count; i++)
// {
// allArgs.Add($"(@p{i * 2}, @p{i * 2 + 1})");
// allParams.Add(arg.Members.ElementAt(i).Id.ToDbLong());
// allParams.Add(arg.Members.ElementAt(i).Username);
// allExpParams.Add(arg.Id.ToDbLong());
// allExpParams.Add(arg.Members.ElementAt(i).Id.ToDbLong());
// }
// using (var context = new MikiContext())
// {
// await context.Database.ExecuteSqlCommandAsync(
// $"INSERT INTO dbo.\"Users\" (\"Id\", \"Name\") VALUES {string.Join(",", allArgs)} ON CONFLICT DO NOTHING", allParams);
// await context.Database.ExecuteSqlCommandAsync(
// $"INSERT INTO dbo.\"LocalExperience\" (\"ServerId\", \"UserId\") VALUES {string.Join(",", allArgs)} ON CONFLICT DO NOTHING", allExpParams);
// await context.SaveChangesAsync();
// }
//}
//catch (Exception e)
//{
// Log.Error(e.ToString());
//}
DogStatsd.Increment("guilds.joined");
}
public static async Task AddCurrencyAsync(this User user, int amount, IDiscordChannel channel = null, User fromUser = null)
{
if (amount < 0)
{
throw new ArgumentLessThanZeroException();
}
DogStatsd.Counter("currency.change", amount);
user.Currency += amount;
if (channel is IDiscordGuildChannel guildchannel)
{
await AchievementManager.Instance.CallTransactionMadeEventAsync(guildchannel, user, fromUser, amount);
}
}
public async Task ResetAsync(IDiscordChannel channel, string permission)
{
if (!ValidatePermission(permission))
{
return;
}
if (!await _permissionManager.ResetChannelPermissionAsync(_guild.Id, channel.Id, permission))
{
Response.AddError(GetString("Command.Reset.Failed", "Channel", permission, channel));
}
else
{
Response.AddSuccess(GetString("Command.Reset.Success", "Channel", permission, channel));
}
}
public static async Task <IDiscordUser> ParseUserAsync(IDiscordChannel channel, string name)
{
if (!string.IsNullOrWhiteSpace(name))
{
if (ulong.TryParse(name.Trim('<', '@', '!', '>'), out ulong l))
{
return(await channel.Guild.GetUserAsync(l));
}
string s = name.ToLower();
List <IDiscordUser> users = await channel.GetUsersAsync();
return(users
.Where(x => x.GetName().ToLower() == s)
.First());
}
return(null);
}
private async Task Client_JoinedGuild(IDiscordGuild arg)
{
IDiscordChannel defaultChannel = await arg.GetDefaultChannelAsync();
defaultChannel.QueueMessageAsync(Locale.GetString(defaultChannel.Id, "miki_join_message"));
List <string> allArgs = new List <string>();
List <object> allParams = new List <object>();
List <object> allExpParams = new List <object>();
try
{
var users = await arg.GetUsersAsync();
for (int i = 0; i < users.Count; i++)
{
allArgs.Add($"(@p{i * 2}, @p{i * 2 + 1})");
allParams.Add(users.ElementAt(i).Id.ToDbLong());
allParams.Add(users.ElementAt(i).Username);
allExpParams.Add((await users.ElementAt(i).GetGuildAsync()).Id.ToDbLong());
allExpParams.Add(users.ElementAt(i).Id.ToDbLong());
}
using (var context = new MikiContext())
{
await context.Database.ExecuteSqlCommandAsync(
$"INSERT INTO dbo.\"Users\" (\"Id\", \"Name\") VALUES {string.Join(",", allArgs)} ON CONFLICT DO NOTHING", allParams);
await context.Database.ExecuteSqlCommandAsync(
$"INSERT INTO dbo.\"LocalExperience\" (\"ServerId\", \"UserId\") VALUES {string.Join(",", allArgs)} ON CONFLICT DO NOTHING", allExpParams);
await context.SaveChangesAsync();
}
}
catch (Exception e)
{
Log.Error(e.ToString());
}
DogStatsd.Increment("guilds.joined");
// DogStatsd.Set("guilds", Bot.Instance.Client.Guilds.Count, Bot.Instance.Client.Guilds.Count);
}
public async Task AddCurrencyAsync(int amount, IDiscordChannel channel = null, User fromUser = null)
{
if (Banned)
{
return;
}
if (amount < 0)
{
if (Currency < Math.Abs(amount))
{
throw new InsufficientCurrencyException(Currency, Math.Abs(amount));
}
}
DogStatsd.Counter("currency.change", amount);
Currency += amount;
if (channel != null)
{
await AchievementManager.Instance.CallTransactionMadeEventAsync((IDiscordGuildChannel)channel, this, fromUser, Currency);
}
}
public ValueTask OnChannelDelete(IDiscordChannel channel)
{
return(_eventManager.CallAsync(new ChannelDeleteEvent(channel)));
}
public ChannelCreateEvent(IDiscordChannel channel)
{
Channel = channel;
}
public async Task CallAchievementUnlockEventAsync(BaseAchievement achievement, IDiscordUser user, IDiscordChannel channel)
{
DogStatsd.Counter("achievements.gained", 1);
if (achievement as AchievementAchievement != null)
{
return;
}
long id = user.Id.ToDbLong();
using (var context = new MikiContext())
{
int achievementCount = await context.Achievements
.Where(q => q.UserId == id)
.CountAsync();
AchievementPacket p = new AchievementPacket()
{
discordUser = user,
discordChannel = channel,
achievement = achievement,
count = achievementCount
};
await OnAchievementUnlocked?.Invoke(p);
}
}
// TODO: rework this
public async Task <EventAccessibility> GetUserAccessibility(IDiscordMessage e, IDiscordChannel channel)
{
if (e.Author.Id == 121919449996460033)
{
return(EventAccessibility.DEVELOPERONLY);
}
if (channel is IDiscordGuildChannel guildChannel)
{
IDiscordGuildUser u = await(await guildChannel.GetGuildAsync()).GetUserAsync(e.Author.Id);
if (u != null)
{
if ((await guildChannel.GetPermissionsAsync(u)).HasFlag(GuildPermission.ManageRoles))
{
return(EventAccessibility.ADMINONLY);
}
}
}
return(EventAccessibility.PUBLIC);
}
public ScriptChannel(IDiscordChannel channel)
{
this.channel = channel;
}
public GamblingModule()
{
if (!Global.Config.IsMainBot)
{
lotteryId = taskScheduler.AddTask(0, (s) =>
{
long size = (Global.RedisClient as StackExchangeCacheClient).Client.GetDatabase(0).ListLength(lotteryKey);
if (size == 0)
{
return;
}
string value = (Global.RedisClient as StackExchangeCacheClient).Client.GetDatabase(0).ListGetByIndex(lotteryKey, MikiRandom.Next(size));
ulong winnerId = ulong.Parse(value);
int wonAmount = (int)Math.Round(size * 100 * 0.75);
IDiscordUser user = null; //Bot.Instance.ChatClient.GetUser(winnerId);
using (var context = new MikiContext())
{
long id = winnerId.ToDbLong();
User profileUser = context.Users.Find(id);
if (user != null)
{
IDiscordChannel channel = user.GetDMChannel().Result;
EmbedBuilder embed = new EmbedBuilder()
{
Author = new EmbedAuthor()
{
Name = "Winner winner chicken dinner",
IconUrl = user.GetAvatarUrl()
},
Description = $"Wow! You won the lottery and gained {wonAmount} mekos!"
};
profileUser.AddCurrencyAsync(wonAmount, channel);
embed.ToEmbed().QueueToChannel(channel);
context.SaveChanges();
Global.RedisClient.RemoveAsync(lotteryKey);
Global.RedisClient.UpsertAsync("lottery:winner", profileUser.Name ?? "unknown");
lotteryDict.ClearAsync();
var lotteryAchievement = AchievementManager.Instance.GetContainerById("lottery");
if (wonAmount > 100000)
{
lotteryAchievement.Achievements[0].UnlockAsync(channel, user, 0);
}
if (wonAmount > 10000000)
{
lotteryAchievement.Achievements[1].UnlockAsync(channel, user, 1);
}
if (wonAmount > 250000000)
{
lotteryAchievement.Achievements[2].UnlockAsync(channel, user, 1);
}
}
}
}, "", new TimeSpan(0, 1, 0, 0), true);
}
}
public static async Task <IDiscordMessage> SendToChannel(this DiscordEmbed embed, IDiscordChannel channel)
{
//if (!(await (await (channel as IDiscordGuildChannel).GetGuildAsync()).GetSelfAsync())
// .GuildPermissions.HasFlag (GuildPermission.EmbedLinks))
//{
// if (!string.IsNullOrEmpty(embed.Image?.Url ?? ""))
// {
// return await channel.SendMessageAsync(embed.ToMessageBuilder().Build());
// }
// using (WebClient wc = new WebClient())
// {
// byte[] image = wc.DownloadData(embed.Image.Url);
// using (MemoryStream ms = new MemoryStream(image))
// {
// return await channel.SendFileAsync(ms, embed.ToMessageBuilder().Build());
// }
// }
//}
return(await channel.SendMessageAsync("", false, embed));
}
public ChannelDeleteEvent(IDiscordChannel channel)
{
Channel = channel;
}
public virtual bool HasPermissions(IDiscordChannel channel, params DiscordGuildPermission[] permissions)
{
throw new NotImplementedException();
}
public async Task <ContextObject> CreateFromUserChannelAsync(IDiscordUser user, IDiscordChannel channel)
{
// TODO : Resolve this in a better way.
DiscordMessage message = new DiscordMessage(
new DiscordMessagePacket
{
Author = new DiscordUserPacket
{
Avatar = user.AvatarId,
Discriminator = user.Discriminator,
Id = user.Id,
Username = user.Username,
IsBot = user.IsBot
},
ChannelId = channel.Id,
GuildId = (channel as IDiscordGuildChannel)?.GuildId,
Content = "no content",
Member = user is IDiscordGuildUser a
? new DiscordGuildMemberPacket
{
JoinedAt = a.JoinedAt.UtcDateTime,
GuildId = a.GuildId,
Nickname = a.Nickname,
Roles = a.RoleIds.ToList(),
} : null,
},
public async Task PermissionsAsync(IDiscordChannel channel)
{
var allowedPermissions = await _permissionManager.GetAllowedChannelPermissionAsync(channel.Id, _guild.Id);
await PermissionsAsync("Channel", channel, allowedPermissions);
}
public static void SendAchievement(AchievementDataContainer d, int rank, IDiscordChannel channel, IDiscordUser user)
{
SendAchievement(d.Achievements[rank], channel, user);
}
public LocalizableString WithToken(string name, IDiscordChannel channel)
{
_tokens[name] = channel.Name;
_tokens[name + ".Id"] = channel.Id.ToString();
return(this);
}
public static void SendAchievement(BaseAchievement d, IDiscordChannel channel, IDiscordUser user)
{
CreateAchievementEmbed(d, user).QueueToChannel(channel);
}
