discorb 0.16.0 → 0.18.0

data/lib/discorb/channel/guild.rb

@@ -0,0 +1,246 @@
+# frozen_string_literal: true
+
+module Discorb
+  #
+  # Represents a channel in guild.
+  # @abstract
+  #
+  class GuildChannel < Channel
+    # @return [Integer] The position of the channel as integer.
+    attr_reader :position
+    # @return [Hash{Discorb::Role, Discorb::Member => PermissionOverwrite}] The permission overwrites of the channel.
+    attr_reader :permission_overwrites
+
+    # @!attribute [r] mention
+    #   @return [String] The mention of the channel.
+    #
+    # @!attribute [r] parent
+    #   @macro client_cache
+    #   @return [Discorb::CategoryChannel] The parent of channel.
+    #   @return [nil] If the channel is not a child of category.
+    #
+    # @!attribute [r] guild
+    #   @return [Discorb::Guild] The guild of channel.
+    #   @macro client_cache
+
+    include Comparable
+    @channel_type = nil
+
+    #
+    # Compares position of two channels.
+    #
+    # @param [Discorb::GuildChannel] other The channel to compare.
+    #
+    # @return [-1, 0, 1] -1 if the channel is at lower than the other, 1 if the channel is at highter than the other.
+    #
+    def <=>(other)
+      return nil unless other.respond_to?(:position)
+
+      @position <=> other.position
+    end
+
+    #
+    # Checks if the channel is same as another.
+    #
+    # @param [Discorb::GuildChannel] other The channel to check.
+    #
+    # @return [Boolean] `true` if the channel is same as another.
+    #
+    def ==(other)
+      return false unless other.respond_to?(:id)
+
+      @id == other.id
+    end
+
+    #
+    # Stringifies the channel.
+    #
+    # @return [String] The name of the channel with `#`.
+    #
+    def to_s
+      "##{@name}"
+    end
+
+    def mention
+      "<##{@id}>"
+    end
+
+    def parent
+      return nil unless @parent_id
+
+      @client.channels[@parent_id]
+    end
+
+    alias category parent
+
+    def guild
+      @client.guilds[@guild_id]
+    end
+
+    def inspect
+      "#<#{self.class} \"##{@name}\" id=#{@id}>"
+    end
+
+    #
+    # Deletes the channel.
+    # @async
+    #
+    # @param [String] reason The reason of deleting the channel.
+    #
+    # @return [Async::Task<self>] The deleted channel.
+    #
+    def delete!(reason: nil)
+      Async do
+        @client.http.request(Route.new(base_url.wait.to_s, "//webhooks/:webhook_id/:token", :delete), {},
+                             audit_log_reason: reason).wait
+        @deleted = true
+        self
+      end
+    end
+
+    alias close! delete!
+    alias destroy! delete!
+
+    #
+    # Moves the channel to another position.
+    # @async
+    #
+    # @param [Integer] position The position to move the channel.
+    # @param [Boolean] lock_permissions Whether to lock the permissions of the channel.
+    # @param [Discorb::CategoryChannel] parent The parent of channel.
+    # @param [String] reason The reason of moving the channel.
+    #
+    # @return [Async::Task<self>] The moved channel.
+    #
+    def move(position, lock_permissions: false, parent: Discorb::Unset, reason: nil)
+      Async do
+        # @type var payload: Hash[Symbol, untyped]
+        payload = {
+          position: position,
+        }
+        payload[:lock_permissions] = lock_permissions
+        payload[:parent_id] = parent&.id if parent != Discorb::Unset
+        @client.http.request(Route.new("/guilds/#{@guild_id}/channels", "//guilds/:guild_id/channels", :patch),
+                             payload, audit_log_reason: reason).wait
+      end
+    end
+
+    #
+    # Set the channel's permission overwrite.
+    # @async
+    #
+    # @param [Discorb::Role, Discorb::Member] target The target of the overwrite.
+    # @param [String] reason The reason of setting the overwrite.
+    # @param [{Symbol => Boolean}] perms The permission overwrites to replace.
+    #
+    # @return [Async::Task<void>] The task.
+    #
+    def set_permissions(target, reason: nil, **perms)
+      Async do
+        allow_value = @permission_overwrites[target]&.allow_value.to_i
+        deny_value = @permission_overwrites[target]&.deny_value.to_i
+        perms.each do |perm, value|
+          allow_value[Discorb::Permission.bits[perm]] = 1 if value == true
+          deny_value[Discorb::Permission.bits[perm]] = 1 if value == false
+        end
+        payload = {
+          allow: allow_value,
+          deny: deny_value,
+          type: target.is_a?(Member) ? 1 : 0,
+        }
+        @client.http.request(
+          Route.new("/channels/#{@id}/permissions/#{target.id}", "//channels/:channel_id/permissions/:target_id",
+                    :put), payload, audit_log_reason: reason,
+        ).wait
+      end
+    end
+
+    alias modify_permissions set_permissions
+    alias modify_permisssion set_permissions
+    alias edit_permissions set_permissions
+    alias edit_permission set_permissions
+
+    #
+    # Delete the channel's permission overwrite.
+    # @async
+    #
+    # @param [Discorb::Role, Discorb::Member] target The target of the overwrite.
+    # @param [String] reason The reason of deleting the overwrite.
+    #
+    # @return [Async::Task<void>] The task.
+    #
+    def delete_permissions(target, reason: nil)
+      Async do
+        @client.http.request(
+          Route.new("/channels/#{@id}/permissions/#{target.id}", "//channels/:channel_id/permissions/:target_id",
+                    :delete), {}, audit_log_reason: reason,
+        ).wait
+      end
+    end
+
+    alias delete_permission delete_permissions
+    alias destroy_permissions delete_permissions
+    alias destroy_permission delete_permissions
+
+    #
+    # Fetch the channel's invites.
+    # @async
+    #
+    # @return [Async::Task<Array<Discorb::Invite>>] The invites in the channel.
+    #
+    def fetch_invites
+      Async do
+        _resp, data = @client.http.request(Route.new("/channels/#{@id}/invites", "//channels/:channel_id/invites",
+                                                     :get)).wait
+        data.map { |invite| Invite.new(@client, invite, false) }
+      end
+    end
+
+    #
+    # Create an invite in the channel.
+    # @async
+    #
+    # @param [Integer] max_age The max age of the invite.
+    # @param [Integer] max_uses The max uses of the invite.
+    # @param [Boolean] temporary Whether the invite is temporary.
+    # @param [Boolean] unique Whether the invite is unique.
+    #   @note if it's `false` it may return existing invite.
+    # @param [String] reason The reason of creating the invite.
+    #
+    # @return [Async::Task<Invite>] The created invite.
+    #
+    def create_invite(max_age: nil, max_uses: nil, temporary: false, unique: false, reason: nil)
+      Async do
+        _resp, data = @client.http.request(
+          Route.new("/channels/#{@id}/invites", "//channels/:channel_id/invites", :post), {
+            max_age: max_age,
+            max_uses: max_uses,
+            temporary: temporary,
+            unique: unique,
+          }, audit_log_reason: reason,
+        ).wait
+        Invite.new(@client, data, false)
+      end
+    end
+
+    private
+
+    def _set_data(data)
+      @guild_id = data[:guild_id]
+      @position = data[:position]
+      @permission_overwrites = if data[:permission_overwrites]
+          data[:permission_overwrites].to_h do |ow|
+            [
+              (ow[:type] == 1 ? guild.roles : guild.members)[ow[:id]],
+              PermissionOverwrite.new(ow[:allow].to_i, ow[:deny].to_i),
+            ]
+          end
+        else
+          {}
+        end
+      @parent_id = data[:parent_id]
+
+      super
+    end
+  end
+end

data/lib/discorb/channel/stage.rb

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+module Discorb
+  #
+  # Represents a stage channel.
+  #
+  class StageChannel < GuildChannel
+    # @return [Integer] The bitrate of the voice channel.
+    attr_reader :bitrate
+    # @return [Integer] The user limit of the voice channel.
+    attr_reader :user_limit
+    #
+    # @private
+    # @return [Discorb::Dictionary{Discorb::Snowflake => StageInstance}]
+    #   The stage instances associated with the stage channel.
+    #
+    attr_reader :stage_instances
+
+    include Connectable
+
+    # @!attribute [r] stage_instance
+    #   @return [Discorb::StageInstance] The stage instance of the channel.
+
+    @channel_type = 13
+    #
+    # Initialize a new stage channel.
+    # @private
+    #
+    def initialize(...)
+      @stage_instances = Dictionary.new
+      super(...)
+    end
+
+    def stage_instance
+      @stage_instances[0]
+    end
+
+    #
+    # Edit the stage channel.
+    # @async
+    # @macro edit
+    #
+    # @param [String] name The name of the stage channel.
+    # @param [Integer] position The position of the stage channel.
+    # @param [Integer] bitrate The bitrate of the stage channel.
+    # @param [Symbol] rtc_region The region of the stage channel.
+    # @param [String] reason The reason of editing the stage channel.
+    #
+    # @return [Async::Task<self>] The edited stage channel.
+    #
+    def edit(
+      name: Discorb::Unset,
+      position: Discorb::Unset,
+      bitrate: Discorb::Unset,
+      rtc_region: Discorb::Unset,
+      reason: nil
+    )
+      Async do
+        payload = {}
+        payload[:name] = name if name != Discorb::Unset
+        payload[:position] = position if position != Discorb::Unset
+        payload[:bitrate] = bitrate if bitrate != Discorb::Unset
+        payload[:rtc_region] = rtc_region if rtc_region != Discorb::Unset
+        @client.http.request(Route.new("/channels/#{@id}", "//channels/:channel_id", :patch), payload,
+                             audit_log_reason: reason).wait
+        self
+      end
+    end
+
+    alias modify edit
+
+    #
+    # Start a stage instance.
+    # @async
+    #
+    # @param [String] topic The topic of the stage instance.
+    # @param [Boolean] public Whether the stage instance is public or not.
+    # @param [String] reason The reason of starting the stage instance.
+    #
+    # @return [Async::Task<Discorb::StageInstance>] The started stage instance.
+    #
+    def start(topic, public: false, reason: nil)
+      Async do
+        _resp, data = @client.http.request(
+          Route.new("/stage-instances", "//stage-instances", :post),
+          {
+            channel_id: @id,
+            topic: topic,
+            public: public ? 2 : 1,
+          }, audit_log_reason: reason,
+        ).wait
+        StageInstance.new(@client, data)
+      end
+    end
+
+    #
+    # Fetch a current stage instance.
+    # @async
+    #
+    # @return [Async::Task<StageInstance>] The current stage instance.
+    # @return [Async::Task<nil>] If there is no current stage instance.
+    #
+    def fetch_stage_instance
+      Async do
+        _resp, data = @client.http.request(Route.new("/stage-instances/#{@id}", "//stage-instances/:stage_instance_id",
+                                                     :get)).wait
+      rescue Discorb::NotFoundError
+        nil
+      else
+        StageInstance.new(@client, data)
+      end
+    end
+
+    def voice_states
+      guild.voice_states.select { |state| state.channel&.id == @id }
+    end
+
+    def members
+      voice_states.map(&:member)
+    end
+
+    def speakers
+      voice_states.reject(&:suppress?).map(&:member)
+    end
+
+    def audiences
+      voice_states.filter(&:suppress?).map(&:member)
+    end
+
+    private
+
+    def _set_data(data)
+      @bitrate = data[:bitrate]
+      @user_limit = data[:user_limit]
+      @topic = data[:topic]
+      @rtc_region = data[:rtc_region]&.to_sym
+      super
+    end
+  end
+end