Class: Discorb::Guild

Inherits:
DiscordModel show all
Defined in:
lib/discorb/guild.rb

Overview

Represents a guild in the Discord.

Defined Under Namespace

Classes: Ban, VanityInvite, Widget

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Methods inherited from DiscordModel

#==, #eql?, #hash

Instance Attribute Details

#afk_timeout -> Integer (readonly)

Returns The AFK timeout of the guild.

Returns:

  • (Integer) —

    The AFK timeout of the guild.



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

def afk_timeout
  @afk_timeout
end

#approximate_member_count -> Integer (readonly)

Returns The approxmate amount of members in the guild.

Returns:

  • (Integer) —

    The approxmate amount of members in the guild.



72
73
74
 
# File 'lib/discorb/guild.rb', line 72

def approximate_member_count
  @approximate_member_count
end

#approximate_presence_count -> Integer (readonly)

Returns The approxmate amount of non-offline members in the guild.

Returns:

  • (Integer) —

    The approxmate amount of non-offline members in the guild.



74
75
76
 
# File 'lib/discorb/guild.rb', line 74

def approximate_presence_count
  @approximate_presence_count
end

#available -> Boolean (readonly) Also known as: available?

Returns Whether the guild is available.

Returns:

  • (Boolean) —

    Whether the guild is available.



97
98
99
 
# File 'lib/discorb/guild.rb', line 97

def available
  @available
end

Returns:

  • (Discorb::Asset) —

    The banner of the guild.

  • (nil) —

    If the guild does not have a banner.



61
62
63
 
# File 'lib/discorb/guild.rb', line 61

def banner
  @banner
end

#channels -> Discorb::Dictionary{Discorb::Snowflake => Discorb::GuildChannel} (readonly)

Returns A dictionary of channels in the guild.

Returns:



47
48
49
 
# File 'lib/discorb/guild.rb', line 47

def channels
  @channels
end

#default_message_notifications -> :all_messages, :only_mentions (readonly)

Returns The default message notification level of the guild.

Returns:

  • (:all_messages, :only_mentions) —

    The default message notification level of the guild.



84
85
86
 
# File 'lib/discorb/guild.rb', line 84

def default_message_notifications
  @default_message_notifications
end

#description -> String (readonly)

Returns The description of the guild.

Returns:

  • (String) —

    The description of the guild.



58
59
60
 
# File 'lib/discorb/guild.rb', line 58

def description
  @description
end

#discovery_splash -> Discorb::Asset (readonly)

Returns The discovery splash of the guild.

Returns:



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

def discovery_splash
  @discovery_splash
end

#emojis -> Discorb::Dictionary{Discorb::Snowflake => Discorb::CustomEmoji} (readonly)

Returns A dictionary of custom emojis in the guild.

Returns:



25
26
27
 
# File 'lib/discorb/guild.rb', line 25

def emojis
  @emojis
end

#explicit_content_filter -> :disabled_in_text, ... (readonly)

Returns The explict content filter level of the guild.

Returns:

  • (:disabled_in_text, :members_without_roles, :all_members) —

    The explict content filter level of the guild.



86
87
88
 
# File 'lib/discorb/guild.rb', line 86

def explicit_content_filter
  @explicit_content_filter
end

#features -> Array<Symbol> (readonly)

Returns features that are enabled in the guild.

Returns:

  • (Array<Symbol>) —

    features that are enabled in the guild.

See Also:



28
29
30
 
# File 'lib/discorb/guild.rb', line 28

def features
  @features
end

#icon -> Discorb::Asset (readonly)

Returns The icon of the guild.

Returns:



40
41
42
 
# File 'lib/discorb/guild.rb', line 40

def icon
  @icon
end

#id -> Discorb::Snowflake (readonly)

Returns ID of the guild.

Returns:



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

def id
  @id
end

#joined_at -> Time (readonly)

Returns Time that representing when bot has joined the guild.

Returns:

  • (Time) —

    Time that representing when bot has joined the guild.



34
35
36
 
# File 'lib/discorb/guild.rb', line 34

def joined_at
  @joined_at
end

#large -> Boolean (readonly) Also known as: large?

Returns Whether the guild is large.

Returns:

  • (Boolean) —

    Whether the guild is large.



91
92
93
 
# File 'lib/discorb/guild.rb', line 91

def large
  @large
end

#max_presences -> Integer (readonly)

Returns Number of online members in the guild.

Returns:

  • (Integer) —

    Number of online members in the guild.



53
54
55
 
# File 'lib/discorb/guild.rb', line 53

def max_presences
  @max_presences
end

#max_video_channel_users -> Integer (readonly)

Returns The maximum amount of users in a video channel.

Returns:

  • (Integer) —

    The maximum amount of users in a video channel.



70
71
72
 
# File 'lib/discorb/guild.rb', line 70

def max_video_channel_users
  @max_video_channel_users
end

#member_count -> Integer (readonly)

Returns The amount of members in the guild.

Returns:

  • (Integer) —

    The amount of members in the guild.



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

def member_count
  @member_count
end

#members -> Discorb::Dictionary{Discorb::Snowflake => Discorb::Member} (readonly)

Note:

You must enable GUILD_MEMBERS intent to use this method.

Returns A dictionary of members in the guild.

Returns:



45
46
47
 
# File 'lib/discorb/guild.rb', line 45

def members
  @members
end

#mfa_level -> :none, :elevated (readonly)

Returns The MFA level of the guild.

Returns:

  • (:none, :elevated) —

    The MFA level of the guild.



30
31
32
 
# File 'lib/discorb/guild.rb', line 30

def mfa_level
  @mfa_level
end

#name -> String (readonly)

Returns The name of the guild.

Returns:

  • (String) —

    The name of the guild.



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

def name
  @name
end

#nsfw_level -> :default, ... (readonly)

Returns The nsfw level of the guild.

Returns:

  • (:default, :explicit, :safe, :age_restricted) —

    The nsfw level of the guild.



78
79
80
 
# File 'lib/discorb/guild.rb', line 78

def nsfw_level
  @nsfw_level
end

#owner -> Boolean (readonly) Also known as: owner?

Returns Whether the client is the owner of the guild.

Returns:

  • (Boolean) —

    Whether the client is the owner of the guild.



88
89
90
 
# File 'lib/discorb/guild.rb', line 88

def owner
  @owner
end

#owner_id -> Discorb::Snowflake (readonly)

Returns ID of the guild owner.

Returns:



17
18
19
 
# File 'lib/discorb/guild.rb', line 17

def owner_id
  @owner_id
end

#permissions -> Discorb::Permission (readonly)

Returns The bot's permission in the guild.

Returns:



19
20
21
 
# File 'lib/discorb/guild.rb', line 19

def permissions
  @permissions
end

#preferred_locale -> Symbol (readonly)

Note:

This modifies the language code, - will be replaced with _.

Returns The preffered language of the guild.

Returns:

  • (Symbol) —

    The preffered language of the guild.



68
69
70
 
# File 'lib/discorb/guild.rb', line 68

def preferred_locale
  @preferred_locale
end

#premium_subscription_count -> Integer (readonly)

Returns The amount of premium subscriptions (Server Boosts) the guild has.

Returns:

  • (Integer) —

    The amount of premium subscriptions (Server Boosts) the guild has.



65
66
67
 
# File 'lib/discorb/guild.rb', line 65

def premium_subscription_count
  @premium_subscription_count
end

#premium_tier -> Integer (readonly)

Returns The premium tier (Boost Level) of the guild.

Returns:

  • (Integer) —

    The premium tier (Boost Level) of the guild.



63
64
65
 
# File 'lib/discorb/guild.rb', line 63

def premium_tier
  @premium_tier
end

#presences -> Discorb::Dictionary{Discorb::User => Discorb::Presence} (readonly)

Returns A dictionary of presence in the guild.

Returns:



51
52
53
 
# File 'lib/discorb/guild.rb', line 51

def presences
  @presences
end

#roles -> Discorb::Dictionary{Discorb::Snowflake => Discorb::Role} (readonly)

Returns A dictionary of roles in the guild.

Returns:



23
24
25
 
# File 'lib/discorb/guild.rb', line 23

def roles
  @roles
end

#splash -> Discorb::Asset (readonly)

Returns The splash of the guild.

Returns:



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

def splash
  @splash
end

#stage_instances -> Discorb::Dictionary{Discorb::Snowflake => Discorb::StageInstance} (readonly)

Returns A dictionary of stage instances in the guild.

Returns:



80
81
82
 
# File 'lib/discorb/guild.rb', line 80

def stage_instances
  @stage_instances
end

#system_channel_flags -> Discorb::Guild::SystemChannelFlag (readonly)

Returns The flag for the system channel.

Returns:

  • (Discorb::Guild::SystemChannelFlag) —

    The flag for the system channel.



32
33
34
 
# File 'lib/discorb/guild.rb', line 32

def system_channel_flags
  @system_channel_flags
end

#threads -> Discorb::Dictionary{Discorb::Snowflake => Discorb::ThreadChannel} (readonly)

Returns A dictionary of threads in the guild.

Returns:



49
50
51
 
# File 'lib/discorb/guild.rb', line 49

def threads
  @threads
end

#unavailable -> Boolean (readonly)

Returns Whether the guild is unavailable.

Returns:

  • (Boolean) —

    Whether the guild is unavailable.



36
37
38
 
# File 'lib/discorb/guild.rb', line 36

def unavailable
  @unavailable
end

#vanity_url_code -> String? (readonly)

Returns:

  • (String) —

    The vanity invite URL for the guild.

  • (nil) —

    If the guild does not have a vanity invite URL.



56
57
58
 
# File 'lib/discorb/guild.rb', line 56

def vanity_url_code
  @vanity_url_code
end

#verification_level -> :none, ... (readonly)

Returns The verification level of the guild.

Returns:

  • (:none, :low, :medium, :high, :very_high) —

    The verification level of the guild.



82
83
84
 
# File 'lib/discorb/guild.rb', line 82

def verification_level
  @verification_level
end

#voice_states -> Discorb::Dictionary{Discorb::User => Discorb::VoiceState} (readonly)

Returns A dictionary of voice states in the guild.

Returns:



42
43
44
 
# File 'lib/discorb/guild.rb', line 42

def voice_states
  @voice_states
end

#welcome_screen -> Discorb::WelcomeScreen (readonly)

Returns The welcome screen of the guild.

Returns:



76
77
78
 
# File 'lib/discorb/guild.rb', line 76

def welcome_screen
  @welcome_screen
end

#widget_enabled -> Boolean (readonly) Also known as: widget_enabled?

Returns Whether the guild enabled the widget.

Returns:

  • (Boolean) —

    Whether the guild enabled the widget.



94
95
96
 
# File 'lib/discorb/guild.rb', line 94

def widget_enabled
  @widget_enabled
end

Class Method Details

Returns a banner url from the guild's ID.

Parameters:

  • guild_id (#to_s) —

    The ID of the guild.

  • style (:shield, :banner1, :banner2, :banner3, :banner4) (defaults to: "banner") —

    The style of the banner.

Returns:

  • (String) —

    The url of the banner.



1074
1075
1076
 
# File 'lib/discorb/guild.rb', line 1074

def banner(guild_id, style: "banner")
  "#{Discorb::API_BASE_URL}/guilds/#{guild_id}/widget.png&style=#{style}"
end

Instance Method Details

#afk_channel -> Object 



136
137
138
 
# File 'lib/discorb/guild.rb', line 136

def afk_channel
  @client.channels[@afk_channel_id]
end

#ban_member(member, delete_message_days: 0, reason: nil) -> Async::Task<Discorb::Guild::Ban>

Note:

This is an asynchronous method, it will return a Async::Task object. Use Async::Task#wait to get the result.

Note:

This method calls HTTP request.

Ban a member from the guild.

Parameters:

  • member (Discorb::Member) —

    The member to ban.

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

    The number of days to delete messages.

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

    The reason for banning the member.

Returns:

Raises:



675
676
677
678
679
680
681
682
 
# File 'lib/discorb/guild.rb', line 675

def ban_member(member, delete_message_days: 0, reason: nil)
  Async do
    _resp, data = @client.http.post(
      "/guilds/#{@id}/bans", { user: member.id, delete_message_days: delete_message_days }, audit_log_reason: reason,
    ).wait
    Ban.new(@client, self, data)
  end
end

#banned?(user) -> Async::Task<Boolean>

Note:

This is an asynchronous method, it will return a Async::Task object. Use Async::Task#wait to get the result.

Note:

This method calls HTTP request.

Checks the user was banned from the guild.

Parameters:

Returns:

  • (Async::Task<Boolean>) —

    Whether the user was banned.

Raises:



658
659
660
661
662
 
# File 'lib/discorb/guild.rb', line 658

def banned?(user)
  Async do
    !fetch_ban(user).wait.nil?
  end
end

#create_category_channel(name, position: nil, permission_overwrites: nil, parent: nil, reason: nil) -> Async::Task<Discorb::CategoryChannel> Also known as: create_category

Note:

This is an asynchronous method, it will return a Async::Task object. Use Async::Task#wait to get the result.

Note:

This method calls HTTP request.

Create a new category channel.

Parameters:

  • name (String) —

    The name of the channel.

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

    The position of the channel.

  • permission_overwrites (Hash{Discorb::Role, Discorb::Member => Discorb::PermissionOverwrite}) (defaults to: nil) —

    A list of permission overwrites.

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

    The parent of the channel.

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

    The reason for creating the channel.

Returns:

Raises:



378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
 
# File 'lib/discorb/guild.rb', line 378

def create_category_channel(name, position: nil, permission_overwrites: nil, parent: nil, reason: nil)
  Async do
    payload = { type: CategoryChannel.channel_type }
    payload[:name] = name
    payload[:position] = position if position
    if permission_overwrites
      payload[:permission_overwrites] = permission_overwrites.map do |target, overwrite|
        {
          type: target.is_a?(Role) ? 0 : 1,
          id: target.id,
          allow: overwrite.allow_value,
          deny: overwrite.deny_value,
        }
      end
    end
    payload[:parent_id] = parent&.id
    _resp, data = @client.http.post(
      "/guilds/#{@id}/channels", payload, audit_log_reason: reason,
    ).wait
    Channel.make_channel(@client, data)
  end
end

#create_emoji(name, image, roles: []) -> Async::Task<Discorb::CustomEmoji>

Note:

This is an asynchronous method, it will return a Async::Task object. Use Async::Task#wait to get the result.

Note:

This method calls HTTP request.

Create a custom emoji.

Parameters:

  • name (#to_s) —

    The name of the emoji.

  • image (Discorb::Image) —

    The image of the emoji.

  • roles (Array<Discorb::Role>) (defaults to: []) —

    A list of roles to give the emoji.

Returns:

Raises:



222
223
224
225
226
227
228
229
230
231
232
 
# File 'lib/discorb/guild.rb', line 222

def create_emoji(name, image, roles: [])
  _resp, data = @client.http.post(
    "/guilds/#{@id}/emojis",
    {
      name: name,
      image: image.to_s,
      roles: roles.map { |r| Discorb::Utils.try(r, :id) },
    }
  ).wait
  @emojis[data[:id]] = CustomEmoji.new(@client, self, data)
end

#create_news_channel(name, topic: nil, rate_limit_per_user: nil, slowmode: nil, position: nil, nsfw: nil, permission_overwrites: nil, parent: nil, reason: nil) -> Async::Task<Discorb::NewsChannel>

Note:

This is an asynchronous method, it will return a Async::Task object. Use Async::Task#wait to get the result.

Note:

This method calls HTTP request.

Create a new news channel.

Parameters:

  • name (String) —

    The name of the channel.

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

    The topic of the channel.

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

    The rate limit per user in the channel.

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

    Alias for rate_limit_per_user.

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

    The position of the channel.

  • nsfw (Boolean) (defaults to: nil) —

    Whether the channel is nsfw.

  • permission_overwrites (Hash{Discorb::Role, Discorb::Member => Discorb::PermissionOverwrite}) (defaults to: nil) —

    A list of permission overwrites.

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

    The parent of the channel.

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

    The reason for creating the channel.

Returns:

Raises:



458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
 
# File 'lib/discorb/guild.rb', line 458

def create_news_channel(
  name, topic: nil, rate_limit_per_user: nil, slowmode: nil, position: nil, nsfw: nil, permission_overwrites: nil, parent: nil, reason: nil
)
  Async do
    payload = { type: NewsChannel.channel_type }
    payload[:name] = name
    payload[:topic] = topic if topic
    rate_limit_per_user ||= slowmode
    payload[:rate_limit_per_user] = rate_limit_per_user if rate_limit_per_user
    payload[:position] = position if position
    if permission_overwrites
      payload[:permission_overwrites] = permission_overwrites.map do |target, overwrite|
        {
          type: target.is_a?(Role) ? 0 : 1,
          id: target.id,
          allow: overwrite.allow_value,
          deny: overwrite.deny_value,
        }
      end
    end
    payload[:nsfw] = nsfw unless nsfw.nil?
    payload[:parent_id] = parent&.id
    _resp, data = @client.http.post(
      "/guilds/#{@id}/channels", payload, audit_log_reason: reason,
    ).wait
    Channel.make_channel(@client, data)
  end
end

#create_role(name = nil, color: nil, hoist: nil, mentionable: nil, reason: nil) -> Async::Task<Discorb::Role>

Note:

This is an asynchronous method, it will return a Async::Task object. Use Async::Task#wait to get the result.

Note:

This method calls HTTP request.

Create a role in the guild.

Parameters:

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

    The name of the role.

  • color (Discorb::Color) (defaults to: nil) —

    The color of the role.

  • hoist (Boolean) (defaults to: nil) —

    Whether the role should be hoisted.

  • mentionable (Boolean) (defaults to: nil) —

    Whether the role should be mentionable.

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

    The reason for creating the role.

Returns:

Raises:



725
726
727
728
729
730
731
732
733
734
735
736
737
 
# File 'lib/discorb/guild.rb', line 725

def create_role(name = nil, color: nil, hoist: nil, mentionable: nil, reason: nil)
  Async do
    payload = {}
    payload[:name] = name if name
    payload[:color] = color.to_i if color
    payload[:hoist] = hoist if hoist
    payload[:mentionable] = mentionable if mentionable
    _resp, data = @client.http.post(
      "/guilds/#{@id}/roles", payload, audit_log_reason: reason,
    ).wait
    Role.new(@client, self, data)
  end
end

#create_stage_channel(name, bitrate: 64, position: nil, permission_overwrites: nil, parent: nil, reason: nil) -> Async::Task<Discorb::StageChannel>

Note:

This is an asynchronous method, it will return a Async::Task object. Use Async::Task#wait to get the result.

Note:

This method calls HTTP request.

Create a new stage channel.

Parameters:

  • name (String) —

    The name of the channel.

  • bitrate (Integer) (defaults to: 64) —

    The bitrate of the channel.

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

    The position of the channel.

  • permission_overwrites (Hash{Discorb::Role, Discorb::Member => Discorb::PermissionOverwrite}) (defaults to: nil) —

    A list of permission overwrites.

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

    The parent of the channel.

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

    The reason for creating the channel.

Returns:

Raises:



417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
 
# File 'lib/discorb/guild.rb', line 417

def create_stage_channel(name, bitrate: 64, position: nil, permission_overwrites: nil, parent: nil, reason: nil)
  Async do
    payload = { type: StageChannel.channel_type }
    payload[:name] = name
    payload[:bitrate] = bitrate * 1000 if bitrate
    payload[:position] = position if position
    if permission_overwrites
      payload[:permission_overwrites] = permission_overwrites.map do |target, overwrite|
        {
          type: target.is_a?(Role) ? 0 : 1,
          id: target.id,
          allow: overwrite.allow_value,
          deny: overwrite.deny_value,
        }
      end
    end
    payload[:parent_id] = parent&.id
    _resp, data = @client.http.post(
      "/guilds/#{@id}/channels", payload, audit_log_reason: reason,
    ).wait
    Channel.make_channel(@client, data)
  end
end

#create_template(name, description = nil, reason: nil) -> Async::Task<Discorb::GuildTemplate>

Create a new template in the guild.

Parameters:

  • name (String) —

    The name of the template.

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

    The description of the template.

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

    The reason for creating the template.

Returns:



934
935
936
937
938
939
940
941
 
# File 'lib/discorb/guild.rb', line 934

def create_template(name, description = nil, reason: nil)
  Async do
    _resp, data = @client.http.post(
      "/guilds/#{@id}/templates", { name: name, description: description }, audit_log_reason: reason,
    ).wait
    GuildTemplate.new(@client, data)
  end
end

#create_text_channel(name, topic: nil, rate_limit_per_user: nil, slowmode: nil, position: nil, nsfw: nil, permission_overwrites: nil, parent: nil, reason: nil) -> Async::Task<Discorb::TextChannel>

Note:

This is an asynchronous method, it will return a Async::Task object. Use Async::Task#wait to get the result.

Note:

This method calls HTTP request.

Create a new text channel.

Parameters:

  • name (String) —

    The name of the channel.

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

    The topic of the channel.

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

    The rate limit per user in the channel.

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

    Alias for rate_limit_per_user.

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

    The position of the channel.

  • nsfw (Boolean) (defaults to: nil) —

    Whether the channel is nsfw.

  • permission_overwrites (Hash{Discorb::Role, Discorb::Member => Discorb::PermissionOverwrite}) (defaults to: nil) —

    A list of permission overwrites.

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

    The parent of the channel.

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

    The reason for creating the channel.

Returns:

Raises:



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/discorb/guild.rb', line 293

def create_text_channel(
  name, topic: nil, rate_limit_per_user: nil, slowmode: nil, position: nil, nsfw: nil, permission_overwrites: nil, parent: nil, reason: nil
)
  Async do
    payload = { type: TextChannel.channel_type }
    payload[:name] = name
    payload[:topic] = topic if topic
    rate_limit_per_user ||= slowmode
    payload[:rate_limit_per_user] = rate_limit_per_user if rate_limit_per_user
    payload[:nsfw] = nsfw if nsfw
    payload[:position] = position if position
    if permission_overwrites
      payload[:permission_overwrites] = permission_overwrites.map do |target, overwrite|
        {
          type: target.is_a?(Role) ? 0 : 1,
          id: target.id,
          allow: overwrite.allow_value,
          deny: overwrite.deny_value,
        }
      end
    end
    payload[:parent_id] = parent.id if parent
    _resp, data = @client.http.post(
      "/guilds/#{@id}/channels", payload, audit_log_reason: reason,
    ).wait
    payload[:parent_id] = parent&.id
    Channel.make_channel(@client, data)
  end
end

#create_voice_channel(name, bitrate: 64, user_limit: nil, position: nil, permission_overwrites: nil, parent: nil, reason: nil) -> Async::Task<Discorb::VoiceChannel>

Note:

This is an asynchronous method, it will return a Async::Task object. Use Async::Task#wait to get the result.

Note:

This method calls HTTP request.

Create a new voice channel.

Parameters:

  • name (String) —

    The name of the channel.

  • bitrate (Integer) (defaults to: 64) —

    The bitrate of the channel.

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

    The user limit of the channel.

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

    The position of the channel.

  • permission_overwrites (Hash{Discorb::Role, Discorb::Member => Discorb::PermissionOverwrite}) (defaults to: nil) —

    A list of permission overwrites.

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

    The parent of the channel.

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

    The reason for creating the channel.

Returns:

Raises:



338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
 
# File 'lib/discorb/guild.rb', line 338

def create_voice_channel(
  name, bitrate: 64, user_limit: nil, position: nil, permission_overwrites: nil, parent: nil, reason: nil
)
  Async do
    payload = { type: VoiceChannel.channel_type }
    payload[:name] = name
    payload[:bitrate] = bitrate * 1000 if bitrate
    payload[:user_limit] = user_limit if user_limit
    payload[:position] = position if position
    if permission_overwrites
      payload[:permission_overwrites] = permission_overwrites.map do |target, overwrite|
        {
          type: target.is_a?(Role) ? 0 : 1,
          id: target.id,
          allow: overwrite.allow_value,
          deny: overwrite.deny_value,
        }
      end
    end
    payload[:parent_id] = parent.id if parent
    _resp, data = @client.http.post(
      "/guilds/#{@id}/channels", payload, audit_log_reason: reason,
    ).wait
    payload[:parent_id] = parent&.id
    Channel.make_channel(@client, data)
  end
end

#edit_nickname(nickname, reason: nil) -> Object Also known as: edit_nick, modify_nickname

Change nickname of client member.

Parameters:

  • nickname (String) —

    The nickname to set.

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

    The reason for changing the nickname.



591
592
593
594
595
 
# File 'lib/discorb/guild.rb', line 591

def edit_nickname(nickname, reason: nil)
  Async do
    @client.http.patch("/guilds/#{@id}/members/@me/nick", { nick: nickname }, audit_log_reason: reason).wait
  end
end

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

Note:

This is an asynchronous method, it will return a Async::Task object. Use Async::Task#wait to get the result.

Note:

This method calls HTTP request.

Fetch a list of active threads in the guild.

Returns:

Raises:



494
495
496
497
498
499
 
# File 'lib/discorb/guild.rb', line 494

def fetch_active_threads
  Async do
    _resp, data = @client.http.get("/guilds/#{@id}/threads/active").wait
    data[:threads].map { |t| Channel.make_thread(@client, t) }
  end
end

#fetch_audit_log -> Async::Task<Discorb::AuditLog>

Note:

This is an asynchronous method, it will return a Async::Task object. Use Async::Task#wait to get the result.

Note:

This method calls HTTP request.

Fetch audit log of the guild.

Returns:

Raises:



255
256
257
258
259
260
 
# File 'lib/discorb/guild.rb', line 255

def fetch_audit_log
  Async do
    _resp, data = @client.http.get("/guilds/#{@id}/audit-logs").wait
    AuditLog.new(@client, data, self)
  end
end

#fetch_ban(user) -> Async::Task<Discorb::Guild::Ban>, Async::Task<nil>

Note:

This is an asynchronous method, it will return a Async::Task object. Use Async::Task#wait to get the result.

Note:

This method calls HTTP request.

Fetch a ban in the guild.

Parameters:

Returns:

  • (Async::Task<Discorb::Guild::Ban>) —

    The ban.

  • (Async::Task<nil>) —

    If the ban is not found.

Raises:



639
640
641
642
643
644
645
646
647
 
# File 'lib/discorb/guild.rb', line 639

def fetch_ban(user)
  Async do
    _resp, data = @client.http.get("/guilds/#{@id}/bans/#{user.id}").wait
  rescue Discorb::NotFoundError
    nil
  else
    Ban.new(@client, self, data)
  end
end

#fetch_bans -> Async::Task<Array<Discorb::Guild::Ban>>

Note:

This is an asynchronous method, it will return a Async::Task object. Use Async::Task#wait to get the result.

Note:

This method calls HTTP request.

Fetch a list of bans in the guild.

Returns:

Raises:



622
623
624
625
626
627
 
# File 'lib/discorb/guild.rb', line 622

def fetch_bans
  Async do
    _resp, data = @client.http.get("/guilds/#{@id}/bans").wait
    data.map { |d| Ban.new(@client, self, d) }
  end
end

#fetch_channels -> Async::Task<Array<Discorb::Channel>>

Note:

This is an asynchronous method, it will return a Async::Task object. Use Async::Task#wait to get the result.

Note:

This method calls HTTP request.

Fetch channels of the guild.

Returns:

Raises:



269
270
271
272
273
274
 
# File 'lib/discorb/guild.rb', line 269

def fetch_channels
  Async do
    _resp, data = @client.http.get("/guilds/#{@id}/channels").wait
    data.map { |c| Channel.make_channel(@client, c) }
  end
end

#fetch_emoji(id) -> Async::Task<Discorb::CustomEmoji>

Note:

This is an asynchronous method, it will return a Async::Task object. Use Async::Task#wait to get the result.

Note:

This method calls HTTP request.

Note:

This querys the API every time. We recommend using #emojis instead.

Fetch emoji id of the guild.

Parameters:

  • id (#to_s) —

    The emoji id.

Returns:

Raises:



206
207
208
209
 
# File 'lib/discorb/guild.rb', line 206

def fetch_emoji(id)
  _resp, data = @client.http.get("/guilds/#{@id}/emojis/#{id}").wait
  @emojis[e[:id]] = CustomEmoji.new(@client, self, data)
end

#fetch_emoji_list -> Async::Task<Discorb::Dictionary{Discorb::Snowflake => Discorb::CustomEmoji}> Also known as: fetch_emojis

Note:

This is an asynchronous method, it will return a Async::Task object. Use Async::Task#wait to get the result.

Note:

This method calls HTTP request.

Note:

This querys the API every time. We recommend using #emojis instead.

Fetch emoji list of the guild.

Returns:

Raises:



180
181
182
183
184
185
186
187
188
189
190
191
192
 
# File 'lib/discorb/guild.rb', line 180

def fetch_emoji_list
  Async do
    _resp, data = @client.http.get("/guilds/#{@id}/emojis").wait
    @emojis = Dictionary.new
    ids = @emojis.map(&:id).map(&:to_s)
    data.map do |e|
      next if ids.include?(e[:id])

      @emojis[e[:id]] = CustomEmoji.new(@client, self, e)
    end
    @emojis
  end
end

#fetch_integrations -> Async::Task<Array<Discorb::Integration>>

Note:

This is an asynchronous method, it will return a Async::Task object. Use Async::Task#wait to get the result.

Note:

This method calls HTTP request.

Fetch integrations in the guild.

Returns:

Raises:



816
817
818
819
820
821
 
# File 'lib/discorb/guild.rb', line 816

def fetch_integrations
  Async do
    _resp, data = @client.http.get("/guilds/#{@id}/integrations").wait
    data.map { |d| Integration.new(@client, d) }
  end
end

#fetch_invites -> Async::Task<Array<Invite>>

Note:

This is an asynchronous method, it will return a Async::Task object. Use Async::Task#wait to get the result.

Note:

This method calls HTTP request.

Fetch invites in the guild.

Returns:

  • (Async::Task<Array<Invite>>) —

    The invites.

Raises:



802
803
804
805
806
807
 
# File 'lib/discorb/guild.rb', line 802

def fetch_invites
  Async do
    _resp, data = @client.http.get("/guilds/#{@id}/invites").wait
    data.map { |d| Invite.new(@client, d) }
  end
end

#fetch_member(id) -> Async::Task<Discorb::Member>, Async::Task<nil>

Note:

This is an asynchronous method, it will return a Async::Task object. Use Async::Task#wait to get the result.

Note:

This method calls HTTP request.

Fetch a member in the guild.

Parameters:

  • id (#to_s) —

    The ID of the member to fetch.

Returns:

  • (Async::Task<Discorb::Member>) —

    The member.

  • (Async::Task<nil>) —

    If the member is not found.

Raises:



511
512
513
514
515
516
517
518
519
 
# File 'lib/discorb/guild.rb', line 511

def fetch_member(id)
  Async do
    _resp, data = @client.http.get("/guilds/#{@id}/members/#{id}").wait
  rescue Discorb::NotFoundError
    nil
  else
    Member.new(@client, @id, data[:user], data)
  end
end

#fetch_member_named -> Async::Task<Discorb::Member>, Async::Task<nil>

Note:

This is an asynchronous method, it will return a Async::Task object. Use Async::Task#wait to get the result.

Note:

This method calls HTTP request.

Almost the same as #fetch_members_named, but returns a single member.

Returns:

  • (Async::Task<Discorb::Member>) —

    The member.

  • (Async::Task<nil>) —

    If the member is not found.

Raises:



579
580
581
582
583
 
# File 'lib/discorb/guild.rb', line 579

def fetch_member_named(...)
  Async do
    fetch_members_named(...).first
  end
end

#fetch_members(limit: 0, after: nil) -> Async::Task<Array<Discorb::Member>> Also known as: fetch_member_list

Note:

This is an asynchronous method, it will return a Async::Task object. Use Async::Task#wait to get the result.

Note:

This method calls HTTP request.

Note:

You must enable GUILD_MEMBERS intent to use this method.

Fetch members in the guild.

Parameters:

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

    The maximum number of members to fetch, 0 for all.

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

    The ID of the member to start fetching after.

Returns:

Raises:



531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
 
# File 'lib/discorb/guild.rb', line 531

def fetch_members(limit: 0, after: nil)
  Async do
    unless limit == 0
      _resp, data = @client.http.get("/guilds/#{@id}/members?#{URI.encode_www_form({ after: after, limit: limit })}").wait
      next data[:members].map { |m| Member.new(@client, @id, m[:user], m) }
    end
    ret = []
    after = 0
    loop do
      params = { after: after, limit: 100 }
      _resp, data = @client.http.get("/guilds/#{@id}/members?#{URI.encode_www_form(params)}").wait
      ret += data.map { |m| Member.new(@client, @id, m[:user], m) }
      after = data.last[:user][:id]
      if data.length != 1000
        break
      end
    end
    ret
  end
end

#fetch_members_named(name, limit: 1) -> Async::Task<Array<Discorb::Member>>

Note:

This is an asynchronous method, it will return a Async::Task object. Use Async::Task#wait to get the result.

Note:

This method calls HTTP request.

Search for members by name in the guild.

Parameters:

  • name (String) —

    The name of the member to search for.

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

    The maximum number of members to return.

Returns:

Raises:



564
565
566
567
568
569
 
# File 'lib/discorb/guild.rb', line 564

def fetch_members_named(name, limit: 1)
  Async do
    _resp, data = @client.http.get("/guilds/#{@id}/members/search?#{URI.encode_www_form({ query: name, limit: limit })}").wait
    data.map { |d| Member.new(@client, @id, d[:user], d) }
  end
end

#fetch_prune(days = 7, roles: []) -> Async::Task<Integer>

Note:

This is an asynchronous method, it will return a Async::Task object. Use Async::Task#wait to get the result.

Note:

This method calls HTTP request.

Fetch how many members will be pruned.

Parameters:

  • days (Integer) (defaults to: 7) —

    The number of days to prune.

  • roles (Array<Discorb::Role>) (defaults to: []) —

    The roles that include for pruning.

Returns:

  • (Async::Task<Integer>) —

    The number of members that will be pruned.

Raises:



749
750
751
752
753
754
755
756
757
758
759
 
# File 'lib/discorb/guild.rb', line 749

def fetch_prune(days = 7, roles: [])
  Async do
    params = {
      days: days,
      include_roles: @id.to_s,
    }
    param[:include_roles] = roles.map(&:id).map(&:to_s).join(";") if roles.any?
    _resp, data = @client.http.get("/guilds/#{@id}/prune?#{URI.encode_www_form(params)}").wait
    data[:pruned]
  end
end

#fetch_roles -> Async::Task<Array<Discorb::Role>>

Note:

This is an asynchronous method, it will return a Async::Task object. Use Async::Task#wait to get the result.

Note:

This method calls HTTP request.

Fetch a list of roles in the guild.

Returns:

Raises:



705
706
707
708
709
710
 
# File 'lib/discorb/guild.rb', line 705

def fetch_roles
  Async do
    _resp, data = @client.http.get("/guilds/#{@id}/roles").wait
    data.map { |d| Role.new(@client, self, d) }
  end
end

#fetch_sticker(id) -> Async::Task<Discorb::Sticker::GuildSticker>, Async::Task<nil>

Note:

This is an asynchronous method, it will return a Async::Task object. Use Async::Task#wait to get the result.

Note:

This method calls HTTP request.

Fetch the sticker by ID.

Parameters:

  • id (#to_s) —

    The ID of the sticker.

Returns:

Raises:



889
890
891
892
893
894
895
896
897
 
# File 'lib/discorb/guild.rb', line 889

def fetch_sticker(id)
  Async do
    _resp, data = @client.http.get("/guilds/#{@id}/stickers/#{id}").wait
  rescue Discorb::NotFoundError
    nil
  else
    Sticker::GuildSticker.new(@client, data)
  end
end

#fetch_stickers -> Async::Task<Array<Discorb::Sticker::GuildSticker>>

Note:

This is an asynchronous method, it will return a Async::Task object. Use Async::Task#wait to get the result.

Note:

This method calls HTTP request.

Fetch stickers in the guild.

Returns:

Raises:



872
873
874
875
876
877
 
# File 'lib/discorb/guild.rb', line 872

def fetch_stickers
  Async do
    _resp, data = @client.http.get("/guilds/#{@id}/stickers").wait
    data.map { |d| Sticker::GuildSticker.new(@client, d) }
  end
end

#fetch_template -> Discorb::GuildTemplate, Async::Task<nil>

Almost the same as #fetch_templates, but returns a single template.

Returns:



919
920
921
922
923
 
# File 'lib/discorb/guild.rb', line 919

def fetch_template
  Async do
    fetch_templates.wait.first
  end
end

#fetch_templates -> Async::Task<Discorb::GuildTemplate>

Note:

This is an asynchronous method, it will return a Async::Task object. Use Async::Task#wait to get the result.

Note:

This method calls HTTP request.

Fetch templates in the guild.

Returns:

Raises:



906
907
908
909
910
911
 
# File 'lib/discorb/guild.rb', line 906

def fetch_templates
  Async do
    _resp, data = @client.http.get("/guilds/#{@id}/templates").wait
    data.map { |d| GuildTemplate.new(@client, d) }
  end
end

#fetch_vanity_invite -> Async::Task<Discorb::Guild::VanityInvite>

Note:

This is an asynchronous method, it will return a Async::Task object. Use Async::Task#wait to get the result.

Note:

This method calls HTTP request.

Fetch the vanity URL of the guild.

Returns:

Raises:



844
845
846
847
848
849
 
# File 'lib/discorb/guild.rb', line 844

def fetch_vanity_invite
  Async do
    _resp, data = @client.http.get("/guilds/#{@id}/vanity-url").wait
    VanityInvite.new(@client, self, data)
  end
end

#fetch_voice_regions -> Async::Task<Array<Discorb::VoiceRegion>>

Note:

This is an asynchronous method, it will return a Async::Task object. Use Async::Task#wait to get the result.

Note:

This method calls HTTP request.

Fetch voice regions that are available in the guild.

Returns:

Raises:



788
789
790
791
792
793
 
# File 'lib/discorb/guild.rb', line 788

def fetch_voice_regions
  Async do
    _resp, data = @client.http.get("/guilds/#{@id}/voice").wait
    data.map { |d| VoiceRegion.new(@client, d) }
  end
end

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

Note:

This is an asynchronous method, it will return a Async::Task object. Use Async::Task#wait to get the result.

Note:

This method calls HTTP request.

Fetch webhooks of the guild.

Returns:

Raises:



241
242
243
244
245
246
 
# File 'lib/discorb/guild.rb', line 241

def fetch_webhooks
  Async do
    _resp, data = @client.http.get("/guilds/#{@id}/webhooks").wait
    data.map { |webhook| Webhook.new([@client, webhook]) }
  end
end

#fetch_welcome_screen -> Async::Task<Discorb::Guild::WelcomeScreen>

Note:

This is an asynchronous method, it will return a Async::Task object. Use Async::Task#wait to get the result.

Note:

This method calls HTTP request.

Fetch the welcome screen of the guild.

Returns:

  • (Async::Task<Discorb::Guild::WelcomeScreen>) —

    The welcome screen.

Raises:



858
859
860
861
862
863
 
# File 'lib/discorb/guild.rb', line 858

def fetch_welcome_screen
  Async do
    _resp, data = @client.http.get("/guilds/#{@id}/welcome-screen").wait
    WelcomeScreen.new(@client, self, data)
  end
end

#fetch_widget -> Async::Task<Discorb::Guild::Widget>

Note:

This is an asynchronous method, it will return a Async::Task object. Use Async::Task#wait to get the result.

Note:

This method calls HTTP request.

Fetch the widget of the guild.

Returns:

Raises:



830
831
832
833
834
835
 
# File 'lib/discorb/guild.rb', line 830

def fetch_widget
  Async do
    _resp, data = @client.http.get("/guilds/#{@id}/widget").wait
    Widget.new(@client, @id, data)
  end
end

#inspect -> Object 



152
153
154
 
# File 'lib/discorb/guild.rb', line 152

def inspect
  "#<#{self.class} \"#{@name}\" id=#{@id}>"
end

#kick_member(member, reason: nil) -> Object

Note:

This is an asynchronous method, it will return a Async::Task object. Use Async::Task#wait to get the result.

Note:

This method calls HTTP request.

Kick a member from the guild.

Parameters:

  • member (Discorb::Member) —

    The member to kick.

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

    The reason for kicking the member.

Raises:



609
610
611
612
613
 
# File 'lib/discorb/guild.rb', line 609

def kick_member(member, reason: nil)
  Async do
    @client.http.delete("/guilds/#{@id}/members/#{member.id}", audit_log_reason: reason).wait
  end
end

#leave! -> Object

Note:

This is an asynchronous method, it will return a Async::Task object. Use Async::Task#wait to get the result.

Note:

This method calls HTTP request.

Leave the guild.

Raises:



165
166
167
168
169
170
 
# File 'lib/discorb/guild.rb', line 165

def leave!
  Async do
    @client.http.delete("/users/@me/guilds/#{@id}").wait
    @client.guilds.delete(@id)
  end
end

#me -> Object 



156
157
158
 
# File 'lib/discorb/guild.rb', line 156

def me
  @members[@client.user.id]
end

#prune(days = 7, roles: [], reason: nil) -> Async::Task<Integer>

Note:

This is an asynchronous method, it will return a Async::Task object. Use Async::Task#wait to get the result.

Note:

This method calls HTTP request.

Prune members from the guild.

Parameters:

  • days (Integer) (defaults to: 7) —

    The number of days to prune.

  • roles (Array<Discorb::Role>) (defaults to: []) —

    The roles that include for pruning.

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

    The reason for pruning.

Returns:

  • (Async::Task<Integer>) —

    The number of members that were pruned.

Raises:



772
773
774
775
776
777
778
779
 
# File 'lib/discorb/guild.rb', line 772

def prune(days = 7, roles: [], reason: nil)
  Async do
    _resp, data = @client.http.post(
      "/guilds/#{@id}/prune", { days: days, roles: roles.map(&:id) }, audit_log_reason: reason,
    ).wait
    data[:pruned]
  end
end

#public_updates_channel -> Object 



148
149
150
 
# File 'lib/discorb/guild.rb', line 148

def public_updates_channel
  @client.channels[@public_updates_channel_id]
end

#rules_channel -> Object 



144
145
146
 
# File 'lib/discorb/guild.rb', line 144

def rules_channel
  @client.channels[@rules_channel_id]
end

#system_channel -> Object 



140
141
142
 
# File 'lib/discorb/guild.rb', line 140

def system_channel
  @client.channels[@system_channel_id]
end

#unban_user(user, reason: nil) -> Object

Note:

This is an asynchronous method, it will return a Async::Task object. Use Async::Task#wait to get the result.

Note:

This method calls HTTP request.

Unban a user from the guild.

Parameters:

  • user (Discorb::User) —

    The user to unban.

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

    The reason for unbanning the user.

Raises:



692
693
694
695
696
 
# File 'lib/discorb/guild.rb', line 692

def unban_user(user, reason: nil)
  Async do
    @client.http.delete("/guilds/#{@id}/bans/#{user.id}", audit_log_reason: reason).wait
  end
end