internal ChannelData(RestDiscordClient client, AuditLogEntryModel model, bool isCreated)
{
var changes = new ChannelChanges(client, model);
if (isCreated)
{
Name = changes.Name.NewValue;
Topic = changes.Topic.NewValue;
Bitrate = changes.Bitrate.NewValue;
Overwrites = changes.Overwrites.NewValue;
IsNsfw = changes.IsNsfw.NewValue;
Slowmode = changes.Slowmode.NewValue;
Type = changes.Type.NewValue;
}
else
{
Name = changes.Name.OldValue;
Topic = changes.Topic.OldValue;
Bitrate = changes.Bitrate.OldValue;
Overwrites = changes.Overwrites.OldValue;
IsNsfw = changes.IsNsfw.OldValue;
Slowmode = changes.Slowmode.OldValue;
Type = changes.Type.OldValue;
}
}
internal RestMemberRolesUpdatedAuditLog(RestDiscordClient client, AuditLogModel log, AuditLogEntryModel entry) : base(client, log, entry)
{
for (var i = 0; i < entry.Changes.Length; i++)
{
var change = entry.Changes[i];
switch (change.Key)
{
case "$add":
{
RolesAdded = AuditLogChange <IReadOnlyList <Role> > .Convert <RoleModel[]>(change, x => x.ToReadOnlyList(y => new Role(y))).NewValue;
break;
}
case "$remove":
{
RolesRemoved = AuditLogChange <IReadOnlyList <Role> > .Convert <RoleModel[]>(change, x => x.ToReadOnlyList(y => new Role(y))).NewValue;
break;
}
default:
{
client.Log(LogSeverity.Error, $"Unknown change key for {nameof(RestMemberRolesUpdatedAuditLog)}: '{change.Key}'.");
break;
}
}
}
}
internal DiscordClientBase(DiscordClientBase client)
{
if (client == null)
{
throw new ArgumentNullException(nameof(client));
}
_client = client;
_getGateway = client._getGateway;
State = client.State;
// This is set, so that events give you the proper (bot) client, and not the underyling one.
State._client = this;
RestClient = client.RestClient;
Logger = client.Logger;
Serializer = client.Serializer;
_extensions = client._extensions;
_ready = client._ready;
_channelCreated = client._channelCreated;
_channelUpdated = client._channelUpdated;
_channelDeleted = client._channelDeleted;
_channelPinsUpdated = client._channelPinsUpdated;
_guildAvailable = client._guildAvailable;
_guildUnavailable = client._guildUnavailable;
_joinedGuild = client._joinedGuild;
_guildUpdated = client._guildUpdated;
_leftGuild = client._leftGuild;
_roleCreated = client._roleCreated;
_roleUpdated = client._roleUpdated;
_roleDeleted = client._roleDeleted;
_inviteCreated = client._inviteCreated;
_inviteDeleted = client._inviteDeleted;
_memberBanned = client._memberBanned;
_memberUnbanned = client._memberUnbanned;
_guildEmojisUpdated = client._guildEmojisUpdated;
_memberJoined = client._memberJoined;
_memberLeft = client._memberLeft;
_memberUpdated = client._memberUpdated;
_messageReceived = client._messageReceived;
_messageDeleted = client._messageDeleted;
_messagesBulkDeleted = client._messagesBulkDeleted;
_messageUpdated = client._messageUpdated;
_reactionAdded = client._reactionAdded;
_reactionRemoved = client._reactionRemoved;
_reactionsCleared = client._reactionsCleared;
_emojiReactionsCleared = client._emojiReactionsCleared;
_presenceUpdated = client._presenceUpdated;
_typingStarted = client._typingStarted;
_userUpdated = client._userUpdated;
_voiceStateUpdated = client._voiceStateUpdated;
_voiceServerUpdated = client._voiceServerUpdated;
_webhooksUpdated = client._webhooksUpdated;
if (this is IDiscordSharder sharder && client is IDiscordSharder clientSharder)
{
sharder._shardReady = clientSharder._shardReady;
}
}
internal DiscordClientBase(RestDiscordClient restClient, DiscordClientBaseConfiguration configuration)
{
if (restClient == null)
{
throw new ArgumentNullException(nameof(restClient));
}
if (!restClient.HasAuthorization)
{
throw new ArgumentException("Clients without authorization are not supported.", nameof(restClient));
}
RestClient = restClient;
State = new DiscordClientState(this, configuration.MessageCache.GetValueOrDefault(() => new DefaultMessageCache(100)));
Logger = configuration.Logger.GetValueOrDefault() ?? restClient.Logger;
Serializer = configuration.Serializer.GetValueOrDefault() ?? restClient.Serializer;
_extensions = new LockedDictionary <Type, DiscordClientExtension>();
_ready = new AsynchronousEvent <ReadyEventArgs>();
_channelCreated = new AsynchronousEvent <ChannelCreatedEventArgs>();
_channelUpdated = new AsynchronousEvent <ChannelUpdatedEventArgs>();
_channelDeleted = new AsynchronousEvent <ChannelDeletedEventArgs>();
_channelPinsUpdated = new AsynchronousEvent <ChannelPinsUpdatedEventArgs>();
_guildAvailable = new AsynchronousEvent <GuildAvailableEventArgs>();
_guildUnavailable = new AsynchronousEvent <GuildUnavailableEventArgs>();
_joinedGuild = new AsynchronousEvent <JoinedGuildEventArgs>();
_guildUpdated = new AsynchronousEvent <GuildUpdatedEventArgs>();
_leftGuild = new AsynchronousEvent <LeftGuildEventArgs>();
_roleCreated = new AsynchronousEvent <RoleCreatedEventArgs>();
_roleUpdated = new AsynchronousEvent <RoleUpdatedEventArgs>();
_roleDeleted = new AsynchronousEvent <RoleDeletedEventArgs>();
_inviteCreated = new AsynchronousEvent <InviteCreatedEventArgs>();
_inviteDeleted = new AsynchronousEvent <InviteDeletedEventArgs>();
_memberBanned = new AsynchronousEvent <MemberBannedEventArgs>();
_memberUnbanned = new AsynchronousEvent <MemberUnbannedEventArgs>();
_guildEmojisUpdated = new AsynchronousEvent <GuildEmojisUpdatedEventArgs>();
_memberJoined = new AsynchronousEvent <MemberJoinedEventArgs>();
_memberLeft = new AsynchronousEvent <MemberLeftEventArgs>();
_memberUpdated = new AsynchronousEvent <MemberUpdatedEventArgs>();
_messageReceived = new AsynchronousEvent <MessageReceivedEventArgs>();
_messageDeleted = new AsynchronousEvent <MessageDeletedEventArgs>();
_messagesBulkDeleted = new AsynchronousEvent <MessagesBulkDeletedEventArgs>();
_messageUpdated = new AsynchronousEvent <MessageUpdatedEventArgs>();
_reactionAdded = new AsynchronousEvent <ReactionAddedEventArgs>();
_reactionRemoved = new AsynchronousEvent <ReactionRemovedEventArgs>();
_reactionsCleared = new AsynchronousEvent <ReactionsClearedEventArgs>();
_emojiReactionsCleared = new AsynchronousEvent <EmojiReactionsClearedEventArgs>();
_presenceUpdated = new AsynchronousEvent <PresenceUpdatedEventArgs>();
_typingStarted = new AsynchronousEvent <TypingStartedEventArgs>();
_userUpdated = new AsynchronousEvent <UserUpdatedEventArgs>();
_voiceStateUpdated = new AsynchronousEvent <VoiceStateUpdatedEventArgs>();
_voiceServerUpdated = new AsynchronousEvent <VoiceServerUpdatedEventArgs>();
_webhooksUpdated = new AsynchronousEvent <WebhooksUpdatedEventArgs>();
if (this is IDiscordSharder sharder)
{
sharder._shardReady = new AsynchronousEvent <ShardReadyEventArgs>();
}
}
protected ExtendedDiscordBot(RestDiscordClient restClient, IPrefixProvider prefixProvider, ExtendedDiscordBotConfiguration configuration = null)
: base(restClient, prefixProvider, configuration?.CopyAndConfigure() ?? new ExtendedDiscordBotConfiguration())
{
_configuration = configuration;
_handlerDict = new Dictionary <Type, IEnumerable <IHandler> >();
typeof(DiscordBotBase).GetField("_provider", BindingFlags.Instance | BindingFlags.NonPublic).SetValue(this,
_configuration.BaseServiceCollection
.AddSingleton(GetType(), this)
.DiscoverServices()
.BuildServiceProvider());
}
internal RoleChanges(RestDiscordClient client, AuditLogEntryModel model)
{
for (var i = 0; i < model.Changes.Length; i++)
{
var change = model.Changes[i];
switch (change.Key)
{
case "name":
{
Name = AuditLogChange <string> .SingleConvert(change, client.Serializer);
break;
}
case "permissions":
{
Permissions = AuditLogChange <GuildPermissions> .DoubleConvert <ulong>(change, client.Serializer, x => x);
break;
}
case "color":
{
Color = AuditLogChange <Color?> .DoubleConvert <int>(change, client.Serializer, x => x == 0
?(int?)null
: x);
break;
}
case "hoist":
{
IsHoisted = AuditLogChange <bool> .SingleConvert(change, client.Serializer);
break;
}
case "mentionable":
{
IsMentionable = AuditLogChange <bool> .SingleConvert(change, client.Serializer);
break;
}
default:
{
client.Log(LogMessageSeverity.Error, $"Unknown change key for {nameof(RoleChanges)}: '{change.Key}'.");
break;
}
}
}
}
internal RestAuditLog(RestDiscordClient client, AuditLogModel log, AuditLogEntryModel entry) : base(client, entry.Id)
{
ResponsibleUserId = entry.UserId;
ResponsibleUser = new RestDownloadable <RestUser>(options => client.GetUserAsync(ResponsibleUserId, options));
var userModel = Array.Find(log.Users, x => x.Id == entry.UserId);
if (userModel != null)
{
ResponsibleUser.SetValue(new RestUser(client, userModel));
}
Reason = entry.Reason;
}
internal EmojiData(RestDiscordClient client, AuditLogEntryModel model, bool isCreated)
{
var changes = new EmojiChanges(client, model);
if (isCreated)
{
Name = changes.Name.NewValue;
}
else
{
Name = changes.Name.OldValue;
}
}
internal RestAuditLog(RestDiscordClient client, AuditLogModel log, AuditLogEntryModel entry) : base(client, entry.Id)
{
TargetId = entry.TargetId;
ResponsibleUserId = entry.UserId;
ResponsibleUser = RestFetchable.Create(this, (@this, options) =>
@this.Client.GetUserAsync(@this.ResponsibleUserId, options));
var userModel = Array.Find(log.Users, x => x.Id == entry.UserId);
if (userModel != null)
{
ResponsibleUser.Value = new RestUser(client, userModel);
}
Reason = entry.Reason;
}
internal OverwriteChanges(RestDiscordClient client, AuditLogEntryModel model)
{
for (var i = 0; i < model.Changes.Length; i++)
{
var change = model.Changes[i];
switch (change.Key)
{
case "id":
{
TargetId = AuditLogChange <Snowflake> .Convert(change);
break;
}
case "allow":
{
Allowed = AuditLogChange <ChannelPermissions> .Convert <ulong>(change, x => x);
break;
}
case "deny":
{
Denied = AuditLogChange <ChannelPermissions> .Convert <ulong>(change, x => x);
break;
}
case "type":
{
TargetType = AuditLogChange <OverwriteTargetType> .Convert(change);
break;
}
default:
{
client.Log(LogSeverity.Error, $"Unknown change key for {nameof(OverwriteChanges)}: '{change.Key}'.");
break;
}
}
}
}
internal WebhookChanges(RestDiscordClient client, AuditLogEntryModel model)
{
for (var i = 0; i < model.Changes.Length; i++)
{
var change = model.Changes[i];
switch (change.Key)
{
case "name":
{
Name = AuditLogChange <string> .SingleConvert(change, client.Serializer);
break;
}
case "type":
{
Type = AuditLogChange <WebhookType> .SingleConvert(change, client.Serializer);
break;
}
case "avatar_hash":
{
AvatarHash = AuditLogChange <string> .SingleConvert(change, client.Serializer);
break;
}
case "channel_id":
{
ChannelId = AuditLogChange <Snowflake> .DoubleConvert <ulong>(change, client.Serializer, x => x);
break;
}
default:
{
client.Log(LogMessageSeverity.Error, $"Unknown change key for {nameof(WebhookChanges)}: '{change.Key}'.");
break;
}
}
}
}
internal WebhookData(RestDiscordClient client, AuditLogEntryModel model, bool isCreated)
{
var changes = new WebhookChanges(client, model);
if (isCreated)
{
Name = changes.Name.NewValue;
Type = changes.Type.NewValue;
AvatarHash = changes.AvatarHash.NewValue;
ChannelId = changes.ChannelId.NewValue;
}
else
{
Name = changes.Name.OldValue;
Type = changes.Type.OldValue;
AvatarHash = changes.AvatarHash.OldValue;
ChannelId = changes.ChannelId.OldValue;
}
}
internal OverwriteData(RestDiscordClient client, AuditLogEntryModel model, bool isCreated)
{
var changes = new OverwriteChanges(client, model);
if (isCreated)
{
TargetId = changes.TargetId.NewValue;
TargetType = changes.TargetType.NewValue;
Allowed = changes.Allowed.NewValue;
Denied = changes.Denied.NewValue;
}
else
{
TargetId = changes.TargetId.OldValue;
TargetType = changes.TargetType.OldValue;
Allowed = changes.Allowed.OldValue;
Denied = changes.Denied.OldValue;
}
}
internal RoleData(RestDiscordClient client, AuditLogEntryModel model, bool isCreated)
{
var changes = new RoleChanges(client, model);
if (isCreated)
{
Name = changes.Name.NewValue;
Permissions = changes.Permissions.NewValue;
Color = changes.Color.NewValue;
IsHoisted = changes.IsHoisted.NewValue;
IsMentionable = changes.IsMentionable.NewValue;
}
else
{
Name = changes.Name.OldValue;
Permissions = changes.Permissions.OldValue;
Color = changes.Color.OldValue;
IsHoisted = changes.IsHoisted.OldValue;
IsMentionable = changes.IsMentionable.OldValue;
}
}
internal EmojiChanges(RestDiscordClient client, AuditLogEntryModel model)
{
for (var i = 0; i < model.Changes.Length; i++)
{
var change = model.Changes[i];
switch (change.Key)
{
case "name":
{
Name = AuditLogChange <string> .Convert(change);
break;
}
default:
{
client.Log(LogSeverity.Error, $"Unknown change key for {nameof(WebhookChanges)}: '{change.Key}'.");
break;
}
}
}
}
internal MemberChanges(RestDiscordClient client, AuditLogEntryModel model)
{
for (var i = 0; i < model.Changes.Length; i++)
{
var change = model.Changes[i];
switch (change.Key)
{
case "nick":
{
Nick = AuditLogChange <string> .Convert(change);
break;
}
case "deaf":
{
IsDeafened = AuditLogChange <bool> .Convert(change);
break;
}
case "mute":
{
IsMuted = AuditLogChange <bool> .Convert(change);
break;
}
default:
{
client.Log(LogSeverity.Error, $"Unknown change key for {nameof(MemberChanges)}: '{change.Key}'.");
break;
}
}
}
}
internal RestEmojiCreatedAuditLog(RestDiscordClient client, AuditLogModel log, AuditLogEntryModel entry) : base(client, log, entry)
{
Data = new EmojiData(client, entry, true);
}
internal RestChannelDeletedAuditLog(RestDiscordClient client, AuditLogModel log, AuditLogEntryModel entry) : base(client, log, entry)
{
Data = new ChannelData(client, entry, false);
}
internal RestMemberKickedAuditLog(RestDiscordClient client, AuditLogModel log, AuditLogEntryModel entry) : base(client, log, entry)
{
}
internal RestAuditLogGuildMetadata(RestDiscordClient client, AuditLogModel auditLogModel, AuditLogEntryModel model) : base(client)
{
for (var i = 0; i < model.Changes.Length; i++)
{
var change = model.Changes[i];
switch (change.Key)
{
case "name":
{
Name = new AuditLogValue <string>(change);
break;
}
case "icon_hash":
{
IconHash = new AuditLogValue <string>(change);
break;
}
case "splash_hash":
{
SplashHash = new AuditLogValue <string>(change);
break;
}
case "owner_id":
{
OwnerId = new AuditLogValue <ulong>(change);
var ownerBeforeModel = Array.Find(auditLogModel.Users, x => x.Id == OwnerId.OldValue);
var ownerAfterModel = Array.Find(auditLogModel.Users, x => x.Id == OwnerId.NewValue);
Owner = new AuditLogValue <RestUser>(
ownerBeforeModel != null
? new RestUser(client, ownerBeforeModel)
: Optional <RestUser> .Empty,
ownerAfterModel != null
? new RestUser(client, ownerAfterModel)
: Optional <RestUser> .Empty);
break;
}
case "region":
{
VoiceRegionId = new AuditLogValue <string>(change);
break;
}
case "afk_channel_id":
{
AfkChannelId = new AuditLogValue <ulong?>(change);
break;
}
case "afk_timeout":
{
AfkTimeout = new AuditLogValue <int>(change);
break;
}
case "mfa_level":
{
MfaLevel = new AuditLogValue <MfaLevel>(change);
break;
}
case "verification_level":
{
VerificationLevel = new AuditLogValue <VerificationLevel>(change);
break;
}
case "explicit_content_filter":
{
ContentFilterLevel = new AuditLogValue <ContentFilterLevel>(change);
break;
}
case "default_message_notifications":
{
DefaultNotificationLevel = new AuditLogValue <DefaultNotificationLevel>(change);
break;
}
case "vanity_url_code":
{
VanityUrlCode = new AuditLogValue <string>(change);
break;
}
case "widget_enabled":
{
IsWidgetEnabled = new AuditLogValue <bool>(change);
break;
}
case "widget_channel_id":
{
WidgetChannelId = new AuditLogValue <ulong?>(change);
break;
}
case "system_channel_id":
{
SystemChannelId = new AuditLogValue <ulong?>(change);
break;
}
}
}
}
public RestFetchableImpl(RestDiscordClient client, T value, RestFetchableDelegate func)
: base(client, value, func)
{
}
internal RestOverwriteUpdatedAuditLog(RestDiscordClient client, AuditLogModel log, AuditLogEntryModel entry) : base(client, log, entry)
{
Changes = new OverwriteChanges(client, entry);
}
public DiscordClient(RestDiscordClient restClient, DiscordClientConfiguration configuration = null) : this(configuration ?? DiscordClientConfiguration.Default)
{
RestClient = restClient;
}
internal RestChannelCreatedAuditLog(RestDiscordClient client, AuditLogModel auditLogModel, AuditLogEntryModel model) : base(client, auditLogModel, model)
{
Metadata = new RestAuditLogChannelMetadata(client, auditLogModel, model);
}
internal RestGuildUpdatedAuditLog(RestDiscordClient client, AuditLogModel auditLogModel, AuditLogEntryModel model) : base(client, auditLogModel, model)
{
Metadata = new RestAuditLogGuildMetadata(client, auditLogModel, model);
}
//public RoleData Data { get; }
internal RestInviteCreatedAuditLog(RestDiscordClient client, AuditLogModel log, AuditLogEntryModel entry) : base(client, log, entry)
{
//Data = new RoleData(client, entry, true);
}
internal ChannelChanges(RestDiscordClient client, AuditLogEntryModel model)
{
for (var i = 0; i < model.Changes.Length; i++)
{
var change = model.Changes[i];
switch (change.Key)
{
case "name":
{
Name = AuditLogChange <string> .Convert(change);
break;
}
case "topic":
{
Topic = AuditLogChange <string> .Convert(change);
break;
}
case "bitrate":
{
Bitrate = AuditLogChange <int> .Convert(change);
break;
}
case "permission_overwrites":
{
var overwritesBefore = Optional <IReadOnlyList <RestOverwrite> > .Empty;
if (change.OldValue.HasValue)
{
var models = change.OldValue.Value.ToType <OverwriteModel[]>();
overwritesBefore = new Optional <IReadOnlyList <RestOverwrite> >(
models.ToReadOnlyList((client, model), (x, tuple) =>
{
var(client, model) = tuple;
return(new RestOverwrite(client, model.TargetId.Value, x));
}));
}
var overwritesAfter = Optional <IReadOnlyList <RestOverwrite> > .Empty;
if (change.NewValue.HasValue)
{
var models = change.NewValue.Value.ToType <OverwriteModel[]>();
overwritesAfter = new Optional <IReadOnlyList <RestOverwrite> >(
models.ToReadOnlyList((client, model), (x, tuple) =>
{
var(client, model) = tuple;
return(new RestOverwrite(client, model.TargetId.Value, x));
}));
}
Overwrites = new AuditLogChange <IReadOnlyList <RestOverwrite> >(overwritesBefore, overwritesAfter);
break;
}
case "nsfw":
{
IsNsfw = AuditLogChange <bool> .Convert(change);
break;
}
case "rate_limit_per_user":
{
Slowmode = AuditLogChange <int> .Convert(change);
break;
}
case "type":
{
Type = AuditLogChange <AuditLogChannelType> .Convert(change);
break;
}
default:
{
client.Log(LogSeverity.Error, $"Unknown change key for {nameof(ChannelChanges)}: '{change.Key}'.");
break;
}
}
}
}
internal RestMessageUnpinnedAuditLog(RestDiscordClient client, AuditLogModel log, AuditLogEntryModel entry) : base(client, log, entry)
{
ChannelId = entry.Options.ChannelId;
MessageId = entry.Options.MessageId;
}
public DiscordClient(TokenType tokenType, string token, DiscordClientConfiguration configuration = null) : this(configuration ?? DiscordClientConfiguration.Default)
{
RestClient = new RestDiscordClient(tokenType, token);
}
internal RestUnknownAuditLog(RestDiscordClient client, AuditLogModel model, AuditLogEntryModel entryModel) : base(client, model, entryModel)
{
Type = (int)entryModel.ActionType;
}
