Class: Discordrb::Channel

Inherits:
Object
  • Object
show all
Includes:
IDObject
Defined in:
lib/discordrb/data.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
}.freeze

Instance Attribute Summary collapse

Attributes included from IDObject

#id

Instance Method Summary collapse

Methods included from IDObject

#==, #creation_time, synthesise

Instance Attribute Details

#bitrate ⇒ Integer

Returns the bitrate (in bps) of the channel.

Returns:

  • (Integer) —

    the bitrate (in bps) of the channel



1335
1336
1337
 
# File 'lib/discordrb/data.rb', line 1335

def bitrate
  @bitrate
end

#name ⇒ String

Returns this channel's name.

Returns:

  • (String) —

    this channel's name.



1314
1315
1316
 
# File 'lib/discordrb/data.rb', line 1314

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



1345
1346
1347
 
# File 'lib/discordrb/data.rb', line 1345

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.

Returns:

  • (Integer, nil) —

    the id of the owner of the group channel or nil if this is not a group channel.



1326
1327
1328
 
# File 'lib/discordrb/data.rb', line 1326

def owner_id
  @owner_id
end

#parent_id ⇒ Integer? (readonly)

Returns the ID of the parent channel, if this channel is inside a cateogry.

Returns:

  • (Integer, nil) —

    the ID of the parent channel, if this channel is inside a cateogry



1320
1321
1322
 
# File 'lib/discordrb/data.rb', line 1320

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



1342
1343
1344
 
# File 'lib/discordrb/data.rb', line 1342

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.



1349
1350
1351
 
# File 'lib/discordrb/data.rb', line 1349

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



1329
1330
1331
 
# File 'lib/discordrb/data.rb', line 1329

def recipients
  @recipients
end

#server ⇒ Server? (readonly)

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.



1317
1318
1319
 
# File 'lib/discordrb/data.rb', line 1317

def server
  @server
end

#topic ⇒ String

Returns the channel's topic.

Returns:

  • (String) —

    the channel's topic



1332
1333
1334
 
# File 'lib/discordrb/data.rb', line 1332

def topic
  @topic
end

#type ⇒ Integer (readonly)

Returns the type of this channel (0: text, 1: private, 2: voice, 3: group).

Returns:

  • (Integer) —

    the type of this channel (0: text, 1: private, 2: voice, 3: group)



1323
1324
1325
 
# File 'lib/discordrb/data.rb', line 1323

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.



1338
1339
1340
 
# File 'lib/discordrb/data.rb', line 1338

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:

  • user_ids (Array<#resolve_id>, #resolve_id) —

    User ID or array of user IDs to add to the group channel.

Returns:



1946
1947
1948
1949
1950
1951
1952
1953
1954
 
# File 'lib/discordrb/data.rb', line 1946

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

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



1897
1898
1899
 
# File 'lib/discordrb/data.rb', line 1897

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

#await!(attributes = {}) ⇒ 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:



1904
1905
1906
 
# File 'lib/discordrb/data.rb', line 1904

def await!(attributes = {})
  @bot.add_await!(Discordrb::Events::MessageEvent, { in: @id }.merge(attributes))
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



1430
1431
1432
 
# File 'lib/discordrb/data.rb', line 1430

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



1439
1440
1441
1442
1443
1444
 
# File 'lib/discordrb/data.rb', line 1439

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:

  • (true, false) 


1425
1426
1427
 
# File 'lib/discordrb/data.rb', line 1425

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:



1578
1579
1580
1581
1582
 
# File 'lib/discordrb/data.rb', line 1578

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.



1935
1936
1937
1938
1939
1940
1941
 
# File 'lib/discordrb/data.rb', line 1935

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

#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



1609
1610
1611
 
# File 'lib/discordrb/data.rb', line 1609

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.



1750
1751
1752
1753
1754
1755
1756
1757
1758
1759
 
# File 'lib/discordrb/data.rb', line 1750

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.



1687
1688
1689
 
# File 'lib/discordrb/data.rb', line 1687

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:



1681
1682
1683
 
# File 'lib/discordrb/data.rb', line 1681

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

#delete_messages(messages, strict = false) ⇒ Integer

Deletes a collection of messages

Parameters:

  • messages (Array<Message, Integer, #resolve_id>) —

    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.

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



1879
1880
1881
1882
1883
1884
 
# File 'lib/discordrb/data.rb', line 1879

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

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

#delete_overwrite(target, reason = nil) ⇒ Object

Deletes a permission overwrite for this channel

Parameters:



1764
1765
1766
1767
1768
 
# File 'lib/discordrb/data.rb', line 1764

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.



1420
1421
1422
 
# File 'lib/discordrb/data.rb', line 1420

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.



1811
1812
1813
1814
 
# File 'lib/discordrb/data.rb', line 1811

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.



2001
2002
2003
 
# File 'lib/discordrb/data.rb', line 2001

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

#invites ⇒ Array<Invite>

Requests a list of Invites to the channel.

Returns:

  • (Array<Invite>) —

    invites to the channel.



1993
1994
1995
1996
1997
1998
 
# File 'lib/discordrb/data.rb', line 1993

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

#leave_group ⇒ Object Also known as: leave

Leaves the group.



1974
1975
1976
1977
1978
 
# File 'lib/discordrb/data.rb', line 1974

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

  API::Channel.leave_group(@bot.token, @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.



1827
1828
1829
1830
1831
1832
 
# File 'lib/discordrb/data.rb', line 1827

def load_message(message_id)
  response = API::Channel.message(@bot.token, @id, message_id)
  Message.new(JSON.parse(response), @bot)
rescue RestClient::ResourceNotFound
  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.



1915
1916
1917
1918
 
# File 'lib/discordrb/data.rb', line 1915

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



1599
1600
1601
 
# File 'lib/discordrb/data.rb', line 1599

def member_overwrites
  permission_overwrites :member
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.



1358
1359
1360
 
# File 'lib/discordrb/data.rb', line 1358

def mention
  "<##{@id}>"
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:



1532
1533
1534
1535
1536
 
# File 'lib/discordrb/data.rb', line 1532

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:



1542
1543
1544
 
# File 'lib/discordrb/data.rb', line 1542

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

#pins ⇒ Array<Message>

Requests all pinned messages in a channel.

Returns:

  • (Array<Message>) —

    the received messages.



1838
1839
1840
1841
 
# File 'lib/discordrb/data.rb', line 1838

def pins
  msgs = API::Channel.pinned_messages(@bot.token, @id)
  JSON.parse(msgs).map { |msg| Message.new(msg, @bot) }
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.



1410
1411
1412
 
# File 'lib/discordrb/data.rb', line 1410

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.



1353
1354
1355
 
# File 'lib/discordrb/data.rb', line 1353

def private?
  pm? || group?
end

#prune(amount, strict = false) {|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.

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



1852
1853
1854
1855
1856
1857
1858
1859
1860
1861
1862
1863
1864
1865
1866
1867
1868
1869
1870
1871
 
# File 'lib/discordrb/data.rb', line 1852

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

  messages =
    if block_given?
      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)
    1
  else
    bulk_delete(messages, strict)
  end
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



1363
1364
1365
 
# File 'lib/discordrb/data.rb', line 1363

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:

  • user_ids (Array<#resolve_id>, #resolve_id) —

    User ID or array of user IDs to remove from the group channel.

Returns:



1961
1962
1963
1964
1965
1966
1967
1968
1969
 
# File 'lib/discordrb/data.rb', line 1961

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

#role_overwrites ⇒ Overwrite

Returns any role-type permission overwrites on this channel.

Returns:

  • (Overwrite) —

    any role-type permission overwrites on this channel



1604
1605
1606
 
# File 'lib/discordrb/data.rb', line 1604

def role_overwrites
  permission_overwrites :role
end

#send_embed(message = '', embed = nil) {|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.

Yields:

  • (embed) —

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

Yield Parameters:

  • embed (Discordrb::Webhooks::Embed) —

    The embed from the parameters, or a new one.

Returns:

  • (Message) —

    The resulting message.



1651
1652
1653
1654
1655
 
# File 'lib/discordrb/data.rb', line 1651

def send_embed(message = '', embed = nil)
  embed ||= Discordrb::Webhooks::Embed.new
  yield(embed) if block_given?
  send_message(message, false, embed)
end

#send_file(file, caption: nil, tts: false) ⇒ 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.



1675
1676
1677
 
# File 'lib/discordrb/data.rb', line 1675

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

#send_message(content, tts = false, embed = nil) ⇒ 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.

Returns:

  • (Message) —

    the message that was sent.



1625
1626
1627
 
# File 'lib/discordrb/data.rb', line 1625

def send_message(content, tts = false, embed = nil)
  @bot.send_message(@id, content, tts, embed)
end

#send_multiple(content) ⇒ Object

Sends multiple messages to a channel

Parameters:

  • content (Array<String>) —

    The messages to send.



1659
1660
1661
 
# File 'lib/discordrb/data.rb', line 1659

def send_multiple(content)
  content.each { |e| send_message(e) }
end

#send_temporary_message(content, timeout, tts = false, embed = nil) ⇒ 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.



1636
1637
1638
 
# File 'lib/discordrb/data.rb', line 1636

def send_temporary_message(content, timeout, tts = false, embed = nil)
  @bot.send_temporary_message(@id, content, timeout, tts, embed)
end

#slowmode? ⇒ true, false

Returns whether or not this channel has slowmode enabled.

Returns:

  • (true, false) —

    whether or not this channel has slowmode enabled



1616
1617
1618
 
# File 'lib/discordrb/data.rb', line 1616

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, #resolve_id, nil) (defaults to: nil) —

    The channel 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) 


1453
1454
1455
1456
1457
1458
1459
1460
1461
1462
1463
1464
1465
1466
1467
1468
1469
1470
1471
1472
1473
1474
1475
1476
1477
1478
1479
1480
1481
1482
1483
1484
1485
1486
1487
1488
1489
1490
1491
1492
1493
1494
1495
1496
1497
1498
1499
1500
1501
1502
1503
1504
1505
1506
1507
1508
1509
1510
1511
1512
 
# File 'lib/discordrb/data.rb', line 1453

def sort_after(other = nil, lock_permissions = false)
  raise TypeError, 'other must be one of Channel, NilClass, or #resolve_id' 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 ourself
    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!



1665
1666
1667
 
# File 'lib/discordrb/data.rb', line 1665

def split_send(content)
  send_multiple(Discordrb.split_message(content))
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()


1927
1928
1929
 
# File 'lib/discordrb/data.rb', line 1927

def start_typing
  API::Channel.start_typing(@bot.token, @id)
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



1559
1560
1561
1562
1563
 
# File 'lib/discordrb/data.rb', line 1559

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



1568
1569
1570
1571
1572
 
# File 'lib/discordrb/data.rb', line 1568

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



1405
1406
1407
 
# File 'lib/discordrb/data.rb', line 1405

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:



1588
1589
1590
 
# File 'lib/discordrb/data.rb', line 1588

def text_channels
  children.select(&:text?)
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



1790
1791
1792
1793
1794
1795
1796
 
# File 'lib/discordrb/data.rb', line 1790

def users
  if text?
    @server.online_members(include_idle: true).select { |u| u.can_read_messages? self }
  elsif voice?
    @server.voice_states.map { |id, voice_state| @server.member(id) if !voice_state.voice_channel.nil? && voice_state.voice_channel.id == @id }.compact
  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.



1415
1416
1417
 
# File 'lib/discordrb/data.rb', line 1415

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:



1594
1595
1596
 
# File 'lib/discordrb/data.rb', line 1594

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.



1984
1985
1986
1987
1988
1989
 
# File 'lib/discordrb/data.rb', line 1984

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