discorb 0.16.0 → 0.18.0

data/lib/discorb/channel/text.rb

@@ -0,0 +1,336 @@
+# frozen_string_literal: true
+
+module Discorb
+  #
+  # Represents a text channel.
+  #
+  class TextChannel < GuildChannel
+    # @return [String] The topic of the channel.
+    attr_reader :topic
+    # @return [Boolean] Whether the channel is nsfw.
+    attr_reader :nsfw
+    # @return [Discorb::Snowflake] The id of the last message.
+    attr_reader :last_message_id
+    # @return [Integer] The rate limit per user (Slowmode) in the channel.
+    attr_reader :rate_limit_per_user
+    alias slowmode rate_limit_per_user
+    # @return [Time] The time when the last pinned message was pinned.
+    attr_reader :last_pin_timestamp
+    alias last_pinned_at last_pin_timestamp
+    # @return [Integer] The default value of duration of auto archive.
+    attr_reader :default_auto_archive_duration
+
+    include Messageable
+
+    @channel_type = 0
+
+    # @!attribute [r] threads
+    #   @return [Array<Discorb::ThreadChannel>] The threads in the channel.
+    def threads
+      guild.threads.select { |thread| thread.parent == self }
+    end
+
+    #
+    # Edits the channel.
+    # @async
+    # @macro edit
+    #
+    # @param [String] name The name of the channel.
+    # @param [Integer] position The position of the channel.
+    # @param [Discorb::CategoryChannel, nil] category The parent of channel. Specify `nil` to remove the parent.
+    # @param [Discorb::CategoryChannel, nil] parent Alias of `category`.
+    # @param [String] topic The topic of the channel.
+    # @param [Boolean] nsfw Whether the channel is nsfw.
+    # @param [Boolean] announce Whether the channel is announce channel.
+    # @param [Integer] rate_limit_per_user The rate limit per user (Slowmode) in the channel.
+    # @param [Integer] slowmode Alias of `rate_limit_per_user`.
+    # @param [Integer] default_auto_archive_duration The default auto archive duration of the channel.
+    # @param [Integer] archive_in Alias of `default_auto_archive_duration`.
+    # @param [String] reason The reason of editing the channel.
+    #
+    # @return [Async::Task<self>] The edited channel.
+    #
+    def edit(
+      name: Discorb::Unset,
+      position: Discorb::Unset,
+      category: Discorb::Unset,
+      parent: Discorb::Unset,
+      topic: Discorb::Unset,
+      nsfw: Discorb::Unset,
+      announce: Discorb::Unset,
+      rate_limit_per_user: Discorb::Unset,
+      slowmode: Discorb::Unset,
+      default_auto_archive_duration: Discorb::Unset,
+      archive_in: Discorb::Unset,
+      reason: nil
+    )
+      Async do
+        payload = {}
+        payload[:name] = name if name != Discorb::Unset
+        payload[:announce] = announce ? 5 : 0 if announce != Discorb::Unset
+        payload[:position] = position if position != Discorb::Unset
+        payload[:topic] = topic || "" if topic != Discorb::Unset
+        payload[:nsfw] = nsfw if nsfw != Discorb::Unset
+
+        slowmode = rate_limit_per_user if slowmode == Discorb::Unset
+        payload[:rate_limit_per_user] = slowmode || 0 if slowmode != Discorb::Unset
+        parent = category if parent == Discorb::Unset
+        payload[:parent_id] = parent&.id if parent != Discorb::Unset
+
+        default_auto_archive_duration ||= archive_in
+        if default_auto_archive_duration != Discorb::Unset
+          payload[:default_auto_archive_duration] =
+            default_auto_archive_duration
+        end
+
+        @client.http.request(Route.new("/channels/#{@id}", "//channels/:channel_id", :patch), payload,
+                             audit_log_reason: reason).wait
+        self
+      end
+    end
+
+    alias modify edit
+
+    #
+    # Create webhook in the channel.
+    # @async
+    #
+    # @param [String] name The name of the webhook.
+    # @param [Discorb::Image] avatar The avatar of the webhook.
+    #
+    # @return [Async::Task<Discorb::Webhook::IncomingWebhook>] The created webhook.
+    #
+    def create_webhook(name, avatar: nil)
+      Async do
+        payload = {}
+        payload[:name] = name
+        payload[:avatar] = avatar.to_s if avatar
+        _resp, data = @client.http.request(
+          Route.new("/channels/#{@id}/webhooks", "//channels/:channel_id/webhooks", :post), payload
+        ).wait
+        Webhook.from_data(@client, data)
+      end
+    end
+
+    #
+    # Fetch webhooks in the channel.
+    # @async
+    #
+    # @return [Async::Task<Array<Discorb::Webhook>>] The webhooks in the channel.
+    #
+    def fetch_webhooks
+      Async do
+        _resp, data = @client.http.request(Route.new("/channels/#{@id}/webhooks", "//channels/:channel_id/webhooks",
+                                                     :get)).wait
+        data.map { |webhook| Webhook.from_data(@client, webhook) }
+      end
+    end
+
+    #
+    # Bulk delete messages in the channel.
+    # @async
+    #
+    # @param [Discorb::Message] messages The messages to delete.
+    # @param [Boolean] force Whether to ignore the validation for message (14 days limit).
+    #
+    # @return [Async::Task<void>] The task.
+    #
+    def delete_messages!(*messages, force: false)
+      Async do
+        messages = messages.flatten
+        unless force
+          time = Time.now
+          messages.delete_if do |message|
+            next false unless message.is_a?(Message)
+
+            time - message.created_at > 60 * 60 * 24 * 14
+          end
+        end
+
+        message_ids = messages.map { |m| Discorb::Utils.try(m, :id).to_s }
+
+        @client.http.request(
+          Route.new("/channels/#{@id}/messages/bulk-delete", "//channels/:channel_id/messages/bulk-delete",
+                    :post), { messages: message_ids }
+        ).wait
+      end
+    end
+
+    alias bulk_delete! delete_messages!
+    alias destroy_messages! delete_messages!
+
+    #
+    # Follow the existing announcement channel.
+    # @async
+    #
+    # @param [Discorb::NewsChannel] target The channel to follow.
+    # @param [String] reason The reason of following the channel.
+    #
+    # @return [Async::Task<void>] The task.
+    #
+    def follow_from(target, reason: nil)
+      Async do
+        @client.http.request(Route.new("/channels/#{target.id}/followers", "//channels/:channel_id/followers", :post),
+                             { webhook_channel_id: @id }, audit_log_reason: reason).wait
+      end
+    end
+
+    #
+    # Start thread in the channel.
+    # @async
+    #
+    # @param [String] name The name of the thread.
+    # @param [Discorb::Message] message The message to start the thread.
+    # @param [:hour, :day, :three_days, :week] auto_archive_duration The duration of auto-archiving.
+    # @param [Boolean] public Whether the thread is public.
+    # @param [Integer] rate_limit_per_user The rate limit per user.
+    # @param [Integer] slowmode Alias of `rate_limit_per_user`.
+    # @param [String] reason The reason of starting the thread.
+    #
+    # @return [Async::Task<Discorb::ThreadChannel>] The started thread.
+    #
+    def start_thread(
+      name,
+      message: nil,
+      auto_archive_duration: nil,
+      public: true,
+      rate_limit_per_user: nil,
+      slowmode: nil,
+      reason: nil
+    )
+      auto_archive_duration ||= @default_auto_archive_duration
+      Async do
+        _resp, data = if message.nil?
+            @client.http.request(
+              Route.new("/channels/#{@id}/threads", "//channels/:channel_id/threads", :post),
+              {
+                name: name,
+                auto_archive_duration: auto_archive_duration,
+                type: public ? 11 : 10,
+                rate_limit_per_user: rate_limit_per_user || slowmode,
+              },
+              audit_log_reason: reason,
+            ).wait
+          else
+            @client.http.request(
+              Route.new("/channels/#{@id}/messages/#{Utils.try(message, :id)}/threads",
+                        "//channels/:channel_id/messages/:message_id/threads", :post),
+              {
+                name: name,
+                auto_archive_duration: auto_archive_duration,
+              },
+              audit_log_reason: reason,
+            ).wait
+          end
+        Channel.make_channel(@client, data)
+      end
+    end
+
+    alias create_thread start_thread
+
+    #
+    # Fetch archived threads in the channel.
+    # @async
+    #
+    # @return [Async::Task<Array<Discorb::ThreadChannel>>] The archived threads in the channel.
+    #
+    def fetch_archived_public_threads
+      Async do
+        _resp, data = @client.http.request(Route.new("/channels/#{@id}/threads/archived/public",
+                                                     "//channels/:channel_id/threads/archived/public", :get)).wait
+        data.map { |thread| Channel.make_channel(@client, thread) }
+      end
+    end
+
+    #
+    # Fetch archived private threads in the channel.
+    # @async
+    #
+    # @return [Async::Task<Array<Discorb::ThreadChannel>>] The archived private threads in the channel.
+    #
+    def fetch_archived_private_threads
+      Async do
+        _resp, data = @client.http.request(Route.new("/channels/#{@id}/threads/archived/private",
+                                                     "//channels/:channel_id/threads/archived/private", :get)).wait
+        data.map { |thread| Channel.make_channel(@client, thread) }
+      end
+    end
+
+    #
+    # Fetch joined archived private threads in the channel.
+    # @async
+    #
+    # @param [Integer] limit The limit of threads to fetch.
+    # @param [Time] before The time before which the threads are created.
+    #
+    # @return [Async::Task<Array<Discorb::ThreadChannel>>] The joined archived private threads in the channel.
+    #
+    def fetch_joined_archived_private_threads(limit: nil, before: nil)
+      Async do
+        if limit.nil?
+          before = Time.now
+          threads = []
+          loop do
+            _resp, data = @client.http.request(
+              Route.new(
+                "/channels/#{@id}/users/@me/threads/archived/private?before=#{before.iso8601}",
+                "//channels/:channel_id/users/@me/threads/archived/private",
+                :get
+              )
+            ).wait
+            threads += data[:threads].map { |thread| Channel.make_channel(@client, thread) }
+
+            break unless data[:has_more]
+
+            before = Snowflake.new(data[:threads][-1][:id]).timestamp
+          end
+          threads
+        else
+          _resp, data = @client.http.request(
+            Route.new(
+              "/channels/#{@id}/users/@me/threads/archived/private?limit=#{limit}&before=#{before.iso8601}",
+              "//channels/:channel_id/users/@me/threads/archived/private",
+              :get
+            )
+          ).wait
+          data.map { |thread| Channel.make_channel(@client, thread) }
+        end
+      end
+    end
+
+    private
+
+    def _set_data(data)
+      @topic = data[:topic]
+      @nsfw = data[:nsfw]
+      @last_message_id = data[:last_message_id]
+      @rate_limit_per_user = data[:rate_limit_per_user]
+      @last_pin_timestamp = data[:last_pin_timestamp] && Time.iso8601(data[:last_pin_timestamp])
+      @default_auto_archive_duration = data[:default_auto_archive_duration]
+      super
+    end
+  end
+
+  #
+  # Represents a news channel (announcement channel).
+  #
+  class NewsChannel < TextChannel
+    @channel_type = 5
+
+    #
+    # Follow the existing announcement channel from self.
+    # @async
+    #
+    # @param [Discorb::TextChannel] target The channel to follow to.
+    # @param [String] reason The reason of following the channel.
+    #
+    # @return [Async::Task<void>] The task.
+    #
+    def follow_to(target, reason: nil)
+      Async do
+        @client.http.request(Route.new("/channels/#{@id}/followers", "//channels/:channel_id/followers", :post),
+                             { webhook_channel_id: target.id }, audit_log_reason: reason).wait
+      end
+    end
+  end
+end

data/lib/discorb/channel/thread.rb

@@ -0,0 +1,325 @@
+# frozen_string_literal: true
+
+module Discorb
+  #
+  # Represents a thread.
+  # @abstract
+  #
+  class ThreadChannel < Channel
+    # @return [Discorb::Snowflake] The ID of the channel.
+    # @note This ID is same as the starter message's ID
+    attr_reader :id
+    # @return [String] The name of the thread.
+    attr_reader :name
+    # @return [Integer] The number of messages in the thread.
+    # @note This will stop counting at 50.
+    attr_reader :message_count
+    # @return [Integer] The number of recipients in the thread.
+    # @note This will stop counting at 50.
+    attr_reader :member_count
+    alias recipient_count member_count
+    # @return [Integer] The rate limit per user (slowmode) in the thread.
+    attr_reader :rate_limit_per_user
+    alias slowmode rate_limit_per_user
+    # @return [Array<Discorb::ThreadChannel::Member>] The members of the thread.
+    attr_reader :members
+    # @return [Time] The time the thread was archived.
+    # @return [nil] If the thread is not archived.
+    attr_reader :archived_timestamp
+    alias archived_at archived_timestamp
+    # @return [Integer] Auto archive duration in seconds.
+    attr_reader :auto_archive_duration
+    alias archive_in auto_archive_duration
+    # @return [Boolean] Whether the thread is archived or not.
+    attr_reader :archived
+    alias archived? archived
+
+    # @!attribute [r] parent
+    #   @macro client_cache
+    #   @return [Discorb::GuildChannel] The parent channel of the thread.
+    # @!attribute [r] me
+    #   @return [Discorb::ThreadChannel::Member] The bot's member in the thread.
+    #   @return [nil] If the bot is not in the thread.
+    # @!attribute [r] joined?
+    #   @return [Boolean] Whether the bot is in the thread or not.
+    # @!attribute [r] guild
+    #   @macro client_cache
+    #   @return [Discorb::Guild] The guild of the thread.
+    # @!attribute [r] owner
+    #   @macro client_cache
+    #   @macro members_intent
+    #   @return [Discorb::Member] The owner of the thread.
+
+    include Messageable
+    @channel_type = nil
+
+    #
+    # Initialize a new thread channel.
+    # @private
+    #
+    # @param [Discorb::Client] client The client.
+    # @param [Hash] data The data of the thread channel.
+    # @param [Boolean] no_cache Whether to disable the cache.
+    #
+    def initialize(client, data, no_cache: false)
+      @members = Dictionary.new
+      super
+      @client.channels[@id] = self unless no_cache
+    end
+
+    #
+    # Edit the thread.
+    # @async
+    # @macro edit
+    #
+    # @param [String] name The name of the thread.
+    # @param [Boolean] archived Whether the thread is archived or not.
+    # @param [Integer] auto_archive_duration The auto archive duration in seconds.
+    # @param [Integer] archive_in Alias of `auto_archive_duration`.
+    # @param [Boolean] locked Whether the thread is locked or not.
+    # @param [String] reason The reason of editing the thread.
+    #
+    # @return [Async::Task<self>] The edited thread.
+    #
+    # @see #archive
+    # @see #lock
+    # @see #unarchive
+    # @see #unlock
+    #
+    def edit(
+      name: Discorb::Unset,
+      archived: Discorb::Unset,
+      auto_archive_duration: Discorb::Unset,
+      archive_in: Discorb::Unset,
+      locked: Discorb::Unset,
+      reason: nil
+    )
+      Async do
+        payload = {}
+        payload[:name] = name if name != Discorb::Unset
+        payload[:archived] = archived if archived != Discorb::Unset
+        auto_archive_duration ||= archive_in
+        payload[:auto_archive_duration] = auto_archive_duration if auto_archive_duration != Discorb::Unset
+        payload[:locked] = locked if locked != Discorb::Unset
+        @client.http.request(Route.new("/channels/#{@id}", "//channels/:channel_id", :patch), payload,
+                             audit_log_reason: reason).wait
+        self
+      end
+    end
+
+    #
+    # Helper method to archive the thread.
+    #
+    # @param [String] reason The reason of archiving the thread.
+    #
+    # @return [Async::Task<self>] The archived thread.
+    #
+    def archive(reason: nil)
+      edit(archived: true, reason: reason)
+    end
+
+    #
+    # Helper method to lock the thread.
+    #
+    # @param [String] reason The reason of locking the thread.
+    #
+    # @return [Async::Task<self>] The locked thread.
+    #
+    def lock(reason: nil)
+      edit(archived: true, locked: true, reason: reason)
+    end
+
+    #
+    # Helper method to unarchive the thread.
+    #
+    # @param [String] reason The reason of unarchiving the thread.
+    #
+    # @return [Async::Task<self>] The unarchived thread.
+    #
+    def unarchive(reason: nil)
+      edit(archived: false, reason: reason)
+    end
+
+    #
+    # Helper method to unlock the thread.
+    #
+    # @param [String] reason The reason of unlocking the thread.
+    #
+    # @return [Async::Task<self>] The unlocked thread.
+    #
+    # @note This method won't unarchive the thread. Use {#unarchive} instead.
+    #
+    def unlock(reason: nil)
+      edit(archived: !unarchive, locked: false, reason: reason)
+    end
+
+    def parent
+      return nil unless @parent_id
+
+      @client.channels[@parent_id]
+    end
+
+    alias channel parent
+
+    def me
+      @members[@client.user.id]
+    end
+
+    def joined?
+      !!me
+    end
+
+    def guild
+      @client.guilds[@guild]
+    end
+
+    def owner
+      guild.members[@owner_id]
+    end
+
+    def inspect
+      "#<#{self.class} \"##{@name}\" id=#{@id}>"
+    end
+
+    #
+    # Add a member to the thread.
+    #
+    # @param [Discorb::Member, :me] member The member to add. If `:me` is given, the bot will be added.
+    #
+    # @return [Async::Task<void>] The task.
+    #
+    def add_member(member = :me)
+      Async do
+        if member == :me
+          @client.http.request(Route.new("/channels/#{@id}/thread-members/@me",
+                                         "//channels/:channel_id/thread-members/@me", :post)).wait
+        else
+          @client.http.request(Route.new("/channels/#{@id}/thread-members/#{Utils.try(member, :id)}",
+                                         "//channels/:channel_id/thread-members/:user_id", :post)).wait
+        end
+      end
+    end
+
+    alias join add_member
+
+    #
+    # Remove a member from the thread.
+    #
+    # @param [Discorb::Member, :me] member The member to remove. If `:me` is given, the bot will be removed.
+    #
+    # @return [Async::Task<void>] The task.
+    #
+    def remove_member(member = :me)
+      Async do
+        if member == :me
+          @client.http.request(Route.new("/channels/#{@id}/thread-members/@me",
+                                         "//channels/:channel_id/thread-members/@me", :delete)).wait
+        else
+          @client.http.request(Route.new("/channels/#{@id}/thread-members/#{Utils.try(member, :id)}",
+                                         "//channels/:channel_id/thread-members/:user_id", :delete)).wait
+        end
+      end
+    end
+
+    alias leave remove_member
+
+    #
+    # Fetch members in the thread.
+    #
+    # @return [Array<Discorb::ThreadChannel::Member>] The members in the thread.
+    #
+    def fetch_members
+      Async do
+        _resp, data = @client.http.request(Route.new("/channels/#{@id}/thread-members",
+                                                     "//channels/:channel_id/thread-members", :get)).wait
+        data.map { |d| @members[d[:id]] = Member.new(@client, d, @guild_id) }
+      end
+    end
+
+    #
+    # Represents a thread in news channel(aka announcement channel).
+    #
+    class News < ThreadChannel
+      @channel_type = 10
+    end
+
+    #
+    # Represents a public thread in text channel.
+    #
+    class Public < ThreadChannel
+      @channel_type = 11
+    end
+
+    #
+    # Represents a private thread in text channel.
+    #
+    class Private < ThreadChannel
+      @channel_type = 12
+    end
+
+    class << self
+      attr_reader :channel_type
+    end
+
+    #
+    # Represents a member in a thread.
+    #
+    class Member < DiscordModel
+      attr_reader :joined_at
+
+      def initialize(client, data, guild_id)
+        @client = client
+        @thread_id = data[:id]
+        @user_id = data[:user_id]
+        @joined_at = Time.iso8601(data[:join_timestamp])
+        @guild_id = guild_id
+      end
+
+      def thread
+        @client.channels[@thread_id]
+      end
+
+      def member
+        @client.guilds[@guild_id].members[@user_id]
+      end
+
+      def id
+        @user_id
+      end
+
+      def user
+        @client.users[@user_id]
+      end
+
+      def inspect
+        "#<#{self.class} id=#{@id.inspect}>"
+      end
+    end
+
+    private
+
+    def _set_data(data)
+      @id = Snowflake.new(data[:id])
+      @name = data[:name]
+      @guild_id = data[:guild_id]
+      @parent_id = data[:parent_id]
+      @archived = data[:thread_metadata][:archived]
+      @owner_id = data[:owner_id]
+      @archived_timestamp =
+        data[:thread_metadata][:archived_timestamp] && Time.iso8601(data[:thread_metadata][:archived_timestamp])
+      @auto_archive_duration = data[:thread_metadata][:auto_archive_duration]
+      @locked = data[:thread_metadata][:locked]
+      @member_count = data[:member_count]
+      @message_count = data[:message_count]
+      if data[:member]
+        @members[@client.user.id] =
+          ThreadChannel::Member.new(
+            @client,
+            data[:member].merge({ id: data[:id], user_id: @client.user.id }),
+            @guild_id
+          )
+      end
+      @data.merge!(data)
+    end
+  end
+end