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) -> Object Also known as: destroy_message!

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.

Delete a message.

Parameters:

  • message_id (#to_s) —

    The message id.

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

    The reason for deleting the message.

Raises:



131
132
133
134
135
 
# File 'lib/discorb/modules.rb', line 131

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

#edit_message(message_id, content = nil, embed: nil, embeds: nil, allowed_mentions: nil, components: nil, supress: 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.

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.

Raises:



85
86
87
88
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
117
118
119
120
121
 
# File 'lib/discorb/modules.rb', line 85

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
    if components
      tmp_components = []
      tmp_row = []
      components.each do |c|
        case c
        when Array
          tmp_components << tmp_row
          tmp_row = []
          tmp_components << c
        when SelectMenu
          tmp_components << tmp_row
          tmp_row = []
          tmp_components << [c]
        else
          tmp_row << c
        end
      end
      tmp_components << tmp_row
      payload[:flags] = (supress ? 1 << 2 : 0) unless flags.nil?
      payload[:components] = tmp_components.filter { |c| c.length.positive? }.map { |c| { type: 1, components: c.map(&:to_hash) } }
    end
    @client.http.patch("/channels/#{channel_id.wait}/messages/#{message_id}", payload).wait
  end
end

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

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 message from ID.

Parameters:

Returns:

Raises:



149
150
151
152
153
154
 
# File 'lib/discorb/modules.rb', line 149

def fetch_message(id)
  Async do
    _resp, data = @client.http.get("/channels/#{channel_id.wait}/messages/#{id}").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>>

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

Raises:



168
169
170
171
172
173
174
175
176
177
178
179
 
# File 'lib/discorb/modules.rb', line 168

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.get("/channels/#{channel_id.wait}/messages?#{URI.encode_www_form(params)}").wait
    messages.map { |m| Message.new(@client, m.merge({ guild_id: @guild_id.to_s })) }
  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>

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.

Post a message to the channel.

Parameters:

Returns:

Raises:



25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
 
# File 'lib/discorb/modules.rb', line 25

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
    if components
      tmp_components = []
      tmp_row = []
      components.each do |c|
        case c
        when Array
          tmp_components << tmp_row
          tmp_row = []
          tmp_components << c
        when SelectMenu
          tmp_components << tmp_row
          tmp_row = []
          tmp_components << [c]
        else
          tmp_row << c
        end
      end
      tmp_components << tmp_row
      payload[:components] = tmp_components.filter { |c| c.length.positive? }.map { |c| { type: 1, components: c.map(&:to_hash) } }
    end
    files = [file] if file
    if files
      seperator, payload = HTTP.multipart(payload, files)
      headers = { "content-type" => "multipart/form-data; boundary=#{seperator}" }
    else
      headers = {}
    end
    _resp, data = @client.http.post("/channels/#{channel_id.wait}/messages", payload, headers: headers).wait
    Message.new(@client, data.merge({ guild_id: @guild_id.to_s }))
  end
end

#typing -> 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.

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

Raises:



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

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