public static async Task <IGuild> ModifyGuildAsync(this IRestClient client, Snowflake guildId, Action <ModifyGuildActionProperties> action, IRestRequestOptions options = null)
        {
            if (action == null)
            {
                throw new ArgumentNullException(nameof(action));
            }

            var properties = new ModifyGuildActionProperties();

            action(properties);
            var content = new ModifyGuildJsonRestRequestContent
            {
                Name = properties.Name,
                VerificationLevel           = properties.VerificationLevel,
                DefaultMessageNotifications = properties.NotificationLevel,
                ExplicitContentFilter       = properties.ContentFilterLevel,
                AfkChannelId           = properties.AfkChannelId,
                AfkTimeout             = properties.AfkTimeout,
                Icon                   = properties.Icon,
                OwnerId                = properties.OwnerId,
                Splash                 = properties.Splash,
                DiscoverySplash        = properties.DiscoverySplash,
                Banner                 = properties.Banner,
                SystemChannelId        = properties.SystemChannelId,
                SystemChannelFlags     = properties.SystemChannelFlags,
                RulesChannelId         = properties.RulesChannelId,
                PublicUpdatesChannelId = properties.PublicUpdatesChannelId,
                PreferredLocale        = Optional.Convert(properties.PreferredLocale, x => x.Name),
                Features               = Optional.Convert(properties.Features, x => x.ToArray()),
                Description            = properties.Description
            };
            var model = await client.ApiClient.ModifyGuildAsync(guildId, content, options).ConfigureAwait(false);

            return(new TransientGuild(client, model));
        }
Exemple #2
0
        public virtual void Update(MessageJsonModel model)
        {
            if (_transientAuthor != null)
            {
                if (model.Member.HasValue)
                {
                    model.Member.Value.User = model.Author;
                    _transientAuthor        = new TransientMember(Client, GuildId.Value, model.Member.Value);
                }
                else
                {
                    _transientAuthor = new TransientUser(Client, model.Author);
                }
            }
            Content        = model.Content;
            MentionedUsers = model.Mentions.ToReadOnlyList(Client, (x, client) =>
            {
                var user = client.GetUser(x.Id);
                if (user != null)
                {
                    return(user);
                }

                return(new TransientUser(client, x) as IUser);
            });
            Reactions = Optional.Convert(model.Reactions, x => x.ToReadOnlyDictionary(x => Emoji.Create(x.Emoji), x => new Reaction(x)));
        }
        public static CreateApplicationCommandJsonRestRequestContent ToContent(this LocalApplicationCommand command, IJsonSerializer serializer)
        {
            Guard.IsNotNull(command);

            var content = new CreateApplicationCommandJsonRestRequestContent
            {
                Name = command.Name.Value,
                DefaultPermission = command.IsEnabledByDefault
            };

            if (command is LocalSlashCommand slashCommand)
            {
                content.Type        = ApplicationCommandType.Slash;
                content.Description = slashCommand.Description;
                content.Options     = Optional.Convert(slashCommand.Options, options => options?.Select(option => option?.ToModel(serializer)).ToArray());
            }
            else if (command is LocalUserContextMenuCommand)
            {
                content.Type = ApplicationCommandType.User;
            }
            else if (command is LocalMessageContextMenuCommand)
            {
                content.Type = ApplicationCommandType.Message;
            }

            return(content);
        }
Exemple #4
0
        internal static AuditLogChange <T> Convert(AuditLogChangeJsonModel model)
        {
            var oldValue = Optional.Convert(model.OldValue, model => model.ToType <T>());
            var newValue = Optional.Convert(model.NewValue, model => model.ToType <T>());

            return(new(oldValue, newValue));
        }
        public static async Task <IUserMessage> ModifyMessageAsync(this IRestClient client, Snowflake channelId, Snowflake messageId, Action <ModifyMessageActionProperties> action, IRestRequestOptions options = null)
        {
            if (action == null)
            {
                throw new ArgumentNullException(nameof(action));
            }

            var properties = new ModifyMessageActionProperties();

            action(properties);
            var content = new ModifyMessageJsonRestRequestContent
            {
                Content = properties.Content,
                Embeds  = Optional.Convert(properties.Embeds, models => models.Select(x =>
                {
                    x.Validate();
                    return(x.ToModel());
                }).ToArray()),
                Flags           = properties.Flags,
                AllowedMentions = Optional.Convert(properties.AllowedMentions, x => x.ToModel()),
                Attachments     = Optional.Convert(properties.AttachmentIds, x => x.Select(x => new AttachmentJsonModel
                {
                    Id = x
                }).ToArray()),
                Components = Optional.Convert(properties.Components, models => models.Select(x =>
                {
                    x.Validate();
                    return(x.ToModel());
                }).ToArray()),
                StickerIds = Optional.Convert(properties.StickerIds, x => x.ToArray())
            };
            var model = await client.ApiClient.ModifyMessageAsync(channelId, messageId, content, options).ConfigureAwait(false);

            return(new TransientUserMessage(client, model));
        }
        internal static Task <ChannelJsonModel> InternalModifyChannelAsync <T>(this IRestClient client, Snowflake channelId, Action <T> action, IRestRequestOptions options = null)
            where T : ModifyGuildChannelActionProperties
        {
            if (action == null)
            {
                throw new ArgumentNullException(nameof(action));
            }

            // Can't use the new() generic constraint because the constructors are internal.
            // Can't use the generic CreateInstance either *because*.
            var properties = (T)Activator.CreateInstance(typeof(T), true);

            action(properties);
            var content = new ModifyChannelJsonRestRequestContent
            {
                Name                 = properties.Name,
                Position             = properties.Position,
                PermissionOverwrites = Optional.Convert(properties.Overwrites, x => x.Select(x => x.ToModel()).ToArray())
            };

            if (properties is ModifyNestableChannelActionProperties nestableProperties)
            {
                content.ParentId = nestableProperties.CategoryId;

                if (nestableProperties is ModifyMessageGuildChannelActionProperties messageGuildChannelProperties)
                {
                    content.RateLimitPerUser = Optional.Convert(messageGuildChannelProperties.Slowmode, x => (int)x.TotalSeconds);

                    if (nestableProperties is ModifyTextChannelActionProperties textProperties)
                    {
                        content.Topic = textProperties.Topic;
                        content.Nsfw  = textProperties.IsNsfw;
                    }
                    else if (nestableProperties is ModifyThreadChannelActionProperties threadProperties)
                    {
                        content.Archived            = threadProperties.IsArchived;
                        content.AutoArchiveDuration = Optional.Convert(threadProperties.AutomaticArchiveDuration, x => (int)x.TotalMinutes);
                        content.Locked = threadProperties.IsLocked;
                    }
                }
                else if (nestableProperties is ModifyVoiceChannelActionProperties voiceProperties)
                {
                    content.Bitrate   = voiceProperties.Bitrate;
                    content.UserLimit = voiceProperties.MemberLimit;
                    content.RtcRegion = voiceProperties.Region;
                }
            }
            else if (properties is ModifyCategoryChannelActionProperties categoryProperties)
            {
                // No extra properties for category channels.
            }
            else
            {
                throw new ArgumentException($"Unknown channel action properties provided ({properties.GetType()}).");
            }

            return(client.ApiClient.ModifyChannelAsync(channelId, content, options));
        }
        internal static Task <ChannelJsonModel> InternalCreateGuildChannelAsync <T>(this IRestClient client,
                                                                                    Snowflake guildId, string name, Action <T> action,
                                                                                    IRestRequestOptions options = null, CancellationToken cancellationToken = default)
            where T : CreateGuildChannelActionProperties
        {
            // Can't use the new() generic constraint because the constructors are internal.
            // Can't use the generic CreateInstance either *because*.
            var properties = (T)Activator.CreateInstance(typeof(T), true);

            action?.Invoke(properties);
            var content = new CreateGuildChannelJsonRestRequestContent(name)
            {
                Position             = properties.Position,
                PermissionOverwrites = Optional.Convert(properties.Overwrites, x => x.Select(x => x.ToModel()).ToArray())
            };

            if (properties is CreateNestedChannelActionProperties nestedProperties)
            {
                content.ParentId = nestedProperties.CategoryId;

                if (properties is CreateTextChannelActionProperties textProperties)
                {
                    if (textProperties.Topic.HasValue && textProperties.Topic.Value != null && textProperties.Topic.Value.Length > 1024)
                    {
                        throw new ArgumentOutOfRangeException(nameof(CreateTextChannelActionProperties.Topic));
                    }

                    content.Type             = ChannelType.Text;
                    content.Topic            = textProperties.Topic;
                    content.RateLimitPerUser = Optional.Convert(textProperties.Slowmode, x => (int)x.TotalSeconds);
                    content.Nsfw             = textProperties.IsNsfw;
                }
                else if (properties is CreateVoiceChannelActionProperties voiceProperties)
                {
                    content.Type      = ChannelType.Voice;
                    content.Bitrate   = voiceProperties.Bitrate;
                    content.UserLimit = voiceProperties.MemberLimit;
                    content.RtcRegion = voiceProperties.Region;
                }
                else
                {
                    throw new ArgumentException($"Unknown channel action properties provided ({properties.GetType()}).");
                }
            }
            else if (properties is CreateCategoryChannelActionProperties categoryProperties)
            {
                content.Type = ChannelType.Category;

                // No extra properties for category channels.
            }
            else
            {
                throw new ArgumentException($"Unknown channel action properties provided ({properties.GetType()}).");
            }

            return(client.ApiClient.CreateGuildChannelAsync(guildId, content, options, cancellationToken));
        }
Exemple #8
0
        public static CreateInitialInteractionResponseJsonRestRequestContent ToContent(this ILocalInteractionResponse response,
                                                                                       IJsonSerializer serializer, out IList <LocalAttachment> attachments)
        {
            Guard.IsNotNull(response);

            var content = new CreateInitialInteractionResponseJsonRestRequestContent
            {
                Type = response.Type
            };

            attachments = Array.Empty <LocalAttachment>();

            if (response is LocalInteractionAutoCompleteResponse autoCompleteResponse)
            {
                content.Data = new InteractionCallbackAutoCompleteDataJsonModel
                {
                    Choices = Optional.Convert(autoCompleteResponse.Choices, choices => choices?.Select(choice => choice.ToModel(serializer)).ToArray())
                };
            }
            else if (response is LocalInteractionMessageResponse messageResponse)
            {
                if (content.Type is not InteractionResponseType.MessageUpdate)
                {
                    messageResponse.Validate();
                    content.Data = new InteractionCallbackMessageDataJsonModel
                    {
                        Tts     = Optional.Conditional(messageResponse.IsTextToSpeech, true),
                        Content = Optional.FromNullable(messageResponse.Content),
                        Embeds  = Optional.Conditional(messageResponse.Embeds.Count != 0,
                                                       x => x.Select(x => x.ToModel()).ToArray(), messageResponse.Embeds),
                        AllowedMentions = Optional.FromNullable(messageResponse.AllowedMentions.ToModel()),
                        Components      = Optional.Conditional(messageResponse.Components.Count != 0,
                                                               x => x.Select(x => x.ToModel()).ToArray(), messageResponse.Components),
                        Flags = Optional.Conditional(messageResponse.Flags != MessageFlag.None,
                                                     messageResponse.Flags)
                    };
                }
                else
                {
                    // TODO: make properties properly optional via different LocalInteractionResponse types?
                    content.Data = new InteractionCallbackMessageDataJsonModel
                    {
                        //Tts = messageResponse.IsTextToSpeech,
                        Content         = messageResponse.Content,
                        Embeds          = messageResponse.Embeds.Select(x => x.ToModel()).ToArray(),
                        AllowedMentions = messageResponse.AllowedMentions?.ToModel(),
                        Components      = messageResponse.Components.Select(x => x.ToModel()).ToArray(),
                        Flags           = messageResponse.Flags
                    };
                }
                attachments = messageResponse.Attachments;
            }
        private static async Task <IUserMessage> InternalModifyInteractionResponseAsync(this IRestClient client,
                                                                                        Snowflake applicationId, string interactionToken, Snowflake?messageId, Action <ModifyWebhookMessageActionProperties> action,
                                                                                        IRestRequestOptions options, CancellationToken cancellationToken)
        {
            var properties = new ModifyWebhookMessageActionProperties();

            action.Invoke(properties);
            var messageContent = new ModifyWebhookMessageJsonRestRequestContent
            {
                Content = properties.Content,
                Embeds  = Optional.Convert(properties.Embeds, x => x.Select(x =>
                {
                    x.Validate();
                    return(x.ToModel());
                }).ToArray()),
                AllowedMentions = Optional.Convert(properties.AllowedMentions, x => x.ToModel()),
                Attachments     = Optional.Convert(properties.AttachmentIds, x => x.Select(x => new AttachmentJsonModel
                {
                    Id = x
                }).ToArray()),
                Components = Optional.Convert(properties.Components, x => x.Select(x =>
                {
                    x.Validate();
                    return(x.ToModel());
                }).ToArray())
            };

            Task <MessageJsonModel> task;

            if (properties.Attachments.HasValue)
            {
                // If there is an attachment, we must send it via multipart HTTP content.
                // Our `messageContent` will be serialized into a "payload_json" form data field.
                var content = new MultipartJsonPayloadRestRequestContent <ModifyWebhookMessageJsonRestRequestContent>(messageContent, properties.Attachments.Value);
                task = messageId == null
                    ? client.ApiClient.ModifyInitialInteractionResponseAsync(applicationId, interactionToken, content, options, cancellationToken)
                    : client.ApiClient.ModifyFollowupInteractionResponseAsync(applicationId, interactionToken, messageId.Value, content, options, cancellationToken);
            }
            else
            {
                task = messageId == null
                    ? client.ApiClient.ModifyInitialInteractionResponseAsync(applicationId, interactionToken, messageContent, options, cancellationToken)
                    : client.ApiClient.ModifyFollowupInteractionResponseAsync(applicationId, interactionToken, messageId.Value, messageContent, options, cancellationToken);
            }

            var model = await task.ConfigureAwait(false);

            return(new TransientUserMessage(client, model));
        }
Exemple #10
0
        public void Update(GuildJsonModel model)
        {
            Name       = model.Name;
            IconHash   = model.Icon;
            SplashHash = model.Splash;

            if (model.DiscoverySplash.HasValue)
            {
                DiscoverySplashHash = model.DiscoverySplash.Value;
            }

            OwnerId      = model.OwnerId;
            VoiceRegion  = model.Region;
            AfkChannelId = model.AfkChannelId;
            AfkTimeout   = TimeSpan.FromSeconds(model.AfkTimeout);

            if (model.WidgetEnabled.HasValue)
            {
                IsWidgetEnabled = model.WidgetEnabled.Value;
            }

            if (model.WidgetChannelId.HasValue)
            {
                WidgetChannelId = model.WidgetChannelId.Value;
            }

            VerificationLevel  = model.VerificationLevel;
            NotificationLevel  = model.DefaultMessageNotifications;
            ContentFilterLevel = model.ExplicitContentFilter;
            SetEmojis(model.Emojis);
            Features               = model.Features;
            MfaLevel               = model.MfaLevel;
            SystemChannelId        = model.SystemChannelId;
            SystemChannelFlags     = model.SystemChannelFlags;
            RulesChannelId         = model.RulesChannelId;
            MaxPresenceCount       = Optional.Convert(model.MaxPresences, x => x ?? Discord.Constants.DefaultMaxGuildPresenceCount).GetValueOrNullable();
            MaxMemberCount         = model.MaxMembers.GetValueOrNullable();
            VanityUrlCode          = model.VanityUrlCode;
            Description            = model.Description;
            BannerHash             = model.Banner;
            BoostTier              = model.PremiumTier;
            BoostingMemberCount    = model.PremiumSubscriptionCount.GetValueOrNullable();
            PreferredLocale        = Discord.Internal.GetLocale(model.PreferredLocale);
            PublicUpdatesChannelId = model.PublicUpdatesChannelId;
            MaxVideoMemberCount    = model.MaxVideoChannelUsers.GetValueOrNullable();
        }
        public override void Update(MessageJsonModel model)
        {
            base.Update(model);

            EditedAt          = model.EditedTimestamp;
            IsPinned          = model.Pinned;
            MentionsEveryone  = model.MentionEveryone;
            MentionedRoleIds  = model.MentionRoles.ReadOnly();
            Attachments       = model.Attachments.ToReadOnlyList(model => new TransientAttachment(model));
            Embeds            = model.Embeds.ToReadOnlyList(model => new TransientEmbed(model));
            Activity          = Optional.ConvertOrDefault(model.Activity, model => new TransientMessageActivity(model));
            Application       = Optional.ConvertOrDefault(model.Application, model => new TransientMessageApplication(model));
            Reference         = Optional.ConvertOrDefault(model.MessageReference, model => new TransientMessageReference(model));
            ReferencedMessage = Optional.Convert(model.ReferencedMessage, model => new TransientUserMessage(Client, model) as IUserMessage);

            Components = Optional.ConvertOrDefault(model.Components, (models, client) => models.ToReadOnlyList(client, (model, client) => new TransientRowComponent(client, model) as IRowComponent), Client) ?? Array.Empty <IRowComponent>();
            Stickers   = Optional.ConvertOrDefault(model.StickerItems, models => models.ToReadOnlyList(model => new TransientMessageSticker(model) as IMessageSticker), Array.Empty <IMessageSticker>());
        }
Exemple #12
0
        public static ModifyApplicationCommandJsonRestRequestContent ToContent(this Action <ModifyApplicationCommandActionProperties> action, IJsonSerializer serializer)
        {
            Guard.IsNotNull(action);

            var properties = new ModifyApplicationCommandActionProperties();

            action(properties);

            var content = new ModifyApplicationCommandJsonRestRequestContent
            {
                Name              = properties.Name,
                Description       = properties.Description,
                DefaultPermission = properties.IsEnabledByDefault,
                Options           = Optional.Convert(properties.Options, options => options?.Select(option => option?.ToModel(serializer)).ToArray())
            };

            return(content);
        }
        public static ApplicationCommandOptionJsonModel ToModel(this LocalSlashCommandOption option, IJsonSerializer serializer)
        {
            Guard.IsNotNull(option);
            OptionalGuard.HasValue(option.Type);
            OptionalGuard.HasValue(option.Name);
            OptionalGuard.HasValue(option.Description);

            return(new ApplicationCommandOptionJsonModel
            {
                Type = option.Type.Value,
                Name = option.Name.Value,
                Description = option.Description.Value,
                Required = option.IsRequired,
                Choices = Optional.Convert(option.Choices, choices => choices?.Select(choice => choice?.ToModel(serializer)).ToArray()),
                Options = Optional.Convert(option.Options, options => options?.Select(option => option?.ToModel(serializer)).ToArray()),
                ChannelTypes = Optional.Convert(option.ChannelTypes, channelTypes => channelTypes?.ToArray())
            });
        }
        public static async Task <IUserMessage> ModifyMessageAsync(this IRestClient client,
                                                                   Snowflake channelId, Snowflake messageId, Action <ModifyMessageActionProperties> action,
                                                                   IRestRequestOptions options = null, CancellationToken cancellationToken = default)
        {
            Guard.IsNotNull(action);

            var properties = new ModifyMessageActionProperties();

            action(properties);
            var messageContent = new ModifyMessageJsonRestRequestContent
            {
                Content = properties.Content,
                Embeds  = Optional.Convert(properties.Embeds, models => models.Select(x =>
                {
                    x.Validate();
                    return(x.ToModel());
                }).ToArray()),
                Flags           = properties.Flags,
                AllowedMentions = Optional.Convert(properties.AllowedMentions, x => x.ToModel()),
                Attachments     = Optional.Convert(properties.AttachmentIds, x => x.Select(x => new AttachmentJsonModel
                {
                    Id = x
                }).ToArray()),
                Components = Optional.Convert(properties.Components, models => models.Select(x =>
                {
                    x.Validate();
                    return(x.ToModel());
                }).ToArray()),
                StickerIds = Optional.Convert(properties.StickerIds, x => x.ToArray())
            };

            Task <MessageJsonModel> task;

            LocalAttachment[] attachments;
            if (properties.Attachments.TryGetValue(out var attachmentsEnumerable) && (attachments = attachmentsEnumerable.GetArray()).Length != 0)
            {
                // If there are attachments, we must send them via multipart HTTP content.
                // Our `messageContent` will be serialized into a "payload_json" form data field.
                var content = new MultipartJsonPayloadRestRequestContent <ModifyMessageJsonRestRequestContent>(messageContent, attachments);
                task = client.ApiClient.ModifyMessageAsync(channelId, messageId, content, options, cancellationToken);
            }
Exemple #15
0
        public override void Update(MessageJsonModel model)
        {
            base.Update(model);

            EditedAt         = model.EditedTimestamp;
            IsPinned         = model.Pinned;
            MentionsEveryone = model.MentionEveryone;
            MentionedRoleIds = model.MentionRoles.ReadOnly();
            Attachments      = model.Attachments.ToReadOnlyList(x => new Attachment(x));
            Embeds           = model.Embeds.ToReadOnlyList(x => new Embed(x));
            Activity         = Optional.ConvertOrDefault(model.Activity, x => new MessageActivity(x));
            Application      = Optional.ConvertOrDefault(model.Application, x => new MessageApplication(x));
            Reference        = Optional.ConvertOrDefault(model.MessageReference, x => new MessageReference(x));
            Flags            = model.Flags.GetValueOrDefault();
            Stickers         = Optional.ConvertOrDefault(model.Stickers, x => x.ToReadOnlyList(y => new Sticker(y)), Array.Empty <Sticker>());

            if (model.Type == MessageType.Reply || model.ReferencedMessage.GetValueOrDefault() != null)
            {
                // Fix for Discord always sending an empty property.
                ReferencedMessage = Optional.Convert(model.ReferencedMessage, x => new TransientUserMessage(Client, x) as IUserMessage);
            }
        }
        public static ModifyMemberJsonRestRequestContent ToContent(this Action <ModifyMemberActionProperties> action, out Optional <string> nick)
        {
            Guard.IsNotNull(action);

            var properties = new ModifyMemberActionProperties();

            action(properties);

            nick = properties.Nick;

            var content = new ModifyMemberJsonRestRequestContent
            {
                Nick      = properties.Nick,
                Roles     = Optional.Convert(properties.RoleIds, x => x.ToArray()),
                ChannelId = properties.VoiceChannelId,
                Mute      = properties.Mute,
                Deaf      = properties.Deaf,
                CommunicationDisabledUntil = properties.TimedOutUntil
            };

            return(content);
        }
        public static ModifyRoleJsonRestRequestContent ToContent(this Action <ModifyRoleActionProperties> action, out Optional <int> position)
        {
            Guard.IsNotNull(action);

            var properties = new ModifyRoleActionProperties();

            action(properties);

            var content = new ModifyRoleJsonRestRequestContent
            {
                Name         = properties.Name,
                Permissions  = Optional.Convert(properties.Permissions, permissions => permissions.RawValue),
                Color        = Optional.Convert(properties.Color, color => color?.RawValue ?? 0),
                Hoist        = properties.IsHoisted,
                Icon         = properties.Icon,
                Mentionable  = properties.IsMentionable,
                UnicodeEmoji = Optional.Convert(properties.UnicodeEmoji, emoji => emoji.Name)
            };

            position = properties.Position;

            return(content);
        }
Exemple #18
0
        public TransientMemberRolesUpdatedAuditLog(IClient client, Snowflake guildId, AuditLogJsonModel auditLogJsonModel, AuditLogEntryJsonModel model)
            : base(client, guildId, auditLogJsonModel, model)
        {
            for (var i = 0; i < model.Changes.Value.Length; i++)
            {
                var change = model.Changes.Value[i];
                switch (change.Key)
                {
                case "$add":
                {
                    RolesGranted = Optional.Convert(change.NewValue, x =>
                        {
                            var models = x.ToType <RoleJsonModel[]>();
                            return(models.ToReadOnlyDictionary(x => x.Id, x => x.Name));
                        });
                    break;
                }

                case "$remove":
                {
                    RolesRevoked = Optional.Convert(change.NewValue, x =>
                        {
                            var models = x.ToType <RoleJsonModel[]>();
                            return(models.ToReadOnlyDictionary(x => x.Id, x => x.Name));
                        });
                    break;
                }

                default:
                {
                    client.Logger.LogDebug("Unknown key {0} for {1}", change.Key, this);
                    break;
                }
                }
            }
        }
Exemple #19
0
        public void Update(MessageUpdateJsonModel model)
        {
            if (model.Author.HasValue)
            {
                if (_transientAuthor != null)
                {
                    if (model.Member.HasValue)
                    {
                        model.Member.Value.User = model.Author;
                        _transientAuthor        = new TransientMember(Client, GuildId.Value, model.Member.Value);
                    }
                    else
                    {
                        _transientAuthor = new TransientUser(Client, model.Author.Value);
                    }
                }
            }

            if (model.Content.HasValue)
            {
                Content = model.Content.Value;
            }

            if (model.Mentions.HasValue)
            {
                MentionedUsers = model.Mentions.Value.ToReadOnlyList(Client, (x, client) =>
                {
                    var user = client.GetUser(x.Id);
                    if (user != null)
                    {
                        return(user);
                    }

                    return(new TransientUser(client, x) as IUser);
                });
            }

            if (model.Reactions.HasValue)
            {
                Reactions = Optional.Convert(model.Reactions, x => x.ToReadOnlyDictionary(x => Emoji.Create(x.Emoji), x => new MessageReaction(x)));
            }

            if (model.EditedTimestamp.HasValue)
            {
                EditedAt = model.EditedTimestamp.Value;
            }

            if (model.Pinned.HasValue)
            {
                IsPinned = model.Pinned.Value;
            }

            if (model.MentionEveryone.HasValue)
            {
                MentionsEveryone = model.MentionEveryone.Value;
            }

            if (model.MentionRoles.HasValue)
            {
                MentionedRoleIds = model.MentionRoles.Value.ReadOnly();
            }

            if (model.Attachments.HasValue)
            {
                Attachments = model.Attachments.Value.ToReadOnlyList(x => new Attachment(x));
            }

            if (model.Embeds.HasValue)
            {
                Embeds = model.Embeds.Value.ToReadOnlyList(x => new Embed(x));
            }

            if (model.Activity.HasValue)
            {
                Activity = Optional.ConvertOrDefault(model.Activity, x => new MessageActivity(x));
            }

            if (model.Application.HasValue)
            {
                Application = Optional.ConvertOrDefault(model.Application, x => new MessageApplication(x));
            }

            if (model.MessageReference.HasValue)
            {
                Reference = Optional.ConvertOrDefault(model.MessageReference, x => new MessageReference(x));
            }

            if (model.Flags.HasValue)
            {
                Flags = model.Flags.Value;
            }

            if (model.ReferencedMessage.HasValue)
            {
                ReferencedMessage = Optional.Convert(model.ReferencedMessage, x => new TransientUserMessage(Client, x) as IUserMessage);
            }

            if (model.Components.HasValue)
            {
                Components = Optional.ConvertOrDefault(model.Components, (models, client) => models.ToReadOnlyList(client, (model, client) => TransientComponent.Create(client, model)), Client) ?? Array.Empty <IComponent>();
            }

            if (model.StickerItems.HasValue)
            {
                Stickers = Optional.ConvertOrDefault(model.StickerItems, x => x.ToReadOnlyList(y => new MessageSticker(y)), Array.Empty <MessageSticker>());
            }
        }
Exemple #20
0
 public void Update(MessageReactionRemoveEmojiJsonModel model)
 {
     Reactions = Optional.Convert(Reactions, reactions => reactions.Where(kvp => !model.Emoji.Equals(kvp.Key)).ToReadOnlyDictionary(kvp => kvp.Key, kvp => kvp.Value));
 }
Exemple #21
0
        public void Update(MessageReactionRemoveEmojiJsonModel model)
        {
            var emoji = Emoji.Create(model.Emoji);

            Reactions = Optional.Convert(Reactions, x => x.Where(x => !x.Key.Equals(emoji)).ToReadOnlyDictionary(x => x.Key, x => x.Value));
        }