internal static InviteDeleteAuditLogData Create(BaseDiscordClient discord, Model log, EntryModel entry)
{
API.AuditLogChangeJson[] changes = entry.Changes;
API.AuditLogChangeJson maxAgeModel = changes.FirstOrDefault(x => x.ChangedProperty == "max_age");
API.AuditLogChangeJson codeModel = changes.FirstOrDefault(x => x.ChangedProperty == "code");
API.AuditLogChangeJson temporaryModel = changes.FirstOrDefault(x => x.ChangedProperty == "temporary");
API.AuditLogChangeJson inviterIdModel = changes.FirstOrDefault(x => x.ChangedProperty == "inviter_id");
API.AuditLogChangeJson channelIdModel = changes.FirstOrDefault(x => x.ChangedProperty == "channel_id");
API.AuditLogChangeJson usesModel = changes.FirstOrDefault(x => x.ChangedProperty == "uses");
API.AuditLogChangeJson maxUsesModel = changes.FirstOrDefault(x => x.ChangedProperty == "max_uses");
int maxAge = maxAgeModel.OldValue.ToObject<int>(discord.ApiClient.Serializer);
string code = codeModel.OldValue.ToObject<string>(discord.ApiClient.Serializer);
bool temporary = temporaryModel.OldValue.ToObject<bool>(discord.ApiClient.Serializer);
ulong channelId = channelIdModel.OldValue.ToObject<ulong>(discord.ApiClient.Serializer);
int uses = usesModel.OldValue.ToObject<int>(discord.ApiClient.Serializer);
int maxUses = maxUsesModel.OldValue.ToObject<int>(discord.ApiClient.Serializer);
RestUser inviter = null;
if (inviterIdModel != null)
{
ulong inviterId = inviterIdModel.OldValue.ToObject<ulong>(discord.ApiClient.Serializer);
API.UserJson inviterInfo = log.Users.FirstOrDefault(x => x.Id == inviterId);
inviter = RestUser.Create(discord, inviterInfo);
}
return new InviteDeleteAuditLogData(maxAge, code, temporary, inviter, channelId, uses, maxUses);
}
internal static InviteDeleteAuditLogData Create(BaseDiscordClient discord, Model log, EntryModel entry)
{
var changes = entry.Changes;
var maxAgeModel = changes.FirstOrDefault(x => x.ChangedProperty == "max_age");
var codeModel = changes.FirstOrDefault(x => x.ChangedProperty == "code");
var temporaryModel = changes.FirstOrDefault(x => x.ChangedProperty == "temporary");
var inviterIdModel = changes.FirstOrDefault(x => x.ChangedProperty == "inviter_id");
var channelIdModel = changes.FirstOrDefault(x => x.ChangedProperty == "channel_id");
var usesModel = changes.FirstOrDefault(x => x.ChangedProperty == "uses");
var maxUsesModel = changes.FirstOrDefault(x => x.ChangedProperty == "max_uses");
var maxAge = maxAgeModel.OldValue.ToObject <int>();
var code = codeModel.OldValue.ToObject <string>();
var temporary = temporaryModel.OldValue.ToObject <bool>();
var inviterId = inviterIdModel.OldValue.ToObject <ulong>();
var channelId = channelIdModel.OldValue.ToObject <ulong>();
var uses = usesModel.OldValue.ToObject <int>();
var maxUses = maxUsesModel.OldValue.ToObject <int>();
var inviterInfo = log.Users.FirstOrDefault(x => x.Id == inviterId);
var inviter = RestUser.Create(discord, inviterInfo);
return(new InviteDeleteAuditLogData(maxAge, code, temporary, inviter, channelId, uses, maxUses));
}
internal void Update(Model model)
{
if (ChannelId != model.ChannelId)
{
ChannelId = model.ChannelId;
}
if (model.Avatar.IsSpecified)
{
AvatarId = model.Avatar.Value;
}
if (model.Creator.IsSpecified)
{
Creator = RestUser.Create(Discord, model.Creator.Value);
}
if (model.GuildId.IsSpecified)
{
GuildId = model.GuildId.Value;
}
if (model.Name.IsSpecified)
{
Name = model.Name.Value;
}
ApplicationId = model.ApplicationId;
}
internal void Update(Model model)
{
Description = model.Description;
RPCOrigins = model.RPCOrigins.IsSpecified ? model.RPCOrigins.Value.ToImmutableArray() : ImmutableArray <string> .Empty;
Name = model.Name;
IconId = model.Icon;
IsBotPublic = model.IsBotPublic;
BotRequiresCodeGrant = model.BotRequiresCodeGrant;
Tags = model.Tags.GetValueOrDefault(null)?.ToImmutableArray() ?? ImmutableArray <string> .Empty;
PrivacyPolicy = model.PrivacyPolicy;
TermsOfService = model.TermsOfService;
var installParams = model.InstallParams.GetValueOrDefault(null);
InstallParams = new ApplicationInstallParams(installParams?.Scopes ?? new string[0], (GuildPermission?)installParams?.Permission ?? null);
if (model.Flags.IsSpecified)
{
Flags = model.Flags.Value;
}
if (model.Owner.IsSpecified)
{
Owner = RestUser.Create(Discord, model.Owner.Value);
}
if (model.Team != null)
{
Team = RestTeam.Create(Discord, model.Team);
}
}
internal static MemberUpdateAuditLogData Create(BaseDiscordClient discord, Model log, EntryModel entry)
{
var changes = entry.Changes;
var nickModel = changes.FirstOrDefault(x => x.ChangedProperty == "nick");
var deafModel = changes.FirstOrDefault(x => x.ChangedProperty == "deaf");
var muteModel = changes.FirstOrDefault(x => x.ChangedProperty == "mute");
var avatarModel = changes.FirstOrDefault(x => x.ChangedProperty == "avatar_hash");
string oldNick = nickModel?.OldValue?.ToObject <string>(discord.ApiClient.Serializer),
newNick = nickModel?.NewValue?.ToObject <string>(discord.ApiClient.Serializer);
bool?oldDeaf = deafModel?.OldValue?.ToObject <bool>(discord.ApiClient.Serializer),
newDeaf = deafModel?.NewValue?.ToObject <bool>(discord.ApiClient.Serializer);
bool?oldMute = muteModel?.OldValue?.ToObject <bool>(discord.ApiClient.Serializer),
newMute = muteModel?.NewValue?.ToObject <bool>(discord.ApiClient.Serializer);
string oldAvatar = avatarModel?.OldValue?.ToObject <string>(discord.ApiClient.Serializer),
newAvatar = avatarModel?.NewValue?.ToObject <string>(discord.ApiClient.Serializer);
var targetInfo = log.Users.FirstOrDefault(x => x.Id == entry.TargetId);
var user = RestUser.Create(discord, targetInfo);
var before = new MemberInfo(oldNick, oldDeaf, oldMute, oldAvatar);
var after = new MemberInfo(newNick, newDeaf, newMute, newAvatar);
return(new MemberUpdateAuditLogData(user, before, after));
}
internal void Update(Model model)
{
Name = model.Name;
Icon = model.Icon.IsSpecified ? model.Icon.Value : null;
Description = model.Description;
Summary = model.Summary;
Bot = RestUser.Create(Discord, model.Bot.Value);
}
internal static StageInstanceCreateAuditLogData Create(BaseDiscordClient discord, Model log, EntryModel entry)
{
var topic = entry.Changes.FirstOrDefault(x => x.ChangedProperty == "topic").NewValue.ToObject <string>(discord.ApiClient.Serializer);
var privacyLevel = entry.Changes.FirstOrDefault(x => x.ChangedProperty == "privacy_level").NewValue.ToObject <StagePrivacyLevel>(discord.ApiClient.Serializer);
var user = log.Users.FirstOrDefault(x => x.Id == entry.UserId);
var channelId = entry.Options.ChannelId;
return(new StageInstanceCreateAuditLogData(topic, privacyLevel, RestUser.Create(discord, user), channelId ?? 0));
}
//Helpers
private static IUser GetAuthor(BaseDiscordClient client, IGuild guild, UserModel model, ulong? webhookId)
{
IUser author = null;
if (guild != null)
author = guild.GetUserAsync(model.Id, CacheMode.CacheOnly).Result;
if (author == null)
author = RestUser.Create(client, guild, model, webhookId);
return author;
}
internal void Update(Model model)
{
base.Update(model);
Inviter = RestUser.Create(Discord, model.Inviter);
IsRevoked = model.Revoked;
IsTemporary = model.Temporary;
MaxAge = model.MaxAge != 0 ? model.MaxAge : (int?)null;
MaxUses = model.MaxUses;
Uses = model.Uses;
_createdAtTicks = model.CreatedAt.UtcTicks;
}
public static async Task <RestUser> GetUserAsync(BaseDiscordClient client,
ulong id, RequestOptions options)
{
var model = await client.ApiClient.GetUserAsync(id, options).ConfigureAwait(false);
if (model != null)
{
return(RestUser.Create(client, model));
}
return(null);
}
internal static MemberUpdateAuditLogData Create(BaseDiscordClient discord, Model log, EntryModel entry)
{
var changes = entry.Changes.FirstOrDefault(x => x.ChangedProperty == "nick");
var newNick = changes.NewValue?.ToObject <string>();
var oldNick = changes.OldValue?.ToObject <string>();
var targetInfo = log.Users.FirstOrDefault(x => x.Id == entry.TargetId);
var user = RestUser.Create(discord, targetInfo);
return(new MemberUpdateAuditLogData(user, newNick, oldNick));
}
internal static RestAuditLogEntry Create(BaseDiscordClient discord, Model fullLog, EntryModel model)
{
var userInfo = fullLog.Users.FirstOrDefault(x => x.Id == model.UserId);
IUser user = null;
if (userInfo != null)
{
user = RestUser.Create(discord, userInfo);
}
return(new RestAuditLogEntry(discord, fullLog, model, user));
}
internal static MessagePinAuditLogData Create(BaseDiscordClient discord, Model log, EntryModel entry)
{
RestUser user = null;
if (entry.TargetId.HasValue)
{
API.UserJson userInfo = log.Users.FirstOrDefault(x => x.Id == entry.TargetId);
user = RestUser.Create(discord, userInfo);
}
return(new MessagePinAuditLogData(entry.Options.MessageId.Value, entry.Options.ChannelId.Value, user));
}
internal void Update(Model model)
{
base.Update(model);
Inviter = model.Inviter != null?RestUser.Create(Discord, model.Inviter) : null;
IsRevoked = model.Revoked;
IsTemporary = model.Temporary;
MaxAge = model.MaxAge.IsSpecified ? model.MaxAge.Value : (int?)null;
MaxUses = model.MaxUses.IsSpecified ? model.MaxUses.Value : (int?)null;
Uses = model.Uses.IsSpecified ? model.Uses.Value : (int?)null;
_createdAtTicks = model.CreatedAt.IsSpecified ? model.CreatedAt.Value.UtcTicks : (long?)null;
}
internal RestTeamMember(BaseDiscordClient discord, Model model)
{
MembershipState = model.MembershipState switch
{
API.MembershipState.Invited => MembershipState.Invited,
API.MembershipState.Accepted => MembershipState.Accepted,
_ => throw new InvalidOperationException("Invalid membership state"),
};
Permissions = model.Permissions;
TeamId = model.TeamId;
User = RestUser.Create(discord, model.User);
}
internal void Update(Model model)
{
GuildId = model.Guild.IsSpecified ? model.Guild.Value.Id : default(ulong?);
ChannelId = model.Channel.Id;
GuildName = model.Guild.IsSpecified ? model.Guild.Value.Name : null;
ChannelName = model.Channel.Name;
MemberCount = model.MemberCount.IsSpecified ? model.MemberCount.Value : null;
PresenceCount = model.PresenceCount.IsSpecified ? model.PresenceCount.Value : null;
ChannelType = (ChannelType)model.Channel.Type;
Inviter = model.Inviter.IsSpecified ? RestUser.Create(Discord, model.Inviter.Value) : null;
TargetUser = model.TargetUser.IsSpecified ? RestUser.Create(Discord, model.TargetUser.Value) : null;
TargetUserType = model.TargetUserType.IsSpecified ? model.TargetUserType.Value : TargetUserType.Undefined;
}
internal void Update(Model model)
{
Name = model.Name;
Type = model.Type;
IsEnabled = model.Enabled;
IsSyncing = model.Syncing;
ExpireBehavior = model.ExpireBehavior;
ExpireGracePeriod = model.ExpireGracePeriod;
_syncedAtTicks = model.SyncedAt.UtcTicks;
RoleId = model.RoleId;
User = RestUser.Create(Discord, model.User);
}
internal static RestUser Create(BaseDiscordClient discord, IGuild guild, EventUserModel model)
{
if (model.Member.IsSpecified)
{
var member = model.Member.Value;
member.User = model.User;
return(RestGuildUser.Create(discord, guild, member));
}
else
{
return(RestUser.Create(discord, model.User));
}
}
//Helpers
private static IUser GetAuthor(BaseDiscordClient client, IGuild guild, UserModel model)
{
IUser author = null;
if (guild != null)
{
author = guild.GetUserAsync(model.Id, CacheMode.CacheOnly).Result;
}
if (author == null)
{
author = RestUser.Create(client, model);
}
return(author);
}
internal static MemberRoleAuditLogData Create(BaseDiscordClient discord, Model log, EntryModel entry)
{
var changes = entry.Changes;
var roleInfos = changes.SelectMany(x => x.NewValue.ToObject <API.Role[]>(discord.ApiClient.Serializer),
(model, role) => new { model.ChangedProperty, Role = role })
.Select(x => new MemberRoleEditInfo(x.Role.Name, x.Role.Id, x.ChangedProperty == "$add"))
.ToList();
var userInfo = log.Users.FirstOrDefault(x => x.Id == entry.TargetId);
RestUser user = (userInfo != null) ? RestUser.Create(discord, userInfo) : null;
return(new MemberRoleAuditLogData(roleInfos.ToReadOnlyCollection(), user));
}
internal static StageInstanceUpdatedAuditLogData Create(BaseDiscordClient discord, Model log, EntryModel entry)
{
var channelId = entry.Options.ChannelId.Value;
var topic = entry.Changes.FirstOrDefault(x => x.ChangedProperty == "topic");
var privacy = entry.Changes.FirstOrDefault(x => x.ChangedProperty == "privacy");
var user = RestUser.Create(discord, log.Users.FirstOrDefault(x => x.Id == entry.UserId));
var oldTopic = topic?.OldValue.ToObject <string>();
var newTopic = topic?.NewValue.ToObject <string>();
var oldPrivacy = privacy?.OldValue.ToObject <StagePrivacyLevel>();
var newPrivacy = privacy?.NewValue.ToObject <StagePrivacyLevel>();
return(new StageInstanceUpdatedAuditLogData(channelId, new StageInfo(user, oldPrivacy, oldTopic), new StageInfo(user, newPrivacy, newTopic)));
}
internal void Update(Model model)
{
Description = model.Description;
RPCOrigins = model.RPCOrigins;
Name = model.Name;
_iconId = model.Icon;
if (model.Flags.IsSpecified)
{
Flags = model.Flags.Value; //TODO: Do we still need this?
}
if (model.Owner.IsSpecified)
{
Owner = RestUser.Create(Discord, model.Owner.Value);
}
}
internal void Update(BaseDiscordClient discord, Model model, bool withSnapshot)
{
Code = model.Code;
Name = model.Name;
Description = model.Description;
UsageCount = model.UsageCount;
CreatorId = model.CreatorId;
Creator = RestUser.Create(discord, model.Creator);
SourceGuildId = model.SourceGuildId;
CreatedAt = model.CreatedAt;
UpdatedAt = model.UpdatedAt;
if (withSnapshot)
{
Snapshot = RestGuildSnapshot.Create(discord, (model as GuildTemplateSnapshotJson).Snapshot);
}
}
internal void Update(Model model)
{
if (model.Avatar.IsSpecified)
{
AvatarId = model.Avatar.Value;
}
if (model.Creator.IsSpecified)
{
Creator = RestUser.Create(Discord, model.Creator.Value);
}
if (model.GuildId.IsSpecified)
{
GuildId = model.GuildId.Value;
}
if (model.Name.IsSpecified)
{
Name = model.Name.Value;
}
}
internal void Update(Model model)
{
Name = model.Name;
Type = model.Type;
IsEnabled = model.Enabled;
IsSyncing = model.Syncing.IsSpecified ? model.Syncing.Value : null;
RoleId = model.RoleId.IsSpecified ? model.RoleId.Value : null;
HasEnabledEmoticons = model.EnableEmoticons.IsSpecified ? model.EnableEmoticons.Value : null;
ExpireBehavior = model.ExpireBehavior.IsSpecified ? model.ExpireBehavior.Value : null;
ExpireGracePeriod = model.ExpireGracePeriod.IsSpecified ? model.ExpireGracePeriod.Value : null;
User = model.User.IsSpecified ? RestUser.Create(Discord, model.User.Value) : null;
Account = model.Account.IsSpecified ? RestIntegrationAccount.Create(model.Account.Value) : null;
SubscriberCount = model.SubscriberAccount.IsSpecified ? model.SubscriberAccount.Value : null;
IsRevoked = model.Revoked.IsSpecified ? model.Revoked.Value : null;
Application = model.Application.IsSpecified ? RestIntegrationApplication.Create(Discord, model.Application.Value) : null;
_syncedAtTicks = model.SyncedAt.IsSpecified ? model.SyncedAt.Value.UtcTicks : null;
}
internal void Update(Model model)
{
if (ChannelId != model.ChannelId)
{
ChannelId = model.ChannelId;
}
if (model.Avatar.IsSpecified)
{
AvatarId = model.Avatar.Value;
}
if (model.Creator.IsSpecified)
{
Creator = RestUser.Create(Discord, model.Creator.Value);
}
if (model.GuildId.IsSpecified)
{
GuildId = model.GuildId.Value;
}
if (model.Name.IsSpecified)
{
Name = model.Name.Value;
}
if (model.SourceGuild.IsSpecified)
{
SourceGuild = new WebhookFollowGuild
{
Id = model.SourceGuild.Value.Id,
Icon = model.SourceGuild.Value.Icon,
Name = model.SourceGuild.Value.Name
}
}
;
if (model.SourceChannel.IsSpecified)
{
SourceChannel = new WebhookFollowChannel
{
Id = model.SourceChannel.Value.Id,
Name = model.SourceChannel.Value.Name
}
}
;
}
internal void Update(Model model)
{
if (model.Creator.IsSpecified)
{
Creator = RestUser.Create(Discord, model.Creator.Value);
}
CreatorId = model.CreatorId.ToNullable() ?? 0; // should be changed?
ChannelId = model.ChannelId.IsSpecified ? model.ChannelId.Value : null;
Name = model.Name;
Description = model.Description.GetValueOrDefault();
StartTime = model.ScheduledStartTime;
EndTime = model.ScheduledEndTime;
PrivacyLevel = model.PrivacyLevel;
Status = model.Status;
Type = model.EntityType;
EntityId = model.EntityId;
Location = model.EntityMetadata?.Location.GetValueOrDefault();
UserCount = model.UserCount.ToNullable();
}
internal void Update(Model model)
{
Description = model.Description;
RPCOrigins = model.RPCOrigins;
Name = model.Name;
_iconId = model.Icon;
IsBotPublic = model.IsBotPublic;
BotRequiresCodeGrant = model.BotRequiresCodeGrant;
if (model.Flags.IsSpecified)
{
Flags = model.Flags.Value; //TODO: Do we still need this?
}
if (model.Owner.IsSpecified)
{
Owner = RestUser.Create(Discord, model.Owner.Value);
}
if (model.Team != null)
{
Team = RestTeam.Create(Discord, model.Team);
}
}
internal static MemberUpdateAuditLogData Create(BaseDiscordClient discord, Model log, EntryModel entry)
{
API.AuditLogChangeJson[] changes = entry.Changes;
API.AuditLogChangeJson nickModel = changes.FirstOrDefault(x => x.ChangedProperty == "nick");
API.AuditLogChangeJson deafModel = changes.FirstOrDefault(x => x.ChangedProperty == "deaf");
API.AuditLogChangeJson muteModel = changes.FirstOrDefault(x => x.ChangedProperty == "mute");
string oldNick = nickModel?.OldValue?.ToObject <string>(discord.ApiClient.Serializer),
newNick = nickModel?.NewValue?.ToObject <string>(discord.ApiClient.Serializer);
bool?oldDeaf = deafModel?.OldValue?.ToObject <bool>(discord.ApiClient.Serializer),
newDeaf = deafModel?.NewValue?.ToObject <bool>(discord.ApiClient.Serializer);
bool?oldMute = muteModel?.OldValue?.ToObject <bool>(discord.ApiClient.Serializer),
newMute = muteModel?.NewValue?.ToObject <bool>(discord.ApiClient.Serializer);
API.UserJson targetInfo = log.Users.FirstOrDefault(x => x.Id == entry.TargetId);
RestUser user = RestUser.Create(discord, targetInfo);
MemberInfo before = new MemberInfo(oldNick, oldDeaf, oldMute);
MemberInfo after = new MemberInfo(newNick, newDeaf, newMute);
return(new MemberUpdateAuditLogData(user, before, after));
}
public static IAsyncEnumerable <IReadOnlyCollection <IUser> > GetReactionUsersAsync(IMessage msg, IEmote emote,
int?limit, BaseDiscordClient client, RequestOptions options)
{
Preconditions.NotNull(emote, nameof(emote));
var emoji = (emote is Emote e ? $"{e.Name}:{e.Id}" : emote.Name);
return(new PagedAsyncEnumerable <IUser>(
DiscordConfig.MaxUserReactionsPerBatch,
async(info, ct) =>
{
var args = new GetReactionUsersParams
{
Limit = info.PageSize
};
if (info.Position != null)
{
args.AfterUserId = info.Position.Value;
}
var models = await client.ApiClient.GetReactionUsersAsync(msg.Channel.Id, msg.Id, emoji, args, options).ConfigureAwait(false);
return models.Select(x => RestUser.Create(client, x)).ToImmutableArray();
},
nextPage: (info, lastPage) =>
{
if (lastPage.Count != DiscordConfig.MaxUsersPerBatch)
{
return false;
}
info.Position = lastPage.Max(x => x.Id);
return true;
},
count: limit
));
}
