onyxcord 2.0.13 → 3.2.0

data/lib/onyxcord/interactions/internal/application_command.rb

@@ -0,0 +1,203 @@
+# frozen_string_literal: true
+
+module OnyxCord
+  # An ApplicationCommand for slash commands.
+  class ApplicationCommand
+    # Command types. `chat_input` is a command that appears in the text input field. `user` and `message` types appear as context menus
+    # for the respective resource.
+    TYPES = {
+      chat_input: 1,
+      user: 2,
+      message: 3,
+      primary_entry_point: 4
+    }.freeze
+
+    # @return [Integer]
+    attr_reader :application_id
+
+    # @return [Integer, nil]
+    attr_reader :server_id
+
+    # @return [String]
+    attr_reader :name
+
+    # @return [String]
+    attr_reader :description
+
+    # @return [true, false]
+    attr_reader :default_permission
+
+    # @return [Hash]
+    attr_reader :options
+
+    # @return [Integer]
+    attr_reader :id
+
+    # @return [true, false]
+    attr_reader :nsfw
+
+    # @return [Array<Integer>]
+    attr_reader :contexts
+
+    # @return [Array<Integer>]
+    attr_reader :integration_types
+
+    # @!visibility private
+    def initialize(data, bot, server_id = nil)
+      @bot = bot
+      @id = data['id'].to_i
+      @application_id = data['application_id'].to_i
+      @server_id = server_id&.to_i
+
+      @name = data['name']
+      @description = data['description']
+      @default_permission = data['default_permission']
+      @options = data['options']
+      @nsfw = data['nsfw'] || false
+      @contexts = data['contexts'] || []
+      @integration_types = data['integration_types'] || []
+    end
+
+    # @param subcommand [String, nil] The subcommand to mention.
+    # @param subcommand_group [String, nil] The subcommand group to mention.
+    # @return [String] the layout to mention it in a message
+    def mention(subcommand_group: nil, subcommand: nil)
+      if subcommand_group && subcommand
+        "</#{name} #{subcommand_group} #{subcommand}:#{id}>"
+      elsif subcommand_group
+        "</#{name} #{subcommand_group}:#{id}>"
+      elsif subcommand
+        "</#{name} #{subcommand}:#{id}>"
+      else
+        "</#{name}:#{id}>"
+      end
+    end
+
+    alias_method :to_s, :mention
+
+    # @param name [String] The name to use for this command.
+    # @param description [String] The description of this command.
+    # @param default_permission [true, false] Whether this command is available with default permissions.
+    # @param nsfw [true, false] Whether this command should be marked as age-restricted.
+    # @yieldparam (see Bot#edit_application_command)
+    # @return (see Bot#edit_application_command)
+    def edit(name: nil, description: nil, default_permission: nil, nsfw: nil, &block)
+      @bot.edit_application_command(@id, server_id: @server_id, name: name, description: description, default_permission: default_permission, nsfw: nsfw, &block)
+    end
+
+    # Delete this application command.
+    # @return (see Bot#delete_application_command)
+    def delete
+      @bot.delete_application_command(@id, server_id: @server_id)
+    end
+
+    # Get the permission configuration for this application command in a specific server.
+    # @param server_id [Integer, String, nil] The ID of the server to fetch command permissions for.
+    # @return [Array<Permission>] the permissions for this application command in the given server.
+    def permissions(server_id: nil)
+      raise ArgumentError, 'A server ID must be provided for global application commands' if @server_id.nil? && server_id.nil?
+
+      response = JSON.parse(REST::Application.get_application_command_permissions(@bot.token, @bot.profile.id, @server_id || server_id&.resolve_id, @id))
+      response['permissions'].map { |permission| Permission.new(permission, response, @bot) }
+    rescue OnyxCord::Errors::UnknownError
+      # If there aren't any explicit overwrites configured for the command, the response is a 400.
+      []
+    end
+
+    # An application command permission for a channel, member, or a role.
+    class Permission
+      # Map of permission types.
+      TYPES = {
+        role: 1,
+        member: 2,
+        channel: 3
+      }.freeze
+
+      # @return [Integer] the type of this permission.
+      # @see TYPES
+      attr_reader :type
+
+      # @return [Integer] the ID of the entity this permission is for.
+      attr_reader :target_id
+
+      # @return [Integer] the ID of the server this permission is for.
+      attr_reader :server_id
+
+      # @!visibility private
+      def initialize(data, command, bot)
+        @bot = bot
+        @type = data['type']
+        @target_id = data['id'].to_i
+        @overwrite = data['permission']
+        @command_id = command['id'].to_i
+        @server_id = command['guild_id'].to_i
+        @application_id = command['application_id'].to_i
+      end
+
+      # Whether this permission has been allowed, e.g has a green check in the UI.
+      # @return [true, false]
+      def allowed?
+        @overwrite == true
+      end
+
+      # Whether this permission has been denied, e.g has a red X-mark in the UI.
+      # @return [true, false]
+      def denied?
+        @overwrite == false
+      end
+
+      # Whether this permission is applied to the everyone role in the server.
+      # @return [true, false]
+      def everyone?
+        @target_id == @server_id
+      end
+
+      # Get the ID of the application command this permission is for.
+      # @return [Integer, nil] This will be `nil` if the permission is the
+      #   default permission.
+      def command_id
+        @command_id unless default?
+      end
+
+      # Whether this permission is the default for all commands that don't
+      #  contain explicit permission oerwrites.
+      # @return [true, false]
+      def default?
+        @command_id == @application_id
+      end
+
+      # Whether this permission is applied to every channel in the server.
+      # @return [true, false]
+      def all_channels?
+        @target_id == (@server_id - 1)
+      end
+
+      # Get the user, role, or channel(s) that this permission targets.
+      # @return [Array<Channel>, Role, Member]
+      def target
+        case @type
+        when TYPES[:role]
+          @bot.server(@server_id).role(@target_id)
+        when TYPES[:member]
+          @bot.server(@server_id).member(@target_id)
+        when TYPES[:channel]
+          all_channels? ? @bot.server(@server_id).channels : [@bot.channel(@target_id)]
+        end
+      end
+
+      alias_method :targets, :target
+
+      # @!method role?
+      #   @return [true, false] whether this permission is for a role.
+      # @!method member?
+      #   @return [true, false] whether this permission is for a member.
+      # @!method channel?
+      #   @return [true, false] whether this permission is for a channel.
+      TYPES.each do |name, value|
+        define_method("#{name}?") do
+          @type == value
+        end
+      end
+    end
+  end
+end

data/lib/onyxcord/interactions/internal/message.rb

@@ -0,0 +1,152 @@
+# frozen_string_literal: true
+
+require 'onyxcord/utils/id_object'
+
+module OnyxCord
+  module Interactions
+    # A message partial for interactions.
+    class Message
+      include IDObject
+
+      # @return [Interaction] The interaction that created this message.
+      attr_reader :interaction
+
+      # @return [String, nil] The content of the message.
+      attr_reader :content
+
+      # @return [true, false] Whether this message is pinned in the channel it belongs to.
+      attr_reader :pinned
+
+      # @return [true, false]
+      attr_reader :tts
+
+      # @return [Time]
+      attr_reader :timestamp
+
+      # @return [Time, nil]
+      attr_reader :edited_timestamp
+
+      # @return [true, false]
+      attr_reader :edited
+
+      # @return [Integer]
+      attr_reader :id
+
+      # @return [User] The user of the application.
+      attr_reader :author
+
+      # @return [Attachment]
+      attr_reader :attachments
+
+      # @return [Array<Embed>]
+      attr_reader :embeds
+
+      # @return [Array<User>]
+      attr_reader :mentions
+
+      # @return [Integer]
+      attr_reader :flags
+
+      # @return [Integer]
+      attr_reader :channel_id
+
+      # @return [Hash, nil]
+      attr_reader :message_reference
+
+      # @return [Array<Component>]
+      attr_reader :components
+
+      # @!visibility private
+      def initialize(data, bot, interaction)
+        @data = data
+        @bot = bot
+        @interaction = interaction
+        @content = data['content']
+        @channel_id = data['channel_id'].to_i
+        @pinned = data['pinned']
+        @tts = data['tts']
+
+        @message_reference = data['message_reference']
+
+        @server_id = @interaction.server_id
+
+        @timestamp = Time.parse(data['timestamp']) if data['timestamp']
+        @edited_timestamp = data['edited_timestamp'].nil? ? nil : Time.parse(data['edited_timestamp'])
+        @edited = !@edited_timestamp.nil?
+
+        @id = data['id'].to_i
+
+        @author = bot.ensure_user(data['author'] || data['member']['user'])
+
+        @attachments = []
+        @attachments = data['attachments'].map { |e| Attachment.new(e, self, @bot) } if data['attachments']
+
+        @embeds = []
+        @embeds = data['embeds'].map { |e| Embed.new(e, self) } if data['embeds']
+
+        @mentions = []
+
+        data['mentions']&.each do |element|
+          @mentions << bot.ensure_user(element)
+        end
+
+        @mention_roles = data['mention_roles']
+        @mention_everyone = data['mention_everyone']
+        @flags = data['flags']
+        @pinned = data['pinned']
+        @components = data['components']&.filter_map { |component| Components.from_data(component, @bot) } || []
+      end
+
+      # @return [Member, nil] This will return nil if the bot does not have access to the
+      #   server the interaction originated in.
+      def member
+        server&.member(@user.id)
+      end
+
+      # @return [Server, nil] This will return nil if the bot does not have access to the
+      #   server the interaction originated in.
+      def server
+        @bot.server(@server_id)
+      end
+
+      # @return [Channel] The channel the interaction originates from.
+      # @raise [Errors::NoPermission] When the bot is not in the server associated with this interaction.
+      def channel
+        @bot.channel(@channel_id)
+      end
+
+      # Respond to this message.
+      # @param (see Interaction#send_message)
+      # @yieldparam (see Interaction#send_message)
+      def respond(content: nil, embeds: nil, allowed_mentions: nil, flags: 0, ephemeral: true, components: nil, attachments: nil, &block)
+        @interaction.send_message(content: content, embeds: embeds, allowed_mentions: allowed_mentions, flags: flags, ephemeral: ephemeral, components: components, attachments: attachments, &block)
+      end
+
+      # Delete this message.
+      def delete
+        @interaction.delete_message(@id)
+      end
+
+      # Edit this message's data.
+      # @param content (see Interaction#send_message)
+      # @param embeds (see Interaction#send_message)
+      # @param allowed_mentions (see Interaction#send_message)
+      # @yieldparam (see Interaction#send_message)
+      def edit(content: nil, embeds: nil, allowed_mentions: nil, components: nil, attachments: nil, &block)
+        @interaction.edit_message(@id, content: content, embeds: embeds, allowed_mentions: allowed_mentions, components: components, attachments: attachments, &block)
+      end
+
+      # @return [OnyxCord::Message]
+      def to_message
+        OnyxCord::Message.new(@data, @bot)
+      end
+
+      alias_method :message, :to_message
+
+      # @!visibility private
+      def inspect
+        "<Interaction::Message content=#{@content.inspect} embeds=#{@embeds.inspect} channel_id=#{@channel_id} server_id=#{@server_id} author=#{@author.inspect}>"
+      end
+    end
+  end
+end

data/lib/onyxcord/interactions/internal/metadata.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+require 'onyxcord/utils/id_object'
+
+module OnyxCord
+  module Interactions
+    # Supplemental metadata about an interaction.
+    class Metadata
+      include IDObject
+
+      # @return [Integer] the type of the interaction.
+      attr_reader :type
+
+      # @return [User] the user that initiated the interaction.
+      attr_reader :user
+
+      # @return [User, nil] the user that the command was ran on.
+      attr_reader :target_user
+
+      # @return [Integer, nil] the ID of the message the command was ran on.
+      attr_reader :target_message_id
+
+      # @return [Metadata, nil] the metadata for the interaction that opened the modal.
+      attr_reader :triggering_metadata
+
+      # @return [Integer, nil] the ID of the message that contained the interactive message component.
+      attr_reader :interacted_message_id
+
+      # @return [Integer, nil] the ID the original response message; only present on follow-up messages.
+      attr_reader :original_response_message_id
+
+      # @!visibility private
+      def initialize(data, message, bot)
+        @bot = bot
+        @message = message
+        @id = data['id'].to_i
+        @type = data['type']
+        @user = bot.ensure_user(data['user']) if data['user']
+        @target_user = bot.ensure_user(data['target_user']) if data['target_user']
+        @target_message_id = data['target_message_id']&.to_i
+        @triggering_metadata = Metadata.new(data['triggering_interaction_metadata'], @message, @bot) if data['triggering_interaction_metadata']
+        @interacted_message_id = data['interacted_message_id']&.to_i
+        @original_response_message_id = data['original_response_message_id']&.to_i
+        @integration_owners = data['authorizing_integration_owners']&.to_h { |key, value| [key.to_i, value.to_i] }
+      end
+
+      # Check if the interaction was triggered by a user by installed the application.
+      # @return [true, false] whether or not the application was installed by the user
+      #   who initiated this interaction.
+      def user_integration?
+        @integration_owners[1] == @user.id
+      end
+
+      # Check if the interaction was triggered by a server by installed the application.
+      # @return [true, false] whether or not the application was installed by the server
+      #   where this interaction originates from.
+      def server_integration?
+        @integration_owners[0] == @message.server.id
+      end
+
+      # Attempt to fetch the target message of the interaction.
+      # @return [Message, nil] the target message of the interaction, or `nil` if it couldn't be found.
+      def target_message
+        return unless @target_message_id
+
+        @target_message ||= @message.channel.message(@target_message_id)
+      end
+
+      # Attempt to fetch the message that contained the interatctive component.
+      # @return [Message, nil] the interacted message with the component, or `nil` if it couldn't be found.
+      def interacted_message
+        return unless @interacted_message_id
+
+        @interacted_message ||= @message.channel.message(@interacted_message_id)
+      end
+
+      # Attempt to fetch the original response message of the interaction.
+      # @return [Message, nil] the original response message of the interaction, or `nil` if it couldn't be found.
+      def original_response_message
+        return unless @original_response_message_id
+
+        @original_response_message ||= @message.channel.message(@original_response_message_id)
+      end
+
+      # @!method command?
+      #  @return [true, false] whether or not the interaction metadata is for an application command.
+      # @!method component?
+      #  @return [true, false] whether or not the interaction metadata is for a message component.
+      # @!method modal_submit?
+      #  @return [true, false] whether or not the interaction metadata is for a modal submission.
+      def command?
+        @type == 1
+      end
+
+      def component?
+        @type == 3
+      end
+
+      def modal_submit?
+        @type == 5
+      end
+
+      # @!visibility private
+      def inspect
+        "<Interactions::Metadata id=#{@id} type=#{@type} user=#{@user.inspect} target_user=#{@target_user.inspect}>"
+      end
+    end
+  end
+end

data/lib/onyxcord/interactions/internal/option_builder.rb

@@ -0,0 +1,230 @@
+# frozen_string_literal: true
+
+module OnyxCord
+  module Interactions
+    # A builder for defining slash commands options.
+    class OptionBuilder
+      # @!visibility private
+      TYPES = {
+        subcommand: 1,
+        subcommand_group: 2,
+        string: 3,
+        integer: 4,
+        boolean: 5,
+        user: 6,
+        channel: 7,
+        role: 8,
+        mentionable: 9,
+        number: 10,
+        attachment: 11
+      }.freeze
+
+      # Channel types that can be provided to #channel
+      CHANNEL_TYPES = {
+        text: 0,
+        dm: 1,
+        voice: 2,
+        group_dm: 3,
+        category: 4,
+        news: 5,
+        store: 6,
+        news_thread: 10,
+        public_thread: 11,
+        private_thread: 12,
+        stage: 13
+      }.freeze
+
+      # @return [Array<Hash>]
+      attr_reader :options
+
+      # @!visibility private
+      def initialize
+        @options = []
+      end
+
+      # @param name [String, Symbol] The name of the subcommand.
+      # @param description [String] A description of the subcommand.
+      # @yieldparam [OptionBuilder]
+      # @return (see #option)
+      # @example
+      #   bot.register_application_command(:test, 'Test command') do |cmd|
+      #     cmd.subcommand(:echo) do |sub|
+      #       sub.string('message', 'What to echo back', required: true)
+      #     end
+      #   end
+      def subcommand(name, description)
+        builder = OptionBuilder.new
+        yield builder if block_given?
+
+        option(TYPES[:subcommand], name, description, options: builder.to_a)
+      end
+
+      # @param name [String, Symbol] The name of the subcommand group.
+      # @param description [String] A description of the subcommand group.
+      # @yieldparam [OptionBuilder]
+      # @return (see #option)
+      # @example
+      #   bot.register_application_command(:test, 'Test command') do |cmd|
+      #     cmd.subcommand_group(:fun) do |group|
+      #       group.subcommand(:8ball) do |sub|
+      #         sub.string(:question, 'What do you ask the mighty 8ball?')
+      #       end
+      #     end
+      #   end
+      def subcommand_group(name, description)
+        builder = OptionBuilder.new
+        yield builder
+
+        option(TYPES[:subcommand_group], name, description, options: builder.to_a)
+      end
+
+      # @param name [String, Symbol] The name of the argument.
+      # @param description [String] A description of the argument.
+      # @param required [true, false] Whether this option must be provided.
+      # @param min_length [Integer] A minimum length for option value.
+      # @param max_length [Integer] A maximum length for option value.
+      # @param choices [Hash, nil] Available choices, mapped as `Name => Value`.
+      # @param autocomplete [true, false] Whether this option can dynamically show choices.
+      # @return (see #option)
+      def string(name, description, required: nil, min_length: nil, max_length: nil, choices: nil, autocomplete: nil,
+                 name_localizations: nil, description_localizations: nil, choice_localizations: nil)
+        option(TYPES[:string], name, description,
+               required: required, min_length: min_length, max_length: max_length, choices: choices, autocomplete: autocomplete,
+               name_localizations: name_localizations, description_localizations: description_localizations,
+               choice_localizations: choice_localizations)
+      end
+
+      # @param name [String, Symbol] The name of the argument.
+      # @param description [String] A description of the argument.
+      # @param required [true, false] Whether this option must be provided.
+      # @param min_value [Integer] A minimum value for option.
+      # @param max_value [Integer] A maximum value for option.
+      # @param choices [Hash, nil] Available choices, mapped as `Name => Value`.
+      # @param autocomplete [true, false] Whether this option can dynamically show choices.
+      # @return (see #option)
+      def integer(name, description, required: nil, min_value: nil, max_value: nil, choices: nil, autocomplete: nil,
+                  name_localizations: nil, description_localizations: nil, choice_localizations: nil)
+        option(TYPES[:integer], name, description,
+               required: required, min_value: min_value, max_value: max_value, choices: choices, autocomplete: autocomplete,
+               name_localizations: name_localizations, description_localizations: description_localizations,
+               choice_localizations: choice_localizations)
+      end
+
+      # @param name [String, Symbol] The name of the argument.
+      # @param description [String] A description of the argument.
+      # @param required [true, false] Whether this option must be provided.
+      # @return (see #option)
+      def boolean(name, description, required: nil, name_localizations: nil, description_localizations: nil)
+        option(TYPES[:boolean], name, description, required: required,
+                                                   name_localizations: name_localizations, description_localizations: description_localizations)
+      end
+
+      # @param name [String, Symbol] The name of the argument.
+      # @param description [String] A description of the argument.
+      # @param required [true, false] Whether this option must be provided.
+      # @return (see #option)
+      def user(name, description, required: nil, name_localizations: nil, description_localizations: nil)
+        option(TYPES[:user], name, description, required: required,
+                                                name_localizations: name_localizations, description_localizations: description_localizations)
+      end
+
+      # @param name [String, Symbol] The name of the argument.
+      # @param description [String] A description of the argument.
+      # @param required [true, false] Whether this option must be provided.
+      # @param types [Array<Symbol, Integer>] See {CHANNEL_TYPES}
+      # @return (see #option)
+      def channel(name, description, required: nil, types: nil, name_localizations: nil, description_localizations: nil)
+        types = types&.collect { |type| type.is_a?(Numeric) ? type : CHANNEL_TYPES[type] }
+        option(TYPES[:channel], name, description, required: required, channel_types: types,
+                                                   name_localizations: name_localizations, description_localizations: description_localizations)
+      end
+
+      # @param name [String, Symbol] The name of the argument.
+      # @param description [String] A description of the argument.
+      # @param required [true, false] Whether this option must be provided.
+      # @return (see #option)
+      def role(name, description, required: nil, name_localizations: nil, description_localizations: nil)
+        option(TYPES[:role], name, description, required: required,
+                                                name_localizations: name_localizations, description_localizations: description_localizations)
+      end
+
+      # @param name [String, Symbol] The name of the argument.
+      # @param description [String] A description of the argument.
+      # @param required [true, false] Whether this option must be provided.
+      # @return (see #option)
+      def mentionable(name, description, required: nil, name_localizations: nil, description_localizations: nil)
+        option(TYPES[:mentionable], name, description, required: required,
+                                                       name_localizations: name_localizations, description_localizations: description_localizations)
+      end
+
+      # @param name [String, Symbol] The name of the argument.
+      # @param description [String] A description of the argument.
+      # @param required [true, false] Whether this option must be provided.
+      # @param min_value [Float] A minimum value for option.
+      # @param max_value [Float] A maximum value for option.
+      # @param autocomplete [true, false] Whether this option can dynamically show choices.
+      # @return (see #option)
+      def number(name, description, required: nil, min_value: nil, max_value: nil, choices: nil, autocomplete: nil,
+                 name_localizations: nil, description_localizations: nil, choice_localizations: nil)
+        option(TYPES[:number], name, description,
+               required: required, min_value: min_value, max_value: max_value, choices: choices, autocomplete: autocomplete,
+               name_localizations: name_localizations, description_localizations: description_localizations,
+               choice_localizations: choice_localizations)
+      end
+
+      # @param name [String, Symbol] The name of the argument.
+      # @param description [String] A description of the argument.
+      # @param required [true, false] Whether this option must be provided.
+      # @return (see #option)
+      def attachment(name, description, required: nil, name_localizations: nil, description_localizations: nil)
+        option(TYPES[:attachment], name, description, required: required,
+                                                      name_localizations: name_localizations, description_localizations: description_localizations)
+      end
+
+      # @!visibility private
+      # @param type [Integer] The argument type.
+      # @param name [String, Symbol] The name of the argument.
+      # @param description [String] A description of the argument.
+      # @param required [true, false] Whether this option must be provided.
+      # @param min_value [Integer, Float] A minimum value for integer and number options.
+      # @param max_value [Integer, Float] A maximum value for integer and number options.
+      # @param min_length [Integer] A minimum length for string option value.
+      # @param max_length [Integer] A maximum length for string option value.
+      # @param channel_types [Array<Integer>] Channel types that can be provides for channel options.
+      # @param autocomplete [true, false] Whether this option can dynamically show options.
+      # @return Hash
+      def option(type, name, description, required: nil, choices: nil, options: nil, min_value: nil, max_value: nil,
+                 min_length: nil, max_length: nil, channel_types: nil, autocomplete: nil,
+                 name_localizations: nil, description_localizations: nil, choice_localizations: nil)
+        opt = { type: type, name: name, description: description }
+        choices = build_choices(choices, choice_localizations) if choices
+
+        opt.merge!({ required: required, choices: choices, options: options, min_value: min_value,
+                     max_value: max_value, min_length: min_length, max_length: max_length,
+                     channel_types: channel_types, autocomplete: autocomplete,
+                     name_localizations: name_localizations, description_localizations: description_localizations }.compact)
+
+        @options << opt
+        opt
+      end
+
+      # @return [Array<Hash>]
+      def to_a
+        @options
+      end
+
+      private
+
+      def build_choices(choices, choice_localizations)
+        choices.map do |option_name, value|
+          choice = { name: option_name, value: value }
+          if choice_localizations&.key?(option_name.to_sym) || choice_localizations&.key?(option_name.to_s)
+            locs = choice_localizations[option_name.to_sym] || choice_localizations[option_name.to_s]
+            choice[:name_localizations] = locs if locs.is_a?(Hash)
+          end
+          choice
+        end
+      end
+    end
+  end
+end