325 lines
15 KiB
C#
325 lines
15 KiB
C#
using Discord;
|
|
using Discord.WebSocket;
|
|
using OpenMetaverse;
|
|
using System;
|
|
using System.Text;
|
|
using System.Threading.Tasks;
|
|
using System.Linq;
|
|
using System.Threading;
|
|
|
|
namespace BetterSecondBot.DiscordSupervisor
|
|
{
|
|
public abstract class DiscordInbound : DiscordRelay
|
|
{
|
|
protected async Task<Task> InboundLocalchatMessage(IUserMessage message)
|
|
{
|
|
if (HasBot() == true)
|
|
{
|
|
IGuildUser user = (IGuildUser)message.Author;
|
|
controler.Bot.GetClient.Self.Chat(message.Content, 0, ChatType.Normal);
|
|
return await MarkMessage(message, "✅");
|
|
}
|
|
return await MarkMessage(message, "❌");
|
|
}
|
|
protected async Task<Task> InboundInterfaceMessage(IUserMessage message)
|
|
{
|
|
if (message.Content == "login")
|
|
{
|
|
if (HasBot() == true)
|
|
{
|
|
return await MarkMessage(message, "❌");
|
|
}
|
|
login_bot(false);
|
|
return await MarkMessage(message, "✅").ConfigureAwait(false);
|
|
}
|
|
else if (message.Content == "logout")
|
|
{
|
|
if(HasBot() == false)
|
|
{
|
|
return await MarkMessage(message, "❌");
|
|
}
|
|
controler.Bot.KillMePlease();
|
|
return await MarkMessage(message, "✅").ConfigureAwait(false);
|
|
}
|
|
else if(message.Content == "exit")
|
|
{
|
|
if (HasBot() == true)
|
|
{
|
|
controler.Bot.KillMePlease();
|
|
controler.Bot.GetClient.Network.Logout();
|
|
}
|
|
exit_super = true;
|
|
return await MarkMessage(message, "✅").ConfigureAwait(false);
|
|
}
|
|
else
|
|
{
|
|
if (HasBot() == true)
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
if (message.Content.StartsWith("!"))
|
|
{
|
|
if (message.Content == "!commands")
|
|
{
|
|
int counter = 0;
|
|
string addon = "";
|
|
foreach (string a in controler.Bot.GetCommandsInterface.GetCommandsList())
|
|
{
|
|
output.Append(addon);
|
|
addon = " , ";
|
|
output.Append(a);
|
|
counter++;
|
|
if (counter == 5)
|
|
{
|
|
output.Append("\n");
|
|
addon = "";
|
|
counter = 0;
|
|
}
|
|
}
|
|
await SendMessageToChannelAsync("interface", output.ToString(), "bot", UUID.Zero, "bot");
|
|
}
|
|
else if (message.Content.StartsWith("!help") == true)
|
|
{
|
|
string[] bits = message.Content.Split(' ');
|
|
if (bits.Length == 2)
|
|
{
|
|
string command = bits[1].ToLowerInvariant();
|
|
|
|
if (controler.Bot.GetCommandsInterface.GetCommandsList().Contains(command) == true)
|
|
{
|
|
output.Append("\n=========================\nCommand:");
|
|
output.Append(command);
|
|
output.Append("\n");
|
|
output.Append("Workspace: ");
|
|
output.Append(controler.Bot.GetCommandsInterface.GetCommandWorkspace(command));
|
|
output.Append("\n");
|
|
output.Append("Min args: ");
|
|
output.Append(controler.Bot.GetCommandsInterface.GetCommandArgs(command).ToString());
|
|
output.Append("\n");
|
|
output.Append("Arg types: ");
|
|
output.Append(String.Join(",", controler.Bot.GetCommandsInterface.GetCommandArgTypes(command)));
|
|
output.Append("\n");
|
|
output.Append("\n");
|
|
output.Append("About: ");
|
|
output.Append(controler.Bot.GetCommandsInterface.GetCommandHelp(command));
|
|
await SendMessageToChannelAsync("interface", output.ToString(), "bot", UUID.Zero, "bot");
|
|
}
|
|
else
|
|
{
|
|
output.Append("Unable to find command: ");
|
|
output.Append(command);
|
|
output.Append(" please use !commands for a full list");
|
|
await SendMessageToChannelAsync("interface", output.ToString(), "bot", UUID.Zero, "bot");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
await SendMessageToChannelAsync("interface", "Please format help request as follows: !help commandname", "bot", UUID.Zero, "bot");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
output.Append("Unknown request: ");
|
|
output.Append(message.Content);
|
|
await SendMessageToChannelAsync("interface", output.ToString(), "bot", UUID.Zero, "bot");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
string[] bits = message.Content.Split("|||");
|
|
string command = bits[0].ToLowerInvariant();
|
|
bool known_command = controler.Bot.GetCommandsInterface.GetCommandsList().Contains(command);
|
|
if (known_command == false)
|
|
{
|
|
known_command = controler.Bot.getCustomCommands.ContainsKey(command);
|
|
}
|
|
if (known_command == true)
|
|
{
|
|
bool process_status = false;
|
|
if (bits.Length == 1)
|
|
{
|
|
bits = new string[] { bits[0], "" };
|
|
}
|
|
if (controler.Bot.getCustomCommands.ContainsKey(command) == false)
|
|
{
|
|
process_status = controler.Bot.GetCommandsInterface.Call(command, bits[1], UUID.Zero);
|
|
}
|
|
else
|
|
{
|
|
process_status = true;
|
|
Thread t = new Thread(() => controler.Bot.custom_commands_loop(command, bits[1], UUID.Zero));
|
|
t.Start();
|
|
}
|
|
if (process_status == true)
|
|
{
|
|
await MarkMessage(message, "✅").ConfigureAwait(false);
|
|
}
|
|
else
|
|
{
|
|
await MarkMessage(message, "❌").ConfigureAwait(false);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
output.Append("Unable to find command: ");
|
|
output.Append(command);
|
|
output.Append(" please use !commands for a full list");
|
|
await SendMessageToChannelAsync("interface", output.ToString(), "bot", UUID.Zero, "bot");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return Task.CompletedTask;
|
|
}
|
|
protected virtual async Task<Task> InboundImMessage(ITextChannel Chan, IUserMessage message)
|
|
{
|
|
if (HasBot() == true)
|
|
{
|
|
if (message.Content.StartsWith("!close"))
|
|
{
|
|
await Chan.DeleteAsync();
|
|
}
|
|
else if (message.Content.StartsWith("!clear"))
|
|
{
|
|
await CleanDiscordChannel(Chan, 0, true);
|
|
}
|
|
else
|
|
{
|
|
string[] bits = Chan.Topic.Split(':');
|
|
if (bits.Length >= 2)
|
|
{
|
|
if (bits[0] == "IM")
|
|
{
|
|
if (UUID.TryParse(bits[1], out UUID avatar) == true)
|
|
{
|
|
IGuildUser user = (IGuildUser)message.Author;
|
|
controler.Bot.GetClient.Self.InstantMessage(avatar, message.Content);
|
|
await MarkMessage(message, "✅");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return Task.CompletedTask;
|
|
}
|
|
|
|
protected async Task<Task> InboundGroupImMessage(ITextChannel Chan, IUserMessage message)
|
|
{
|
|
if (HasBot() == true)
|
|
{
|
|
string[] bits = Chan.Topic.Split(':');
|
|
if (bits.Length >= 2)
|
|
{
|
|
if (bits[0] == "Group")
|
|
{
|
|
if (UUID.TryParse(bits[1], out UUID group) == true)
|
|
{
|
|
if (controler.Bot.MyGroups.ContainsKey(group) == true)
|
|
{
|
|
if (message.Content == "!clear")
|
|
{
|
|
await CleanDiscordChannel(Chan, 0, true).ConfigureAwait(false);
|
|
}
|
|
else if (message.Content.StartsWith("!notice") == true)
|
|
{
|
|
string Noticetitle = "Notice";
|
|
string Noticemessage;
|
|
bits = message.Content.Split("|||", StringSplitOptions.None);
|
|
if (bits.Length == 2)
|
|
{
|
|
Noticetitle = bits[0];
|
|
Noticemessage = bits[1];
|
|
}
|
|
else
|
|
{
|
|
Noticemessage = bits[0];
|
|
}
|
|
Noticetitle = Noticetitle.Replace("!notice ", "");
|
|
Noticetitle = Noticetitle.Trim();
|
|
controler.Bot.GetCommandsInterface.Call("GroupNotice", "" + group.ToString() + "~#~" + Noticetitle + "~#~" + Noticemessage, UUID.Zero);
|
|
await MarkMessage(message, "✅");
|
|
}
|
|
else
|
|
{
|
|
IGuildUser user = (IGuildUser)message.Author;
|
|
controler.Bot.GetCommandsInterface.Call("Groupchat", "" + group.ToString() + "~#~" + message.Content, UUID.Zero);
|
|
await MarkMessage(message, "✅");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
await MarkMessage(message, "❌").ConfigureAwait(false);
|
|
}
|
|
return Task.CompletedTask;
|
|
}
|
|
|
|
protected async Task<Task> MarkMessage(IUserMessage message,string emote)
|
|
{
|
|
var Tickmark = new Emoji(emote);
|
|
await message.AddReactionAsync(Tickmark, RequestOptions.Default);
|
|
return Task.CompletedTask;
|
|
}
|
|
|
|
|
|
|
|
protected async Task<Task> DiscordClientMessageReceived(SocketMessage message)
|
|
{
|
|
if (AllowNewOutbound() == true)
|
|
{
|
|
if (message.Author.IsBot == false)
|
|
{
|
|
ITextChannel Chan = (ITextChannel)message.Channel;
|
|
if (message.Content.StartsWith("!clear") == true)
|
|
{
|
|
await CleanDiscordChannel(Chan, 0, true).ConfigureAwait(false);
|
|
}
|
|
else if (Chan.CategoryId == catmap["bot"].Id)
|
|
{
|
|
if (Chan.Name == "interface")
|
|
{
|
|
await InboundInterfaceMessage((IUserMessage)message).ConfigureAwait(false);
|
|
}
|
|
else if (Chan.Name == "localchat")
|
|
{
|
|
await InboundLocalchatMessage((IUserMessage)message).ConfigureAwait(false);
|
|
}
|
|
else if(Chan.Name == "status")
|
|
{
|
|
IUserMessage Message = await SendMessageToChannelAsync("interface", message.Content, "bot", UUID.Zero, "bot").ConfigureAwait(true);
|
|
if (Message == null)
|
|
{
|
|
await MarkMessage((IUserMessage)message, "❌").ConfigureAwait(false);
|
|
}
|
|
else
|
|
{
|
|
ITextChannel channel = await FindTextChannel(DiscordServer, "interface");
|
|
if (channel != null)
|
|
{
|
|
await message.DeleteAsync().ConfigureAwait(false);
|
|
await InboundInterfaceMessage(Message).ConfigureAwait(false);
|
|
}
|
|
else
|
|
{
|
|
await MarkMessage((IUserMessage)message, "❌").ConfigureAwait(false);
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|
|
else if (Chan.CategoryId == catmap["im"].Id)
|
|
{
|
|
await InboundImMessage(Chan, (IUserMessage)message).ConfigureAwait(false);
|
|
}
|
|
else if (Chan.CategoryId == catmap["group"].Id)
|
|
{
|
|
await InboundGroupImMessage(Chan, (IUserMessage)message).ConfigureAwait(false);
|
|
}
|
|
}
|
|
}
|
|
return Task.CompletedTask;
|
|
}
|
|
}
|
|
}
|