public async Task PermRole(IUserMessage msg, [Remainder] IRole role = null)
{
var channel = (ITextChannel)msg.Channel;
using (var uow = DbHandler.UnitOfWork())
{
var config = uow.GuildConfigs.For(channel.Guild.Id);
if (role == null)
{
await channel.SendMessageAsync($"ℹ️ Current permission role is **{config.PermissionRole}**.").ConfigureAwait(false);
return;
}
else {
config.PermissionRole = role.Name.Trim();
Cache.AddOrUpdate(channel.Guild.Id, new PermissionCache()
{
PermRole = config.PermissionRole,
RootPermission = Permission.GetDefaultRoot(),
Verbose = config.VerbosePermissions
}, (id, old) => { old.PermRole = role.Name.Trim(); return old; });
await uow.CompleteAsync().ConfigureAwait(false);
}
}
await channel.SendMessageAsync($"✅ Users now require **{role.Name}** role in order to edit permissions.").ConfigureAwait(false);
}
public async Task AutoAssignRole(IUserMessage umsg, [Remainder] IRole role = null)
{
var channel = (ITextChannel)umsg.Channel;
GuildConfig conf;
using (var uow = DbHandler.UnitOfWork())
{
conf = uow.GuildConfigs.For(channel.Guild.Id);
if (role == null)
conf.AutoAssignRoleId = 0;
else
conf.AutoAssignRoleId = role.Id;
uow.GuildConfigs.Update(conf);
await uow.CompleteAsync().ConfigureAwait(false);
}
if (role == null)
{
await channel.SendMessageAsync("🆗 **Auto assign role** on user join is now **disabled**.").ConfigureAwait(false);
return;
}
await channel.SendMessageAsync("✅ **Auto assign role** on user join is now **enabled**.").ConfigureAwait(false);
}
public async Task ServerInfo(IUserMessage msg, string guild = null)
{
var channel = (ITextChannel)msg.Channel;
guild = guild?.ToUpperInvariant();
IGuild server;
if (guild == null)
server = channel.Guild;
else
server = _client.GetGuilds().Where(g => g.Name.ToUpperInvariant() == guild.ToUpperInvariant()).FirstOrDefault();
if (server == null)
return;
var createdAt = new DateTime(2015, 1, 1, 0, 0, 0, 0, DateTimeKind.Utc).AddMilliseconds(server.Id >> 22);
var sb = new StringBuilder();
var users = await server.GetUsersAsync();
sb.AppendLine($@"__`Name:`__ **{server.Name}**
__`Owner:`__ **{await server.GetUserAsync(server.OwnerId)}**
__`ID:`__ **{server.Id}**
__`Icon URL:`__ { server.IconUrl}
__`TextChannels:`__ **{(await server.GetTextChannelsAsync()).Count()}** `VoiceChannels:` **{(await server.GetVoiceChannelsAsync()).Count()}**
__`Members:`__ **{users.Count}** `-` {users.Count(u => u.Status == UserStatus.Online)}💚 {users.Count(u => u.Status == UserStatus.Idle)}🔶 {users.Count(u => u.Status == UserStatus.DoNotDisturb)}🔴 {users.Count(u=> u.Status == UserStatus.Offline || u.Status == UserStatus.Unknown)}⬛️
__`Roles:`__ **{server.Roles.Count()}**
__`Created At:`__ **{createdAt.ToString("dd.MM.yyyy HH:mm")}**
");
if (server.Emojis.Count() > 0)
sb.AppendLine($"__`Custom Emojis:`__ *{string.Join(", ", server.Emojis)}*");
if (server.Features.Count() > 0)
sb.AppendLine($"__`Features:`__ **{string.Join(", ", server.Features)}**");
if (!string.IsNullOrWhiteSpace(server.SplashUrl))
sb.AppendLine($"__`Region:`__ **{server.VoiceRegionId}**");
await msg.Reply(sb.ToString()).ConfigureAwait(false);
}
public async Task Osu(IUserMessage umsg, string usr, [Remainder] string mode = null)
{
var channel = (ITextChannel)umsg.Channel;
if (string.IsNullOrWhiteSpace(usr))
return;
using (HttpClient http = new HttpClient())
{
try
{
var m = 0;
if (!string.IsNullOrWhiteSpace(mode))
{
m = ResolveGameMode(mode);
}
http.AddFakeHeaders();
var res = await http.GetStreamAsync(new Uri($"http://lemmmy.pw/osusig/sig.php?uname={ usr }&flagshadow&xpbar&xpbarhex&pp=2&mode={m}")).ConfigureAwait(false);
MemoryStream ms = new MemoryStream();
res.CopyTo(ms);
ms.Position = 0;
await channel.SendFileAsync(ms, $"{usr}.png", $"🎧 **Profile Link: **https://osu.ppy.sh/u/{Uri.EscapeDataString(usr)}\n`Image provided by https://lemmmy.pw/osusig`").ConfigureAwait(false);
}
catch (Exception ex)
{
await channel.SendMessageAsync("💢 Failed retrieving osu signature :\\").ConfigureAwait(false);
_log.Warn(ex, "Osu command failed");
}
}
}
public async Task CreateWar(IUserMessage umsg, int size, [Remainder] string enemyClan = null)
{
var channel = (ITextChannel)umsg.Channel;
if (!(umsg.Author as IGuildUser).GuildPermissions.ManageChannels)
return;
if (string.IsNullOrWhiteSpace(enemyClan))
return;
if (size < 10 || size > 50 || size % 5 != 0)
{
await channel.SendMessageAsync("💢🔰 Not a Valid war size").ConfigureAwait(false);
return;
}
List<ClashWar> wars;
if (!ClashWars.TryGetValue(channel.Guild.Id, out wars))
{
wars = new List<ClashWar>();
if (!ClashWars.TryAdd(channel.Guild.Id, wars))
return;
}
var cw = await CreateWar(enemyClan, size, channel.Guild.Id, umsg.Channel.Id);
wars.Add(cw);
await channel.SendMessageAsync($"❗🔰**CREATED CLAN WAR AGAINST {cw.ShortPrint()}**").ConfigureAwait(false);
}
public async Task Osub(IUserMessage umsg, [Remainder] string map)
{
var channel = (ITextChannel)umsg.Channel;
if (string.IsNullOrWhiteSpace(NadekoBot.Credentials.OsuApiKey))
{
await channel.SendMessageAsync("💢 An osu! API key is required.").ConfigureAwait(false);
return;
}
if (string.IsNullOrWhiteSpace(map))
return;
try
{
using (var http = new HttpClient())
{
var mapId = ResolveMap(map);
var reqString = $"https://osu.ppy.sh/api/get_beatmaps?k={NadekoBot.Credentials.OsuApiKey}&{mapId}";
var obj = JArray.Parse(await http.GetStringAsync(reqString).ConfigureAwait(false))[0];
var sb = new System.Text.StringBuilder();
var starRating = Math.Round(Double.Parse($"{obj["difficultyrating"]}", CultureInfo.InvariantCulture), 2);
var time = TimeSpan.FromSeconds(Double.Parse($"{obj["total_length"]}")).ToString(@"mm\:ss");
sb.AppendLine($"{obj["artist"]} - {obj["title"]}, mapped by {obj["creator"]}. https://osu.ppy.sh/s/{obj["beatmapset_id"]}");
sb.AppendLine($"{starRating} stars, {obj["bpm"]} BPM | AR{obj["diff_approach"]}, CS{obj["diff_size"]}, OD{obj["diff_overall"]} | Length: {time}");
await channel.SendMessageAsync(sb.ToString()).ConfigureAwait(false);
}
}
catch (Exception ex)
{
await channel.SendMessageAsync("Something went wrong.");
_log.Warn(ex, "Osub command failed");
}
}
public async Task Hentai(IUserMessage umsg, [Remainder] string tag = null)
{
var channel = (ITextChannel)umsg.Channel;
tag = tag?.Trim() ?? "";
tag = "rating%3Aexplicit+" + tag;
var rng = new NadekoRandom();
Task<string> provider = Task.FromResult("");
switch (rng.Next(0,4))
{
case 0:
provider = GetDanbooruImageLink(tag);
break;
case 1:
provider = GetGelbooruImageLink(tag);
break;
case 2:
provider = GetKonachanImageLink(tag);
break;
case 3:
provider = GetYandereImageLink(tag);
break;
default:
break;
}
var link = await provider.ConfigureAwait(false);
if (string.IsNullOrWhiteSpace(link))
await channel.SendMessageAsync("Search yielded no results ;(").ConfigureAwait(false);
else
await channel.SendMessageAsync(link).ConfigureAwait(false);
}
public async Task InRole(IUserMessage umsg, [Remainder] string roles)
{
if (string.IsNullOrWhiteSpace(roles))
return;
var channel = (ITextChannel)umsg.Channel;
var arg = roles.Split(',').Select(r => r.Trim().ToUpperInvariant());
string send = _l["ℹ️ **Here is a list of users in a specfic role:**"];
foreach (var roleStr in arg.Where(str => !string.IsNullOrWhiteSpace(str) && str != "@EVERYONE" && str != "EVERYONE"))
{
var role = channel.Guild.Roles.Where(r => r.Name.ToUpperInvariant() == roleStr).FirstOrDefault();
if (role == null) continue;
send += $"```css\n[{role.Name}]\n";
send += string.Join(", ", channel.Guild.GetUsers().Where(u => u.Roles.Contains(role)).Select(u => u.ToString()));
send += $"\n```";
}
var usr = umsg.Author as IGuildUser;
while (send.Length > 2000)
{
if (!usr.GetPermissions(channel).ManageMessages)
{
await channel.SendMessageAsync($"⚠️ {usr.Mention} **you are not allowed to use this command on roles with a lot of users in them to prevent abuse.**").ConfigureAwait(false);
return;
}
var curstr = send.Substring(0, 2000);
await channel.SendMessageAsync(curstr.Substring(0,
curstr.LastIndexOf(", ", StringComparison.Ordinal) + 1)).ConfigureAwait(false);
send = curstr.Substring(curstr.LastIndexOf(", ", StringComparison.Ordinal) + 1) +
send.Substring(2000);
}
await channel.SendMessageAsync(send).ConfigureAwait(false);
}
public override Task<TypeReaderResult> Read(IUserMessage context, string input)
{
input = input.ToUpperInvariant();
switch (input)
{
case "1":
case "T":
case "TRUE":
case "ENABLE":
case "ENABLED":
case "ALLOW":
case "PERMIT":
case "UNBAN":
return Task.FromResult(TypeReaderResult.FromSuccess(PermissionAction.Enable));
case "0":
case "F":
case "FALSE":
case "DENY":
case "DISABLE":
case "DISABLED":
case "DISALLOW":
case "BAN":
return Task.FromResult(TypeReaderResult.FromSuccess(PermissionAction.Disable));
default:
return Task.FromResult(TypeReaderResult.FromError(CommandError.ParseFailed, "Did not receive a valid boolean value"));
}
}
public async Task MigrateData(IUserMessage umsg)
{
var channel = (ITextChannel)umsg.Channel;
var version = 0;
using (var uow = DbHandler.UnitOfWork())
{
version = uow.BotConfig.GetOrCreate().MigrationVersion;
}
try
{
for (var i = version; i < CURRENT_VERSION; i++)
{
switch (i)
{
case 0:
Migrate0_9To1_0();
break;
}
}
await umsg.Channel.SendMessageAsync("🆙 **Migration done.**").ConfigureAwait(false);
}
catch (Exception ex)
{
_log.Error(ex);
await umsg.Channel.SendMessageAsync("⚠️ **Error while migrating, check `logs` for more informations.**").ConfigureAwait(false);
}
}
//null = not applicable
//true = applicable, allowed
//false = applicable, not allowed
public static bool? CheckPermission(this Permission perm, IUserMessage message, string commandName, string moduleName)
{
if (!((perm.SecondaryTarget == SecondaryPermissionType.Command &&
perm.SecondaryTargetName.ToLowerInvariant() == commandName.ToLowerInvariant()) ||
(perm.SecondaryTarget == SecondaryPermissionType.Module &&
perm.SecondaryTargetName.ToLowerInvariant() == moduleName.ToLowerInvariant()) ||
perm.SecondaryTarget == SecondaryPermissionType.AllModules))
return null;
var guildUser = message.Author as IGuildUser;
switch (perm.PrimaryTarget)
{
case PrimaryPermissionType.User:
if (perm.PrimaryTargetId == message.Author.Id)
return perm.State;
break;
case PrimaryPermissionType.Channel:
if (perm.PrimaryTargetId == message.Channel.Id)
return perm.State;
break;
case PrimaryPermissionType.Role:
if (guildUser == null)
break;
if (guildUser.Roles.Any(r => r.Id == perm.PrimaryTargetId))
return perm.State;
break;
case PrimaryPermissionType.Server:
if (guildUser == null)
break;
return perm.State;
}
return null;
}
public async Task Asar(IUserMessage umsg, [Remainder] IRole role)
{
var channel = (ITextChannel)umsg.Channel;
IEnumerable<SelfAssignedRole> roles;
string msg;
using (var uow = DbHandler.UnitOfWork())
{
roles = uow.SelfAssignedRoles.GetFromGuild(channel.Guild.Id);
if (roles.Any(s => s.RoleId == role.Id && s.GuildId == role.GuildId))
{
msg = $"💢 Role **{role.Name}** is already in the list.";
}
else
{
uow.SelfAssignedRoles.Add(new SelfAssignedRole {
RoleId = role.Id,
GuildId = role.GuildId
});
await uow.CompleteAsync();
msg = $"🆗 Role **{role.Name}** added to the list.";
}
}
await channel.SendMessageAsync(msg.ToString()).ConfigureAwait(false);
}
public async Task Roll(IUserMessage umsg, string arg)
{
var channel = (ITextChannel)umsg.Channel;
if (channel == null)
return;
var ordered = true;
var rng = new NadekoRandom();
Match match;
if ((match = dndRegex.Match(arg)).Length != 0)
{
int n1;
int n2;
if (int.TryParse(match.Groups["n1"].ToString(), out n1) &&
int.TryParse(match.Groups["n2"].ToString(), out n2) &&
n1 <= 50 && n2 <= 100000 && n1 > 0 && n2 > 0)
{
var add = 0;
var sub = 0;
int.TryParse(match.Groups["add"].Value, out add);
int.TryParse(match.Groups["sub"].Value, out sub);
var arr = new int[n1];
for (int i = 0; i < n1; i++)
{
arr[i] = rng.Next(1, n2 + 1) + add - sub;
}
var elemCnt = 0;
await channel.SendMessageAsync($"{umsg.Author.Mention} rolled {n1} {(n1 == 1 ? "die" : "dice")} `1 to {n2}` +`{add}` -`{sub}`.\n`Result:` " + string.Join(", ", (ordered ? arr.OrderBy(x => x).AsEnumerable() : arr).Select(x => elemCnt++ % 2 == 0 ? $"**{x}**" : x.ToString()))).ConfigureAwait(false);
}
}
}
public async Task Placelist(IUserMessage imsg)
{
var channel = (ITextChannel)imsg.Channel;
await channel.SendMessageAsync(typesStr)
.ConfigureAwait(false);
}
public async Task Draw(IUserMessage msg, int num = 1)
{
var channel = (ITextChannel)msg.Channel;
var cards = AllDecks.GetOrAdd(channel.Guild, (s) => new Cards());
var images = new List<Image>();
var cardObjects = new List<Cards.Card>();
if (num > 5) num = 5;
for (var i = 0; i < num; i++)
{
if (cards.CardPool.Count == 0 && i != 0)
{
try { await channel.SendMessageAsync("No more cards in a deck.").ConfigureAwait(false); } catch (Exception ex) { _log.Warn(ex); }
break;
}
var currentCard = cards.DrawACard();
cardObjects.Add(currentCard);
using (var stream = File.OpenRead(Path.Combine(cardsPath, currentCard.ToString().ToLowerInvariant()+ ".jpg").Replace(' ','_')))
images.Add(new Image(stream));
}
MemoryStream bitmapStream = new MemoryStream();
images.Merge().SaveAsPng(bitmapStream);
bitmapStream.Position = 0;
//todo CARD NAMES?
var toSend = $"{msg.Author.Mention}";
if (cardObjects.Count == 5)
toSend += $" drew `{Cards.GetHandValue(cardObjects)}`";
await channel.SendFileAsync(bitmapStream, images.Count + " cards.jpg", toSend).ConfigureAwait(false);
}
public async Task Flip(IUserMessage imsg, int count = 1)
{
var channel = (ITextChannel)imsg.Channel;
if (count == 1)
{
if (rng.Next(0, 2) == 1)
await channel.SendFileAsync(headsPath, $"{imsg.Author.Mention} rolled " + Format.Code("Heads") + ".").ConfigureAwait(false);
else
await channel.SendFileAsync(tailsPath, $"{imsg.Author.Mention} rolled " + Format.Code("Tails") + ".").ConfigureAwait(false);
return;
}
if (count > 10 || count < 1)
{
await channel.SendMessageAsync("`Invalid number specified. You can flip 1 to 10 coins.`");
return;
}
var imgs = new Image[count];
for (var i = 0; i < count; i++)
{
imgs[i] = rng.Next(0, 10) < 5 ?
new Image(File.OpenRead(headsPath)) :
new Image(File.OpenRead(tailsPath));
}
await channel.SendFileAsync(imgs.Merge().ToStream(), $"{count} coins.png").ConfigureAwait(false);
}
public async Task Memelist(IUserMessage umsg)
{
var channel = (ITextChannel)umsg.Channel;
HttpClientHandler handler = new HttpClientHandler();
handler.AllowAutoRedirect = false;
using (var http = new HttpClient(handler))
{
http.DefaultRequestHeaders.Accept.Add(new System.Net.Http.Headers.MediaTypeWithQualityHeaderValue("application/json"));
string rawJson = "";
try
{
rawJson = await http.GetStringAsync("https://memegen.link/api/templates/").ConfigureAwait(false);
}
catch (Exception ex)
{
Console.WriteLine(ex);
}
var data = JsonConvert.DeserializeObject<Dictionary<string, string>>(rawJson)
.Select(kvp => Path.GetFileName(kvp.Value));
await channel.SendTableAsync(data, x => $"{x,-17}", 3);
}
}
public async Task Cash(IUserMessage umsg, [Remainder] IUser user = null)
{
var channel = umsg.Channel;
user = user ?? umsg.Author;
await channel.SendMessageAsync($"{user.Username} has {GetCurrency(user.Id)} {CurrencySign}").ConfigureAwait(false);
}
public async Task Pollend(IUserMessage umsg)
{
var channel = (ITextChannel)umsg.Channel;
Poll poll;
ActivePolls.TryRemove(channel.Guild, out poll);
await poll.StopPoll().ConfigureAwait(false);
}
public async Task Memegen(IUserMessage umsg, string meme, string topText, string botText)
{
var channel = (ITextChannel)umsg.Channel;
var top = Uri.EscapeDataString(topText.Replace(' ', '-'));
var bot = Uri.EscapeDataString(botText.Replace(' ', '-'));
await channel.SendMessageAsync($"http://memegen.link/{meme}/{top}/{bot}.jpg");
}
public Poll(IUserMessage umsg, string question, IEnumerable<string> enumerable, bool isPublic = false)
{
this.originalMessage = umsg;
this.guild = ((ITextChannel)umsg.Channel).Guild;
this.question = question;
this.answers = enumerable as string[] ?? enumerable.ToArray();
this.isPublic = isPublic;
}
public async Task Betflip(IUserMessage umsg, int amount, string guess)
{
var channel = (ITextChannel)umsg.Channel;
var guildUser = (IGuildUser)umsg.Author;
var guessStr = guess.Trim().ToUpperInvariant();
if (guessStr != "H" && guessStr != "T" && guessStr != "HEADS" && guessStr != "TAILS")
return;
if (amount < 3)
{
await channel.SendMessageAsync($"You can't bet less than 3{Gambling.CurrencySign}.")
.ConfigureAwait(false);
return;
}
// todo update this
long userFlowers;
using (var uow = DbHandler.UnitOfWork())
{
userFlowers = uow.Currency.GetOrCreate(umsg.Author.Id).Amount;
}
if (userFlowers < amount)
{
await channel.SendMessageAsync($"{umsg.Author.Mention} You don't have enough {Gambling.CurrencyPluralName}. You only have {userFlowers}{Gambling.CurrencySign}.").ConfigureAwait(false);
return;
}
await CurrencyHandler.RemoveCurrencyAsync(guildUser, "Betflip Gamble", amount, false).ConfigureAwait(false);
//heads = true
//tails = false
var isHeads = guessStr == "HEADS" || guessStr == "H";
bool result = false;
string imgPathToSend;
if (rng.Next(0, 2) == 1)
{
imgPathToSend = headsPath;
result = true;
}
else
{
imgPathToSend = tailsPath;
}
string str;
if (isHeads == result)
{
var toWin = (int)Math.Round(amount * 1.8);
str = $"{umsg.Author.Mention}`You guessed it!` You won {toWin}{Gambling.CurrencySign}";
await CurrencyHandler.AddCurrencyAsync((IGuildUser)umsg.Author, "Betflip Gamble", toWin, false).ConfigureAwait(false);
}
else
{
str = $"{umsg.Author.Mention}`Better luck next time.`";
}
await channel.SendFileAsync(imgPathToSend, str).ConfigureAwait(false);
}
public override Task<TypeReaderResult> Read(IUserMessage context, string input)
{
input = input.ToUpperInvariant();
var module = NadekoBot.CommandService.Modules.FirstOrDefault(m => m.Name.ToUpperInvariant() == input);
if (module == null)
return Task.FromResult(TypeReaderResult.FromError(CommandError.ParseFailed, "No such module found."));
return Task.FromResult(TypeReaderResult.FromSuccess(module));
}
public async Task WowJoke(IUserMessage umsg)
{
var channel = (ITextChannel)umsg.Channel;
if (!wowJokes.Any())
{
}
await channel.SendMessageAsync(wowJokes[new NadekoRandom().Next(0, wowJokes.Count)].ToString());
}
public async Task Race(IUserMessage umsg)
{
var channel = (ITextChannel)umsg.Channel;
var ar = new AnimalRace(channel.Guild.Id, channel);
if (ar.Fail)
await channel.SendMessageAsync("🏁 `Failed starting a race. Another race is probably running.`");
}
public async Task Randjoke(IUserMessage umsg)
{
var channel = (ITextChannel)umsg.Channel;
using (var http = new HttpClient())
{
var response = await http.GetStringAsync("http://tambal.azurewebsites.net/joke/random").ConfigureAwait(false);
await channel.SendMessageAsync("`" + JObject.Parse(response)["joke"].ToString() + "` 😆").ConfigureAwait(false);
}
}
public async Task Yomama(IUserMessage umsg)
{
var channel = (ITextChannel)umsg.Channel;
using (var http = new HttpClient())
{
var response = await http.GetStringAsync("http://api.yomomma.info/").ConfigureAwait(false);
await channel.SendMessageAsync("`" + JObject.Parse(response)["joke"].ToString() + "` 😆").ConfigureAwait(false);
}
}
public async Task ChuckNorris(IUserMessage umsg)
{
var channel = (ITextChannel)umsg.Channel;
using (var http = new HttpClient())
{
var response = await http.GetStringAsync("http://api.icndb.com/jokes/random/").ConfigureAwait(false);
await channel.SendMessageAsync("`" + JObject.Parse(response)["value"]["joke"].ToString() + "` 😆").ConfigureAwait(false);
}
}
public async Task Leet(IUserMessage umsg, int level, [Remainder] string text = null)
{
var channel = (ITextChannel)umsg.Channel;
text = text.Trim();
if (string.IsNullOrWhiteSpace(text))
return;
await channel.SendMessageAsync(ToLeet(text, level)).ConfigureAwait(false);
}
public async Task Jcsc(IUserMessage imsg, int token)
{
var channel = (ITextChannel)imsg.Channel;
ConcurrentHashSet<ITextChannel> set;
if (!Subscribers.TryGetValue(token, out set))
return;
set.Add(channel);
await channel.SendMessageAsync(":ok:").ConfigureAwait(false);
}
public async Task MovePerm(IUserMessage imsg, int from, int to)
{
from -= 1;
to -= 1;
var channel = (ITextChannel)imsg.Channel;
if (!(from == to || from < 0 || to < 0))
{
try
{
Permission fromPerm = null;
Permission toPerm = null;
using (var uow = DbHandler.UnitOfWork())
{
var config = uow.GuildConfigs.PermissionsFor(channel.Guild.Id);
var perms = config.RootPermission;
var root = perms;
var index = 0;
var fromFound = false;
var toFound = false;
while ((!toFound || !fromFound) && perms != null)
{
if (index == from)
{
fromPerm = perms;
fromFound = true;
}
if (index == to)
{
toPerm = perms;
toFound = true;
}
if (!toFound)
{
toPerm = perms; //In case of to > size
}
perms = perms.Next;
index++;
}
if (perms == null)
{
if (!fromFound)
{
await channel.SendMessageAsync($"❗️`Can't find permission at index `#{++from}`").ConfigureAwait(false);
return;
}
if (!toFound)
{
await channel.SendMessageAsync($"❗️`Can't find permission at index `#{++to}`").ConfigureAwait(false);
return;
}
}
//Change chain for from indx
var next = fromPerm.Next;
var pre = fromPerm.Previous;
if (pre != null)
{
pre.Next = next;
}
if (fromPerm.Next == null || toPerm.Next == null)
{
throw new IndexOutOfRangeException();
}
next.Previous = pre;
if (from == 0)
{
root = next;
}
await uow.CompleteAsync().ConfigureAwait(false);
//Inserting
if (to > from)
{
fromPerm.Previous = toPerm;
fromPerm.Next = toPerm.Next;
toPerm.Next.Previous = fromPerm;
toPerm.Next = fromPerm;
}
else
{
pre = toPerm.Previous;
fromPerm.Next = toPerm;
fromPerm.Previous = pre;
toPerm.Previous = fromPerm;
if (pre != null)
{
pre.Next = fromPerm;
}
}
config.RootPermission = fromPerm.GetRoot();
Cache.AddOrUpdate(channel.Guild.Id, new PermissionCache()
{
PermRole = config.PermissionRole,
RootPermission = config.RootPermission,
Verbose = config.VerbosePermissions
}, (id, old) => { old.RootPermission = config.RootPermission; return(old); });
await uow.CompleteAsync().ConfigureAwait(false);
}
await channel.SendMessageAsync($"✅ `Moved permission:` \"{fromPerm.GetCommand(channel.Guild)}\" `from #{++from} to #{++to}.`").ConfigureAwait(false);
return;
}
catch (Exception e) when(e is ArgumentOutOfRangeException || e is IndexOutOfRangeException)
{
}
}
await channel.SendMessageAsync("`Invalid index(es) specified.`").ConfigureAwait(false);
}
public Task <bool> TryBlockEarly(IGuild guild, IUserMessage usrMsg)
=> Task.FromResult((guild != null && BlacklistedGuilds.Contains(guild.Id)) ||
BlacklistedChannels.Contains(usrMsg.Channel.Id) ||
BlacklistedUsers.Contains(usrMsg.Author.Id));
public CustomReaction TryGetCustomReaction(IUserMessage umsg)
{
var channel = umsg.Channel as SocketTextChannel;
if (channel == null)
{
return(null);
}
var content = umsg.Content.Trim().ToLowerInvariant();
if (_guildReactions.TryGetValue(channel.Guild.Id, out var reactions))
{
if (reactions != null && reactions.Any())
{
var rs = reactions.Values.Where(cr =>
{
if (cr == null)
{
return(false);
}
var hasTarget = cr.Response.ToLowerInvariant().Contains("%target%");
var trigger = cr.TriggerWithContext(umsg, _client).Trim().ToLowerInvariant();
return((cr.ContainsAnywhere &&
(content.GetWordPosition(trigger) != WordPosition.None)) ||
(hasTarget && content.StartsWith(trigger + " ", StringComparison.InvariantCulture)) ||
(_bc.BotConfig.CustomReactionsStartWith && content.StartsWith(trigger + " ", StringComparison.InvariantCulture)) ||
content == trigger);
}).ToArray();
if (rs.Length != 0)
{
var reaction = rs[new NadekoRandom().Next(0, rs.Length)];
if (reaction != null)
{
if (reaction.Response == "-")
{
return(null);
}
//using (var uow = _db.UnitOfWork)
//{
// var rObj = uow.CustomReactions.GetById(reaction.Id);
// if (rObj != null)
// {
// rObj.UseCount += 1;
// uow.Complete();
// }
//}
return(reaction);
}
}
}
}
var grs = _globalReactions.Values.Where(cr =>
{
if (cr == null)
{
return(false);
}
var hasTarget = cr.Response.ToLowerInvariant().Contains("%target%");
var trigger = cr.TriggerWithContext(umsg, _client).Trim().ToLowerInvariant();
return((cr.ContainsAnywhere &&
(content.GetWordPosition(trigger) != WordPosition.None)) ||
(hasTarget && content.StartsWith(trigger + " ", StringComparison.InvariantCulture)) ||
(_bc.BotConfig.CustomReactionsStartWith && content.StartsWith(trigger + " ", StringComparison.InvariantCulture)) ||
content == trigger);
}).ToArray();
if (grs.Length == 0)
{
return(null);
}
var greaction = grs[new NadekoRandom().Next(0, grs.Length)];
return(greaction);
}
public async Task TryRunCommand(SocketGuild guild, ITextChannel channel, IUserMessage usrMsg)
{
var execTime = Environment.TickCount;
if (guild != null && guild.OwnerId != usrMsg.Author.Id)
{
if (await InviteFiltered(guild, usrMsg).ConfigureAwait(false))
{
return;
}
if (await WordFiltered(guild, usrMsg).ConfigureAwait(false))
{
return;
}
}
if (IsBlacklisted(guild, usrMsg))
{
return;
}
var exec1 = Environment.TickCount - execTime;
var cleverBotRan = await Task.Run(() => TryRunCleverbot(usrMsg, guild)).ConfigureAwait(false);
if (cleverBotRan)
{
return;
}
var exec2 = Environment.TickCount - execTime;
// maybe this message is a custom reaction
// todo log custom reaction executions. return struct with info
var cr = await Task.Run(() => CustomReactions.TryGetCustomReaction(usrMsg)).ConfigureAwait(false);
if (cr != null) //if it was, don't execute the command
{
try
{
if (guild != null)
{
PermissionCache pc = Permissions.GetCache(guild.Id);
int index;
if (
!pc.Permissions.CheckPermissions(usrMsg, cr.Trigger, "ActualCustomReactions",
out index))
{
//todo print in guild actually
var returnMsg =
$"Permission number #{index + 1} **{pc.Permissions[index].GetCommand(guild)}** is preventing this action.";
_log.Info(returnMsg);
return;
}
}
await cr.Send(usrMsg).ConfigureAwait(false);
if (cr.AutoDeleteTrigger)
{
try { await usrMsg.DeleteAsync().ConfigureAwait(false); } catch { }
}
}
catch (Exception ex)
{
_log.Warn("Sending CREmbed failed");
_log.Warn(ex);
}
return;
}
var exec3 = Environment.TickCount - execTime;
string messageContent = usrMsg.Content;
if (guild != null)
{
ConcurrentDictionary <string, string> maps;
if (Modules.Utility.Utility.CommandMapCommands.AliasMaps.TryGetValue(guild.Id, out maps))
{
var keys = maps.Keys
.OrderByDescending(x => x.Length);
var lowerMessageContent = messageContent.ToLowerInvariant();
foreach (var k in keys)
{
string newMessageContent;
if (lowerMessageContent.StartsWith(k + " "))
{
newMessageContent = maps[k] + messageContent.Substring(k.Length, messageContent.Length - k.Length);
}
else if (lowerMessageContent == k)
{
newMessageContent = maps[k];
}
else
{
continue;
}
_log.Info(@"--Mapping Command--
GuildId: {0}
Trigger: {1}
Mapping: {2}", guild.Id, messageContent, newMessageContent);
var oldMessageContent = messageContent;
messageContent = newMessageContent;
try { await usrMsg.Channel.SendConfirmAsync($"{oldMessageContent} => {newMessageContent}").ConfigureAwait(false); } catch { }
break;
}
}
}
// execute the command and measure the time it took
var exec = await Task.Run(() => ExecuteCommand(new CommandContext(_client, usrMsg), messageContent, DependencyMap.Empty, MultiMatchHandling.Best)).ConfigureAwait(false);
execTime = Environment.TickCount - execTime;
if (exec.Result.IsSuccess)
{
await CommandExecuted(usrMsg, exec.CommandInfo).ConfigureAwait(false);
await LogSuccessfulExecution(usrMsg, exec, channel, exec1, exec2, exec3, execTime).ConfigureAwait(false);
}
else if (!exec.Result.IsSuccess && exec.Result.Error != CommandError.UnknownCommand)
{
LogErroredExecution(usrMsg, exec, channel, exec1, exec2, exec3, execTime);
if (guild != null && exec.CommandInfo != null && exec.Result.Error == CommandError.Exception)
{
if (exec.PermissionCache != null && exec.PermissionCache.Verbose)
{
try { await usrMsg.Channel.SendMessageAsync("⚠️ " + exec.Result.ErrorReason).ConfigureAwait(false); } catch { }
}
}
}
else
{
if (usrMsg.Channel is IPrivateChannel)
{
// rofl, gotta do this to prevent dm help message being sent to
// users who are voting on private polls (sending a number in a DM)
int vote;
if (int.TryParse(usrMsg.Content, out vote))
{
return;
}
await usrMsg.Channel.SendMessageAsync(Help.DMHelpString).ConfigureAwait(false);
await SelfCommands.HandleDmForwarding(usrMsg, ownerChannels).ConfigureAwait(false);
}
}
}
public async Task <bool> RunBehavior(DiscordSocketClient client, IGuild guild, IUserMessage msg)
{
if (guild == null)
{
return(false);
}
if (!ActivePolls.TryGetValue(guild.Id, out var poll))
{
return(false);
}
try
{
return(await poll.TryVote(msg).ConfigureAwait(false));
}
catch (Exception ex)
{
_log.Warn(ex);
}
return(false);
}
public async ValueTask <IUserMessage> SendAsync(bool stealthy = false)
{
if (string.IsNullOrWhiteSpace(Localised) && Embedable == null && Attachment == null)
{
return(null);
}
IUserMessage msg = null;
try
{
var me = Guild?.GetUserAsync(Client.CurrentUser.Id).Result ?? (IUser)Client.CurrentUser;
IsTTS = IsTTS && Channel.UserHasPermission(me, ChannelPermission.SendTTSMessages);
if (Attachment == null)
{
if (GeneralUserSetting.UseEmbeds && Channel.UserHasPermission(me, ChannelPermission.EmbedLinks))
{
msg = await Channel.SendMessageAsync(Localised, IsTTS, Embedable?.GetEmbed().Localise(TextResource), Options);
}
else
{
msg = await Channel.SendMessageAsync(Localised + "\n" + Embedable?.GetString(), IsTTS, null, Options);
}
}
else
{
msg = await Channel.SendFileAsync(Attachment(), AttachmentName, Localised + "\n" + Embedable?.GetString().Localise(TextResource), IsTTS, Options);
}
}
catch (HttpException ex) when(ex.DiscordCode == 50013 || ex.DiscordCode == 50001)
{
Message = new LocalisedString(UNABLE_SEND, ReplyType.Error, Channel, Localised);
Channel = await User.GetOrCreateDMChannelAsync();
return(await SendAsync(stealthy));
}
catch (ArgumentException ex) when(ex.Message.StartsWith("Message content is too long,"))
{
var message = (Localised + "\n" + Embedable?.GetString()).Trim();
if (Attachment != null)
{
message += "\n\n" + TextResource.Format(MESSAGE_CONTAINED_ATTACHMENT, AttachmentName);
}
Attachment = () => message.ToStream();
AttachmentName = "Output.txt";
Message = new LocalisedString(MESSAGE_TOO_LONG, ReplyType.Error);
Embedable = null;
return(await SendAsync(stealthy));
}
catch (Exception ex)
{
if (Handler == null)
{
throw;
}
await Handler(ex, Channel, Localised, Embedable);
}
if (!stealthy)
{
await OnSend(this, msg);
}
Logger.Log(Logging.LogSeverity.Verbose, LogType.Message, $"Sent Message | Channel: {Channel} | Guild: {Guild} | Content: {msg.Content}", "Replier");
return(msg);
}
public static void SetLastTimerMessage(IUserMessage msg)
{
lastTimerMessage = msg;
}
public async Task Table([Summary("Номер страницы")] int pageNum = 0)
{
EmbedBuilder builder = new EmbedBuilder();
builder.Author = new EmbedAuthorBuilder()
{
IconUrl = Context.User.GetAvatarUrl(),
Name = Context.User.Username,
};
builder.Color = Color.DarkBlue;
builder.Title = @"Список товаров";
List <Active> actives = Core.It.ActiveList
.OrderByDescending(Common.Common.GetActiveRating).Skip(_itemsOnPage * pageNum).Take(_itemsOnPage).ToList();
IUserMessage message = await Context.Channel.SendMessageAsync(
string.Empty, false, builder.WithDescription(
$@"```
Page {pageNum + 1}/{(Core.It.ActiveList.Count - 1) / _itemsOnPage + 1}
{new string('-', 60)}
{
string.Join("\r\n",
actives.Select(
x =>
$"|{(_itemsOnPage * pageNum + actives.IndexOf(x) + 1).ToString().PadRight(3)}|{x.Name.PadRight(49)}|{Common.Common.GetActiveRating(x).ToString("C0").PadRight(4)}|"))
}
{new string('-', 60)}
```").Build()
);
ReactInterface react = new ReactInterface(message, Context.User.Id, new[] { '\u2B05'.ToString(), '\u27A1'.ToString() });
react.PageCount = Core.It.ActiveList.Count;
react.PageChangedEvent += async currentPage =>
{
actives = Core.It.ActiveList
.OrderByDescending(x => x.Rating).Skip(_itemsOnPage * currentPage).Take(_itemsOnPage).ToList();
await message.ModifyAsync(prop =>
{
prop.Embed = builder.WithDescription(
$@"```
Page {currentPage + 1}/{(Core.It.ActiveList.Count - 1)/_itemsOnPage + 1}
{
new string('-', 60)}
{
string.Join("\r\n",
actives.Select(
x =>
$"|{(_itemsOnPage*currentPage + actives.IndexOf(x) + 1).ToString().PadRight(3)}➤{x.Name.PadRight(49)}:{Common.Common.GetActiveRating(x).ToString("C0").PadRight(4)}|"))
}
{new string('-', 60)}
```").Build();
});
};
/*
* await message.AddReactionAsync(new Emoji('\u2B05'.ToString()));
* await message.AddReactionAsync(new Emoji('\u27A1'.ToString()));
* await message.AddReactionAsync(new Emoji(@"🚮"));
*/
}
private bool IsSceneChallengeMessage(IUserMessage message)
{
return(message.Embeds.FirstOrDefault()?.Title?.Equals(SceneChallengeResources.SceneChallenge, StringComparison.OrdinalIgnoreCase) ?? false);
}
public abstract Task Start(IUserMessage msg, ICommandContext channel);
public async Task <bool> RunBehavior(DiscordSocketClient client, IGuild guild, IUserMessage msg)
{
// maybe this message is a custom reaction
var cr = await Task.Run(() => TryGetCustomReaction(msg)).ConfigureAwait(false);
if (cr != null)
{
try
{
if (_gperm.BlockedModules.Contains("ActualCustomReactions"))
{
return(true);
}
if (guild is SocketGuild sg)
{
var pc = _perms.GetCacheFor(guild.Id);
if (!pc.Permissions.CheckPermissions(msg, cr.Trigger, "ActualCustomReactions",
out int index))
{
if (pc.Verbose)
{
var returnMsg = _strings.GetText("trigger", guild.Id,
"Permissions".ToLowerInvariant(),
index + 1,
Format.Bold(pc.Permissions[index].GetCommand(_cmd.GetPrefix(guild),
(SocketGuild)guild)));
try { await msg.Channel.SendErrorAsync(returnMsg).ConfigureAwait(false); } catch { }
_log.Info(returnMsg);
}
return(true);
}
}
await cr.Send(msg, _client, this).ConfigureAwait(false);
if (cr.AutoDeleteTrigger)
{
try { await msg.DeleteAsync().ConfigureAwait(false); } catch { }
}
return(true);
}
catch (Exception ex)
{
_log.Warn(ex.Message);
}
}
return(false);
}
public Boolean ActionApplies(IUserMessage message, ISocketMessageChannel channel, SocketReaction reaction)
{
return(reaction.MessageId == Global.RoleManagerMessageId);
}
internal override void Update(Model model)
{
base.Update(model);
if (model.IsTextToSpeech.IsSpecified)
{
_isTTS = model.IsTextToSpeech.Value;
}
if (model.Pinned.IsSpecified)
{
_isPinned = model.Pinned.Value;
}
if (model.EditedTimestamp.IsSpecified)
{
_editedTimestampTicks = model.EditedTimestamp.Value?.UtcTicks;
}
if (model.MentionEveryone.IsSpecified)
{
_isMentioningEveryone = model.MentionEveryone.Value;
}
if (model.Flags.IsSpecified)
{
_isSuppressed = model.Flags.Value.HasFlag(API.MessageFlags.Suppressed);
}
if (model.RoleMentions.IsSpecified)
{
_roleMentionIds = model.RoleMentions.Value.ToImmutableArray();
}
if (model.Attachments.IsSpecified)
{
var value = model.Attachments.Value;
if (value.Length > 0)
{
var attachments = ImmutableArray.CreateBuilder <Attachment>(value.Length);
for (int i = 0; i < value.Length; i++)
{
attachments.Add(Attachment.Create(value[i]));
}
_attachments = attachments.ToImmutable();
}
else
{
_attachments = ImmutableArray.Create <Attachment>();
}
}
if (model.Embeds.IsSpecified)
{
var value = model.Embeds.Value;
if (value.Length > 0)
{
var embeds = ImmutableArray.CreateBuilder <Embed>(value.Length);
for (int i = 0; i < value.Length; i++)
{
embeds.Add(value[i].ToEntity());
}
_embeds = embeds.ToImmutable();
}
else
{
_embeds = ImmutableArray.Create <Embed>();
}
}
if (model.UserMentions.IsSpecified)
{
var value = model.UserMentions.Value;
if (value.Length > 0)
{
var newMentions = ImmutableArray.CreateBuilder <RestUser>(value.Length);
for (int i = 0; i < value.Length; i++)
{
var val = value[i];
if (val.Object != null)
{
newMentions.Add(RestUser.Create(Discord, val.Object));
}
}
_userMentions = newMentions.ToImmutable();
}
}
var guildId = (Channel as IGuildChannel)?.GuildId;
var guild = guildId != null ? (Discord as IDiscordClient).GetGuildAsync(guildId.Value, CacheMode.CacheOnly).Result : null;
if (model.Content.IsSpecified)
{
var text = model.Content.Value;
_tags = MessageHelper.ParseTags(text, null, guild, _userMentions);
model.Content = text;
}
if (model.ReferencedMessage.IsSpecified && model.ReferencedMessage.Value != null)
{
var refMsg = model.ReferencedMessage.Value;
IUser refMsgAuthor = MessageHelper.GetAuthor(Discord, guild, refMsg.Author.Value, refMsg.WebhookId.ToNullable());
_referencedMessage = RestUserMessage.Create(Discord, Channel, refMsgAuthor, refMsg);
}
}
public async Task TryRunCommand(SocketGuild guild, ISocketMessageChannel channel, IUserMessage usrMsg)
{
var execTime = Environment.TickCount;
//its nice to have early blockers and early blocking executors separate, but
//i could also have one interface with priorities, and just put early blockers on
//highest priority. :thinking:
foreach (var beh in _earlyBehaviors)
{
if (await beh.RunBehavior(_client, guild, usrMsg).ConfigureAwait(false))
{
if (beh.BehaviorType == ModuleBehaviorType.Blocker)
{
_log.Info("Blocked User: [{0}] Message: [{1}] Service: [{2}]", usrMsg.Author, usrMsg.Content, beh.GetType().Name);
}
else if (beh.BehaviorType == ModuleBehaviorType.Executor)
{
_log.Info("User [{0}] executed [{1}] in [{2}]", usrMsg.Author, usrMsg.Content, beh.GetType().Name);
}
return;
}
}
var exec2 = Environment.TickCount - execTime;
string messageContent = usrMsg.Content;
foreach (var exec in _inputTransformers)
{
string newContent;
if ((newContent = await exec.TransformInput(guild, usrMsg.Channel, usrMsg.Author, messageContent).ConfigureAwait(false)) != messageContent.ToLowerInvariant())
{
messageContent = newContent;
break;
}
}
var prefix = GetPrefix(guild?.Id);
var isPrefixCommand = messageContent.StartsWith(".prefix", StringComparison.InvariantCultureIgnoreCase);
// execute the command and measure the time it took
if (messageContent.StartsWith(prefix, StringComparison.InvariantCulture) || isPrefixCommand)
{
var(Success, Error, Info) = await ExecuteCommandAsync(new CommandContext(_client, usrMsg), messageContent, isPrefixCommand? 1 : prefix.Length, _services, MultiMatchHandling.Best).ConfigureAwait(false);
execTime = Environment.TickCount - execTime;
if (Success)
{
await LogSuccessfulExecution(usrMsg, channel as ITextChannel, exec2, execTime).ConfigureAwait(false);
await CommandExecuted(usrMsg, Info).ConfigureAwait(false);
return;
}
else if (Error != null)
{
LogErroredExecution(Error, usrMsg, channel as ITextChannel, exec2, execTime);
if (guild != null)
{
await CommandErrored(Info, channel as ITextChannel, Error).ConfigureAwait(false);
}
}
}
else
{
await OnMessageNoTrigger(usrMsg).ConfigureAwait(false);
}
foreach (var exec in _lateExecutors)
{
await exec.LateExecute(_client, guild, usrMsg).ConfigureAwait(false);
}
}
private async Task DeleteMessageAfterTimeout(IUserMessage message, int timeout = 5)
{
await Task.Delay(timeout * 1000);
await message.DeleteAsync();
}
public static bool CheckPermissions(this IEnumerable <Permissionv2> permsEnumerable, IUserMessage message,
string commandName, string moduleName, out int permIndex)
{
var perms = permsEnumerable as List <Permissionv2> ?? permsEnumerable.ToList();
for (int i = perms.Count - 1; i >= 0; i--)
{
var perm = perms[i];
var result = perm.CheckPermission(message, commandName, moduleName);
if (result == null)
{
continue;
}
permIndex = i;
return(result.Value);
}
permIndex = -1; //defaut behaviour
return(true);
}
public ReactionListener(IUserMessage message, Dictionary <int, IEmote> emotes)
{
Message = message;
Emotes = emotes;
}
private static async Task OnReactionAdded(Cacheable <IUserMessage, ulong> incomingMessage, ISocketMessageChannel channel, SocketReaction reaction)
{
try
{
// Don't react to your own reacts!
if (reaction.UserId == Program.DiscordClient.CurrentUser.Id)
{
return;
}
// No active game, no handling
if (activeGame == null)
{
return;
}
// Only handle reacts to blackjack game
if (activeGame.MessageId != incomingMessage.Id)
{
return;
}
// Only handle reacts from the original user, remove the reaction
if (activeGame.UserId != reaction.UserId)
{
IUserMessage message = await incomingMessage.DownloadAsync();
await message.RemoveReactionAsync(reaction.Emote, reaction.User.Value);
return;
}
// Only handle relevant reacts
if (!Reactions.Contains(reaction.Emote))
{
IUserMessage message = await incomingMessage.DownloadAsync();
await message.RemoveReactionAsync(reaction.Emote, reaction.User.Value);
return;
}
if (channel is SocketGuildChannel guildChannel)
{
IUserMessage message = await incomingMessage.DownloadAsync();
await message.RemoveReactionAsync(reaction.Emote, reaction.User.Value);
// Play
switch (reaction.Emote.Name.ToLower())
{
case "hit":
activeGame.DealCardToUser();
break;
case "stand":
activeGame.UserIsStanding = true;
break;
default:
break;
}
if (activeGame.UserIsStanding)
{
PlayDealerHand(message, guildChannel, reaction);
}
else
{
// Build and send
await message.ModifyAsync(x => x.Embed = GetEmbedBuilder().Build());
if (activeGame.UserBusted || activeGame.UserHandValue == 21)
{
PlayDealerHand(message, guildChannel, reaction);
}
}
}
}
catch (Exception ex)
{
Log.Write(ex);
}
}
public async Task Whois(IUserMessage msg, IGuildUser user)
{
}
private static async Task <string> ResolveResponseStringAsync(this string str, IUserMessage ctx, DiscordSocketClient client, string resolvedTrigger, bool containsAnywhere)
{
var substringIndex = resolvedTrigger.Length;
if (containsAnywhere)
{
var pos = ctx.Content.AsSpan().GetWordPosition(resolvedTrigger);
if (pos == WordPosition.Start)
{
substringIndex += 1;
}
else if (pos == WordPosition.End)
{
substringIndex = ctx.Content.Length;
}
else if (pos == WordPosition.Middle)
{
substringIndex += ctx.Content.IndexOf(resolvedTrigger, StringComparison.InvariantCulture);
}
}
var canMentionEveryone = (ctx.Author as IGuildUser)?.GuildPermissions.MentionEveryone ?? true;
var rep = new ReplacementBuilder()
.WithDefault(ctx.Author, ctx.Channel, (ctx.Channel as ITextChannel)?.Guild as SocketGuild, client)
.WithOverride("%target%", () =>
canMentionEveryone
? ctx.Content.Substring(substringIndex).Trim()
: ctx.Content.Substring(substringIndex).Trim().SanitizeMentions(true))
.Build();
str = rep.Replace(str);
#if !GLOBAL_NADEKO
foreach (var ph in regexPlaceholders)
{
str = await ph.Key.ReplaceAsync(str, ph.Value).ConfigureAwait(false);
}
#endif
return(str);
}
public async Task Info(IUserMessage msg)
{
}
public async Task RollDuel(ShmartNumber amount, IUser u)
{
if (Context.User.Id == u.Id)
{
return;
}
if (amount <= 0)
{
return;
}
var embed = new EmbedBuilder()
.WithOkColor()
.WithTitle(GetText("roll_duel"));
var game = new RollDuelGame(_cs, _client.CurrentUser.Id, Context.User.Id, u.Id, amount);
//means challenge is just created
if (_service.Duels.TryGetValue((Context.User.Id, u.Id), out var other))
{
if (other.Amount != amount)
{
await ReplyErrorLocalizedAsync("roll_duel_already_challenged").ConfigureAwait(false);
}
else
{
await RollDuel(u).ConfigureAwait(false);
}
return;
}
if (_service.Duels.TryAdd((u.Id, Context.User.Id), game))
{
game.OnGameTick += Game_OnGameTick;
game.OnEnded += Game_OnEnded;
await ReplyConfirmLocalizedAsync("roll_duel_challenge",
Format.Bold(Context.User.ToString()),
Format.Bold(u.ToString()),
Format.Bold(amount + CurrencySign))
.ConfigureAwait(false);
}
async Task Game_OnGameTick(RollDuelGame arg)
{
var rolls = arg.Rolls.Last();
embed.Description += $@"{Format.Bold(Context.User.ToString())} rolled **{rolls.Item1}**
{Format.Bold(u.ToString())} rolled **{rolls.Item2}**
--
";
if (rdMsg == null)
{
rdMsg = await Context.Channel.EmbedAsync(embed)
.ConfigureAwait(false);
}
else
{
await rdMsg.ModifyAsync(x =>
{
x.Embed = embed.Build();
}).ConfigureAwait(false);
}
}
async Task Game_OnEnded(RollDuelGame rdGame, RollDuelGame.Reason reason)
{
try
{
if (reason == RollDuelGame.Reason.Normal)
{
var winner = rdGame.Winner == rdGame.P1
? Context.User
: u;
embed.Description += $"\n**{winner}** Won {((long)(rdGame.Amount * 2 * 0.98)) + CurrencySign}";
await rdMsg.ModifyAsync(x => x.Embed = embed.Build())
.ConfigureAwait(false);
}
else if (reason == RollDuelGame.Reason.Timeout)
{
await ReplyErrorLocalizedAsync("roll_duel_timeout").ConfigureAwait(false);
}
else if (reason == RollDuelGame.Reason.NoFunds)
{
await ReplyErrorLocalizedAsync("roll_duel_no_funds").ConfigureAwait(false);
}
}
finally
{
_service.Duels.TryRemove((u.Id, Context.User.Id), out var _);
}
}
}
public void Add(ulong channelId, IUserMessage msg)
{
var channelMsgs = _deletedMsgs.GetOrAdd(channelId, x => new ConcurrentBag <IUserMessage>());
channelMsgs.Add(msg);
}
private bool IsBlacklisted(IGuild guild, IUserMessage usrMsg) => (guild != null && BlacklistCommands.BlacklistedGuilds.Contains(guild.Id)) || BlacklistCommands.BlacklistedChannels.Contains(usrMsg.Channel.Id) || BlacklistCommands.BlacklistedUsers.Contains(usrMsg.Author.Id);
private async Task BuildProgressTrackerPostAsync(ChallengeRank cr, string nameOfTrack, IUserMessage messageToEdit = null)
{
if (messageToEdit == null)
{
var tracker = new SceneChallengeInfo(cr, nameOfTrack);
messageToEdit = ReplyAsync(embed: tracker.BuildEmbed() as Embed).Result;
}
else
{
var tracker = new SceneChallengeInfo().FromMessage(messageToEdit, cr);
await messageToEdit.ModifyAsync(msg =>
{
msg.Content = string.Empty;
msg.Embed = tracker.BuildEmbed() as Embed;
});
}
await messageToEdit.RemoveAllReactionsAsync();
_ = Task.Run(async() =>
{
await messageToEdit.AddReactionAsync(DecreaseEmoji);
await messageToEdit.AddReactionAsync(IncreaseEmoji);
await messageToEdit.AddReactionAsync(FullEmoji);
await messageToEdit.AddReactionAsync(emptyChallengeEmoji);
await messageToEdit.AddReactionAsync(fullChallengeEmoji);
await messageToEdit.AddReactionAsync(RollEmoji);
}).ConfigureAwait(false);
return;
}
private async Task Bj_StateUpdated(Blackjack bj)
{
try
{
if (_msg != null)
{
var _ = _msg.DeleteAsync();
}
var c = bj.Dealer.Cards.Select(x => x.GetEmojiString());
var dealerIcon = "❔ ";
if (bj.State == Blackjack.GameState.Ended)
{
if (bj.Dealer.GetHandValue() == 21)
{
dealerIcon = "💰 ";
}
else if (bj.Dealer.GetHandValue() > 21)
{
dealerIcon = "💥 ";
}
else
{
dealerIcon = "🏁 ";
}
}
var cStr = string.Concat(c.Select(x => x.Substring(0, x.Length - 1) + " "));
cStr += "\n" + string.Concat(c.Select(x => x.Last() + " "));
var embed = new EmbedBuilder()
.WithOkColor()
.WithTitle("BlackJack")
.AddField($"{dealerIcon} Dealer's Hand | Value: {bj.Dealer.GetHandValue()}", cStr);
if (bj.CurrentUser != null)
{
embed.WithFooter($"Player to make a choice: {bj.CurrentUser.DiscordUser.ToString()}");
}
foreach (var p in bj.Players)
{
c = p.Cards.Select(x => x.GetEmojiString());
cStr = "-\t" + string.Concat(c.Select(x => x.Substring(0, x.Length - 1) + " "));
cStr += "\n-\t" + string.Concat(c.Select(x => x.Last() + " "));
var full = $"{p.DiscordUser.ToString().TrimTo(20)} | Bet: {p.Bet} | Value: {p.GetHandValue()}";
if (bj.State == Blackjack.GameState.Ended)
{
if (p.State == User.UserState.Lost)
{
full = "❌ " + full;
}
else
{
full = "✅ " + full;
}
}
else if (p == bj.CurrentUser)
{
full = "▶ " + full;
}
else if (p.State == User.UserState.Stand)
{
full = "⏹ " + full;
}
else if (p.State == User.UserState.Bust)
{
full = "💥 " + full;
}
else if (p.State == User.UserState.Blackjack)
{
full = "💰 " + full;
}
embed.AddField(full, cStr);
}
_msg = await Context.Channel.EmbedAsync(embed);
}
catch
{
}
}
private static string ResolveTriggerString(this string str, IUserMessage ctx, DiscordSocketClient client)
=> str.Replace("%bot.mention%", client.CurrentUser.Mention, StringComparison.Ordinal);
private async Task AddReaction(Cacheable <IUserMessage, ulong> message, ISocketMessageChannel channel, SocketReaction reaction)
{
if (reaction.User.Value.IsBot)
{
return;
}
IUserMessage Mess1 = await message.GetOrDownloadAsync();
if ((reaction.Emote.Name == ConstVariables.DEmoji.EDelete.Name) && (reaction.UserId == ConstVariables.DateBase.OwnerID))
{
await Mess1.DeleteAsync();
ConstVariables.Logger.Info($"is grout 'automatic' is func 'AddReaction' is punkt 'delete message' is guild '{(channel as SocketGuildChannel)?.Guild.Name}' is channel '{channel.Name}' is user '{reaction.User.Value.Username}#{reaction.User.Value.Discriminator}'");
}
else if (reaction.Emote.Name == ConstVariables.DEmoji.ERemuv.Name)
{
try
{
foreach (var react in Mess1.Reactions)
{
if (react.Key.Name == ConstVariables.DEmoji.ERemuv.Name)
{
if (react.Value.ReactionCount > 1)
{
return;
}
else
{
break;
}
}
}
String str = Mess1.Content,
copy = "";
int index = 0;
while (str[index] == '<' && (str[index + 1] == '!' || str[index + 1] == '@'))
{
bool isflag = false;
for (; index < str.Length; index++)
{
if (str[index] == '>')
{
break;
}
}
index++;
for (; index < str.Length; index++)
{
if (str[index] == ' ' || str[index] == '?')
{
continue;
}
if (str[index] == '<' && (str[index + 1] == '!' || str[index + 1] == '@'))
{
break;
}
else
{
isflag = true;
break;
}
}
if (isflag)
{
break;
}
}
for (int i = 0; i < index; i++)
{
if (str[i] != '?')
{
copy += str[i];
}
else
{
copy += ',';
}
}
for (; index < str.Length; index++)
{
if (str[index] == '<' && str[index + 1] == ':')
{
while (str[index] != '>')
{
copy += str[index];
index++;
if (index == str.Length)
{
break;
}
}
copy += str[index];
index++;
}
if (index == str.Length)
{
break;
}
if (ConstVariables.Code.ContainsKey(str[index]))
{
copy += ConstVariables.Code[str[index]];
}
else
{
copy += str[index];
}
}
EmbedBuilder builder = new EmbedBuilder();
builder.WithColor(ConstVariables.UserColor);
builder.WithDescription(copy);
builder.WithAuthor(Mess1.Author);
builder.WithTimestamp(Mess1.CreatedAt);
await channel.SendMessageAsync("", false, builder.Build());
ConstVariables.Logger.Info($"is grout 'automatic' is func 'AddReaction' is punkt 'remuv' is guild '{(channel as SocketGuildChannel)?.Guild.Name}' is channel '{channel.Name}' is user '{reaction.User.Value.Username}#{reaction.User.Value.Discriminator}'");
}
catch (Exception e)
{
ConstVariables.Logger.Error($"is grout 'automatic' is func 'AddReaction' is punkt 'remuv' is guild '{(channel as SocketGuildChannel)?.Guild.Name}' is channel '{channel.Name}' is user '{reaction.User.Value.Username}#{reaction.User.Value.Discriminator}' is error '{e}'");
}
}
}
public async Task Buy([Summary("Название контента")] string activeName)
{
IUser autor = Context.Message.Author;
if (Core.It.UserList.All(x => x.Id != autor.Mention))
{
User newUser = new User
{
Id = autor.Mention,
Rating = 1,
Money = 10000
};
Core.It.AddUser(newUser);
}
User currentUser = Core.It.UserList.First(x => x.Id == autor.Mention);
Active active = Core.It.ActiveList.FirstOrDefault(x => x.Name == activeName);
if (active == null)
{
await Context.Channel.SendMessageAsync(@"Контент с таким наименованием не найден");
return;
}
if (currentUser.Money < Common.Common.GetActiveRating(active))
{
await Context.Channel.SendMessageAsync(@"На вашем счету недостаточно средств");
return;
}
await Context.Channel.SendMessageAsync(@"Контент был выслан личным сообщением");
double activeRating = Common.Common.GetActiveRating(active);
Buy buy = new Buy
{
Id = Guid.NewGuid(),
Active = active,
Price = activeRating,
Stamp = DateTime.Now,
User = currentUser
};
Core.It.AddBuy(buy);
currentUser.Money -= activeRating;
active.User.Money += activeRating;
Core.It.Save();
IUserMessage message =
await Context.User
.SendMessageAsync($@"Текущий баланс - {currentUser.Money.ToString(@"C0")}");
await Context.User
.SendMessageAsync($@"{active.Name}
{active.Url}");
ReactInterface react = new ReactInterface(message, Context.User.Id, new [] { @"🔺", @"🔻" });
Action <bool> voteAction = async vote =>
{
Note newNote = new Note
{
Active = active,
Id = Guid.NewGuid(),
User = currentUser,
Value = vote ? 1 : -1
};
Core.It.AddNote(newNote);
await Context.User.SendMessageAsync(
$@"Спасибо за оценку! Контент был оценён {(vote ? "положительно" : "отрицательно")
}.
Текущий рейтинг контента {active.Name} - {Common.Common.GetActiveRating(active)}");
react.Dispose();
};
react.VotedEvent += voteAction;
}
public static Task <string> ResponseWithContextAsync(this CustomReaction cr, IUserMessage ctx, DiscordSocketClient client, bool containsAnywhere) => cr.Response.ResolveResponseStringAsync(ctx, client, cr.Trigger.ResolveTriggerString(ctx, client), containsAnywhere);
