Class: Discordrb::Channel

Inherits:
Object
  • Object
show all
Includes:
IDObject
Defined in:
lib/discordrb/data/channel.rb

Overview

A Discord channel, including data like the topic

Constant Summary collapse

TYPES =

Map of channel types

{
  text: 0,
  dm: 1,
  voice: 2,
  group: 3,
  category: 4,
  news: 5,
  store: 6,
  news_thread: 10,
  public_thread: 11,
  private_thread: 12,
  stage_voice: 13,
  directory: 14,
  forum: 15
}.freeze

Instance Attribute Summary collapse

Attributes included from IDObject

#id

Threads collapse

Instance Method Summary collapse

Methods included from IDObject

#==, #creation_time, synthesise

Instance Attribute Details

#archive_timestamp ⇒ Time? (readonly)

Returns The timestamp of when this threads status last changed.

Returns:

  • (Time, nil) —

    The timestamp of when this threads status last changed.



81
82
83
 
# File 'lib/discordrb/data/channel.rb', line 81

def archive_timestamp
  @archive_timestamp
end

#archived ⇒ true, ... (readonly) Also known as: archived?

Returns Whether or not this thread is archived.

Returns:

  • (true, false, nil) —

    Whether or not this thread is archived.



74
75
76
 
# File 'lib/discordrb/data/channel.rb', line 74

def archived
  @archived
end

#auto_archive_duration ⇒ Integer? (readonly)

Returns How long after the last message before a thread is automatically archived.

Returns:

  • (Integer, nil) —

    How long after the last message before a thread is automatically archived.



78
79
80
 
# File 'lib/discordrb/data/channel.rb', line 78

def auto_archive_duration
  @auto_archive_duration
end

#bitrate ⇒ Integer

Returns the bitrate (in bps) of the channel.

Returns:

  • (Integer) —

    the bitrate (in bps) of the channel



50
51
52
 
# File 'lib/discordrb/data/channel.rb', line 50

def bitrate
  @bitrate
end

#invitable ⇒ true, ... (readonly) Also known as: invitable?

Returns For private threads, determines whether non-moderators can add other non-moderators to a thread.

Returns:

  • (true, false, nil) —

    For private threads, determines whether non-moderators can add other non-moderators to a thread.



95
96
97
 
# File 'lib/discordrb/data/channel.rb', line 95

def invitable
  @invitable
end

#join_timestamp ⇒ Time? (readonly)

Returns When the current user joined this thread.

Returns:

  • (Time, nil) —

    When the current user joined this thread.



88
89
90
 
# File 'lib/discordrb/data/channel.rb', line 88

def join_timestamp
  @join_timestamp
end

#last_pin_timestamp ⇒ Time? (readonly)

Returns The time at when the last pinned message was pinned in this channel.

Returns:

  • (Time, nil) —

    The time at when the last pinned message was pinned in this channel.



99
100
101
 
# File 'lib/discordrb/data/channel.rb', line 99

def last_pin_timestamp
  @last_pin_timestamp
end

#locked ⇒ true, ... (readonly) Also known as: locked?

Returns Whether this thread is locked or not.

Returns:

  • (true, false, nil) —

    Whether this thread is locked or not.



84
85
86
 
# File 'lib/discordrb/data/channel.rb', line 84

def locked
  @locked
end

#member_count ⇒ Integer? (readonly)

Returns An approximate count of members in a thread. Stops counting at 50.

Returns:

  • (Integer, nil) —

    An approximate count of members in a thread. Stops counting at 50.



71
72
73
 
# File 'lib/discordrb/data/channel.rb', line 71

def member_count
  @member_count
end

#member_flags ⇒ Integer? (readonly)

Returns Member flags for this thread, used for notifications.

Returns:

  • (Integer, nil) —

    Member flags for this thread, used for notifications.



91
92
93
 
# File 'lib/discordrb/data/channel.rb', line 91

def member_flags
  @member_flags
end

#message_count ⇒ Integer? (readonly)

Returns An approximate count of messages sent in a thread, excluding deleted messages.

Returns:

  • (Integer, nil) —

    An approximate count of messages sent in a thread, excluding deleted messages.



68
69
70
 
# File 'lib/discordrb/data/channel.rb', line 68

def message_count
  @message_count
end

#name ⇒ String

Returns this channel's name.

Returns:

  • (String) —

    this channel's name.



29
30
31
 
# File 'lib/discordrb/data/channel.rb', line 29

def name
  @name
end

#nsfw ⇒ true, false Also known as: nsfw?

Returns if this channel is marked as nsfw.

Returns:

  • (true, false) —

    if this channel is marked as nsfw



60
61
62
 
# File 'lib/discordrb/data/channel.rb', line 60

def nsfw
  @nsfw
end

#owner_id ⇒ Integer? (readonly)

Returns the ID of the owner of the group channel or nil if this is not a group channel. If this channel is a thread, this is the member that started the thread.

Returns:

  • (Integer, nil) —

    the ID of the owner of the group channel or nil if this is not a group channel. If this channel is a thread, this is the member that started the thread.



41
42
43
 
# File 'lib/discordrb/data/channel.rb', line 41

def owner_id
  @owner_id
end

#parent_id ⇒ Integer? (readonly)

Returns the ID of the parent channel, if this channel is inside a category. If this channel is a thread, this is the text channel it is a child to.

Returns:

  • (Integer, nil) —

    the ID of the parent channel, if this channel is inside a category. If this channel is a thread, this is the text channel it is a child to.



33
34
35
 
# File 'lib/discordrb/data/channel.rb', line 33

def parent_id
  @parent_id
end

#position ⇒ Integer

Returns the channel's position on the channel list.

Returns:

  • (Integer) —

    the channel's position on the channel list



57
58
59
 
# File 'lib/discordrb/data/channel.rb', line 57

def position
  @position
end

#rate_limit_per_user ⇒ Integer Also known as: slowmode_rate

Returns the amount of time (in seconds) users need to wait to send in between messages.

Returns:

  • (Integer) —

    the amount of time (in seconds) users need to wait to send in between messages.



64
65
66
 
# File 'lib/discordrb/data/channel.rb', line 64

def rate_limit_per_user
  @rate_limit_per_user
end

#recipients ⇒ Array<Recipient>? (readonly)

Returns the array of recipients of the private messages, or nil if this is not a Private channel.

Returns:

  • (Array<Recipient>, nil) —

    the array of recipients of the private messages, or nil if this is not a Private channel



44
45
46
 
# File 'lib/discordrb/data/channel.rb', line 44

def recipients
  @recipients
end

#topic ⇒ String

Returns the channel's topic.

Returns:

  • (String) —

    the channel's topic



47
48
49
 
# File 'lib/discordrb/data/channel.rb', line 47

def topic
  @topic
end

#type ⇒ Integer (readonly)

Returns the type of this channel.

Returns:

  • (Integer) —

    the type of this channel

See Also:



37
38
39
 
# File 'lib/discordrb/data/channel.rb', line 37

def type
  @type
end

#user_limit ⇒ Integer Also known as: limit

Returns the amount of users that can be in the channel. 0 means it is unlimited.

Returns:

  • (Integer) —

    the amount of users that can be in the channel. 0 means it is unlimited.



53
54
55
 
# File 'lib/discordrb/data/channel.rb', line 53

def user_limit
  @user_limit
end

Instance Method Details

#add_group_users(user_ids) ⇒ Channel Also known as: add_group_user

Adds a user to a group channel.

Parameters:

Returns:



849
850
851
852
853
854
855
856
857
 
# File 'lib/discordrb/data/channel.rb', line 849

def add_group_users(user_ids)
  raise 'Attempted to add a user to a non-group channel!' unless group?

  user_ids = [user_ids] unless user_ids.is_a? Array
  user_ids.each do |user_id|
    API::Channel.add_group_user(@bot.token, @id, user_id.resolve_id)
  end
  self
end

#add_member(member) ⇒ Object

Add a member to the thread

Parameters:



993
994
995
 
# File 'lib/discordrb/data/channel.rb', line 993

def add_member(member)
  @bot.add_thread_member(@id, member)
end

#await(key, attributes = {}, &block) ⇒ Object

Deprecated.

Will be changed to blocking behavior in v4.0. Use #await! instead.

Add an Await for a message in this channel. This is identical in functionality to adding a Events::MessageEvent await with the in attribute as this channel.

See Also:



800
801
802
 
# File 'lib/discordrb/data/channel.rb', line 800

def await(key, attributes = {}, &block)
  @bot.add_await(key, Discordrb::Events::MessageEvent, { in: @id }.merge(attributes), &block)
end

#await!(attributes = {}, &block) ⇒ Object

Add a blocking Await for a message in this channel. This is identical in functionality to adding a Events::MessageEvent await with the in attribute as this channel.

See Also:



807
808
809
 
# File 'lib/discordrb/data/channel.rb', line 807

def await!(attributes = {}, &block)
  @bot.add_await!(Discordrb::Events::MessageEvent, { in: @id }.merge(attributes), &block)
end

#category ⇒ Channel? Also known as: parent

Returns the category channel, if this channel is in a category.

Returns:

  • (Channel, nil) —

    the category channel, if this channel is in a category



239
240
241
 
# File 'lib/discordrb/data/channel.rb', line 239

def category
  @bot.channel(@parent_id) if @parent_id
end

#category=(channel) ⇒ Object Also known as: parent=

Sets this channels parent category

Parameters:

Raises:

  • (ArgumentError) —

    if the target channel isn't a category



248
249
250
251
252
253
 
# File 'lib/discordrb/data/channel.rb', line 248

def category=(channel)
  channel = @bot.channel(channel)
  raise ArgumentError, 'Cannot set parent category to a channel that isn\'t a category' unless channel.category?

  update_channel_data(parent_id: channel.id)
end

#category? ⇒ true, false

Returns whether or not this channel is a category channel.

Returns:

  • (true, false) —

    whether or not this channel is a category channel.



204
205
206
 
# File 'lib/discordrb/data/channel.rb', line 204

def category?
  @type == 4
end

#children ⇒ Array<Channel> Also known as: channels

Returns the children of this channel, if it is a category. Otherwise returns an empty array.

Returns:



387
388
389
390
391
 
# File 'lib/discordrb/data/channel.rb', line 387

def children
  return [] unless category?

  server.channels.select { |c| c.parent_id == id }
end

#create_group(user_ids) ⇒ Channel

Creates a Group channel

Parameters:

  • user_ids (Array<Integer>) —

    Array of user IDs to add to the new group channel (Excluding the recipient of the PM channel).

Returns:

  • (Channel) —

    the created channel.



838
839
840
841
842
843
844
 
# File 'lib/discordrb/data/channel.rb', line 838

def create_group(user_ids)
  raise 'Attempted to create group channel on a non-pm channel!' unless pm?

  response = API::Channel.create_group(@bot.token, @id, user_ids.shift)
  channel = Channel.new(JSON.parse(response), @bot)
  channel.add_group_users(user_ids)
end

#create_webhook(name, avatar = nil, reason = nil) ⇒ Webhook

Creates a webhook in this channel

Parameters:

  • name (String) —

    the default name of this webhook.

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

    the default avatar URL to give this webhook.

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

    the reason for the webhook creation.

Returns:

  • (Webhook) —

    the created webhook.

Raises:

  • (ArgumentError) —

    if the channel isn't a text channel in a server.



891
892
893
894
895
896
897
 
# File 'lib/discordrb/data/channel.rb', line 891

def create_webhook(name, avatar = nil, reason = nil)
  raise ArgumentError, 'Tried to create a webhook in a non-server channel' unless server
  raise ArgumentError, 'Tried to create a webhook in a non-text channel' unless text?

  response = API::Channel.create_webhook(@bot.token, @id, name, avatar, reason)
  Webhook.new(JSON.parse(response), @bot)
end

#default_channel? ⇒ true, false Also known as: default?

Returns whether or not this channel is the default channel.

Returns:

  • (true, false) —

    whether or not this channel is the default channel



418
419
420
 
# File 'lib/discordrb/data/channel.rb', line 418

def default_channel?
  server.default_channel == self
end

#define_overwrite(overwrite) ⇒ Object #define_overwrite(thing, allow, deny) ⇒ Object

Defines a permission overwrite for this channel that sets the specified thing to the specified allow and deny permission sets, or change an existing one.

Overloads:

  • #define_overwrite(overwrite) ⇒ Object

    Parameters:

    • thing (Overwrite) —

      an Overwrite object to apply to this channel

    • reason (String) —

      The reason the for defining the overwrite.

  • #define_overwrite(thing, allow, deny) ⇒ Object

    Examples:

    Define a permission overwrite for a user that can then mention everyone and use TTS, but not create any invites

    allow = Discordrb::Permissions.new
allow.can_mention_everyone = true
allow.can_send_tts_messages = true

deny = Discordrb::Permissions.new
deny.can_create_instant_invite = true

channel.define_overwrite(user, allow, deny)

    Parameters:

    • thing (User, Role) —

      What to define an overwrite for.

    • allow (#bits, Permissions, Integer) —

      The permission sets that should receive an allow override (i.e. a green checkmark on Discord)

    • deny (#bits, Permissions, Integer) —

      The permission sets that should receive a deny override (i.e. a red cross on Discord)

    • reason (String) —

      The reason the for defining the overwrite.



626
627
628
629
630
631
632
633
634
635
 
# File 'lib/discordrb/data/channel.rb', line 626

def define_overwrite(thing, allow = 0, deny = 0, reason: nil)
  unless thing.is_a? Overwrite
    allow_bits = allow.respond_to?(:bits) ? allow.bits : allow
    deny_bits = deny.respond_to?(:bits) ? deny.bits : deny

    thing = Overwrite.new thing, allow: allow_bits, deny: deny_bits
  end

  API::Channel.update_permission(@bot.token, @id, thing.id, thing.allow.bits, thing.deny.bits, thing.type, reason)
end

#delete(reason = nil) ⇒ Object

Permanently deletes this channel

Parameters:

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

    The reason the for the channel deletion.



563
564
565
 
# File 'lib/discordrb/data/channel.rb', line 563

def delete(reason = nil)
  API::Channel.delete(@bot.token, @id, reason)
end

#delete_message(message) ⇒ Object

Deletes a message on this channel. Mostly useful in case a message needs to be deleted when only the ID is known

Parameters:



557
558
559
 
# File 'lib/discordrb/data/channel.rb', line 557

def delete_message(message)
  API::Channel.delete_message(@bot.token, @id, message.resolve_id)
end

#delete_messages(messages, strict = false, reason = nil) ⇒ Integer

Deletes a collection of messages

Parameters:

  • messages (Array<Message, String, Integer>) —

    the messages (or message IDs) to delete. Total must be an amount between 2 and 100 (Discord limitation)

  • strict (true, false) (defaults to: false) —

    Whether an error should be raised when a message is reached that is too old to be bulk deleted. If this is false only a warning message will be output to the console.

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

    The reason for deleting the messages

Returns:

  • (Integer) —

    The amount of messages that were successfully deleted

Raises:

  • (ArgumentError) —

    if the amount of messages is not a value between 2 and 100



782
783
784
785
786
787
 
# File 'lib/discordrb/data/channel.rb', line 782

def delete_messages(messages, strict = false, reason = nil)
  raise ArgumentError, 'Can only delete between 2 and 100 messages!' unless messages.count.between?(2, 100)

  messages.map!(&:resolve_id)
  bulk_delete(messages, strict, reason)
end

#delete_overwrite(target, reason = nil) ⇒ Object

Deletes a permission overwrite for this channel

Parameters:



640
641
642
643
644
 
# File 'lib/discordrb/data/channel.rb', line 640

def delete_overwrite(target, reason = nil)
  raise 'Tried deleting a overwrite for an invalid target' unless target.is_a?(Member) || target.is_a?(User) || target.is_a?(Role) || target.is_a?(Profile) || target.is_a?(Recipient) || target.respond_to?(:resolve_id)

  API::Channel.delete_permission(@bot.token, @id, target.resolve_id, reason)
end

#group? ⇒ true, false

Returns whether or not this channel is a group channel.

Returns:

  • (true, false) —

    whether or not this channel is a group channel.



199
200
201
 
# File 'lib/discordrb/data/channel.rb', line 199

def group?
  @type == 3
end

#history(amount, before_id = nil, after_id = nil, around_id = nil) ⇒ Array<Message>

Retrieves some of this channel's message history.

Examples:

Count the number of messages in the last 50 messages that contain the letter 'e'.

message_count = channel.history(50).count {|message| message.content.include? "e"}

Get the last 10 messages before the provided message.

last_ten_messages = channel.history(10, message.id)

Parameters:

  • amount (Integer) —

    How many messages to retrieve. This must be less than or equal to 100, if it is higher than 100 it will be treated as 100 on Discord's side.

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

    The ID of the most recent message the retrieval should start at, or nil if it should start at the current message.

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

    The ID of the oldest message the retrieval should start at, or nil if it should start as soon as possible with the specified amount.

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

    The ID of the message retrieval should start from, reading in both directions

Returns:

  • (Array<Message>) —

    the retrieved messages.



694
695
696
697
 
# File 'lib/discordrb/data/channel.rb', line 694

def history(amount, before_id = nil, after_id = nil, around_id = nil)
  logs = API::Channel.messages(@bot.token, @id, amount, before_id, after_id, around_id)
  JSON.parse(logs).map { |message| Message.new(message, @bot) }
end

#inspect ⇒ Object

The default inspect method is overwritten to give more useful output.



1005
1006
1007
 
# File 'lib/discordrb/data/channel.rb', line 1005

def inspect
  "<Channel name=#{@name} id=#{@id} topic=\"#{@topic}\" type=#{@type} position=#{@position} server=#{@server || @server_id}>"
end

#invites ⇒ Array<Invite>

Requests a list of Invites to the channel.

Returns:

  • (Array<Invite>) —

    invites to the channel.



910
911
912
913
914
915
 
# File 'lib/discordrb/data/channel.rb', line 910

def invites
  raise 'Tried to request invites from a non-server channel' unless server

  invites = JSON.parse(API::Channel.invites(@bot.token, @id))
  invites.map { |invite_data| Invite.new(invite_data, @bot) }
end

#join_thread ⇒ Object

Join this thread.



977
978
979
 
# File 'lib/discordrb/data/channel.rb', line 977

def join_thread
  @bot.join_thread(@id)
end

#leave_group ⇒ Object Also known as: leave

Leaves the group.



877
878
879
880
881
 
# File 'lib/discordrb/data/channel.rb', line 877

def leave_group
  raise 'Attempted to leave a non-group channel!' unless group?

  API::Channel.leave_group(@bot.token, @id)
end

#leave_thread ⇒ Object

Leave this thread



982
983
984
 
# File 'lib/discordrb/data/channel.rb', line 982

def leave_thread
  @bot.leave_thread(@id)
end

#link ⇒ String Also known as: jump_link

Returns a URL that a user can use to navigate to this channel in the client.

Returns:

  • (String) —

    a URL that a user can use to navigate to this channel in the client



1059
1060
1061
 
# File 'lib/discordrb/data/channel.rb', line 1059

def link
  "https://discord.com/channels/#{@server_id || '@me'}/#{@channel.id}"
end

#load_message(message_id) ⇒ Message? Also known as: message

Returns a single message from this channel's history by ID.

Parameters:

  • message_id (Integer) —

    The ID of the message to retrieve.

Returns:

  • (Message, nil) —

    the retrieved message, or nil if it couldn't be found.



710
711
712
713
714
715
716
717
 
# File 'lib/discordrb/data/channel.rb', line 710

def load_message(message_id)
  raise ArgumentError, 'message_id cannot be nil' if message_id.nil?

  response = API::Channel.message(@bot.token, @id, message_id)
  Message.new(JSON.parse(response), @bot)
rescue Discordrb::Errors::UnknownMessage
  nil
end

#make_invite(max_age = 0, max_uses = 0, temporary = false, unique = false, reason = nil) ⇒ Invite Also known as: invite

Creates a new invite to this channel.

Parameters:

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

    How many seconds this invite should last.

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

    How many times this invite should be able to be used.

  • temporary (true, false) (defaults to: false) —

    Whether membership should be temporary (kicked after going offline).

  • unique (true, false) (defaults to: false) —

    If true, Discord will always send a unique invite instead of possibly re-using a similar one

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

    The reason the for the creation of this invite.

Returns:

  • (Invite) —

    the created invite.



818
819
820
821
 
# File 'lib/discordrb/data/channel.rb', line 818

def make_invite(max_age = 0, max_uses = 0, temporary = false, unique = false, reason = nil)
  response = API::Channel.create_invite(@bot.token, @id, max_age, max_uses, temporary, unique, reason)
  Invite.new(JSON.parse(response), @bot)
end

#member_overwrites ⇒ Overwrite

Returns any member-type permission overwrites on this channel.

Returns:

  • (Overwrite) —

    any member-type permission overwrites on this channel



408
409
410
 
# File 'lib/discordrb/data/channel.rb', line 408

def member_overwrites
  permission_overwrites :member
end

#members ⇒ Object

Members in the thread.



987
988
989
 
# File 'lib/discordrb/data/channel.rb', line 987

def members
  @bot.thread_members[@id].collect { |id| @server_id ? @bot.member(@server_id, id) : @bot.user(id) }
end

#mention ⇒ String

Returns a string that will mention the channel as a clickable link on Discord.

Returns:

  • (String) —

    a string that will mention the channel as a clickable link on Discord.



107
108
109
 
# File 'lib/discordrb/data/channel.rb', line 107

def mention
  "<##{@id}>"
end

#news? ⇒ true, false

Returns whether or not this channel is a news channel.

Returns:

  • (true, false) —

    whether or not this channel is a news channel.



209
210
211
 
# File 'lib/discordrb/data/channel.rb', line 209

def news?
  @type == 5
end

#news_thread? ⇒ true, false

Returns whether or not this channel is a news thread.

Returns:

  • (true, false) —

    whether or not this channel is a news thread.



219
220
221
 
# File 'lib/discordrb/data/channel.rb', line 219

def news_thread?
  @type == 10
end

#permission_overwrites ⇒ Hash<Integer => Overwrite> #permission_overwrites(type) ⇒ Array<Overwrite> Also known as: overwrites

This channel's permission overwrites

Overloads:

  • #permission_overwrites ⇒ Hash<Integer => Overwrite>

    The overwrites represented as a hash of role/user ID to an Overwrite object

    Returns:

  • #permission_overwrites(type) ⇒ Array<Overwrite>

    Return an array of a certain type of overwrite

    Parameters:

    • type (Symbol) —

      the kind of overwrite to return

    Returns:



341
342
343
344
345
 
# File 'lib/discordrb/data/channel.rb', line 341

def permission_overwrites(type = nil)
  return @permission_overwrites unless type

  @permission_overwrites.values.select { |e| e.type == type }
end

#permission_overwrites=(overwrites) ⇒ Object

Bulk sets this channels permission overwrites

Parameters:



351
352
353
 
# File 'lib/discordrb/data/channel.rb', line 351

def permission_overwrites=(overwrites)
  update_channel_data(permission_overwrites: overwrites)
end

#pins(limit: 50) ⇒ Array<Message>

Requests the pinned messages in a channel.

Parameters:

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

    the limit of how many pinned messages to retrieve. nil will return all the pinned messages.

Returns:

  • (Array<Message>) —

    the messages pinned in the channel.



724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
 
# File 'lib/discordrb/data/channel.rb', line 724

def pins(limit: 50)
  get_pins = proc do |fetch_limit, before = nil|
    resp = API::Channel.pinned_messages(@bot.token, @id, fetch_limit, before&.iso8601)
    JSON.parse(resp)['items'].map { |pin| Message.new(pin['message'].merge({ 'pinned_at' => pin['pinned_at'] }), @bot) }
  end

  # Can be done without pagination.
  return get_pins.call(limit) if limit && limit <= 50

  paginator = Paginator.new(limit, :down) do |last_page|
    if last_page && last_page.count < 50
      []
    else
      get_pins.call(50, last_page&.last&.pinned_at)
    end
  end

  paginator.to_a
end

#pm? ⇒ true, false

Returns whether or not this channel is a PM channel.

Returns:

  • (true, false) —

    whether or not this channel is a PM channel.



189
190
191
 
# File 'lib/discordrb/data/channel.rb', line 189

def pm?
  @type == 1
end

#private? ⇒ true, false

Returns whether or not this channel is a PM or group channel.

Returns:

  • (true, false) —

    whether or not this channel is a PM or group channel.



102
103
104
 
# File 'lib/discordrb/data/channel.rb', line 102

def private?
  pm? || group?
end

#private_thread? ⇒ true, false

Returns whether or not this channel is a private thread.

Returns:

  • (true, false) —

    whether or not this channel is a private thread.



229
230
231
 
# File 'lib/discordrb/data/channel.rb', line 229

def private_thread?
  @type == 12
end

#prune(amount, strict = false, reason = nil) {|message| ... } ⇒ Integer

Delete the last N messages on this channel.

Examples:

Pruning messages from a specific user ID

channel.prune(100) { |m| m.author.id == 83283213010599936 }

Parameters:

  • amount (Integer) —

    The amount of message history to consider for pruning. Must be a value between 2 and 100 (Discord limitation)

  • strict (true, false) (defaults to: false) —

    Whether an error should be raised when a message is reached that is too old to be bulk deleted. If this is false only a warning message will be output to the console.

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

    The reason for pruning

Yields:

  • (message) —

    Yields each message in this channels history for filtering the messages to delete

Returns:

  • (Integer) —

    The amount of messages that were successfully deleted

Raises:

  • (ArgumentError) —

    if the amount of messages is not a value between 2 and 100



754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
 
# File 'lib/discordrb/data/channel.rb', line 754

def prune(amount, strict = false, reason = nil, &block)
  raise ArgumentError, 'Can only delete between 1 and 100 messages!' unless amount.between?(1, 100)

  messages =
    if block
      history(amount).select(&block).map(&:id)
    else
      history_ids(amount)
    end

  case messages.size
  when 0
    0
  when 1
    API::Channel.delete_message(@bot.token, @id, messages.first, reason)
    1
  else
    bulk_delete(messages, strict, reason)
  end
end

#public_thread? ⇒ true, false

Returns whether or not this channel is a public thread.

Returns:

  • (true, false) —

    whether or not this channel is a public thread.



224
225
226
 
# File 'lib/discordrb/data/channel.rb', line 224

def public_thread?
  @type == 11
end

#recipient ⇒ Recipient?

Returns the recipient of the private messages, or nil if this is not a PM channel.

Returns:

  • (Recipient, nil) —

    the recipient of the private messages, or nil if this is not a PM channel



112
113
114
 
# File 'lib/discordrb/data/channel.rb', line 112

def recipient
  @recipients.first if pm?
end

#remove_group_users(user_ids) ⇒ Channel Also known as: remove_group_user

Removes a user from a group channel.

Parameters:

Returns:



864
865
866
867
868
869
870
871
872
 
# File 'lib/discordrb/data/channel.rb', line 864

def remove_group_users(user_ids)
  raise 'Attempted to remove a user from a non-group channel!' unless group?

  user_ids = [user_ids] unless user_ids.is_a? Array
  user_ids.each do |user_id|
    API::Channel.remove_group_user(@bot.token, @id, user_id.resolve_id)
  end
  self
end

#remove_member(member) ⇒ Object

Parameters:

  • member (Member, Integer, String) —

    The member, or ID of the member, to remove from a thread.



998
999
1000
 
# File 'lib/discordrb/data/channel.rb', line 998

def remove_member(member)
  @bot.remove_thread_member(@id, member)
end

#role_overwrites ⇒ Overwrite

Returns any role-type permission overwrites on this channel.

Returns:

  • (Overwrite) —

    any role-type permission overwrites on this channel



413
414
415
 
# File 'lib/discordrb/data/channel.rb', line 413

def role_overwrites
  permission_overwrites :role
end

#send_embed(message = '', embed = nil, attachments = nil, tts = false, allowed_mentions = nil, message_reference = nil, components = nil, flags = 0) {|embed| ... } ⇒ Message

Convenience method to send a message with an embed.

Examples:

Send a message with an embed

channel.send_embed do |embed|
  embed.title = 'The Ruby logo'
  embed.image = Discordrb::Webhooks::EmbedImage.new(url: 'https://www.ruby-lang.org/images/header-ruby-logo.png')
end

Parameters:

  • message (String) (defaults to: '') —

    The message that should be sent along with the embed. If this is the empty string, only the embed will be shown.

  • embed (Discordrb::Webhooks::Embed, nil) (defaults to: nil) —

    The embed to start the building process with, or nil if one should be created anew.

  • attachments (Array<File>) (defaults to: nil) —

    Files that can be referenced in embeds via attachment://file.png

  • tts (true, false) (defaults to: false) —

    Whether or not this message should be sent using Discord text-to-speech.

  • allowed_mentions (Hash, Discordrb::AllowedMentions, false, nil) (defaults to: nil) —

    Mentions that are allowed to ping on this message. false disables all pings

  • message_reference (Message, String, Integer, nil) (defaults to: nil) —

    The message, or message ID, to reply to if any.

  • components (View, Array<Hash>) (defaults to: nil) —

    Interaction components to associate with this message.

  • flags (Integer) (defaults to: 0) —

    Flags for this message. Currently only SUPPRESS_EMBEDS (1 << 2) and SUPPRESS_NOTIFICATIONS (1 << 12) can be set.

Yields:

  • (embed) —

    Yields the embed to allow for easy building inside a block.

Yield Parameters:

Returns:

  • (Message) —

    The resulting message.



476
477
478
479
480
481
482
483
 
# File 'lib/discordrb/data/channel.rb', line 476

def send_embed(message = '', embed = nil, attachments = nil, tts = false, allowed_mentions = nil, message_reference = nil, components = nil, flags = 0)
  embed ||= Discordrb::Webhooks::Embed.new
  view = Discordrb::Webhooks::View.new

  yield(embed, view) if block_given?

  send_message(message, tts, embed, attachments, allowed_mentions, message_reference, components || view.to_a, flags)
end

#send_file(file, caption: nil, tts: false, filename: nil, spoiler: nil) ⇒ Object

Sends a file to this channel. If it is an image, it will be embedded.

Examples:

Send a file from disk

channel.send_file(File.open('rubytaco.png', 'r'))

Parameters:

  • file (File) —

    The file to send. There's no clear size limit for this, you'll have to attempt it for yourself (most non-image files are fine, large images may fail to embed)

  • caption (string) (defaults to: nil) —

    The caption for the file.

  • tts (true, false) (defaults to: false) —

    Whether or not this file's caption should be sent using Discord text-to-speech.

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

    Overrides the filename of the uploaded file

  • spoiler (true, false) (defaults to: nil) —

    Whether or not this file should appear as a spoiler.



551
552
553
 
# File 'lib/discordrb/data/channel.rb', line 551

def send_file(file, caption: nil, tts: false, filename: nil, spoiler: nil)
  @bot.send_file(@id, file, caption: caption, tts: tts, filename: filename, spoiler: spoiler)
end

#send_message(content, tts = false, embed = nil, attachments = nil, allowed_mentions = nil, message_reference = nil, components = nil, flags = 0) ⇒ Message Also known as: send

Sends a message to this channel.

Parameters:

  • content (String) —

    The content to send. Should not be longer than 2000 characters or it will result in an error.

  • tts (true, false) (defaults to: false) —

    Whether or not this message should be sent using Discord text-to-speech.

  • embed (Hash, Discordrb::Webhooks::Embed, nil) (defaults to: nil) —

    The rich embed to append to this message.

  • attachments (Array<File>) (defaults to: nil) —

    Files that can be referenced in embeds via attachment://file.png

  • allowed_mentions (Hash, Discordrb::AllowedMentions, false, nil) (defaults to: nil) —

    Mentions that are allowed to ping on this message. false disables all pings

  • message_reference (Message, String, Integer, nil) (defaults to: nil) —

    The message, or message ID, to reply to if any.

  • components (View, Array<Hash>) (defaults to: nil) —

    Interaction components to associate with this message.

  • flags (Integer) (defaults to: 0) —

    Flags for this message. Currently only SUPPRESS_EMBEDS (1 << 2) and SUPPRESS_NOTIFICATIONS (1 << 12) can be set.

Returns:

  • (Message) —

    the message that was sent.



439
440
441
 
# File 'lib/discordrb/data/channel.rb', line 439

def send_message(content, tts = false, embed = nil, attachments = nil, allowed_mentions = nil, message_reference = nil, components = nil, flags = 0)
  @bot.send_message(@id, content, tts, embed, attachments, allowed_mentions, message_reference, components, flags)
end

#send_message!(content: '', timeout: nil, tts: false, embeds: [], attachments: nil, allowed_mentions: nil, reference: nil, components: nil, flags: 0, has_components: false, nonce: nil, enforce_nonce: false) {|builder, view| ... } ⇒ Message?

Send a message to this channel.

Examples:

This sends a silent message with an embed.

channel.send_message!(content: 'Hi <@171764626755813376>', flags: :suppress_notifications) do |builder|
  builder.add_embed do |embed|
    embed.title = 'The Ruby logo'
    embed.image = Discordrb::Webhooks::EmbedImage.new(url: 'https://www.ruby-lang.org/images/header-ruby-logo.png')
  end
end

Parameters:

  • content (String) (defaults to: '') —

    The content of the message. Should not be longer than 2000 characters or it will result in an error.

  • timeout (Float, nil) (defaults to: nil) —

    The amount of time in seconds after which the message sent will be deleted, or nil if the message should not be deleted.

  • tts (true, false) (defaults to: false) —

    Whether or not this message should be sent using Discord text-to-speech.

  • embeds (Array<Hash, Webhooks::Embed>) (defaults to: []) —

    The embeds that should be attached to the message.

  • attachments (Array<File>) (defaults to: nil) —

    Files that can be referenced in embeds and components via attachment://file.png.

  • allowed_mentions (Hash, Discordrb::AllowedMentions, nil) (defaults to: nil) —

    Mentions that are allowed to ping on this message.

  • reference (Message, String, Integer, Hash, nil) (defaults to: nil) —

    The optional message, or message ID, to reply to or forward.

  • components (View, Array<#to_h>) (defaults to: nil) —

    Interaction components to associate with this message.

  • flags (Integer, Symbol, Array<Symbol, Integer>) (defaults to: 0) —

    Flags for this message. Currently only :suppress_embeds (1 << 2), :suppress_notifications (1 << 12), and :uikit_components (1 << 15) can be set.

  • has_components (true, false) (defaults to: false) —

    Whether this message includes any V2 components. Enabling this disables sending content and embeds.

  • nonce (nil, String, Integer, false) (defaults to: nil) —

    The 25 character nonce that should be used when sending this message.

  • enforce_nonce (true, false) (defaults to: false) —

    Whether the provided nonce should be enforced and used for message de-duplication.

Yield Parameters:

  • builder (Webhooks::Builder) —

    An optional message builder. Arguments passed to the builder overwrite method data.

  • view (Webhooks::View) —

    An optional component builder. Arguments passed to the builder overwrite method data.

Returns:

  • (Message, nil) —

    The resulting message that was created, or nil if the timeout parameter was set to a non nil value.



508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
 
# File 'lib/discordrb/data/channel.rb', line 508

def send_message!(content: '', timeout: nil, tts: false, embeds: [], attachments: nil, allowed_mentions: nil, reference: nil, components: nil, flags: 0, has_components: false, nonce: nil, enforce_nonce: false)
  builder = Discordrb::Webhooks::Builder.new
  view = Discordrb::Webhooks::View.new

  builder.tts = tts
  builder.content = content
  embeds&.each { |embed| builder << embed }
  builder.allowed_mentions = allowed_mentions

  yield(builder, view) if block_given?

  flags = Array(flags).map { |flag| Discordrb::Message::FLAGS[flag] || flag }.reduce(&:|)
  flags |= (1 << 15) if has_components
  builder = builder.to_json_hash

  if timeout
    @bot.send_temporary_message(@id, builder[:content], timeout, builder[:tts], builder[:embeds], attachments, builder[:allowed_mentions], reference, components&.to_a || view.to_a, flags, nonce, enforce_nonce)
  else
    @bot.send_message(@id, builder[:content], builder[:tts], builder[:embeds], attachments, builder[:allowed_mentions], reference, components&.to_a || view.to_a, flags, nonce, enforce_nonce)
  end
end

#send_multiple(content) ⇒ Object

Sends multiple messages to a channel

Parameters:

  • content (Array<String>) —

    The messages to send.



532
533
534
 
# File 'lib/discordrb/data/channel.rb', line 532

def send_multiple(content)
  content.each { |text| send_message!(content: text) }
end

#send_temporary_message(content, timeout, tts = false, embed = nil, attachments = nil, allowed_mentions = nil, message_reference = nil, components = nil, flags = 0) ⇒ Object

Sends a temporary message to this channel.

Parameters:

  • content (String) —

    The content to send. Should not be longer than 2000 characters or it will result in an error.

  • timeout (Float) —

    The amount of time in seconds after which the message sent will be deleted.

  • tts (true, false) (defaults to: false) —

    Whether or not this message should be sent using Discord text-to-speech.

  • embed (Hash, Discordrb::Webhooks::Embed, nil) (defaults to: nil) —

    The rich embed to append to this message.

  • attachments (Array<File>) (defaults to: nil) —

    Files that can be referenced in embeds via attachment://file.png

  • allowed_mentions (Hash, Discordrb::AllowedMentions, false, nil) (defaults to: nil) —

    Mentions that are allowed to ping on this message. false disables all pings

  • message_reference (Message, String, Integer, nil) (defaults to: nil) —

    The message, or message ID, to reply to if any.

  • components (View, Array<Hash>) (defaults to: nil) —

    Interaction components to associate with this message.

  • flags (Integer) (defaults to: 0) —

    Flags for this message. Currently only SUPPRESS_EMBEDS (1 << 2) and SUPPRESS_NOTIFICATIONS (1 << 12) can be set.



455
456
457
 
# File 'lib/discordrb/data/channel.rb', line 455

def send_temporary_message(content, timeout, tts = false, embed = nil, attachments = nil, allowed_mentions = nil, message_reference = nil, components = nil, flags = 0)
  @bot.send_temporary_message(@id, content, timeout, tts, embed, attachments, allowed_mentions, message_reference, components, flags)
end

#server ⇒ Server?

Returns the server this channel is on. If this channel is a PM channel, it will be nil.

Returns:

  • (Server, nil) —

    the server this channel is on. If this channel is a PM channel, it will be nil.

Raises:



173
174
175
176
177
178
179
180
181
 
# File 'lib/discordrb/data/channel.rb', line 173

def server
  return @server if @server
  return nil if private?

  @server = @bot.server(@server_id)
  raise Discordrb::Errors::NoPermission, 'The bot does not have access to this server' unless @server

  @server
end

#slowmode? ⇒ true, false

Returns whether or not this channel has slowmode enabled.

Returns:

  • (true, false) —

    whether or not this channel has slowmode enabled



425
426
427
 
# File 'lib/discordrb/data/channel.rb', line 425

def slowmode?
  @rate_limit_per_user != 0
end

#sort_after(other = nil, lock_permissions = false) ⇒ Object

Sorts this channel's position to follow another channel.

Parameters:

  • other (Channel, String, Integer, nil) (defaults to: nil) —

    The channel, or its ID, below which this channel should be sorted. If the given channel is a category, this channel will be sorted at the top of that category. If it is nil, the channel will be sorted at the top of the channel list.

  • lock_permissions (true, false) (defaults to: false) —

    Whether the channel's permissions should be synced to the category's

Raises:

  • (TypeError) 


262
263
264
265
266
267
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
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
 
# File 'lib/discordrb/data/channel.rb', line 262

def sort_after(other = nil, lock_permissions = false)
  raise TypeError, 'other must be one of Channel, NilClass, String, or Integer' unless other.is_a?(Channel) || other.nil? || other.respond_to?(:resolve_id)

  other = @bot.channel(other.resolve_id) if other

  # Container for the API request payload
  move_argument = []

  if other
    raise ArgumentError, 'Can only sort a channel after a channel of the same type!' unless other.category? || (@type == other.type)

    raise ArgumentError, 'Can only sort a channel after a channel in the same server!' unless other.server == server

    # Store `others` parent (or if `other` is a category itself)
    parent = if category? && other.category?
               # If we're sorting two categories, there is no new parent
               nil
             elsif other.category?
               # `other` is the category this channel will be moved into
               other
             else
               # `other`'s parent is the category this channel will be
               # moved into (if it exists)
               other.parent
             end
  end

  # Collect and sort the IDs within the context (category or not) that we
  # need to form our payload with
  ids = if parent
          parent.children
        else
          server.channels.reject(&:parent_id).select { |c| c.type == @type }
        end.sort_by(&:position).map(&:id)

  # Move our channel ID after the target ID by deleting it,
  # getting the index of `other`, and inserting it after.
  ids.delete(@id) if ids.include?(@id)
  index = other ? (ids.index { |c| c == other.id } || -1) + 1 : 0
  ids.insert(index, @id)

  # Generate `move_argument`, making the positions in order from how
  # we have sorted them in the above logic
  ids.each_with_index do |id, pos|
    # These keys are present in each element
    hash = { id: id, position: pos }

    # Conditionally add `lock_permissions` and `parent_id` if we're
    # iterating past ourselves
    if id == @id
      hash[:lock_permissions] = true if lock_permissions
      hash[:parent_id] = parent.nil? ? nil : parent.id
    end

    # Add it to the stack
    move_argument << hash
  end

  API::Server.update_channel_positions(@bot.token, @server_id, move_argument)
end

#split_send(content) ⇒ Object

Splits a message into chunks whose length is at most the Discord character limit, then sends them individually. Useful for sending long messages, but be wary of rate limits!



538
539
540
541
 
# File 'lib/discordrb/data/channel.rb', line 538

def split_send(content)
  send_multiple(Discordrb.split_message(content))
  nil
end

#start_forum_thread(name:, auto_archive_duration: nil, rate_limit_per_user: nil, tags: nil, content: nil, embeds: nil, allowed_mentions: nil, components: nil, stickers: nil, attachments: nil, flags: nil, has_components: false, reason: nil) {|builder, view| ... } ⇒ Message

Start a thread in a forum or media channel.

Parameters:

  • name (String) —

    The name of the forum post to create.

  • auto_archive_duration (Integer, nil) (defaults to: nil) —

    How long before the post is automatically archived.

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

    The slowmode rate of the forum post to create.

  • tags (Array<#resolve_id>, nil) (defaults to: nil) —

    The tags of the forum channel to apply onto the forum post.

  • content (String, nil) (defaults to: nil) —

    The content of the forum post's starter message.

  • embeds (Array<Hash, Webhooks::Embed>, nil) (defaults to: nil) —

    The embeds that should be attached to the forum post's starter message.

  • allowed_mentions (Hash, Discordrb::AllowedMentions, nil) (defaults to: nil) —

    Mentions that are allowed to ping on this forum post's starter message.

  • components (Webhooks::View, Array<#to_h>, nil) (defaults to: nil) —

    The interaction components to associate with this forum post's starter message.

  • stickers (Array<#resolve_id>, nil) (defaults to: nil) —

    The stickers to include in the forum post's starter message.

  • attachments (Array<File>, nil) (defaults to: nil) —

    Files that can be referenced in embeds and components via attachment://file.png.

  • flags (Integer, Symbol, Array<Symbol, Integer>, nil) (defaults to: nil) —

    The flags to set on the forum post's starter message. Currently only :suppress_embeds (1 << 2), :suppress_notifications (1 << 12), and :uikit_components (1 << 15) can be set.

  • has_components (true, false) (defaults to: false) —

    Whether the starter message for this forum post includes any V2 components. Enabling this disables sending content and embeds.

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

    The reason for creating this forum post.

Yield Parameters:

  • builder (Webhooks::Builder) —

    An optional message builder. Arguments passed to the builder overwrite method data.

  • view (Webhooks::View) —

    An optional component builder. Arguments passed to the builder overwrite method data.

Returns:

  • (Message) —

    the starter message of the forum post. The forum post that was created can be accessed via Message#thread.



954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
 
# File 'lib/discordrb/data/channel.rb', line 954

def start_forum_thread(name:, auto_archive_duration: nil, rate_limit_per_user: nil, tags: nil, content: nil, embeds: nil, allowed_mentions: nil, components: nil, stickers: nil, attachments: nil, flags: nil, has_components: false, reason: nil)
  builder = Discordrb::Webhooks::Builder.new
  view = Discordrb::Webhooks::View.new

  builder.content = content
  embeds&.each { |embed| builder << embed }
  builder.allowed_mentions = allowed_mentions

  yield(builder, view) if block_given?

  flags = Array(flags).map { |flag| Discordrb::Message::FLAGS[flag] || flag }.reduce(&:|)
  flags |= (1 << 15) if has_components
  builder = builder.to_json_hash

  message = { content: builder[:content], embeds: builder[:embeds], allowed_mentions: builder[:allowed_mentions], components: components&.to_a || view.to_a, sticker_ids: stickers&.map(&:resolve_id), flags: flags }
  response = JSON.parse(API::Channel.start_thread_in_forum_or_media_channel(@bot.token, @id, name, message.compact, attachments, rate_limit_per_user, auto_archive_duration, tags&.map(&:resolve_id), reason))

  Message.new(response['message'].merge!('channel_id' => response['id'], 'thread' => response), @bot)
end

#start_thread(name, auto_archive_duration, message: nil, type: 11) ⇒ Channel

Start a thread.

Parameters:

  • name (String) —

    The name of the thread.

  • auto_archive_duration (60, 1440, 4320, 10080) —

    How long before a thread is automatically archived.

  • message (Message, Integer, String) (defaults to: nil) —

    The message to reference when starting this thread.

  • type (Symbol, Integer) (defaults to: 11) —

    The type of thread to create. Can be a key from TYPES or the value.

Returns:



924
925
926
927
928
929
930
931
932
933
934
935
 
# File 'lib/discordrb/data/channel.rb', line 924

def start_thread(name, auto_archive_duration, message: nil, type: 11)
  message_id = message&.id || message
  type = TYPES[type] || type

  data = if message
           API::Channel.start_thread_with_message(@bot.token, @id, message_id, name, auto_archive_duration)
         else
           API::Channel.start_thread_without_message(@bot.token, @id, name, auto_archive_duration, type)
         end

  Channel.new(JSON.parse(data), @bot, @server)
end

#start_typing ⇒ Object

Starts typing, which displays the typing indicator on the client for five seconds. If you want to keep typing you'll have to resend this every five seconds. (An abstraction for this will eventually be coming)

Examples:

Send a typing indicator for the bot in a given channel.

channel.start_typing()


830
831
832
 
# File 'lib/discordrb/data/channel.rb', line 830

def start_typing
  API::Channel.start_typing(@bot.token, @id)
end

#store? ⇒ true, false

Returns whether or not this channel is a store channel.

Returns:

  • (true, false) —

    whether or not this channel is a store channel.



214
215
216
 
# File 'lib/discordrb/data/channel.rb', line 214

def store?
  @type == 6
end

#sync_overwrites ⇒ Object Also known as: sync

Syncs this channels overwrites with its parent category

Raises:

  • (RuntimeError) —

    if this channel is not in a category



368
369
370
371
372
 
# File 'lib/discordrb/data/channel.rb', line 368

def sync_overwrites
  raise 'Cannot sync overwrites on a channel with no parent category' unless parent

  self.permission_overwrites = parent.permission_overwrites
end

#synchronized? ⇒ true, ... Also known as: synced?

Returns whether this channels permissions match the permission overwrites of the category that it's in, or nil if it is not in a category.

Returns:

  • (true, false, nil) —

    whether this channels permissions match the permission overwrites of the category that it's in, or nil if it is not in a category



377
378
379
380
381
 
# File 'lib/discordrb/data/channel.rb', line 377

def synchronized?
  return unless parent

  permission_overwrites == parent.permission_overwrites
end

#text? ⇒ true, false

Returns whether or not this channel is a text channel.

Returns:

  • (true, false) —

    whether or not this channel is a text channel



184
185
186
 
# File 'lib/discordrb/data/channel.rb', line 184

def text?
  @type.zero?
end

#text_channels ⇒ Array<Channel>

Returns the text channels in this category, if it is a category channel. Otherwise returns an empty array.

Returns:



397
398
399
 
# File 'lib/discordrb/data/channel.rb', line 397

def text_channels
  children.select(&:text?)
end

#thread? ⇒ true, false

Returns whether or not this channel is a thread.

Returns:

  • (true, false) —

    whether or not this channel is a thread.



234
235
236
 
# File 'lib/discordrb/data/channel.rb', line 234

def thread?
  news_thread? || public_thread? || private_thread?
end

#users ⇒ Array<Member>

The list of users currently in this channel. For a voice channel, it will return all the members currently in that channel. For a text channel, it will return all online members that have permission to read it.

Returns:

  • (Array<Member>) —

    the users in this channel



673
674
675
676
677
678
679
 
# File 'lib/discordrb/data/channel.rb', line 673

def users
  if text?
    server.online_members(include_idle: true).select { |u| u.can_read_messages? self }
  elsif voice?
    server.voice_states.filter_map { |id, voice_state| server.member(id) if !voice_state.voice_channel.nil? && voice_state.voice_channel.id == @id }
  end
end

#voice? ⇒ true, false

Returns whether or not this channel is a voice channel.

Returns:

  • (true, false) —

    whether or not this channel is a voice channel.



194
195
196
 
# File 'lib/discordrb/data/channel.rb', line 194

def voice?
  @type == 2
end

#voice_channels ⇒ Array<Channel>

Returns the voice channels in this category, if it is a category channel. Otherwise returns an empty array.

Returns:



403
404
405
 
# File 'lib/discordrb/data/channel.rb', line 403

def voice_channels
  children.select(&:voice?)
end

#webhooks ⇒ Array<Webhook>

Requests a list of Webhooks on the channel.

Returns:

  • (Array<Webhook>) —

    webhooks on the channel.



901
902
903
904
905
906
 
# File 'lib/discordrb/data/channel.rb', line 901

def webhooks
  raise 'Tried to request webhooks from a non-server channel' unless server

  webhooks = JSON.parse(API::Channel.webhooks(@bot.token, @id))
  webhooks.map { |webhook_data| Webhook.new(webhook_data, @bot) }
end