Class: Discorb::TextChannel

Inherits:
GuildChannel show all
Includes:
Messageable
Defined in:
lib/discorb/channel/text.rb

Overview

Represents a text channel.

Direct Known Subclasses

NewsChannel

Instance Attribute Summary collapse

Attributes inherited from GuildChannel

#permission_overwrites, #position

Attributes inherited from Channel

#id, #name

Instance Method Summary collapse

Methods included from Messageable

#delete_message!, #edit_message, #fetch_message, #fetch_messages, #fetch_pins, #pin_message, #post, #typing, #unpin_message

Methods inherited from GuildChannel

#<=>, #==, #create_invite, #delete!, #delete_permissions, #fetch_invites, #guild, #inspect, #mention, #move, #parent, #set_permissions, #to_s

Methods inherited from Channel

#==, #inspect, #type

Methods inherited from DiscordModel

#==, #eql?, #inspect

Instance Attribute Details

#default_auto_archive_duration -> Integer (readonly)

Returns The default value of duration of auto archive.

Returns:

  • (Integer) —

    The default value of duration of auto archive.



21
22
23
 
# File 'lib/discorb/channel/text.rb', line 21

def default_auto_archive_duration
  @default_auto_archive_duration
end

#last_message_id -> Discorb::Snowflake (readonly)

Returns The id of the last message.

Returns:



13
14
15
 
# File 'lib/discorb/channel/text.rb', line 13

def last_message_id
  @last_message_id
end

#last_pin_timestamp -> Time (readonly) Also known as: last_pinned_at

Returns The time when the last pinned message was pinned.

Returns:

  • (Time) —

    The time when the last pinned message was pinned.



18
19
20
 
# File 'lib/discorb/channel/text.rb', line 18

def last_pin_timestamp
  @last_pin_timestamp
end

#nsfw -> Boolean (readonly)

Returns Whether the channel is nsfw.

Returns:

  • (Boolean) —

    Whether the channel is nsfw.



11
12
13
 
# File 'lib/discorb/channel/text.rb', line 11

def nsfw
  @nsfw
end

#rate_limit_per_user -> Integer (readonly) Also known as: slowmode

Returns The rate limit per user (Slowmode) in the channel.

Returns:

  • (Integer) —

    The rate limit per user (Slowmode) in the channel.



15
16
17
 
# File 'lib/discorb/channel/text.rb', line 15

def rate_limit_per_user
  @rate_limit_per_user
end

#threads -> Object (readonly) 



38
39
40
 
# File 'lib/discorb/channel/text.rb', line 38

def threads
  guild.threads.select { |thread| thread.parent == self }
end

#topic -> String (readonly)

Returns The topic of the channel.

Returns:

  • (String) —

    The topic of the channel.



9
10
11
 
# File 'lib/discorb/channel/text.rb', line 9

def topic
  @topic
end

Instance Method Details

#create_webhook(name, avatar: nil) -> Async::Task<Discorb::Webhook::IncomingWebhook>

Create webhook in the channel.

Parameters:

  • name (String) —

    The name of the webhook.

  • avatar (Discorb::Image) (defaults to: nil) —

    The avatar of the webhook.

Returns:



112
113
114
115
116
117
118
119
120
121
122
 
# File 'lib/discorb/channel/text.rb', line 112

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

#delete_messages!(*messages, force: false) -> Async::Task<void> Also known as: bulk_delete!, destroy_messages!

Bulk delete messages in the channel.

Parameters:

  • messages (Discorb::Message) —

    The messages to delete.

  • force (Boolean) (defaults to: false) —

    Whether to ignore the validation for message (14 days limit).

Returns:

  • (Async::Task<void>) —

    The task.



147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
 
# File 'lib/discorb/channel/text.rb', line 147

def delete_messages!(*messages, force: false)
  Async do
    messages = messages.first if messages.length == 1 && messages.first.is_a?(Array)
    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

#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::Task<self> Also known as: modify

Note:

The arguments of this method are defaultly set to Discorb::Unset. Specify value to set the value, if not don't specify or specify Discorb::Unset.

Edits the channel.

Parameters:

  • name (String) (defaults to: Discorb::Unset) —

    The name of the channel.

  • position (Integer) (defaults to: Discorb::Unset) —

    The position of the channel.

  • category (Discorb::CategoryChannel, nil) (defaults to: Discorb::Unset) —

    The parent of channel. Specify nil to remove the parent.

  • parent (Discorb::CategoryChannel, nil) (defaults to: Discorb::Unset) —

    Alias of category.

  • topic (String) (defaults to: Discorb::Unset) —

    The topic of the channel.

  • nsfw (Boolean) (defaults to: Discorb::Unset) —

    Whether the channel is nsfw.

  • announce (Boolean) (defaults to: Discorb::Unset) —

    Whether the channel is announce channel.

  • rate_limit_per_user (Integer) (defaults to: Discorb::Unset) —

    The rate limit per user (Slowmode) in the channel.

  • slowmode (Integer) (defaults to: Discorb::Unset) —

    Alias of rate_limit_per_user.

  • default_auto_archive_duration (Integer) (defaults to: Discorb::Unset) —

    The default auto archive duration of the channel.

  • archive_in (Integer) (defaults to: Discorb::Unset) —

    Alias of default_auto_archive_duration.

  • reason (String) (defaults to: nil) —

    The reason of editing the channel.

Returns:

  • (Async::Task<self>) —

    The edited channel.



62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
 
# File 'lib/discorb/channel/text.rb', line 62

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

#fetch_archived_private_threads -> Async::Task<Array<Discorb::ThreadChannel>>

Fetch archived private threads in the channel.

Returns:



261
262
263
264
265
266
267
 
# File 'lib/discorb/channel/text.rb', line 261

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_archived_public_threads -> Async::Task<Array<Discorb::ThreadChannel>>

Fetch archived threads in the channel.

Returns:



247
248
249
250
251
252
253
 
# File 'lib/discorb/channel/text.rb', line 247

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_joined_archived_private_threads(limit: nil, before: nil) -> Async::Task<Array<Discorb::ThreadChannel>>

Fetch joined archived private threads in the channel.

Parameters:

  • limit (Integer) (defaults to: nil) —

    The limit of threads to fetch.

  • before (Time) (defaults to: nil) —

    <description>

Returns:



278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
 
# File 'lib/discorb/channel/text.rb', line 278

def fetch_joined_archived_private_threads(limit: nil, before: nil)
  Async do
    if limit.nil?
      before = 0
      threads = []
      loop do
        _resp, data = @client.http.request(
          Route.new(
            "/channels/#{@id}/users/@me/threads/archived/private?before=#{before}",
            "//channels/:channel_id/users/@me/threads/archived/private",
            :get
          )
        ).wait
        threads += data[:threads].map { |thread| Channel.make_channel(@client, thread) }
        before = data[:threads][-1][:id]

        break unless data[:has_more]
      end
      threads
    else
      _resp, data = @client.http.request(
        Route.new(
          "/channels/#{@id}/users/@me/threads/archived/private?limit=#{limit}&before=#{before}",
          "//channels/:channel_id/users/@me/threads/archived/private",
          :get
        )
      ).wait
      data.map { |thread| Channel.make_channel(@client, thread) }
    end
  end
end

#fetch_webhooks -> Async::Task<Array<Discorb::Webhook>>

Fetch webhooks in the channel.

Returns:



130
131
132
133
134
135
136
 
# File 'lib/discorb/channel/text.rb', line 130

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.new([@client, webhook]) }
  end
end

#follow_from(target, reason: nil) -> Async::Task<void>

Follow the existing announcement channel.

Parameters:

  • target (Discorb::NewsChannel) —

    The channel to follow.

  • reason (String) (defaults to: nil) —

    The reason of following the channel.

Returns:

  • (Async::Task<void>) —

    The task.



180
181
182
183
184
185
 
# File 'lib/discorb/channel/text.rb', line 180

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(name, message: nil, auto_archive_duration: nil, public: true, rate_limit_per_user: nil, slowmode: nil, reason: nil) -> Async::Task<Discorb::ThreadChannel> Also known as: create_thread

Start thread in the channel.

Parameters:

  • name (String) —

    The name of the thread.

  • message (Discorb::Message) (defaults to: nil) —

    The message to start the thread.

  • auto_archive_duration (:hour, :day, :three_days, :week) (defaults to: nil) —

    The duration of auto-archiving.

  • public (Boolean) (defaults to: true) —

    Whether the thread is public.

  • rate_limit_per_user (Integer) (defaults to: nil) —

    The rate limit per user.

  • slowmode (Integer) (defaults to: nil) —

    Alias of rate_limit_per_user.

  • reason (String) (defaults to: nil) —

    The reason of starting the thread.

Returns:



201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
 
# File 'lib/discorb/channel/text.rb', line 201

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
  auto_archive_duration_value = DEFAULT_AUTO_ARCHIVE_DURATION.key(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_value,
            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_value,
          },
          audit_log_reason: reason,
        ).wait
      end
    Channel.make_channel(@client, data)
  end
end