public DiscordFixture()
{
SettingsManager.Prepare(TEST_CONFIG_FILE);
API = new DiscordAPI();
API.Start().GetAwaiter().GetResult();
while (!API.IsAvailable)
{
Thread.Sleep(100);
}
Debug.WriteLine("DiscordFixture ONLINE!");
}
public async Task Report(IMessage msg)
{
GuildConfig guildConfig = await GuildConfigRepository.CreateDefault(ServiceProvider).GetGuildConfig(Context.Guild.Id);
if (string.IsNullOrEmpty(guildConfig.ModInternalNotificationWebhook))
{
await Context.Interaction.RespondAsync(Translator.T().CmdNoWebhookConfigured(), ephemeral : true);
return;
}
StringBuilder sb = new();
sb.AppendLine(Translator.T().CmdReportContent(Context.User, msg, msg.Channel as ITextChannel));
if (!string.IsNullOrEmpty(msg.Content))
{
sb.Append("```\n");
sb.Append(msg.Content.Truncate(1024));
sb.Append("\n``` ");
}
if (msg.Attachments.Count > 0)
{
sb.AppendLine(Translator.T().Attachments());
foreach (IAttachment attachment in msg.Attachments.Take(5))
{
sb.Append($"- <{attachment.Url}>\n");
}
if (msg.Attachments.Count > 5)
{
sb.AppendLine(Translator.T().AndXMore(msg.Attachments.Count - 5));
}
}
try
{
await DiscordAPI.ExecuteWebhook(guildConfig.ModInternalNotificationWebhook, null, sb.ToString(), AllowedMentions.None);
}
catch (Exception e)
{
Logger.LogError(e, "Failed to send internal notification to moderators for report command.");
await Context.Interaction.RespondAsync(Translator.T().CmdReportFailed(), ephemeral : true);
return;
}
await Context.Interaction.RespondAsync(Translator.T().CmdReportSent(), ephemeral : true);
}
static async void Start()
{
string token;
using (StreamReader r = new StreamReader("config.json"))
{
string json = r.ReadToEnd();
var config = JsonConvert.DeserializeObject <Dictionary <string, string> >(json);
token = config["token"];
}
await DiscordAPI.StartWithBot(token);
DiscordAPI.RegisterEventsHandler(new Handler());
Console.WriteLine("DiscordUnity Started: " + (Thread.CurrentThread == thread));
}
// TODO: Return the message
/// <summary>
/// Create a message in the specified channel
/// </summary>
/// <param name="channelId">The channel in which to send the message</param>
/// <param name="content">The message's content</param>
public async Task <Message> CreateMessage(string channelId, string content)
{
var response = await ClientToolbox.PostAsync(DiscordAPI.ChannelMessages(channelId), new Dictionary <string, string>() {
{ "content", content }
});
if (response.IsSuccessStatusCode)
{
Message message = this.client.CreateStructure <Message>(await response.Content.ReadAsStringAsync());
// TODO: Should be by reference, Client object may be large
// Inject client
return(this.InjectClient(ref message));
}
return(null);
}
static void Main(string[] args)
{
Console.Title = "DiscordUnity";
Console.ForegroundColor = ConsoleColor.Green;
Console.WriteLine("Starting up DiscordUnity!");
thread = Thread.CurrentThread;
DiscordAPI.Logger = new Logger();
Start();
while (Console.ReadLine() != "exit")
{
DiscordAPI.Update();
}
DiscordAPI.Stop();
Console.ReadKey();
}
public async void OnMessageReactionAdded(DiscordMessageReaction messageReaction)
{
if (messageReaction.Member.User.Bot == null || messageReaction.Member.User.Bot == false)
{
Debug.Log("reaction added to: " + messageReaction.MessageId + ", from: " + messageReaction.UserId + ", reaction: " + messageReaction.Emoji.User + ", " + messageReaction.Emoji.User);
await DiscordAPI.CreateMessage(messageReaction.ChannelId, "User: "******" sent Emoji: " + messageReaction.Emoji.Name, null, false, null, null, null, null);
RestResult <DiscordUser[]> reactionResult;
reactionResult = await DiscordAPI.GetReactions(messageReaction.ChannelId, messageReaction.MessageId, "👍");
DiscordUser[] array;
array = reactionResult.Data.ToArray();
for (int i = 0; i < array.Length; i++)
{
Debug.Log(array[i].Username + ", has entered thumbs up");
}
Debug.Log(messageReaction.MessageId);
}
}
public async Task View([Summary("id", "the id of the case")] long caseId, [Summary("guildid", "the id of the guild")] string guildId = "")
{
ulong parsedGuildId = 0;
if (Context.Guild == null)
{
if (!ulong.TryParse(guildId, out parsedGuildId))
{
await Context.Interaction.RespondAsync(Translator.T().CmdViewInvalidGuildId());
return;
}
}
else if (string.IsNullOrEmpty(guildId))
{
parsedGuildId = Context.Guild.Id;
}
else
{
try
{
parsedGuildId = ulong.Parse(guildId);
}
catch (Exception)
{
await Context.Interaction.RespondAsync(Translator.T().CmdViewInvalidGuildId());
return;
}
}
await Context.Interaction.RespondAsync("Getting modcases...");
ModCase modCase;
try
{
modCase = await ModCaseRepository.CreateDefault(ServiceProvider, CurrentIdentity).GetModCase(parsedGuildId, (int)caseId);
}
catch (ResourceNotFoundException)
{
await Context.Interaction.ModifyOriginalResponseAsync(message => message.Content = Translator.T().NotFound());
return;
}
if (!await CurrentIdentity.IsAllowedTo(APIActionPermission.View, modCase))
{
await Context.Interaction.ModifyOriginalResponseAsync(message => message.Content = Translator.T().CmdViewNotAllowedToView());
return;
}
EmbedBuilder embed = new();
embed.WithUrl($"{Config.GetBaseUrl()}/guilds/{modCase.GuildId}/cases/{modCase.CaseId}");
embed.WithTimestamp(modCase.CreatedAt);
embed.WithColor(Color.Blue);
IUser suspect = await DiscordAPI.FetchUserInfo(modCase.UserId, CacheBehavior.Default);
if (suspect != null)
{
embed.WithThumbnailUrl(suspect.GetAvatarOrDefaultUrl());
}
embed.WithTitle($"#{modCase.CaseId} {modCase.Title.Truncate(200)}");
embed.WithDescription(modCase.Description.Truncate(2000));
embed.AddField($"{SCALES_EMOTE} - {Translator.T().Punishment()}", Translator.T().Enum(modCase.PunishmentType), true);
if (modCase.PunishedUntil != null)
{
embed.AddField($"{ALARM_CLOCK} - {Translator.T().PunishmentUntil()}", modCase.PunishedUntil.Value.ToDiscordTS(), true);
}
if (modCase.Labels.Length > 0)
{
StringBuilder labels = new();
foreach (string label in modCase.Labels)
{
if (labels.ToString().Length + label.Length + 2 > 2000)
{
break;
}
labels.Append($"`{label}` ");
}
embed.AddField($"{SCROLL_EMOTE} - {Translator.T().Labels()}", labels.ToString(), false);
}
await Context.Interaction.ModifyOriginalResponseAsync(message => { message.Content = ""; message.Embed = embed.Build(); });
}
public async void OnServerJoined(DiscordServer server)
{
//server.Channels.Values.FirstOrDefault(x => x.Type == DiscordUnity.Models.ChannelType.GUILD_TEXT)?.CreateMessage("Hello World!", null, null, null, null, null, null);
Debug.Log("hello world");
await DiscordAPI.CreateMessage("772015084633325580", "Hello World", null, false, null, null, null, null);
}
private void Update()
{
DiscordAPI.Update();
}
private async Task AddEmoji(string ChannelId, string messageId, string emoji)
{
await DiscordAPI.CreateReaction(ChannelId, messageId, emoji);
}
public async Task Track([Summary("invite", "Either enter the invite code or the url")] string inviteCode)
{
await Context.Interaction.RespondAsync("Tracking invite code...");
if (!inviteCode.ToLower().Contains("https://discord.gg/"))
{
inviteCode = $"https://discord.gg/{inviteCode}";
}
List <UserInvite> invites = await InviteRepository.CreateDefault(ServiceProvider).GetInvitesByCode(inviteCode);
invites = invites.Where(x => x.GuildId == Context.Guild.Id).OrderByDescending(x => x.JoinedAt).ToList();
DateTime?createdAt = null;
IUser creator = null;
int? usages = invites.Count;
Dictionary <ulong, IUser> invitees = new();
if (invites.Count > 0)
{
createdAt = invites[0].InviteCreatedAt;
if (invites[0].InviteIssuerId != 0)
{
creator = await DiscordAPI.FetchUserInfo(invites[0].InviteIssuerId, CacheBehavior.Default);
}
int count = 0;
foreach (UserInvite invite in invites)
{
if (count > 20)
{
break;
}
if (!invitees.ContainsKey(invite.JoinedUserId))
{
invitees.Add(invite.JoinedUserId, await DiscordAPI.FetchUserInfo(invite.JoinedUserId, CacheBehavior.Default));
}
}
}
else
{
string code = inviteCode.Split("/").Last();
try
{
var fetchedInvite = await Context.Client.GetInviteAsync(code);
if (fetchedInvite.GuildId != Context.Guild.Id)
{
await Context.Interaction.ModifyOriginalResponseAsync(message => message.Content = Translator.T().CmdTrackInviteNotFromThisGuild());
return;
}
try
{
usages = fetchedInvite.Uses;
creator = await DiscordAPI.FetchUserInfo(fetchedInvite.Inviter.Id, CacheBehavior.Default);
}
catch (NullReferenceException) { }
}
catch (HttpException e)
{
if (e.HttpCode == HttpStatusCode.NotFound)
{
await Context.Interaction.ModifyOriginalResponseAsync(message => message.Content = Translator.T().CmdTrackCannotFindInvite());
}
else
{
await Context.Interaction.ModifyOriginalResponseAsync(message => message.Content = Translator.T().CmdTrackFailedToFetchInvite());
}
return;
}
}
EmbedBuilder embed = new();
embed.WithDescription(inviteCode);
if (creator != null)
{
embed.WithAuthor(creator);
if (createdAt.HasValue && createdAt.Value != default)
{
embed.WithDescription(Translator.T().CmdTrackCreatedByAt(inviteCode, creator, createdAt.Value));
}
else
{
embed.WithDescription(Translator.T().CmdTrackCreatedBy(inviteCode, creator));
}
}
else if (createdAt.HasValue && createdAt.Value != default)
{
embed.WithDescription(Translator.T().CmdTrackCreatedAt(inviteCode, createdAt.Value));
}
StringBuilder usedBy = new();
foreach (UserInvite invite in invites)
{
if (usedBy.Length > 900)
{
break;
}
usedBy.Append("- ");
if (invitees.ContainsKey(invite.JoinedUserId))
{
IUser user = invitees[invite.JoinedUserId];
usedBy.Append($"`{user.Username}#{user.Discriminator}` ");
}
usedBy.AppendLine($"`{invite.JoinedUserId}` - {invite.JoinedAt.ToDiscordTS()}");
}
if (invites.Count == 0)
{
usedBy.Clear();
usedBy.Append(Translator.T().CmdTrackNotTrackedYet());
}
embed.AddField(Translator.T().CmdTrackUsedBy(usages.GetValueOrDefault()), usedBy.ToString(), false);
embed.WithFooter($"Invite: {inviteCode}");
embed.WithTimestamp(DateTime.UtcNow);
embed.WithColor(Color.Gold);
await Context.Interaction.ModifyOriginalResponseAsync(message => { message.Content = ""; message.Embed = embed.Build(); });
}
public Task <ChannelType> GetChannel <ChannelType>(string channelId) where ChannelType : Channel
{
// TODO: Need to inject client
return(ClientToolbox.FetchStructure <ChannelType>(DiscordAPI.Channel(channelId)));
}
public static async Task <bool> DeleteMessage(string channelId, string messageId)
{
var response = await ClientToolbox.DeleteAsync(DiscordAPI.Message(channelId, messageId));
return(response.StatusCode == System.Net.HttpStatusCode.NoContent);
}
private AutoModerationConfigRepository(IServiceProvider serviceProvider) : base(serviceProvider)
{
_currentUser = DiscordAPI.GetCurrentBotInfo();
}
private ModCaseCommentRepository(IServiceProvider serviceProvider) : base(serviceProvider)
{
_currentUser = DiscordAPI.GetCurrentBotInfo();
}
//Constructor
/// <summary> Initializes a new instance of the DiscordClient class. </summary>
public DiscordClient(DiscordClientConfig config = null)
{
_blockEvent = new ManualResetEventSlim(true);
_config = config ?? new DiscordClientConfig();
_isDebugMode = config.EnableDebug;
_rand = new Random();
_serializer = new JsonSerializer();
#if TEST_RESPONSES
_serializer.CheckAdditionalContent = true;
_serializer.MissingMemberHandling = MissingMemberHandling.Error;
#endif
_userRegex = new Regex(@"<@\d+?>", RegexOptions.Compiled);
_channelRegex = new Regex(@"<#\d+?>", RegexOptions.Compiled);
_userRegexEvaluator = new MatchEvaluator(e =>
{
string id = e.Value.Substring(2, e.Value.Length - 3);
var user = _users[id];
if (user != null)
{
return('@' + user.Name);
}
else //User not found
{
return(e.Value);
}
});
_channelRegexEvaluator = new MatchEvaluator(e =>
{
string id = e.Value.Substring(2, e.Value.Length - 3);
var channel = _channels[id];
if (channel != null)
{
return(channel.Name);
}
else //Channel not found
{
return(e.Value);
}
});
if (_config.UseMessageQueue)
{
_pendingMessages = new ConcurrentQueue <Message>();
}
_http = new JsonHttpClient(config.EnableDebug);
_api = new DiscordAPI(_http);
if (_isDebugMode)
{
_http.OnDebugMessage += (s, e) => RaiseOnDebugMessage(e.Type, e.Message);
}
CreateCaches();
_webSocket = new DiscordDataSocket(this, config.ConnectionTimeout, config.WebSocketInterval, config.EnableDebug);
_webSocket.Connected += (s, e) => RaiseConnected();
_webSocket.Disconnected += async(s, e) =>
{
RaiseDisconnected();
//Reconnect if we didn't cause the disconnect
if (e.WasUnexpected)
{
while (!_disconnectToken.IsCancellationRequested)
{
try
{
await Task.Delay(_config.ReconnectDelay);
await _webSocket.ReconnectAsync();
if (_http.Token != null)
{
await _webSocket.Login(_http.Token);
}
break;
}
catch (Exception ex)
{
RaiseOnDebugMessage(DebugMessageType.Connection, $"DataSocket reconnect failed: {ex.Message}");
//Net is down? We can keep trying to reconnect until the user runs Disconnect()
await Task.Delay(_config.FailedReconnectDelay);
}
}
}
};
if (_isDebugMode)
{
_webSocket.OnDebugMessage += (s, e) => RaiseOnDebugMessage(e.Type, $"DataSocket: {e.Message}");
}
#if !DNXCORE50
if (_config.EnableVoice)
{
_voiceWebSocket = new DiscordVoiceSocket(this, _config.VoiceConnectionTimeout, _config.WebSocketInterval, config.EnableDebug);
_voiceWebSocket.Connected += (s, e) => RaiseVoiceConnected();
_voiceWebSocket.Disconnected += async(s, e) =>
{
RaiseVoiceDisconnected();
//Reconnect if we didn't cause the disconnect
if (e.WasUnexpected)
{
while (!_disconnectToken.IsCancellationRequested)
{
try
{
await Task.Delay(_config.ReconnectDelay);
await _voiceWebSocket.ReconnectAsync();
await _voiceWebSocket.Login(_currentVoiceServerId, _myId, _sessionId, _currentVoiceToken);
break;
}
catch (Exception ex)
{
if (_isDebugMode)
{
RaiseOnDebugMessage(DebugMessageType.Connection, $"VoiceSocket reconnect failed: {ex.Message}");
}
//Net is down? We can keep trying to reconnect until the user runs Disconnect()
await Task.Delay(_config.FailedReconnectDelay);
}
}
}
};
if (_isDebugMode)
{
_voiceWebSocket.OnDebugMessage += (s, e) => RaiseOnDebugMessage(e.Type, $"VoiceSocket: {e.Message}");
}
}
#endif
#if !DNXCORE50
_webSocket.GotEvent += async(s, e) =>
#else
_webSocket.GotEvent += (s, e) =>
#endif
{
switch (e.Type)
{
//Global
case "READY": //Resync
{
var data = e.Event.ToObject <TextWebSocketEvents.Ready>(_serializer);
_servers.Clear();
_channels.Clear();
_users.Clear();
_myId = data.User.Id;
#if !DNXCORE50
_sessionId = data.SessionId;
#endif
_user = _users.Update(data.User.Id, data.User);
foreach (var server in data.Guilds)
{
_servers.Update(server.Id, server);
}
foreach (var channel in data.PrivateChannels)
{
_channels.Update(channel.Id, null, channel);
}
}
break;
//Servers
case "GUILD_CREATE":
{
var data = e.Event.ToObject <TextWebSocketEvents.GuildCreate>(_serializer);
var server = _servers.Update(data.Id, data);
try { RaiseServerCreated(server); } catch { }
}
break;
case "GUILD_UPDATE":
{
var data = e.Event.ToObject <TextWebSocketEvents.GuildUpdate>(_serializer);
var server = _servers.Update(data.Id, data);
try { RaiseServerUpdated(server); } catch { }
}
break;
case "GUILD_DELETE":
{
var data = e.Event.ToObject <TextWebSocketEvents.GuildDelete>(_serializer);
var server = _servers.Remove(data.Id);
if (server != null)
{
try { RaiseServerDestroyed(server); } catch { }
}
}
break;
//Channels
case "CHANNEL_CREATE":
{
var data = e.Event.ToObject <TextWebSocketEvents.ChannelCreate>(_serializer);
var channel = _channels.Update(data.Id, data.GuildId, data);
try { RaiseChannelCreated(channel); } catch { }
}
break;
case "CHANNEL_UPDATE":
{
var data = e.Event.ToObject <TextWebSocketEvents.ChannelUpdate>(_serializer);
var channel = _channels.Update(data.Id, data.GuildId, data);
try { RaiseChannelUpdated(channel); } catch { }
}
break;
case "CHANNEL_DELETE":
{
var data = e.Event.ToObject <TextWebSocketEvents.ChannelDelete>(_serializer);
var channel = _channels.Remove(data.Id);
if (channel != null)
{
try { RaiseChannelDestroyed(channel); } catch { }
}
}
break;
//Members
case "GUILD_MEMBER_ADD":
{
var data = e.Event.ToObject <TextWebSocketEvents.GuildMemberAdd>(_serializer);
var user = _users.Update(data.User.Id, data.User);
var server = _servers[data.ServerId];
if (server != null)
{
var member = server.UpdateMember(data);
try { RaiseMemberAdded(member); } catch { }
}
}
break;
case "GUILD_MEMBER_UPDATE":
{
var data = e.Event.ToObject <TextWebSocketEvents.GuildMemberUpdate>(_serializer);
var user = _users.Update(data.User.Id, data.User);
var server = _servers[data.ServerId];
if (server != null)
{
var member = server.UpdateMember(data);
try { RaiseMemberUpdated(member); } catch { }
}
}
break;
case "GUILD_MEMBER_REMOVE":
{
var data = e.Event.ToObject <TextWebSocketEvents.GuildMemberRemove>(_serializer);
var server = _servers[data.ServerId];
if (server != null)
{
var member = server.RemoveMember(data.User.Id);
if (member != null)
{
try { RaiseMemberRemoved(member); } catch { }
}
}
}
break;
//Roles
case "GUILD_ROLE_CREATE":
{
var data = e.Event.ToObject <TextWebSocketEvents.GuildRoleCreateUpdate>(_serializer);
var role = _roles.Update(data.Role.Id, data.ServerId, data.Role);
try { RaiseRoleCreated(role); } catch { }
}
break;
case "GUILD_ROLE_UPDATE":
{
var data = e.Event.ToObject <TextWebSocketEvents.GuildRoleCreateUpdate>(_serializer);
var role = _roles.Update(data.Role.Id, data.ServerId, data.Role);
try { RaiseRoleUpdated(role); } catch { }
}
break;
case "GUILD_ROLE_DELETE":
{
var data = e.Event.ToObject <TextWebSocketEvents.GuildRoleDelete>(_serializer);
var role = _roles.Remove(data.RoleId);
if (role != null)
{
try { RaiseRoleDeleted(role); } catch { }
}
}
break;
//Bans
case "GUILD_BAN_ADD":
{
var data = e.Event.ToObject <TextWebSocketEvents.GuildBanAddRemove>(_serializer);
var user = _users.Update(data.User.Id, data.User);
var server = _servers[data.ServerId];
try { RaiseBanAdded(user, server); } catch { }
}
break;
case "GUILD_BAN_REMOVE":
{
var data = e.Event.ToObject <TextWebSocketEvents.GuildBanAddRemove>(_serializer);
var user = _users.Update(data.User.Id, data.User);
var server = _servers[data.ServerId];
if (server != null && server.RemoveBan(user.Id))
{
try { RaiseBanRemoved(user, server); } catch { }
}
}
break;
//Messages
case "MESSAGE_CREATE":
{
var data = e.Event.ToObject <TextWebSocketEvents.MessageCreate>(_serializer);
Message msg = null;
bool wasLocal = _config.UseMessageQueue && data.Author.Id == _myId && data.Nonce != null;
if (wasLocal)
{
msg = _messages.Remap("nonce" + data.Nonce, data.Id);
if (msg != null)
{
msg.IsQueued = false;
msg.Id = data.Id;
}
}
msg = _messages.Update(data.Id, data.ChannelId, data);
msg.User.UpdateActivity(data.Timestamp);
if (wasLocal)
{
try { RaiseMessageSent(msg); } catch { }
}
try { RaiseMessageCreated(msg); } catch { }
}
break;
case "MESSAGE_UPDATE":
{
var data = e.Event.ToObject <TextWebSocketEvents.MessageUpdate>(_serializer);
var msg = _messages.Update(data.Id, data.ChannelId, data);
try { RaiseMessageUpdated(msg); } catch { }
}
break;
case "MESSAGE_DELETE":
{
var data = e.Event.ToObject <TextWebSocketEvents.MessageDelete>(_serializer);
var msg = GetMessage(data.MessageId);
if (msg != null)
{
_messages.Remove(msg.Id);
try { RaiseMessageDeleted(msg); } catch { }
}
}
break;
case "MESSAGE_ACK":
{
var data = e.Event.ToObject <TextWebSocketEvents.MessageAck>(_serializer);
var msg = GetMessage(data.MessageId);
if (msg != null)
{
try { RaiseMessageRead(msg); } catch { }
}
}
break;
//Statuses
case "PRESENCE_UPDATE":
{
var data = e.Event.ToObject <TextWebSocketEvents.PresenceUpdate>(_serializer);
var user = _users.Update(data.User.Id, data.User);
var server = _servers[data.ServerId];
if (server != null)
{
var member = server.UpdateMember(data);
try { RaisePresenceUpdated(member); } catch { }
}
}
break;
case "VOICE_STATE_UPDATE":
{
var data = e.Event.ToObject <TextWebSocketEvents.VoiceStateUpdate>(_serializer);
var server = _servers[data.ServerId];
if (server != null)
{
var member = server.UpdateMember(data);
if (member != null)
{
try { RaiseVoiceStateUpdated(member); } catch { }
}
}
}
break;
case "TYPING_START":
{
var data = e.Event.ToObject <TextWebSocketEvents.TypingStart>(_serializer);
var channel = _channels[data.ChannelId];
var user = _users[data.UserId];
if (user != null)
{
user.UpdateActivity(DateTime.UtcNow);
if (channel != null)
{
try { RaiseUserTyping(user, channel); } catch { }
}
}
}
break;
//Voice
case "VOICE_SERVER_UPDATE":
{
var data = e.Event.ToObject <TextWebSocketEvents.VoiceServerUpdate>(_serializer);
var server = _servers[data.ServerId];
server.VoiceServer = data.Endpoint;
try { RaiseVoiceServerUpdated(server, data.Endpoint); } catch { }
#if !DNXCORE50
if (_config.EnableVoice && data.ServerId == _currentVoiceServerId)
{
_currentVoiceToken = data.Token;
await _voiceWebSocket.ConnectAsync("wss://" + data.Endpoint.Split(':')[0]);
await _voiceWebSocket.Login(_currentVoiceServerId, _myId, _myId, data.Token);
}
#endif
}
break;
//Settings
case "USER_UPDATE":
{
var data = e.Event.ToObject <TextWebSocketEvents.UserUpdate>(_serializer);
var user = _users.Update(data.Id, data);
try { RaiseUserUpdated(user); } catch { }
}
break;
case "USER_SETTINGS_UPDATE":
{
//TODO: Process this
}
break;
//Others
default:
RaiseOnDebugMessage(DebugMessageType.WebSocketUnknownEvent, "Unknown WebSocket message type: " + e.Type);
break;
}
};
}
private GuildLevelAuditLogConfigRepository(IServiceProvider serviceProvider) : base(serviceProvider)
{
_currentUser = DiscordAPI.GetCurrentBotInfo();
}
public static void PurgeCache()
{
ESIAPI.PurgeCache();
DiscordAPI.PurgeCache();
ZKillAPI.PurgeCache();
}
public Task <RestResult <DiscordMessage> > CreateMessage(string content, string nonce, bool?tts, object file, object embed, string payload_json, object allowed_mentions) => DiscordAPI.CreateMessage(Id, content, nonce, tts, file, embed, payload_json, allowed_mentions);
public static void ResetCache()
{
ESIAPI.ResetCache();
DiscordAPI.ResetCache();
ZKillAPI.ResetCache();
}
private CaseTemplateRepository(IServiceProvider serviceProvider) : base(serviceProvider)
{
_currentUser = DiscordAPI.GetCurrentBotInfo();
_isBot = true;
}
public static async Task StartDiscord()
{
await DiscordAPI.Start();
}
public async Task Connect()
{
Console.WriteLine($"Authenticating using token '{this.client.GetToken()}'");
// TODO: Use response
var response = await Fetch.GetJsonAsyncAuthorized <GetGatewayBotResponse>(DiscordAPI.BotGateway(), this.client.GetToken());
var convertedResponse = JsonConvert.SerializeObject(response);
var connectionUrl = (string)JsonConvert.DeserializeObject <dynamic>(await Fetch.GetAsync(DiscordAPI.Gateway())).url;
this.socket = new PureWebSocket(connectionUrl, new PureWebSocketOptions()
{
});
// Events
this.socket.OnMessage += this.WS_OnMessage;
this.socket.OnClosed += this.WS_OnClosed;
// Connect
this.socket.Connect();
// TODO: Debugging
Console.WriteLine($"GOT url => {convertedResponse}");
}
public static async Task <bool> DeleteOwnReaction(string channelId, string messageId, SimpleEmoji emoji)
{
var response = await ClientToolbox.DeleteAsync(DiscordAPI.MessageReaction(channelId, messageId, emoji.ToString()));
return(response.StatusCode == System.Net.HttpStatusCode.NoContent);
}
//message events
public async void OnMessageCreated(DiscordMessage message)
{
if (message.Author.Bot == null || message.Author.Bot == false) // check if the author is not a bot
{
Debug.Log("Message send: " + message.Content + ", from: " + message.Author.Username + ", messageID: " + message.Id);
Debug.Log("Server name: " + message.ChannelId);
Debug.Log("");
if (message.Content.Contains("ping"))
{
Debug.Log("sending pong");
await DiscordAPI.CreateMessage(message.ChannelId, "Pong", null, false, null, null, null, null);
}
}
if (message.Author.Bot == true && message.Content.Contains("Pong"))
{
Debug.Log("Message send: " + message.Content + ", from: " + message.Author.Username + ", messageID: " + message.Id);
await AddEmoji(message.ChannelId, message.Id, "💩");
await Task.Delay(100);
await AddEmoji(message.ChannelId, message.Id, "👺");
await Task.Delay(100);
await AddEmoji(message.ChannelId, message.Id, "👻");
await Task.Delay(100);
await AddEmoji(message.ChannelId, message.Id, "👍");
Debug.Log("poop Sent");
}
/*
* if (message.Author.Bot == null )
* {
* Debug.Log("sender is not a bot, null");
*
* }
*
* if (message.Author.Bot == false)
* {
* Debug.Log("sender is not a bot, false");
*
* }
*
* if (message.Author.Bot == true)
* {
* Debug.Log("sender is a bot, true");
*
* }
*
* if (!message.Author.Bot == true)
* {
* Debug.Log("sender is not a bot, not true");
*
* }
*
* if (message.Author.Bot == null || message.Author.Bot == false)
* {
* Debug.Log("sender is not a bot, or");
*
* }
*/
}
private UserNoteRepository(IServiceProvider serviceProvider) : base(serviceProvider)
{
_currentUser = DiscordAPI.GetCurrentBotInfo();
}
private ScheduledMessageRepository(IServiceProvider serviceProvider) : base(serviceProvider)
{
_currentUser = DiscordAPI.GetCurrentBotInfo();
}
