public override async Task <RiftMessage> ApplyAsync(RiftMessage message, FormatData data)
{
var userRoles = await DB.RoleInventory.GetAsync(data.UserId);
if (userRoles is null || userRoles.Count == 0)
{
return(await ReplaceDataAsync(message, NoItems));
}
var roles = await DB.Roles.GetAllAsync();
var replacement = string.Join('\n', userRoles.Select(x =>
{
var role = roles.FirstOrDefault(y => y.Id == x.RoleId);
if (role is null)
{
TemplateError($"Role ID {x.RoleId.ToString()} does not exist in DB!");
return("N/A");
}
return(x.RoleId.ToString());
}));
return(await ReplaceDataAsync(message, replacement));
}
public IonicMessage(RiftMessage msg)
{
Text = msg.Text;
ImageUrl = msg.ImageUrl;
if (msg.EmbedJson is null)
{
return;
}
try
{
Embed = JsonConvert
.DeserializeObject <RiftEmbed>(
msg.EmbedJson, new JsonSerializerSettings {
NullValueHandling = NullValueHandling.Ignore
})
.ToEmbed();
}
catch (Exception ex)
{
RiftBot.Log.Error(ex, $"Failed to deserialize \"{nameof(RiftMessage)}\"!");
Embed = null;
}
}
public override async Task <RiftMessage> ApplyAsync(RiftMessage message, FormatData data)
{
var invList = await DB.BackgroundInventory.GetAsync(data.UserId);
if (invList is null || invList.Count == 0)
{
return(await ReplaceDataAsync(message, NoItems));
}
var profileBackgrounds = await DB.ProfileBackgrounds.GetAllAsync();
var replacement = string.Join('\n', invList.Select(x =>
{
var back = profileBackgrounds.FirstOrDefault(y => y.Id == x.BackgroundId);
if (back is null)
{
TemplateError($"Background ID {x.BackgroundId.ToString()} does not exist in DB!");
return("N/A");
}
return($"[{back.Name}]({back.Url})");
}));
return(await ReplaceDataAsync(message, replacement));
}
public override async Task <RiftMessage> ApplyAsync(RiftMessage message, FormatData data)
{
var cds = await DB.Cooldowns.GetAsync(data.UserId);
return(await ReplaceDataAsync(message, cds.TeamVoteTimeSpan
.Humanize(minUnit: TimeUnit.Second, maxUnit: TimeUnit.Day, culture: RiftBot.Culture)));
}
public override async Task <RiftMessage> ApplyAsync(RiftMessage message, FormatData data)
{
var cd = await DB.Cooldowns.GetAsync(data.UserId);
return(await ReplaceDataAsync(message, cd.DoubleExpTimeSpan == TimeSpan.Zero
?NotActive
: $"осталось {cd.DoubleExpTimeSpan.Humanize(culture: RiftBot.Culture)}"));
}
public override async Task <RiftMessage> ApplyAsync(RiftMessage message, FormatData data)
{
var inventory = await DB.Inventory.GetAsync(data.UserId);
var coins = Settings.Economy.GiftPrice - inventory.Coins;
return(await ReplaceDataAsync(message, coins.ToString()));
}
public override async Task <RiftMessage> ApplyAsync(RiftMessage message, FormatData data)
{
var cd = await DB.Cooldowns.GetAsync(data.UserId);
return(await ReplaceDataAsync(message, cd.ItemStoreTimeSpan == TimeSpan.Zero
?Available
: $"осталось {cd.ItemStoreTimeSpan.Humanize(minUnit: TimeUnit.Second, culture: RiftBot.Culture)}"));
}
public async Task <IonicMessage> FormatMessageAsync(RiftMessage message, FormatData data = null)
{
if (templates.Count == 0)
{
return(new IonicMessage(message));
}
if (message is null)
{
RiftBot.Log.Error("Message is empty!");
return(Error);
}
if (string.IsNullOrWhiteSpace(message.Text) &&
string.IsNullOrWhiteSpace(message.EmbedJson) &&
string.IsNullOrWhiteSpace(message.ImageUrl))
{
RiftBot.Log.Error($"Message \"{message.Id.ToString()}\" has no data!");
return(Error);
}
var matches = new List <Match>();
if (!string.IsNullOrWhiteSpace(message.Text))
{
matches.AddRange(Regex.Matches(message.Text, TemplateRegex));
}
if (!string.IsNullOrWhiteSpace(message.EmbedJson))
{
matches.AddRange(Regex.Matches(message.EmbedJson, TemplateRegex));
}
foreach (var match in matches)
{
if (!templates.TryGetValue(match.Value, out var template))
{
if (!match.Value.StartsWith(EmotePrefix))
{
continue;
}
emoteService.FormatMessage(match.Value, message);
continue;
}
try
{
await template.ApplyAsync(message, data).ConfigureAwait(false);
}
catch (Exception ex)
{
RiftBot.Log.Error(ex, "An error occured while applying template");
}
}
return(new IonicMessage(message));
}
public override Task <RiftMessage> ApplyAsync(RiftMessage message, FormatData data)
{
var stats = data.Brag.Stats;
var kills = stats.Kills.ToString();
var deaths = stats.Deaths.ToString();
var assists = stats.Assists.ToString();
return(ReplaceDataAsync(message, $"{kills} / {deaths} / {assists}"));
}
public override Task <RiftMessage> ApplyAsync(RiftMessage message, FormatData data)
{
var stats = data.Brag.Stats;
var laneMinions = stats.TotalMinionsKilled;
var neutralMinions = stats.NeutralMinionsKilled;
var cs = (laneMinions + neutralMinions).ToString();
return(ReplaceDataAsync(message, cs));
}
public override async Task <RiftMessage> ApplyAsync(RiftMessage message, FormatData data)
{
return(await ReplaceDataAsync(message,
TimeSpan.FromMinutes(data.Statistics.VoiceUptimeMinutes)
.Humanize(
minUnit: TimeUnit.Minute,
maxUnit: TimeUnit.Hour,
culture: RiftBot.Culture)));
}
public override Task <RiftMessage> ApplyAsync(RiftMessage message, FormatData data)
{
if (!IonicHelper.GetGuildUserById(Settings.App.MainGuildId, data.Moderation.TargetId, out var sgUser))
{
TemplateError("No user data found.");
return(null);
}
return(ReplaceDataAsync(message, sgUser.ToString()));
}
public override Task <RiftMessage> ApplyAsync(RiftMessage message, FormatData data)
{
if (data.LeagueStat.Summoner is null)
{
TemplateError("No summoner data found.");
return(Task.FromResult(message));
}
return(ReplaceDataAsync(message, data.LeagueStat.Summoner.SummonerLevel.ToString()));
}
public override Task <RiftMessage> ApplyAsync(RiftMessage message, FormatData data)
{
var rating = data.EconomyService.SortedRating;
var position = rating is null
? NoRating
: $"{(rating.IndexOf(data.UserId) + 1).ToString()} / {rating.Count.ToString()}";
return(ReplaceDataAsync(message, position));
}
public override Task <RiftMessage> ApplyAsync(RiftMessage message, FormatData data)
{
if (!IonicHelper.GetGuildUserById(Settings.App.MainGuildId, data.Moderation.ModeratorId, out var sgUser))
{
TemplateError("No user data found.");
return(Task.FromResult(message));
}
return(ReplaceDataAsync(message, sgUser.Username));
}
public override Task <RiftMessage> ApplyAsync(RiftMessage message, FormatData data)
{
if (!IonicHelper.GetGuild(Settings.App.MainGuildId, out var guild))
{
TemplateError($"No guild found.");
return(Task.FromResult(message));
}
return(ReplaceDataAsync(message, guild.Name));
}
public override async Task <RiftMessage> ApplyAsync(RiftMessage message, FormatData data)
{
if (!IonicHelper.GetGuildUserById(Settings.App.MainGuildId, data.UserId, out var sgUser))
{
TemplateError("No user data found.");
return(message);
}
return(await ReplaceDataAsync(message, sgUser.GetAvatarUrl()));
}
public override Task <RiftMessage> ApplyAsync(RiftMessage message, FormatData data)
{
if (!IonicHelper.GetGuildUserById(Settings.App.MainGuildId, data.Giveaway.TicketGiveaway.WinnerId, out var sgUser))
{
TemplateError("No user data found.");
return(null);
}
return(ReplaceDataAsync(message, sgUser.Username));
}
public override async Task <RiftMessage> ApplyAsync(RiftMessage message, FormatData data)
{
var cds = await DB.Cooldowns.GetAsync(data.UserId);
var statusString = cds.DailyRewardTimeSpan == TimeSpan.Zero
? $"Написать первое сообщение за день в <#{Settings.ChannelId.Chat.ToString()}>."
: $"Вы уже выполнили задание, подождите {cds.DailyRewardTimeSpan.Humanize(culture: RiftBot.Culture, minUnit: TimeUnit.Second)}.";
return(await ReplaceDataAsync(message, statusString));
}
public override async Task <RiftMessage> ApplyAsync(RiftMessage message, FormatData data)
{
if (!IonicHelper.GetGuildUserById(Settings.App.MainGuildId, data.UserId, out var sgUser) ||
sgUser?.JoinedAt is null)
{
TemplateError("No user data found.");
return(message);
}
return(await ReplaceDataAsync(message, sgUser.JoinedAt.Value.UtcDateTime.ToString("dd.MM.yyyy", CultureInfo.InvariantCulture)));
}
public override async Task <RiftMessage> ApplyAsync(RiftMessage message, FormatData data)
{
var user = await DB.Users.GetAsync(data.UserId);
var currentLevelExp = data.EconomyService.GetExpForLevel(user.Level);
var fullLevelExp = data.EconomyService.GetExpForLevel(user.Level + 1u) - currentLevelExp;
var remainingExp = fullLevelExp - (user.Experience - currentLevelExp);
var levelPerc = 100 - (int)Math.Floor((float)remainingExp / fullLevelExp * 100);
return(await ReplaceDataAsync(message, levelPerc.ToString()));
}
public override Task <RiftMessage> ApplyAsync(RiftMessage message, FormatData data)
{
var coinsEmote = data.EmoteService.GetEmoteString("$emotecoins");
var top = data.Economy.Top10Coins;
var coins = top.Select(x => $"{coinsEmote} {x.Coins.ToString()}");
var formattedString = string.Join('\n', coins);
return(ReplaceDataAsync(message, formattedString));
}
public override Task <RiftMessage> ApplyAsync(RiftMessage message, FormatData data)
{
var lvlEmote = data.EmoteService.GetEmoteString("$emotelvl");
var expEmote = data.EmoteService.GetEmoteString("$emoteexp");
var top = data.Economy.Top10Exp;
var coins = top.Select(x => $"{lvlEmote} {x.Level.ToString()} {expEmote} {x.Experience.ToString()}");
var formattedString = string.Join('\n', coins);
return(ReplaceDataAsync(message, formattedString));
}
public override async Task <RiftMessage> ApplyAsync(RiftMessage message, FormatData data)
{
var rewardString = data.Reward switch
{
ItemReward itemReward => data.RewardService.Format(itemReward),
RoleReward roleReward => await data.RewardService.FormatAsync(roleReward),
BackgroundReward backgroundReward => await data.RewardService.FormatAsync(backgroundReward),
_ => "Пусто :("
};
return(await ReplaceDataAsync(message, rewardString));
}
}
public override Task <RiftMessage> ApplyAsync(RiftMessage message, FormatData data)
{
var transparentEmote = data.EmoteService.GetEmoteString("$emotetran");
var top = data.Economy.Top10Exp;
var users = top.Select(
x => $"{(top.IndexOf(x) + 1).ToString()}. <@{x.UserId.ToString()}>{transparentEmote}");
var formattedString = string.Join('\n', users);
return(ReplaceDataAsync(message, formattedString));
}
protected Task <RiftMessage> ReplaceDataAsync(RiftMessage message, string replacement)
{
if (message.Text != null)
{
message.Text = message.Text.Replace(Template, replacement);
}
if (message.EmbedJson != null)
{
message.EmbedJson = message.EmbedJson.Replace(Template, replacement);
}
return(Task.FromResult(message));
}
public override Task <RiftMessage> ApplyAsync(RiftMessage message, FormatData data)
{
if (data.LeagueStat.Flex5v5 is null)
{
return(ReplaceDataAsync(message, "Недостаточно игр"));
}
var league = data.LeagueStat.Flex5v5;
var totalGames = league.Wins + league.Losses;
var winRatePerc = (int)Math.Round((double)league.Wins / (double)totalGames * 100);
var leagueName = $"{data.RiotService.GetStatStringFromRank(data.RiotService.GetRankFromEntry(league))} {league.Rank}";
return(ReplaceDataAsync(message, $"{leagueName} ({league.LeaguePoints.ToString()}LP / " +
$"{league.Wins.ToString()}W {league.Losses.ToString()}L) ({winRatePerc.ToString()}%)"));
}
public RiftMessage FormatMessage(string template, RiftMessage message)
{
var replacement = GetReplacement(template);
if (message.Text != null)
{
message.Text = message.Text.Replace(template, replacement);
}
if (message.EmbedJson != null)
{
message.EmbedJson = message.EmbedJson.Replace(template, replacement);
}
return(message);
}
public override async Task <RiftMessage> ApplyAsync(RiftMessage message, FormatData data)
{
var cds = await DB.Cooldowns.GetAsync(data.UserId);
var emoteName = cds.DailyRewardTimeSpan == TimeSpan.Zero ? "noach" : "ach";
var emote = data.EmoteService.GetEmoteString($"$emote{emoteName}");
if (string.IsNullOrWhiteSpace(emote))
{
TemplateError($"Could not find emote \"{emoteName}\"");
return(message);
}
return(await ReplaceDataAsync(message, emote));
}
public override async Task <RiftMessage> ApplyAsync(RiftMessage message, FormatData data)
{
var dbUser = await DB.Users.GetAsync(data.UserId);
if (dbUser.ProfileBackground == 0)
{
dbUser.ProfileBackground = 11; //default
}
var background = await DB.ProfileBackgrounds.GetAsync(dbUser.ProfileBackground);
if (background is null)
{
TemplateError($"No background found with ID {dbUser.ProfileBackground.ToString()}");
return(message);
}
return(await ReplaceDataAsync(message, background.Url));
}
