293 lines
12 KiB
C#
293 lines
12 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 class DiscordMessageEvent : EventArgs
|
|
{
|
|
public ulong channel { get; }
|
|
public ulong server { get; }
|
|
public string name { get; }
|
|
public string message { get; }
|
|
|
|
public DiscordMessageEvent(ulong server, ulong channel, string name,string message)
|
|
{
|
|
this.channel = channel;
|
|
this.server = server;
|
|
this.name = name;
|
|
this.message = message;
|
|
}
|
|
}
|
|
|
|
public abstract class DiscordInbound : DiscordRelay
|
|
{
|
|
private EventHandler<DiscordMessageEvent> _MessageEvent;
|
|
private readonly object _MessageEventLock = new object();
|
|
public event EventHandler<DiscordMessageEvent> MessageEvent
|
|
{
|
|
add { lock (_MessageEventLock) { _MessageEvent += value; } }
|
|
remove { lock (_MessageEventLock) { _MessageEvent -= value; } }
|
|
}
|
|
protected void On_MessageEvent(DiscordMessageEvent e)
|
|
{
|
|
EventHandler<DiscordMessageEvent> handler = _MessageEvent;
|
|
handler?.Invoke(this, e);
|
|
}
|
|
|
|
|
|
protected async Task<Task> InboundLocalchatMessage(IUserMessage message)
|
|
{
|
|
if (HasBot() == true)
|
|
{
|
|
IGuildUser user = (IGuildUser)message.Author;
|
|
controler.getBot().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.getBot().KillMePlease();
|
|
controler = null;
|
|
return await MarkMessage(message, "✅").ConfigureAwait(false);
|
|
}
|
|
else if(message.Content == "exit")
|
|
{
|
|
if (HasBot() == true)
|
|
{
|
|
controler.getBot().KillMePlease();
|
|
controler.getBot().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")
|
|
{
|
|
string[] commands = controler.getBot().getFullListOfCommands();
|
|
await SendMessageToChannelAsync("interface", string.Join("\n",commands)+ " \n For more details please see the wiki \n https://wiki.magicmadpeter.xyz/", "bot", UUID.Zero, "bot");
|
|
}
|
|
else
|
|
{
|
|
await MarkMessage(message, "❌").ConfigureAwait(false);
|
|
output.Append("Unknown request: ");
|
|
output.Append(message.Content);
|
|
await SendMessageToChannelAsync("interface", output.ToString(), "bot", UUID.Zero, "bot");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
string[] bits = message.Content.Split("|||");
|
|
string target = "None";
|
|
if (bits.Length == 3)
|
|
{
|
|
target = bits[2];
|
|
}
|
|
string args = null;
|
|
if (bits.Length >= 2)
|
|
{
|
|
args = bits[1];
|
|
}
|
|
if (controler.getBot().GetFullListOfCommandsWithCustoms().Contains(bits[0].ToLowerInvariant()) == true)
|
|
{
|
|
string reply = controler.getBot().CallAPI(bits[0], args.Split("~#~"), target);
|
|
await message.Channel.SendMessageAsync(reply, false, null,null,null, new MessageReference(message.Id)).ConfigureAwait(false);
|
|
}
|
|
else
|
|
{
|
|
await MarkMessage(message, "❌").ConfigureAwait(false);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
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
|
|
{
|
|
await MarkMessage(message, "⏳").ConfigureAwait(true);
|
|
Thread.Sleep(400);
|
|
string[] bits = Chan.Topic.Split(':');
|
|
if (bits.Length >= 2)
|
|
{
|
|
if (bits[0] == "IM")
|
|
{
|
|
if (UUID.TryParse(bits[1], out UUID avatar) == true)
|
|
{
|
|
string content = message.Content;
|
|
await message.DeleteAsync().ConfigureAwait(true);
|
|
SendIM(avatar, content);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
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.getBot().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.getBot().CallAPI("Groupnotice", new [] { Noticetitle, Noticemessage });
|
|
await MarkMessage(message, "✅");
|
|
}
|
|
else
|
|
{
|
|
IGuildUser user = (IGuildUser)message.Author;
|
|
controler.getBot().CallAPI("Groupchat", new [] { group.ToString(), message.Content });
|
|
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;
|
|
IGuildUser user = await Chan.Guild.GetUserAsync(message.Author.Id).ConfigureAwait(true);
|
|
string username = user.Nickname;
|
|
if(username == null) {
|
|
username = message.Author.Username;
|
|
}
|
|
On_MessageEvent(new DiscordMessageEvent(Chan.GuildId, message.Channel.Id, username, message.Content));
|
|
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;
|
|
}
|
|
}
|
|
}
|