public async Task GetUInfoAsync(SocketGuildUser user = null)
{
// Makes a default value for the user the bot gets info for if the command was given no user.
var userGet = user ?? Context.User as SocketGuildUser;
// Creates new EmbedBuilder.
var userInfo = new Discord.EmbedBuilder()
{
Title = $"Info about **{userGet.Username}**",
ThumbnailUrl = userGet.GetAvatarUrl() ?? userGet.GetDefaultAvatarUrl(),
Color = Discord.Color.Green
};
// Adds fields containing various types of information about the user.
userInfo.AddField("Username & Discriminator", userGet.Username + "#" + userGet.Discriminator, true);
userInfo.AddField("Nickname", userGet.Nickname ?? "None", true);
userInfo.AddField("Account Created At", userGet.CreatedAt.DateTime.ToString(), true);
userInfo.AddField("Joined Server At", userGet.JoinedAt.Value.DateTime.ToString(), true);
if (userGet.Status != Discord.UserStatus.DoNotDisturb)
{
userInfo.AddField("Status", userGet.Status.ToString(), true);
}
else
{
userInfo.AddField("Status", "Do Not Disturb", true);
}
userInfo.AddField("Bot", userGet.IsBot ? "Yes" : "No", true);
// Posts the embed to the channel.
await ReplyAsync("", false, userInfo.Build());
}
private async Task SendMessages(Contract contract, VetMember sender, string message)
{
var stakeHolders = await GetStakeHolders(contract.Id);
var trade = DbContext.Contracts.AsQueryable().Where(c => c.Id == contract.Id).Select(c => c.Trade).First();
// var dmMessage = $@"
//メッセージ元:{trade.Title}
//URL:https://vetcoin.azurewebsites.net/Trades/Contracts?contractId={contract.Id}
//差出人:{sender.Name}
//{message}";
Discord.EmbedBuilder builder = new Discord.EmbedBuilder();
builder.WithTitle(trade.Title)
.WithAuthor(sender.Name, sender.GetAvaterIconUrl(), sender.GetMemberPageUrl(StaticSettings.SiteBaseUrl))
.WithUrl($"https://vetcoin.azurewebsites.net/Trades/Contracts?contractId={contract.Id}")
// .AddField("アクション", "メッセージがあります")
.AddField("メッセージ内容", message);
var messageTargets = stakeHolders.Where(c => c.Id != sender.Id).ToArray();
//#if DEBUG
// messageTargets = new[] { sender };
//#endif
await CoreService.SendDirectMessage(messageTargets, string.Empty, builder.Build());
}
private async Task SalesNotification(UserContext userContext, Vender vender, VenderSale venderSale)
{
var builder = new Discord.EmbedBuilder();
builder
.WithTitle($"{vender.Title} 【購入】")
.WithUrl($"{StaticSettings.SiteBaseUrl}Venders/Details?id={vender.Id}")
.WithAuthor(
userContext.CurrentUser.Name,
userContext.CurrentUser.GetAvaterIconUrl(),
userContext.CurrentUser.GetMemberPageUrl(StaticSettings.SiteBaseUrl)
)
.AddField("金額", $"{venderSale.Amount}{StaticSettings.CurrenryUnit}", false);
if (!string.IsNullOrEmpty(venderSale.Message))
{
builder
.AddField("メッセージ", venderSale.Message, false);
}
var messageTargets = new[] { vender.VetMember };
await CoreService.SendDirectMessage(messageTargets, string.Empty, builder.Build());
}
private async Task SendMessages(Trade trade, VetMember sender, string message)
{
var senderIsOwner = trade.VetMemberId == sender.Id;
var messageTargets =
senderIsOwner ? DbContext.TradeMessages.AsQueryable().Where(c => c.TradeId == trade.Id).Select(c => c.VetMember).Distinct().ToArray()
: new[] { trade.VetMember };
var dmMessage = $@"
メッセージ元:{trade.Title}
URL:{StaticSettings.SiteBaseUrl}Trades/Details?id={trade.Id}
差出人:{sender.Name}
{message}";
Discord.EmbedBuilder builder = new Discord.EmbedBuilder();
builder.WithTitle(trade.Title)
.WithAuthor(sender.Name, sender.GetAvaterIconUrl(), sender.GetMemberPageUrl(StaticSettings.SiteBaseUrl))
.WithUrl($"{StaticSettings.SiteBaseUrl}Trades/Details?id={trade.Id}")
// .AddField("アクション", "メッセージがあります")
.AddField("メッセージ内容", message);
await CoreService.SendDirectMessage(messageTargets, string.Empty, builder.Build());
}
public static Discord.EmbedBuilder ForEach <T>(this Discord.EmbedBuilder builder, IEnumerable <T> collection, Action <Discord.EmbedBuilder, T> action)
{
foreach (var item in collection)
{
action(builder, item);
}
return(builder);
}
private async Task ErrorAsync(string message)
{
Discord.EmbedBuilder embed = new Discord.EmbedBuilder();
embed.Title = "whois Command Error";
embed.Description = "An error has occurred trying to execute your command.";
embed.AddField("Error Message", message);
await ReplyAsync(null, false, embed.Build());
}
public static async Task <Discord.EmbedBuilder> AddFieldAsync(this Discord.EmbedBuilder builder, Func <Discord.EmbedFieldBuilder, Task> fieldBuilder)
{
var field = new Discord.EmbedFieldBuilder();
await fieldBuilder(field).ConfigureAwait(false);
builder.AddField(field);
return(builder);
}
public async Task AboutAsync()
{
Discord.EmbedBuilder embed = new Discord.EmbedBuilder();
embed.Title = "Master Spriggans";
embed.Description = "The provider of callouts to all those in need.";
embed.AddField("About Me", "I'm a discord bot. I'm not ready for use yet, but I will be soon.");
embed.ThumbnailUrl = _renaThumbnail;
await ReplyAsync(null, false, embed.Build());
}
public async Task SendEmbedAsync(string v1, Embed v3)
{
var builder = new Discord.EmbedBuilder();
foreach (var value in v3)
{
builder.AddInlineField(value.Key, value.Value);
}
await DiscordSocketMessage.Channel.SendMessageAsync(v1, false, builder.Build());
}
private async Task SendConfirmNotificationAsync(ExteralApplication app, VetMember user, ExteralApplicationPayment eap)
{
Discord.EmbedBuilder builder = new Discord.EmbedBuilder();
builder.WithTitle($"{app.Name}:購入確認");
builder.WithUrl(app.CallbackUrl + $"?id={eap.Id}");
builder.WithAuthor(app.VetMember.Name, app.VetMember.GetAvaterIconUrl(), app.VetMember.GetMemberPageUrl(StaticSettings.SiteBaseUrl));
builder.AddField("金額", eap.Amount);
builder.WithDescription(eap.Description);
builder.WithFooter("よろしければ、タイトルをクリックして購入処理をつづけてください");
await CoreService.SendDirectMessage(new[] { user }, string.Empty, builder.Build());
}
private void SendRaport()
{
var embed = new Discord.EmbedBuilder();
embed.WithTitle($"Results of the battle in __**{this.attackedSystem}**__");
embed.WithColor(new Discord.Color(255, 0, 0));
embed.WithCurrentTimestamp();
embed.AddField("Time of battle", $"From: {this.encounterStart.ToString("T")}\nTo: {this.lastNotification.ToString("T")}\nTotal: {this.GetEncounterTime().ToString(@"hh\:mm\:ss")}", false);
embed.AddField("Statistics", $"Total number of characters attacking: {this.attackingPlayers.Count}\nTotal number of teams attacking: {this.attackingTeams.Count}\nNumber of messages: {this.totalMessageAmount}", false);
embed.AddField("Players attacking", string.Join("\n", this.attackingPlayers.ToArray()), false);
embed.AddField("Teams attacking", string.Join("\n", this.attackingTeams.ToArray()), false);
_ = this.discordApi.EmbedObjectAsync(this.channelID, embed.Build(), true);
}
private Task Result(string arg)
{
int haramLevel = _random.Next(101);
int barLevel = (int)Math.Round((double)haramLevel / 5);
var embed = new Discord.EmbedBuilder()
.WithTitle("Haram Meter")
.WithDescription($"{arg} is {haramLevel}% haram.\n`Halal` {new String('-', barLevel)}🔵{new String('-', 20 - barLevel)} `Haram`");
ReplyAsync("", false, embed.Build());
return(Task.CompletedTask);
}
public Discord.Embed FormatPlay(PlayFile playFile)
{
var game = playFile.Games.FirstOrDefault();
var location = playFile.Locations.FirstOrDefault();
var play = playFile.Plays.FirstOrDefault();
var playerScores = play?.PlayerScores;
var players = playFile.Players;
var builder = new Discord.EmbedBuilder()
.WithTitle(game?.Name ?? "None")
.WithDescription(BuildDescription(location, play))
.WithFooter(BuildFooter(game))
.WithThumbnailUrl(game.UrlThumb)
.WithColor(Discord.Color.Green);
if (DateTimeOffset.TryParse(play.EntryDate, out DateTimeOffset timestamp))
{
builder.WithTimestamp(timestamp.ToLocalTime());
}
if (play.UsesTeams)
{
var teams = playerScores.GroupBy(x => x.Team).OrderBy(g => g.Key);
var i = 1;
foreach (var team in teams)
{
var teamWon = team.Any(x => x.Winner);
var teamName = $"\r\nTeam {i++}{(teamWon ? " :trophy:" : "")}";
var sb = new StringBuilder();
foreach (var playerScore in team)
{
var playerData = players.FirstOrDefault(x => x.Id == playerScore.PlayerRefId);
if (playerData == null)
{
continue;
}
sb.AppendLine($"{playerData.Name}{(string.IsNullOrEmpty(playerScore.Score) ? "" : $" - {playerScore.Score}")}");
sb.AppendLine($"```{(string.IsNullOrEmpty(playerScore.TeamRole) ? "" : $"Role: {playerScore.TeamRole}\r\n")}BGG: {(string.IsNullOrEmpty(playerData.BggUsername) ? "Not set" : playerData.BggUsername)}```");
}
builder.AddField(x =>
{
x.Name = teamName;
x.Value = sb.ToString();
});
}
}
private async Task DeliveryMessage(UserContext userContext, Vender vender, VenderSale venderSale)
{
var builder = new Discord.EmbedBuilder();
builder
.WithTitle($"{vender.Title} 【購入】")
.WithUrl($"{StaticSettings.SiteBaseUrl}Venders/Details?id={vender.Id}")
.WithAuthor(
userContext.CurrentUser.Name,
userContext.CurrentUser.GetAvaterIconUrl(),
userContext.CurrentUser.GetMemberPageUrl(StaticSettings.SiteBaseUrl)
)
.AddField("金額", $"{venderSale.Amount}{StaticSettings.CurrenryUnit}", false);
//.AddField("メッセージ", venderSale.Message, false);
if (!string.IsNullOrEmpty(venderSale.Message))
{
builder
.AddField("メッセージ", venderSale.Message, false);
}
//if (!string.IsNullOrEmpty(vender.DeliveryMessage))
//{
// builder.WithDescription(vender.DeliveryMessage);
//}
//else
//{
// builder.WithDescription("[配信メッセージが未設定です]");
//}
string message = null;
if (!string.IsNullOrEmpty(vender.DeliveryMessage))
{
message = $@"販売者からのメッセージです
----------------------------
{vender.DeliveryMessage}";
}
else
{
}
var messageTargets = new[] { userContext.CurrentUser };
await CoreService.SendDirectMessage(messageTargets, message, builder.Build());
await Task.Yield();
}
private void userinfo(ServerMessage e, string m)
{
var user = Funcs.GetUserByMentionOrName(e.Server.Users, m);
if (user != null)
{
var eb = new Discord.EmbedBuilder().WithAuthor("The Overbork", server.DC.CurrentUser.GetAvatarUrl()).WithCurrentTimestamp();
eb.WithTitle(user.Nickname + "(" + user.Username + ")").WithDescription(user.Mention);
eb.AddInlineField("Status", user.Status).AddInlineField("Joined", user.JoinedAt).AddInlineField("Hierarchy Position", user.Hierarchy).AddInlineField("Registered", user.CreatedAt);
var embed = eb.Build();
server.safeSendEmbed(e.Channel, embed);
}
else
{
server.safeSendMessage(e.Channel, "Could not find user: " + m);
}
}
public void UploadScreenshot(string name)
{
if (ChessService.CurrentGame == null || ChessService.CurrentGame.HasEnded)
{
RespondRaw("Failed", 500);
return;
}
if (SelfPlayer == null)
{
RespondRaw("Failed", 400);
return;
}
var p = ChessService.CurrentGame.GetPlayer(SelfPlayer.Id);
if (p == null)
{
RespondRaw("Not connected to chess", 403);
return;
}
if (!p.ExpectDemand)
{
RespondRaw("Unexpected image", 400);
return;
}
var path = Path.Combine(Program.BASE_PATH, "ChessO", "Demands", DateTime.Now.DayOfYear.ToString("000"));
if (!Directory.Exists(path))
{
Directory.CreateDirectory(path);
}
string fName = $"{SelfPlayer.Id.ToString("00")}_{p.DemandsSent.ToString("000")}_{name}.png";
p.DemandsSent++;
path = Path.Combine(path, fName);
SaveFile(Context.Request.ContentEncoding, GetBoundary(Context.Request.ContentType),
new MemoryStream(Encoding.UTF8.GetBytes(Context.Body)), path);
var builder = new Discord.EmbedBuilder();
builder.Title = "Desktop Uploaded";
builder.Description = $"In response to admin demand, {SelfPlayer.Name} has uploaded a screenshot of their screens.\n" +
$"For privacy purposes, this screenshot will be reviewed by the Chief Justice and released to their discretion";
builder.AddField("File Name", fName);
ChessS.LogAdmin(builder);
RespondRaw("Saved");
}
private async Task EmbedCharacterAsync(CharacterResponseModel xivApiResponse)
{
if (xivApiResponse.Error.HasValue)
{
await ErrorAsync(xivApiResponse.Message);
return;
}
CharacterModel character = xivApiResponse.Character;
Discord.EmbedBuilder embed = new Discord.EmbedBuilder();
embed.Title = character.Name;
embed.ImageUrl = character.Portrait;
embed.ThumbnailUrl = character.Avatar;
await ReplyAsync(null, false, embed.Build());
}
public void UploadProcesses()
{
if (ChessService.CurrentGame == null || ChessService.CurrentGame.HasEnded)
{
RespondRaw("Failed", 500);
return;
}
if (SelfPlayer == null)
{
RespondRaw("Failed", 400);
return;
}
var p = ChessService.CurrentGame.GetPlayer(SelfPlayer.Id);
if (p == null)
{
RespondRaw("Not connected to chess", 403);
return;
}
if (!p.ExpectDemand)
{
RespondRaw("Unexpected image", 400);
return;
}
var path = Path.Combine(Program.BASE_PATH, "ChessO", "Demands", DateTime.Now.DayOfYear.ToString("000"));
if (!Directory.Exists(path))
{
Directory.CreateDirectory(path);
}
string fName = $"{SelfPlayer.Id.ToString("00")}_{p.DemandsSent.ToString("000")}_processes.txt";
p.DemandsSent++;
File.WriteAllText(Path.Combine(path, fName), Context.Body);
var builder = new Discord.EmbedBuilder();
builder.Title = "Processes Gathered";
builder.Description = $"In response to admin demand, {SelfPlayer.Name} has sent a list of active processes.\n" +
$"For privacy purposes, this screenshot will be reviewed by the Chief Justice and released to their discretion";
builder.AddField("File Name", fName);
ChessS.LogAdmin(builder);
RespondRaw("Saved");
}
//private async Task<VetMember[]> GetStakeHolders(int id)
//{
// var contractMember = DbContext.Contracts.AsQueryable().Where(c => c.Id == id).Select(c => c.VetMember);
// var tradeMember = DbContext.Contracts.AsQueryable().Where(c => c.Id == id).Select(c => c.Trade.VetMember);
// var messageMembers = DbContext.TradeMessages.AsQueryable().Where(c => c.TradeId == id).Select(c => c.VetMember);
// var stakeHolders = contractMember.Concat(tradeMember).Concat(messageMembers).Distinct();
// return await stakeHolders.ToArrayAsync();
//}
private async Task SendMessages(Contract contract, VetMember sender, VetMember reciver, VetMember postUser)
{
//var stakeHolders = await GetStakeHolders(contract.Id);
var trade = DbContext.Contracts.AsQueryable().Where(c => c.Id == contract.Id).Select(c => c.Trade).First();
Discord.EmbedBuilder builder = new Discord.EmbedBuilder();
builder.WithTitle(trade.Title)
.WithAuthor(postUser.Name, postUser.GetAvaterIconUrl(), postUser.GetMemberPageUrl(StaticSettings.SiteBaseUrl))
.WithUrl($"https://vetcoin.azurewebsites.net/Trades/Contracts?contractId={contract.Id}")
.AddField("アクション", "作業完了通知")
.AddField("メッセージ内容", @"作業完了したようです。
納品物などを確認して契約完了ボタンをおしてください");
var messageTargets = new[] { sender };
await CoreService.SendDirectMessage(messageTargets, string.Empty, builder.Build());
}
public Discord.Embed getHelpMessageEmbed()
{
var eb = new Discord.EmbedBuilder().WithAuthor("The Overbork", server.DC.CurrentUser.GetAvatarUrl()).WithCurrentTimestamp();
eb.WithTitle(name).WithDescription(helpmessage.getDescription()).AddInlineField("Format", helpmessage.getFormat()).AddInlineField("Permission Required", priv == PrivilegeLevel.Everyone ? "None" : "Bot Admin");
var args = helpmessage.getArguments().SelectMany(x => x + "\n").ToArray();
eb.AddField("Arguments", args.Length == 0 ? "None" : new String(args));
/* const int maxFieldSize = 1024;
* for (int i = 0; i < ((botInfo.Length + (maxFieldSize - 1)) / maxFieldSize); i++)
* {
* int remLen = botInfo.Length - i * maxFieldSize;
* int len = remLen < maxFieldSize ? remLen : maxFieldSize;
* eb = eb.AddField("help" + i, botInfo.Substring(i * maxFieldSize, len));
* }
* safeSendEmbed(e.Channel, eb.Build());*/
return(eb.Build());
}
private async Task SendMessages(Vender vender, VetMember sender, string message)
{
var senderIsOwner = vender.VetMemberId == sender.Id;
var messageTargets =
senderIsOwner ? DbContext.VenderMessages
.AsQueryable()
.Where(c => c.VenderId == vender.Id)
.Select(c => c.VetMember).Distinct().ToArray()
: new[] { vender.VetMember };
Discord.EmbedBuilder builder = new Discord.EmbedBuilder();
builder.WithTitle($"{ vender.Title} 【メッセージ】")
.WithAuthor(sender.Name, sender.GetAvaterIconUrl(), sender.GetMemberPageUrl(StaticSettings.SiteBaseUrl))
.WithUrl($"{StaticSettings.SiteBaseUrl}Venders/Details?id={vender.Id}")
.AddField("内容", message);
await CoreService.SendDirectMessage(messageTargets, string.Empty, builder.Build());
}
public void UploadChromeTabs()
{
if (ChessService.CurrentGame == null || ChessService.CurrentGame.HasEnded)
{
RespondRaw("Failed", 500);
return;
}
if (SelfPlayer == null)
{
RespondRaw("Failed", 400);
return;
}
var p = ChessService.CurrentGame.GetPlayer(SelfPlayer.Id);
if (p == null)
{
RespondRaw("Not connected to chess", 403);
return;
}
// we dont expect anything, client pro-actively notifies
var path = Path.Combine(Program.BASE_PATH, "ChessO", "Demands", DateTime.Now.DayOfYear.ToString("000"));
if (!Directory.Exists(path))
{
Directory.CreateDirectory(path);
}
string fName = $"{SelfPlayer.Id.ToString("00")}_{p.DemandsSent.ToString("000")}_chrome.txt";
p.DemandsSent++;
File.WriteAllText(Path.Combine(path, fName), Context.Body);
var builder = new Discord.EmbedBuilder();
builder.Title = "Chrome Processes";
builder.Description = $"Client has identified possible concern in open Chrome tabs.\n" +
$"For privacy purposes, the tab names will be reviewed by the Chief Justice and released to their discretion";
builder.AddField("File Name", fName);
ChessS.LogAdmin(builder);
RespondRaw("Saved");
}
private async Task ReplyWithResponse(QueryResponse response, Discord.EmbedBuilder overload = null)
{
Discord.EmbedBuilder embed = overload;
if (overload == null)
{
embed = new Discord.EmbedBuilder
{
Title = response.Title,
Description = WebUtility.HtmlDecode(response.Description),
Url = response.Url,
Color = new Discord.Color(104, 33, 122),
Author = new Discord.EmbedAuthorBuilder
{
Name = $"{new Uri(response.Url).Host} (click for more)",
Url = response.ListingUrl
}
};
}
await ReplyAsync($"Found something for **{response.OriginalQuery}**!", false, embed);
}
private async Task Notification(VetMember from, VetMember to, long amount, string message, long totalAmount)
{
var builder = new Discord.EmbedBuilder();
builder
.WithTitle($"{from.Name} から{amount}{StaticSettings.CurrenryUnit} 送金されました")
.WithAuthor(
from.Name,
from.GetAvaterIconUrl(),
from.GetMemberPageUrl(StaticSettings.SiteBaseUrl)
)
.AddField("金額", $"{amount}{StaticSettings.CurrenryUnit}", false)
.AddField("残高", $"{totalAmount}{StaticSettings.CurrenryUnit}", false);
if (!string.IsNullOrEmpty(message))
{
builder
.AddField("メッセージ", message, false);
}
var messageTargets = new[] { to };
await CoreService.SendDirectMessage(messageTargets, string.Empty, builder.Build());
}
protected override async Task Run(SocketMessage sm, string msg)
{
if (!Server.GetServerFromID(_id, out Server server))
{
await Bot.Instance.Send(sm.Channel.Id, "Server not found. Either the server does not exist, or its server page is disabled.");
return;
}
Discord.EmbedBuilder eb = new Discord.EmbedBuilder()
.WithTitle(server.Name)
.AddField("Type", server.Type, true)
.AddField("Location", server.Location, true);
if (_desc != null)
{
eb.Description = _desc;
}
await Bot.Instance.Send(Config.Profile.AdChannel, embed : eb.Build());
await Bot.Instance.Send(sm.Channel.Id, "Message sent!");
}
private async void OnCommandRecieved(BotWideCommandArguments args)
{
BotChannel bChan = await GetBotChannel(args);
if (bChan == null)
{
return;
}
await DBVerify(bChan);
InsultSettings settings = await Settings <InsultSettings>(bChan, PluginName);
BotWideResponseArguments response = new BotWideResponseArguments(args);
if (args.command.ToLower() == "insult" && settings._active)
{
string pickedLine = dbStrings.GetRandomLine(bChan, "INSULT");
response.message = pickedLine;
response.parseMessage = true;
response.victim = args.user;
Respond(bChan, response);
}
if (!args.isModerator && !args.isBroadcaster && !args.canManageMessages)
{
// No access below
return;
}
if (args.command.ToLower() == "insults")
{
// Blank insults response here
if (args.arguments.Count == 0)
{
if (args.source == MESSAGESOURCE.DISCORD)
{
Discord.EmbedFooterBuilder footer = new Discord.EmbedFooterBuilder {
Text = $"The plugin is currently {(settings._active ? "active" : "inactive")} here."
};
Discord.EmbedBuilder embedded = new Discord.EmbedBuilder {
Title = "Plugin: Insults ",
Description = HelpText(settings),
Color = Discord.Color.DarkOrange,
Footer = footer
};
await SayEmbedOnDiscord(args.channelID, embedded.Build());
return;
}
if (args.source == MESSAGESOURCE.TWITCH)
{
response.message = $"The plugin is currently {(settings._active ? "active" : "inactive")} here.";
Respond(bChan, response);
return;
}
}
// resolve subcommands
switch (args.arguments[0])
{
case "off":
settings._active = false;
SaveBaseSettings(bChan, PluginName, settings);
response.message = $"Insults is inactive.";
Respond(bChan, response);
break;
case "on":
settings._active = true;
SaveBaseSettings(bChan, PluginName, settings);
response.message = $"Insults is active.";
Respond(bChan, response);
break;
case "add":
if (args.source == MESSAGESOURCE.TWITCH)
{
return;
}
if (args.arguments.Count <= 1)
{
response.message = "You need to have line after the add. Use [VICTIM] as replacement of the user's name.";
Respond(bChan, response);
return;
}
args.arguments.RemoveAt(0);
string line = string.Empty;
foreach (string part in args.arguments)
{
line += " " + part;
}
line = line.Trim();
dbStrings.SaveNewLine(bChan, "INSULT", line);
response.message = $"Added one more line for the Insult plugin.";
Respond(bChan, response);
break;
case "use":
if (args.source == MESSAGESOURCE.TWITCH)
{
return;
}
if (args.arguments.Count <= 1)
{
response.message = "You need to give a valid ID. Check the List command to see ID for the lines in the database.";
Respond(bChan, response);
return;
}
int id = -1;
int.TryParse(args.arguments[1], out id);
if (id < 1)
{
response.message = "You need to give a valid ID. That ID couldn't be used.";
Respond(bChan, response);
return;
}
DBString entry = await dbStrings.GetStringByID(bChan, id);
if (entry == null)
{
response.message = "That ID didn't match anything I could find. Doublecheck it.";
Respond(bChan, response);
return;
}
DBString edited = new DBString(entry._id, !entry._inuse, entry._topic, entry._text);
if (dbStrings.SaveEditedLineByID(bChan, edited))
{
response.message = "Entry updated.";
}
else
{
response.message = "Failed to update entry.";
}
Respond(bChan, response);
break;
case "remove":
if (args.arguments.Count <= 1)
{
response.message = "You need to give a valid ID. Check the List command to see ID for the lines in the database.";
Respond(bChan, response);
return;
}
int id2 = -1;
int.TryParse(args.arguments[1], out id2);
if (id2 < 1)
{
response.message = "You need to give a valid ID. That ID couldn't be used.";
Respond(bChan, response);
return;
}
DBString entry2 = await dbStrings.GetStringByID(bChan, id2);
if (entry2 == null)
{
response.message = "That ID didn't match anything I could find. Doublecheck it.";
Respond(bChan, response);
return;
}
if (entry2._inuse)
{
response.message = $"Only entries that is not in use can be deleted. Use \"{CMC}insults use <ID>\" to toggle the inuse flag on entries.";
Respond(bChan, response);
return;
}
// Remove the actual entry
if (dbStrings.DeleteEntry(bChan, id2))
{
response.message = $"Entry {id2} deleted.";
Respond(bChan, response);
return;
}
response.message = $"Failed to delete line {id2} for some reason.";
Respond(bChan, response);
break;
case "list":
if (args.source != MESSAGESOURCE.DISCORD)
{
return;
}
if (args.arguments.Count == 1)
{
await ListLinesFromDB(bChan, args.channelID, 0);
return;
}
int page = 0;
int.TryParse(args.arguments[1], out page);
if (page <= 0)
{
page = 1;
}
await ListLinesFromDB(bChan, args.channelID, page - 1);
break;
}
}
}
private async void OnCommandRecieved(BotWideCommandArguments args)
{
BotChannel bChan = await GetBotChannel(args);
if (bChan == null)
{
return;
}
QueueSettings settings = await Settings <QueueSettings>(bChan, PluginName);
BotWideResponseArguments response = new BotWideResponseArguments(args);
if (settings._active && args.source == MESSAGESOURCE.TWITCH && (args.command.ToLower() == "addqueue" || args.command.ToLower() == "aq"))
{
QueueUp(bChan, args.userDisplayName);
return;
}
if (settings._active && args.source == MESSAGESOURCE.TWITCH && (args.command.ToLower() == "leavequeue" || args.command.ToLower() == "lq"))
{
if (QueueLeave(bChan, args.userDisplayName))
{
response.message = $"{args.userDisplayName} left the queue";
response.parseMessage = true;
response.victim = args.user;
Respond(bChan, response);
}
return;
}
if (!args.isModerator && !args.isBroadcaster && !args.canManageMessages)
{
// No access below
return;
}
if (args.command.ToLower() == "queue")
{
// Blank queue response here
if (args.arguments.Count == 0)
{
if (args.source == MESSAGESOURCE.DISCORD)
{
Discord.EmbedFooterBuilder footer = new Discord.EmbedFooterBuilder
{
Text = $"The plugin is currently {(settings._active ? "active" : "inactive")} here.{(HasActiveQueue(bChan) ? $" {QueuedUserCount(bChan)} in queue." : "")}"
};
Discord.EmbedBuilder embedded = new Discord.EmbedBuilder
{
Title = "Plugin: Queue ",
Description = HelpText(settings),
Color = Discord.Color.DarkOrange,
Footer = footer
};
await SayEmbedOnDiscord(args.channelID, embedded.Build());
return;
}
if (args.source == MESSAGESOURCE.TWITCH)
{
response.message = $"The plugin is currently {(settings._active ? "active" : "inactive")} here.{(HasActiveQueue(bChan) ? $" {QueuedUserCount(bChan)} in queue." : "")}";
Respond(bChan, response);
return;
}
}
// resolve subcommands
switch (args.arguments[0])
{
case "off":
settings._active = false;
SaveBaseSettings(bChan, PluginName, settings);
response.message = $"Queue is inactive.";
Respond(bChan, response);
break;
case "on":
settings._active = true;
SaveBaseSettings(bChan, PluginName, settings);
response.message = $"Queue is active.";
Respond(bChan, response);
break;
case "next":
if (settings._active)
{
response.message = NextInQueue(bChan);
Respond(bChan, response);
if (response.source == MESSAGESOURCE.DISCORD && bChan.TwitchChannelName != string.Empty)
{
Program.TwitchSayMessage(bChan.TwitchChannelName, response.message);
}
}
break;
case "reset":
if (settings._active)
{
CreateQueue(bChan, settings);
response.message = "Queue reset";
Respond(bChan, response);
if (response.source == MESSAGESOURCE.DISCORD && bChan.TwitchChannelName != string.Empty)
{
Program.TwitchSayMessage(bChan.TwitchChannelName, response.message);
}
}
break;
case "start":
if (settings._active)
{
CreateQueue(bChan, settings);
response.message = $"Queue started";
Respond(bChan, response);
if (response.source == MESSAGESOURCE.DISCORD && bChan.TwitchChannelName != string.Empty)
{
Program.TwitchSayMessage(bChan.TwitchChannelName, response.message);
}
}
break;
case "stop":
if (settings._active)
{
StopQueue(bChan);
response.message = $"Queue stopped.";
Respond(bChan, response);
if (response.source == MESSAGESOURCE.DISCORD && bChan.TwitchChannelName != string.Empty)
{
Program.TwitchSayMessage(bChan.TwitchChannelName, response.message);
}
}
break;
}
}
}
public async Task Price([Remainder, Summary("Item name")] string item)
{
try
{
item = item.ToLower();
if (!bItemsCached)
{
using (StreamReader sr = new StreamReader(@"res\osrsitems.txt"))
{
string itemsJson = await sr.ReadToEndAsync();
string format = itemsJson.Trim(new char[] { '{', '}' });
List <string> items = format.Split(new string[] { "}," }, StringSplitOptions.None).ToList <string>();
for (int i = 0; i < items.Count; i++)
{
items[i] = items[i].Trim().Replace("\"", String.Empty).Replace("{", String.Empty);
string[] itemArray = items[i].Split('\n');
string id = itemArray[0].Trim('\"').Split(':').First();
string name = itemArray[1].Split(':').Last().Replace(",", String.Empty).Trim();
bool trade = Boolean.Parse(itemArray[3].Split(':').Last().Replace(",", String.Empty).Trim());
RunescapeItem rsItem = new RunescapeItem(id, name, trade);
try
{
if (trade)
{
dictItems.Add(rsItem.Name.ToLower(), rsItem);
}
}
catch
{
}
}
}
bItemsCached = true;
}
RunescapeItem OsrsItem = dictItems[item];
if (!OsrsItem.Trade)
{
await Context.Channel.SendMessageAsync("Item is not tradeable!");
return;
}
string itemId = OsrsItem.Id;
string responseString = await client.GetStringAsync($"http://services.runescape.com/m=itemdb_oldschool/api/catalogue/detail.json?item={itemId}");
XmlDocument docItem = JsonConvert.DeserializeXmlNode(responseString);
XmlNode ndItem = docItem.DocumentElement;
string price = ndItem.SelectSingleNode("current/price").InnerText;
string icon = ndItem.SelectSingleNode("icon_large").InnerText;
string trend = ndItem.SelectSingleNode("day30/change").InnerText;
var embed = new Discord.EmbedBuilder();
embed.WithImageUrl(icon);
await Context.Channel.SendMessageAsync($"{item}: {price} gp", false, embed.Build());
await Context.Channel.SendMessageAsync($"Trend: {trend}");
}
catch (Exception ex)
{
await Context.Channel.SendMessageAsync($"Error looking item in GE. Item is either untradeable or spelled wrong.");
}
}
public static Discord.EmbedBuilder Conditionally(this Discord.EmbedBuilder builder, bool condition, Func <Discord.EmbedBuilder, Discord.EmbedBuilder> action) => condition?action(builder) : builder;
public static Discord.EmbedBuilder AddInlineField(this Discord.EmbedBuilder builder, string name, object value)
{
return(builder.AddField(name, value, inline: true));
}
