public async Task Service_MessageReceived(IDiscordMessage m)
{
if (await IsEnabled(Global.RedisClient, m.GetChannelAsync().Result.Id))
{
await AccountManager.Instance.CheckAsync(m);
}
}
public async Task LevelUpGlobalAsync(IDiscordMessage e, int l)
{
if (OnGlobalLevelUp != null)
{
await OnGlobalLevelUp.Invoke(e.Author, await e.GetChannelAsync(), l);
}
}
static async Task OnMessageReceived(IDiscordMessage message)
{
if (message.Content == "ping")
{
var channel = await message.GetChannelAsync();
await channel.SendMessageAsync("pong!");
}
}
public async Task HandleCommand(IDiscordMessage message)
{
var messageCallValue = int.Parse(await DiscordBot.Instance.cacheManger.GetAsync("MessageCall")) + 1;
await DiscordBot.Instance.cacheManger.UpdateAsync("MessageCall", messageCallValue.ToString());
if (message.Author.IsBot)
{
return;
}
var guild = await((IDiscordGuildChannel)await message.GetChannelAsync()).GetGuildAsync();
var guildData = await Program.GuildsData.GetAsync(guild.Id.ToString());
var Prefix = guildData?.Prefix != null ? guildData.Prefix : _prefix;
var botUser = await DiscordBot.Instance.bot.GetCurrentUserAsync();
var MentionPrefix = "";
if (message.Content.StartsWith($"<@!{botUser.Id}>"))
{
MentionPrefix = $"<@!{botUser.Id}> ";
}
if (message.Content == $"<@!{botUser.Id}>" || message.Content == (await DiscordBot.Instance.bot.GetCurrentUserAsync()).Mention)
{
var Channel = await message.GetChannelAsync();
await Channel.SendMessageAsync($"Haiii <3, The Prefix for this Bot is {Prefix} \n to See all Commands use {Prefix}help Command");
return;
}
if (message.Content.StartsWith(Prefix))
{
MessageContext context = new MessageContext(Prefix, message);
var commandCallValue = int.Parse(await DiscordBot.Instance.cacheManger.GetAsync("CommandCall")) + 1;
await DiscordBot.Instance.cacheManger.UpdateAsync("CommandCall", commandCallValue.ToString());
await _handler.ExecuteCommand(context);
}
else if (!string.IsNullOrEmpty(MentionPrefix))
{
MessageContext context = new MessageContext(MentionPrefix, message);
await _handler.ExecuteCommand(context);
}
}
private async Task Bot_MessageReceived(IDiscordMessage arg)
{
DogStatsd.Increment("messages.received");
if (arg.Content.StartsWith($"<@!{Global.CurrentUser.Id}>") || arg.Content.StartsWith($"<@{Global.CurrentUser.Id}>"))
{
string msg = (await Locale.GetLanguageInstanceAsync(arg.ChannelId)).GetString("miki_join_message");
(await arg.GetChannelAsync()).QueueMessageAsync(msg);
}
}
private async Task Bot_MessageReceived(IDiscordMessage arg)
{
var user = await MikiApp.Instance.Discord.GetCurrentUserAsync();
DogStatsd.Increment("messages.received");
if (arg.Content.StartsWith($"<@!{user.Id}>") || arg.Content.StartsWith($"<@{user.Id}>"))
{
using (var context = new MikiContext())
{
string msg = (await Locale.GetLanguageInstanceAsync(context, arg.ChannelId)).GetString("miki_join_message");
(await arg.GetChannelAsync()).QueueMessage(msg);
}
}
}
public static async Task <IDiscordMessage> EditAsync(this DiscordEmbed embed, IDiscordMessage msg)
{
var channel = await msg.GetChannelAsync();
if (channel is IDiscordGuildChannel guildChannel)
{
var currentGuildUser = await guildChannel.GetSelfAsync();
var permissions = await guildChannel.GetPermissionsAsync(currentGuildUser);
if (!permissions.HasFlag(GuildPermission.EmbedLinks))
{
return(await msg.EditAsync(new EditMessageArgs(embed.ToMessageBuilder().Build())));
}
}
return(await msg.EditAsync(new EditMessageArgs("", embed)));
}
public async Task OnMessageReceivedAsync(IDiscordMessage msg)
{
if (!await MessageFilter.IsAllowedAsync(msg))
{
return;
}
Task task = Task.Run(async() =>
{
var stopwatch = Stopwatch.StartNew();
try
{
MessageContext context = new MessageContext();
context.message = msg;
context.eventSystem = this;
foreach (var handler in commandHandlers.Values)
{
await handler.CheckAsync(context);
}
}
catch (BotException botEx)
{
config.ErrorEmbedBuilder
.SetDescription(Locale.GetString(msg.ChannelId, botEx.Resource))
.ToEmbed()
.QueueToChannel(await msg.GetChannelAsync());
Log.Error(botEx);
}
catch (Exception ex)
{
Log.Error(ex);
}
stopwatch.Stop();
});
}
public async Task LevelUpLocalAsync(IDiscordMessage e, int l)
{
await OnLocalLevelUp.Invoke(e.Author, await e.GetChannelAsync(), l);
}
public async Task CheckAsync(IDiscordMessage e)
{
if (e.Author.IsBot)
{
return;
}
if (isSyncing)
{
return;
}
try
{
if (await e.GetChannelAsync() is IDiscordGuildChannel channel)
{
string key = GetContextKey(channel.GuildId, e.Author.Id);
if (lastTimeExpGranted.GetOrAdd(e.Author.Id, DateTime.Now).AddMinutes(1) < DateTime.Now)
{
int currentExp = 0;
if (!await Global.RedisClient.ExistsAsync(key))
{
using (var context = new MikiContext())
{
LocalExperience user = await LocalExperience.GetAsync(
context,
(long)channel.GuildId,
e.Author
);
await Global.RedisClient.AddAsync(key, user.Experience);
currentExp = user.Experience;
}
}
else
{
currentExp = await Global.RedisClient.GetAsync <int>(key);
}
var bonusExp = MikiRandom.Next(1, 4);
currentExp += bonusExp;
if (!experienceQueue.ContainsKey(e.Author.Id))
{
var expObject = new ExperienceAdded()
{
UserId = e.Author.Id.ToDbLong(),
GuildId = channel.GuildId.ToDbLong(),
Experience = bonusExp,
Name = e.Author.Username,
};
experienceQueue.AddOrUpdate(e.Author.Id, expObject, (u, eo) =>
{
eo.Experience += expObject.Experience;
return(eo);
});
}
else
{
experienceQueue[e.Author.Id].Experience += bonusExp;
}
int level = User.CalculateLevel(currentExp);
if (User.CalculateLevel(currentExp - bonusExp) != level)
{
await LevelUpLocalAsync(e, level);
}
lastTimeExpGranted.AddOrUpdate(e.Author.Id, DateTime.Now, (x, d) => DateTime.Now);
await Global.RedisClient.AddAsync(key, currentExp);
}
}
if (DateTime.Now >= lastDbSync + new TimeSpan(0, 1, 0))
{
isSyncing = true;
Log.Message($"Applying Experience for {experienceQueue.Count} users");
lastDbSync = DateTime.Now;
try
{
await UpdateGlobalDatabase();
await UpdateLocalDatabase();
await UpdateGuildDatabase();
}
catch (Exception ex)
{
Log.Error(ex.Message + "\n" + ex.StackTrace);
}
finally
{
experienceQueue.Clear();
isSyncing = false;
}
Log.Message($"Done Applying!");
}
}
catch (Exception ex)
{
Log.Error(ex.ToString());
}
}
