Class: Discorb::ThreadChannel Abstract

Inherits:
Channel show all
Includes:
Messageable
Defined in:
lib/discorb/channel/thread.rb

Overview

This class is abstract.

Represents a thread.

Direct Known Subclasses

News, Private, Public

Defined Under Namespace

Classes: Member, News, Private, Public

Class Attribute Summary collapse

Instance Attribute Summary collapse

Instance Method Summary collapse

Methods included from Messageable

#delete_message, #edit_message, #fetch_message, #fetch_messages, #fetch_pins, #pin_message, #post, #typing, #unpin_message

Methods inherited from Channel

#==, #type

Methods inherited from DiscordModel

#==, #eql?

Class Attribute Details

.channel_type ⇒ Object (readonly)

Returns the value of attribute channel_type.



310
311
312
 
# File 'lib/discorb/channel/thread.rb', line 310

def channel_type
  @channel_type
end

Instance Attribute Details

#archived ⇒ Boolean (readonly) Also known as: archived?

Returns Whether the thread is archived or not.

Returns:

  • Whether the thread is archived or not.



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

def archived
  @archived
end

#archived_timestamp ⇒ Time? (readonly) Also known as: archived_at

Returns:

  • The time the thread was archived.

  • If the thread is not archived.



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

def archived_timestamp
  @archived_timestamp
end

#auto_archive_duration ⇒ Integer (readonly) Also known as: archive_in

Returns Auto archive duration in seconds.

Returns:

  • Auto archive duration in seconds.



31
32
33
 
# File 'lib/discorb/channel/thread.rb', line 31

def auto_archive_duration
  @auto_archive_duration
end

#id ⇒ Discorb::Snowflake (readonly)

Note:

This ID is same as the starter message's ID

Returns The ID of the channel.

Returns:

  • The ID of the channel.



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

def id
  @id
end

#member_count ⇒ Integer (readonly) Also known as: recipient_count

Note:

This will stop counting at 50.

Returns The number of recipients in the thread.

Returns:

  • The number of recipients in the thread.



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

def member_count
  @member_count
end

#members ⇒ Array<Discorb::ThreadChannel::Member> (readonly)

Returns The members of the thread.

Returns:

  • The members of the thread.



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

def members
  @members
end

#message_count ⇒ Integer (readonly)

Note:

This will stop counting at 50.

Returns The number of messages in the thread.

Returns:

  • The number of messages in the thread.



16
17
18
 
# File 'lib/discorb/channel/thread.rb', line 16

def message_count
  @message_count
end

#name ⇒ String (readonly)

Returns The name of the thread.

Returns:

  • The name of the thread.



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

def name
  @name
end

#rate_limit_per_user ⇒ Integer (readonly) Also known as: slowmode

Returns The rate limit per user (slowmode) in the thread.

Returns:

  • The rate limit per user (slowmode) in the thread.



22
23
24
 
# File 'lib/discorb/channel/thread.rb', line 22

def rate_limit_per_user
  @rate_limit_per_user
end

Instance Method Details

#add_member(member = :me) ⇒ Async::Task<void> Also known as: join

Add a member to the thread.

Parameters:

  • (defaults to: :me)

    The member to add. If :me is given, the bot will be added.

Returns:

  • The task.



199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
 
# File 'lib/discorb/channel/thread.rb', line 199

def add_member(member = :me)
  Async do
    if member == :me
      @client
        .http
        .request(
          Route.new(
            "/channels/#{@id}/thread-members/@me",
            "//channels/:channel_id/thread-members/@me",
            :post
          )
        )
        .wait
    else
      @client
        .http
        .request(
          Route.new(
            "/channels/#{@id}/thread-members/#{Utils.try(member, :id)}",
            "//channels/:channel_id/thread-members/:user_id",
            :post
          )
        )
        .wait
    end
  end
end

#archive(reason: nil) ⇒ Async::Task<self>

Helper method to archive the thread.

Parameters:

  • (defaults to: nil)

    The reason of archiving the thread.

Returns:

  • The archived thread.



125
126
127
 
# File 'lib/discorb/channel/thread.rb', line 125

def archive(reason: nil)
  edit(archived: true, reason: reason)
end

#edit(name: Discorb::Unset, archived: Discorb::Unset, auto_archive_duration: Discorb::Unset, archive_in: Discorb::Unset, locked: Discorb::Unset, reason: nil) ⇒ Async::Task<self>

Note:

The arguments of this method are defaultly set to Discorb::Unset. Specify value to set the value, if not don't specify or specify Discorb::Unset.

Edit the thread.

See Also:

Parameters:

  • (defaults to: Discorb::Unset)

    The name of the thread.

  • (defaults to: Discorb::Unset)

    Whether the thread is archived or not.

  • (defaults to: Discorb::Unset)

    The auto archive duration in seconds.

  • (defaults to: Discorb::Unset)

    Alias of auto_archive_duration.

  • (defaults to: Discorb::Unset)

    Whether the thread is locked or not.

  • (defaults to: nil)

    The reason of editing the thread.

Returns:

  • The edited thread.



89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
 
# File 'lib/discorb/channel/thread.rb', line 89

def edit(
  name: Discorb::Unset,
  archived: Discorb::Unset,
  auto_archive_duration: Discorb::Unset,
  archive_in: Discorb::Unset,
  locked: Discorb::Unset,
  reason: nil
)
  Async do
    payload = {}
    payload[:name] = name if name != Discorb::Unset
    payload[:archived] = archived if archived != Discorb::Unset
    auto_archive_duration ||= archive_in
    payload[
      :auto_archive_duration
    ] = auto_archive_duration if auto_archive_duration != Discorb::Unset
    payload[:locked] = locked if locked != Discorb::Unset
    @client
      .http
      .request(
        Route.new("/channels/#{@id}", "//channels/:channel_id", :patch),
        payload,
        audit_log_reason: reason
      )
      .wait
    self
  end
end

#fetch_members ⇒ Array<Discorb::ThreadChannel::Member>

Fetch members in the thread.

Returns:

  • The members in the thread.



271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
 
# File 'lib/discorb/channel/thread.rb', line 271

def fetch_members
  Async do
    _resp, data =
      @client
        .http
        .request(
          Route.new(
            "/channels/#{@id}/thread-members",
            "//channels/:channel_id/thread-members",
            :get
          )
        )
        .wait
    data.map { |d| @members[d[:id]] = Member.new(@client, d, @guild_id) }
  end
end

#guild ⇒ Object 



180
181
182
 
# File 'lib/discorb/channel/thread.rb', line 180

def guild
  @client.guilds[@guild]
end

#inspect ⇒ Object 



188
189
190
 
# File 'lib/discorb/channel/thread.rb', line 188

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

#joined? ⇒ Boolean

Returns:



176
177
178
 
# File 'lib/discorb/channel/thread.rb', line 176

def joined?
  !!me
end

#lock(reason: nil) ⇒ Async::Task<self>

Helper method to lock the thread.

Parameters:

  • (defaults to: nil)

    The reason of locking the thread.

Returns:

  • The locked thread.



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

def lock(reason: nil)
  edit(archived: true, locked: true, reason: reason)
end

#me ⇒ Object 



172
173
174
 
# File 'lib/discorb/channel/thread.rb', line 172

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

#owner ⇒ Object 



184
185
186
 
# File 'lib/discorb/channel/thread.rb', line 184

def owner
  guild.members[@owner_id]
end

#parent ⇒ Object Also known as: channel 



164
165
166
167
168
 
# File 'lib/discorb/channel/thread.rb', line 164

def parent
  return nil unless @parent_id

  @client.channels[@parent_id]
end

#remove_member(member = :me) ⇒ Async::Task<void> Also known as: leave

Remove a member from the thread.

Parameters:

  • (defaults to: :me)

    The member to remove. If :me is given, the bot will be removed.

Returns:

  • The task.



236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
 
# File 'lib/discorb/channel/thread.rb', line 236

def remove_member(member = :me)
  Async do
    if member == :me
      @client
        .http
        .request(
          Route.new(
            "/channels/#{@id}/thread-members/@me",
            "//channels/:channel_id/thread-members/@me",
            :delete
          )
        )
        .wait
    else
      @client
        .http
        .request(
          Route.new(
            "/channels/#{@id}/thread-members/#{Utils.try(member, :id)}",
            "//channels/:channel_id/thread-members/:user_id",
            :delete
          )
        )
        .wait
    end
  end
end

#unarchive(reason: nil) ⇒ Async::Task<self>

Helper method to unarchive the thread.

Parameters:

  • (defaults to: nil)

    The reason of unarchiving the thread.

Returns:

  • The unarchived thread.



147
148
149
 
# File 'lib/discorb/channel/thread.rb', line 147

def unarchive(reason: nil)
  edit(archived: false, reason: reason)
end

#unlock(reason: nil) ⇒ Async::Task<self>

Note:

This method won't unarchive the thread. Use #unarchive instead.

Helper method to unlock the thread.

Parameters:

  • (defaults to: nil)

    The reason of unlocking the thread.

Returns:

  • The unlocked thread.



160
161
162
 
# File 'lib/discorb/channel/thread.rb', line 160

def unlock(reason: nil)
  edit(archived: !unarchive, locked: false, reason: reason)
end