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) 



29
30
31
 
# File 'lib/discorb/channel/text.rb', line 29

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:



103
104
105
106
107
108
109
110
111
112
113
 
# File 'lib/discorb/channel/text.rb', line 103

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.



138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
 
# File 'lib/discorb/channel/text.rb', line 138

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

#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.



53
54
55
56
57
58
59
60
61
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
 
# File 'lib/discorb/channel/text.rb', line 53

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:



251
252
253
254
255
256
257
 
# File 'lib/discorb/channel/text.rb', line 251

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:



237
238
239
240
241
242
243
 
# File 'lib/discorb/channel/text.rb', line 237

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) —

    The time before which the threads are created.

Returns:



268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
 
# File 'lib/discorb/channel/text.rb', line 268

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

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

Fetch webhooks in the channel.

Returns:



121
122
123
124
125
126
127
 
# File 'lib/discorb/channel/text.rb', line 121

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

#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.



171
172
173
174
175
176
 
# File 'lib/discorb/channel/text.rb', line 171

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:



192
193
194
195
196
197
198
199
200
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
 
# File 'lib/discorb/channel/text.rb', line 192

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