Module: Discorb::Messageable

Included in:
DMChannel, NewsChannel, TextChannel, ThreadChannel, User
Defined in:
lib/discorb/modules.rb

Overview

Module for sending and reading messages.

Instance Method Summary collapse

Instance Method Details

#delete_message!(message_id, reason: nil) -> Async::Task<void> Also known as: destroy_message!

Delete a message.

Parameters:

  • message_id (#to_s) —

    The message id.

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

    The reason for deleting the message.

Returns:

  • (Async::Task<void>) —

    The task.



90
91
92
93
94
 
# File 'lib/discorb/modules.rb', line 90

def delete_message!(message_id, reason: nil)
  Async do
    @client.http.request(Route.new("/channels/#{channel_id.wait}/messages/#{message_id}", "//channels/:channel_id/messages/:message_id", :delete), audit_log_reason: reason).wait
  end
end

#edit_message(message_id, content = nil, embed: nil, embeds: nil, allowed_mentions: nil, components: nil, supress: nil) -> Async::Task<void>

Edit a message.

Parameters:

  • message_id (#to_s) —

    The message id.

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

    The message content.

  • embed (Discorb::Embed) (defaults to: nil) —

    The embed to send.

  • embeds (Array<Discorb::Embed>) (defaults to: nil) —

    The embeds to send.

  • allowed_mentions (Discorb::AllowedMentions) (defaults to: nil) —

    The allowed mentions.

  • components (Array<Discorb::Component>, Array<Array<Discorb::Component>>) (defaults to: nil) —

    The components to send.

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

    Whether to supress embeds.

Returns:

  • (Async::Task<void>) —

    The task.



62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
 
# File 'lib/discorb/modules.rb', line 62

def edit_message(message_id, content = nil, embed: nil, embeds: nil, allowed_mentions: nil,
                                            components: nil, supress: nil)
  Async do
    payload = {}
    payload[:content] = content if content
    tmp_embed = if embed
        [embed]
      elsif embeds
        embeds
      end
    payload[:embeds] = tmp_embed.map(&:to_hash) if tmp_embed
    payload[:allowed_mentions] =
      allowed_mentions ? allowed_mentions.to_hash(@client.allowed_mentions) : @client.allowed_mentions.to_hash
    payload[:components] = Component.to_payload(components) if components
    payload[:flags] = (supress ? 1 << 2 : 0) unless supress.nil?
    @client.http.request(Route.new("/channels/#{channel_id.wait}/messages/#{message_id}", "//channels/:channel_id/messages/:message_id", :patch), payload).wait
  end
end

#fetch_message(id) -> Async::Task<Discorb::Message>

Fetch a message from ID.

Parameters:

Returns:

Raises:



107
108
109
110
111
112
 
# File 'lib/discorb/modules.rb', line 107

def fetch_message(id)
  Async do
    _resp, data = @client.http.request(Route.new("/channels/#{channel_id.wait}/messages/#{id}", "//channels/:channel_id/messages/:message_id", :get)).wait
    Message.new(@client, data.merge({ guild_id: @guild_id.to_s }))
  end
end

#fetch_messages(limit = 50, before: nil, after: nil, around: nil) -> Async::Task<Array<Discorb::Message>>

Fetch a message history.

Parameters:

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

    The number of messages to fetch.

  • before (Discorb::Snowflake) (defaults to: nil) —

    The ID of the message to fetch before.

  • after (Discorb::Snowflake) (defaults to: nil) —

    The ID of the message to fetch after.

  • around (Discorb::Snowflake) (defaults to: nil) —

    The ID of the message to fetch around.

Returns:



125
126
127
128
129
130
131
132
133
134
135
136
 
# File 'lib/discorb/modules.rb', line 125

def fetch_messages(limit = 50, before: nil, after: nil, around: nil)
  Async do
    params = {
      limit: limit,
      before: Discorb::Utils.try(after, :id),
      after: Discorb::Utils.try(around, :id),
      around: Discorb::Utils.try(before, :id),
    }.filter { |_k, v| !v.nil? }.to_h
    _resp, messages = @client.http.request(Route.new("/channels/#{channel_id.wait}/messages?#{URI.encode_www_form(params)}", "//channels/:channel_id/messages", :get)).wait
    messages.map { |m| Message.new(@client, m.merge({ guild_id: @guild_id.to_s })) }
  end
end

#fetch_pins -> Async::Task<Array<Discorb::Message>>

Fetch the pinned messages in the channel.

Returns:

  • (Async::Task<Array<Discorb::Message>>) —

    The pinned messages in the channel.



144
145
146
147
148
149
 
# File 'lib/discorb/modules.rb', line 144

def fetch_pins
  Async do
    _resp, data = @client.http.request(Route.new("/channels/#{channel_id.wait}/pins", "//channels/:channel_id/pins", :get)).wait
    data.map { |pin| Message.new(@client, pin) }
  end
end

#pin_message(message, reason: nil) -> Async::Task<void>

Pin a message in the channel.

Parameters:

  • message (Discorb::Message) —

    The message to pin.

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

    The reason of pinning the message.

Returns:

  • (Async::Task<void>) —

    The task.



160
161
162
163
164
 
# File 'lib/discorb/modules.rb', line 160

def pin_message(message, reason: nil)
  Async do
    @client.http.request(Route.new("/channels/#{channel_id.wait}/pins/#{message.id}", "//channels/:channel_id/pins/:message_id", :put), {}, audit_log_reason: reason).wait
  end
end

#post(content = nil, tts: false, embed: nil, embeds: nil, allowed_mentions: nil, reference: nil, components: nil, file: nil, files: nil) -> Async::Task<Discorb::Message> Also known as: send_message

Post a message to the channel.

Parameters:

Returns:



24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
 
# File 'lib/discorb/modules.rb', line 24

def post(content = nil, tts: false, embed: nil, embeds: nil, allowed_mentions: nil,
                        reference: nil, components: nil, file: nil, files: nil)
  Async do
    payload = {}
    payload[:content] = content if content
    payload[:tts] = tts
    tmp_embed = if embed
        [embed]
      elsif embeds
        embeds
      end
    payload[:embeds] = tmp_embed.map(&:to_hash) if tmp_embed
    payload[:allowed_mentions] =
      allowed_mentions ? allowed_mentions.to_hash(@client.allowed_mentions) : @client.allowed_mentions.to_hash
    payload[:message_reference] = reference.to_reference if reference
    payload[:components] = Component.to_payload(components) if components
    files = [file]
    _resp, data = @client.http.multipart_request(Route.new("/channels/#{channel_id.wait}/messages", "//channels/:channel_id/messages", :post), payload, files).wait
    Message.new(@client, data.merge({ guild_id: @guild_id.to_s }))
  end
end

#typing -> Object

Trigger the typing indicator in the channel. If block is given, trigger typing indicator during executing block.

Examples:

channel.typing do
  channel.post("Waiting for 60 seconds...")
  sleep 60
  channel.post("Done!")
end


193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
 
# File 'lib/discorb/modules.rb', line 193

def typing
  if block_given?
    begin
      post_task = Async do
        loop do
          @client.http.request(Route.new("/channels/#{@id}/typing", "//channels/:channel_id/typing", :post), {})
          sleep(5)
        end
      end
      yield
    ensure
      post_task.stop
    end
  else
    Async do |task|
      @client.http.request(Route.new("/channels/#{@id}/typing", "//channels/:channel_id/typing", :post), {})
    end
  end
end

#unpin_message(message, reason: nil) -> Async::Task<void>

Unpin a message in the channel.

Parameters:

  • message (Discorb::Message) —

    The message to unpin.

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

    The reason of unpinning the message.

Returns:

  • (Async::Task<void>) —

    The task.



175
176
177
178
179
 
# File 'lib/discorb/modules.rb', line 175

def unpin_message(message, reason: nil)
  Async do
    @client.http.request(Route.new("/channels/#{channel_id.wait}/pins/#{message.id}", "//channels/:channel_id/pins/:message_id", :delete), audit_log_reason: reason).wait
  end
end