Class: Discorb::TextChannel

Inherits:
GuildChannel show all
Includes:
Messageable
Defined in:
lib/discorb/channel.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

#<=>, #==, #delete!, #guild, #inspect, #mention, #move, #parent, #to_s

Methods inherited from Channel

#==, #inspect, #type

Methods inherited from DiscordModel

#==, #eql?, #inspect

Instance Attribute Details

#last_message_id -> Discorb::Snowflake (readonly)

Returns The id of the last message.

Returns:



256
257
258
 
# File 'lib/discorb/channel.rb', line 256

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.



261
262
263
 
# File 'lib/discorb/channel.rb', line 261

def last_pin_timestamp
  @last_pin_timestamp
end

#nsfw -> Boolean (readonly)

Returns Whether the channel is nsfw.

Returns:

  • (Boolean) —

    Whether the channel is nsfw.



254
255
256
 
# File 'lib/discorb/channel.rb', line 254

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.



258
259
260
 
# File 'lib/discorb/channel.rb', line 258

def rate_limit_per_user
  @rate_limit_per_user
end

#threads -> Object (readonly) 



270
271
272
 
# File 'lib/discorb/channel.rb', line 270

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.



252
253
254
 
# File 'lib/discorb/channel.rb', line 252

def topic
  @topic
end

Instance Method Details

#create_invite(max_age: nil, max_uses: nil, temporary: false, unique: false, reason: nil) -> Async::Task<Invite>

Create an invite in the channel.

Parameters:

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

    The max age of the invite.

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

    The max uses of the invite.

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

    Whether the invite is temporary.

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

    Whether the invite is unique. @note if it's false it may return existing invite.

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

    The reason of creating the invite.

Returns:

  • (Async::Task<Invite>) —

    The created invite.



460
461
462
463
464
465
466
467
468
469
470
 
# File 'lib/discorb/channel.rb', line 460

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

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



330
331
332
333
334
335
336
337
338
 
# File 'lib/discorb/channel.rb', line 330

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.new([@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.



362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
 
# File 'lib/discorb/channel.rb', line 362

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

#delete_permissions(target, reason: nil) -> Async::Task<void> Also known as: delete_permission, destroy_permissions, destroy_permission

Delete the channel's permission overwrite.

Parameters:

  • target (Discorb::Role, Discorb::Member) —

    The target of the overwrite.

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

    The reason of deleting the overwrite.

Returns:

  • (Async::Task<void>) —

    The task.



424
425
426
427
428
 
# File 'lib/discorb/channel.rb', line 424

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

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



294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
 
# File 'lib/discorb/channel.rb', line 294

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
    payload[:default_auto_archive_duration] = default_auto_archive_duration if default_auto_archive_duration != Discorb::Unset

    @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:



556
557
558
559
560
561
 
# File 'lib/discorb/channel.rb', line 556

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:



543
544
545
546
547
548
 
# File 'lib/discorb/channel.rb', line 543

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_invites -> Async::Task<Array<Discorb::Invite>>

Fetch the channel's invites.

Returns:



440
441
442
443
444
445
 
# File 'lib/discorb/channel.rb', line 440

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

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



572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
 
# File 'lib/discorb/channel.rb', line 572

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:



346
347
348
349
350
351
 
# File 'lib/discorb/channel.rb', line 346

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.



481
482
483
484
485
 
# File 'lib/discorb/channel.rb', line 481

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

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

Follow the existing announcement channel from self.

Parameters:

  • target (Discorb::TextChannel) —

    The channel to follow to.

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

    The reason of following the channel.

Returns:

  • (Async::Task<void>) —

    The task.



496
497
498
499
500
 
# File 'lib/discorb/channel.rb', line 496

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

#set_permissions(target, reason: nil, **perms) -> Async::Task<void> Also known as: modify_permissions, modify_permisssion, edit_permissions, edit_permission

Set the channel's permission overwrite.

Parameters:

  • target (Discorb::Role, Discorb::Member) —

    The target of the overwrite.

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

    The reason of setting the overwrite.

  • perms ({Symbol => Boolean}) —

    The permission overwrites to replace.

Returns:

  • (Async::Task<void>) —

    The task.



393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
 
# File 'lib/discorb/channel.rb', line 393

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

#start_thread(name, message: nil, auto_archive_duration: 1440, 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 (Integer) (defaults to: 1440) —

    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:



516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
 
# File 'lib/discorb/channel.rb', line 516

def start_thread(name, message: nil, auto_archive_duration: 1440, public: true, rate_limit_per_user: nil, slowmode: nil, reason: nil)
  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