Module: MatrixSdk::Protocols::CS

Included in:
Api
Defined in:
lib/matrix_sdk/protocols/cs.rb

Overview

rubocop:disable Metrics/ModuleLength

Instance Method Summary collapse

Instance Method Details

#add_user_tag(user_id, room_id, tag, **params) ⇒ Object 



929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
 
# File 'lib/matrix_sdk/protocols/cs.rb', line 929

def add_user_tag(user_id, room_id, tag, **params)
  query = {}
  query[:user_id] = params.delete(:user_id) if protocol?(:AS) && params.key?(:user_id)

  if params[:body]
    content = params[:body]
  else
    content = {}
    content[:order] = params[:order] if params.key? :order
  end

  room_id = ERB::Util.url_encode room_id.to_s
  user_id = ERB::Util.url_encode user_id.to_s
  tag = ERB::Util.url_encode tag.to_s

  request(:put, :client_r0, "/user/#{user_id}/rooms/#{room_id}/tags/#{tag}", body: content, query: query)
end

#allowed_login_methods ⇒ Response

Gets the list of available methods for logging in

Returns:



31
32
33
 
# File 'lib/matrix_sdk/protocols/cs.rb', line 31

def 
  request(:get, :client_r0, '/login')
end

#ban_user(room_id, user_id, reason: '', **params) ⇒ Object 



883
884
885
886
887
888
889
890
891
892
893
894
 
# File 'lib/matrix_sdk/protocols/cs.rb', line 883

def ban_user(room_id, user_id, reason: '', **params)
  query = {}
  query[:user_id] = params.delete(:user_id) if protocol?(:AS) && params.key?(:user_id)

  content = {
    user_id: user_id,
    reason: reason
  }
  room_id = ERB::Util.url_encode room_id.to_s

  request(:post, :client_r0, "/rooms/#{room_id}/ban", body: content, query: query)
end

#client_api_unstable_features ⇒ Hash

Gets the list of available unstable client API features

Returns:

  • (Hash) 


19
20
21
22
23
24
25
26
27
 
# File 'lib/matrix_sdk/protocols/cs.rb', line 19

def client_api_unstable_features
  (@client_api_versions ||= request(:get, :client, '/versions')).unstable_features.tap do |vers|
    vers.instance_eval <<-'CODE', __FILE__, __LINE__ + 1
      def has?(feature)
        fetch(feature, nil)
      end
    CODE
  end
end

#client_api_versions ⇒ Array

Gets the available client API versions

Returns:

  • (Array) 


7
8
9
10
11
12
13
14
15
 
# File 'lib/matrix_sdk/protocols/cs.rb', line 7

def client_api_versions
  (@client_api_versions ||= request(:get, :client, '/versions')).versions.tap do |vers|
    vers.instance_eval <<-'CODE', __FILE__, __LINE__ + 1
      def latest
        last
      end
    CODE
  end
end

#create_filter(user_id, filter_params, **params) ⇒ Object 



999
1000
1001
1002
1003
1004
1005
1006
 
# File 'lib/matrix_sdk/protocols/cs.rb', line 999

def create_filter(user_id, filter_params, **params)
  query = {}
  query[:user_id] = params.delete(:user_id) if protocol?(:AS) && params.key?(:user_id)

  user_id = ERB::Util.url_encode user_id.to_s

  request(:post, :client_r0, "/user/#{user_id}/filter", body: filter_params, query: query)
end

#create_room(visibility: :public, **params) ⇒ Response

Creates a new room

Parameters:

  • params (Hash) —

    The room creation details

Options Hash (**params):

  • :visibility (Symbol) — default: :public —

    The room visibility

  • :room_alias (String) —

    A room alias to apply on creation

  • :invite (Boolean) —

    Should the room be created invite-only

Returns:

  • (Response) —

    A response hash with …

See Also:



207
208
209
210
211
212
213
214
215
216
217
218
219
 
# File 'lib/matrix_sdk/protocols/cs.rb', line 207

def create_room(visibility: :public, **params)
  query = {}
  query[:user_id] = params.delete(:user_id) if protocol?(:AS) && params.key?(:user_id)

  content = {
    visibility: visibility
  }
  content[:room_alias_name] = params.delete(:room_alias) if params[:room_alias]
  content[:invite] = [params.delete(:invite)].flatten if params[:invite]
  content.merge! params

  request(:post, :client_r0, '/createRoom', body: content, query: query)
end

#delete_device(device_id, auth:) ⇒ Object

Removes a device from the current user

Parameters:

  • device_id (String) —

    The device to remove

  • auth (Hash) —

    Authentication data for the removal request

Raises:

  • (MatrixNotAuthorizeedError) —

    The request did not contain enough authentication information, the data in this error will include the necessary information to perform interactive auth

See Also:



1180
1181
1182
1183
1184
 
# File 'lib/matrix_sdk/protocols/cs.rb', line 1180

def delete_device(device_id, auth:)
  device_id = ERB::Util.url_encode device_id.to_s

  request(:delete, :client_r0, "/devices/#{device_id}", body: { auth: auth })
end

#forget_room(room_id, **params) ⇒ Object 



827
828
829
830
831
832
833
834
 
# File 'lib/matrix_sdk/protocols/cs.rb', line 827

def forget_room(room_id, **params)
  query = {}
  query[:user_id] = params.delete(:user_id) if protocol?(:AS) && params.key?(:user_id)

  room_id = ERB::Util.url_encode room_id.to_s

  request(:post, :client_r0, "/rooms/#{room_id}/forget", query: query)
end

#get_account_data(user_id, type_key, **params) ⇒ Object 



947
948
949
950
951
952
953
954
955
 
# File 'lib/matrix_sdk/protocols/cs.rb', line 947

def (user_id, type_key, **params)
  query = {}
  query[:user_id] = params.delete(:user_id) if protocol?(:AS) && params.key?(:user_id)

  user_id = ERB::Util.url_encode user_id.to_s
  type_key = ERB::Util.url_encode type_key.to_s

  request(:get, :client_r0, "/user/#{user_id}/account_data/#{type_key}", query: query)
end

#get_avatar_url(user_id, **params) ⇒ Object 



1037
1038
1039
1040
1041
1042
1043
1044
 
# File 'lib/matrix_sdk/protocols/cs.rb', line 1037

def get_avatar_url(user_id, **params)
  query = {}
  query[:user_id] = params.delete(:user_id) if protocol?(:AS) && params.key?(:user_id)

  user_id = ERB::Util.url_encode user_id.to_s

  request(:get, :client_r0, "/profile/#{user_id}/avatar_url", query: query)
end

#get_device(device_id) ⇒ Response

Gets the information about a certain client device

Parameters:

  • device_id (String) —

    The ID of the device to look up

Returns:

  • (Response) —

    An object containing all available device information

See Also:



1156
1157
1158
1159
1160
 
# File 'lib/matrix_sdk/protocols/cs.rb', line 1156

def get_device(device_id)
  device_id = ERB::Util.url_encode device_id.to_s

  request(:get, :client_r0, "/devices/#{device_id}")
end

#get_devices ⇒ Response

Gets a list of the current users registered devices

Returns:

  • (Response) —

    An object including all information about the users devices.

See Also:



1147
1148
1149
 
# File 'lib/matrix_sdk/protocols/cs.rb', line 1147

def get_devices
  request(:get, :client_r0, '/devices')
end

#get_display_name(user_id, **params) ⇒ Object 



1015
1016
1017
1018
1019
1020
1021
1022
 
# File 'lib/matrix_sdk/protocols/cs.rb', line 1015

def get_display_name(user_id, **params)
  query = {}
  query[:user_id] = params.delete(:user_id) if protocol?(:AS) && params.key?(:user_id)

  user_id = ERB::Util.url_encode user_id.to_s

  request(:get, :client_r0, "/profile/#{user_id}/displayname", query: query)
end

#get_download_url(mxcurl, source: nil, **_params) ⇒ URI

Converts a Matrix content URL (mxc://) to a media download URL

Examples:

Converting a MXC URL

url = 'mxc://example.com/media_hash'

api.get_download_url(url)
# => #<URI::HTTPS https://example.com/_matrix/media/r0/download/example.com/media_hash>
api.get_download_url(url, source: 'matrix.org')
# => #<URI::HTTPS https://matrix.org/_matrix/media/r0/download/example.com/media_hash>

Parameters:

  • mxcurl (String, URI) —

    The Matrix content URL to convert

  • source (String, URI) (defaults to: nil) —

    A source HS to use for the convertion, defaults to the connected HS

Returns:

  • (URI) —

    The full download URL for the requested piece of media



1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
 
# File 'lib/matrix_sdk/protocols/cs.rb', line 1080

def get_download_url(mxcurl, source: nil, **_params)
  mxcurl = URI.parse(mxcurl.to_s) unless mxcurl.is_a? URI
  raise 'Not a mxc:// URL' unless mxcurl.is_a? URI::MATRIX

  source ||= homeserver.dup
  source = URI(hs.to_s) unless hs.is_a? URI
  source.tap do |u|
    full_path = ERB::Util.url_encode mxcurl.full_path.to_s
    u.path = "/_matrix/media/r0/download/#{full_path}"
  end
end

#get_filter(user_id, filter_id, **params) ⇒ Object 



989
990
991
992
993
994
995
996
997
 
# File 'lib/matrix_sdk/protocols/cs.rb', line 989

def get_filter(user_id, filter_id, **params)
  query = {}
  query[:user_id] = params.delete(:user_id) if protocol?(:AS) && params.key?(:user_id)

  user_id = ERB::Util.url_encode user_id.to_s
  filter_id = ERB::Util.url_encode filter_id.to_s

  request(:get, :client_r0, "/user/#{user_id}/filter/#{filter_id}", query: query)
end

#get_joined_rooms(**params) ⇒ Response

Gets the list of rooms joined by the current user

Returns:

  • (Response) —

    An array of room IDs under the key :joined_rooms

See Also:



159
160
161
162
163
164
 
# File 'lib/matrix_sdk/protocols/cs.rb', line 159

def get_joined_rooms(**params)
  query = {}
  query[:user_id] = params.delete(:user_id) if protocol?(:AS) && params.key?(:user_id)

  request(:get, :client_r0, '/joined_rooms', query: query)
end

#get_membership(room_id, user_id, **params) ⇒ Object 



862
863
864
865
866
867
868
869
870
 
# File 'lib/matrix_sdk/protocols/cs.rb', line 862

def get_membership(room_id, user_id, **params)
  query = {}
  query[:user_id] = params.delete(:user_id) if protocol?(:AS) && params.key?(:user_id)

  room_id = ERB::Util.url_encode room_id.to_s
  user_id = ERB::Util.url_encode user_id.to_s

  request(:get, :client_r0, "/rooms/#{room_id}/state/m.room.member/#{user_id}", query: query)
end

#get_profile(user_id, **params) ⇒ Object 



1059
1060
1061
1062
1063
1064
1065
1066
 
# File 'lib/matrix_sdk/protocols/cs.rb', line 1059

def get_profile(user_id, **params)
  query = {}
  query[:user_id] = params.delete(:user_id) if protocol?(:AS) && params.key?(:user_id)

  user_id = ERB::Util.url_encode user_id.to_s

  request(:get, :client_r0, "/profile/#{user_id}", query: query)
end

#get_public_rooms(server: nil, **params) ⇒ Response

Gets the list of public rooms on a Matrix server

Parameters:

  • limit (Integer) —

    Limits the number of results returned

  • since (String) —

    A pagination token received from an earlier call

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

    The Matrix server to request public rooms from

Returns:

  • (Response) —

    An array of public rooms in the :chunk key, along with :next_batch, :prev_batch, and :total_room_count_estimate for pagination

See Also:



176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
 
# File 'lib/matrix_sdk/protocols/cs.rb', line 176

def get_public_rooms(server: nil, **params)
  query = {
    server: server
  }.compact
  body = nil
  method = :get

  if !params[:filter].nil? || !params[:include_all_networks].nil? || !params[:third_party_instance_id].nil?
    body = {
      limit: params[:limit],
      since: params[:since],
      filter: params[:filter],
      include_all_networks: params[:include_all_networks],
      third_party_instance_id: params[:third_party_instance_id]
    }.merge(params).compact
    method = :post
  else
    query = query.merge(params).compact
  end

  request(method, :client_r0, '/publicRooms', query: query, body: body)
end

#get_room_account_data(user_id, room_id, type_key, **params) ⇒ Object 



967
968
969
970
971
972
973
974
975
976
 
# File 'lib/matrix_sdk/protocols/cs.rb', line 967

def (user_id, room_id, type_key, **params)
  query = {}
  query[:user_id] = params.delete(:user_id) if protocol?(:AS) && params.key?(:user_id)

  user_id = ERB::Util.url_encode user_id.to_s
  room_id = ERB::Util.url_encode room_id.to_s
  type_key = ERB::Util.url_encode type_key.to_s

  request(:get, :client_r0, "/user/#{user_id}/rooms/#{room_id}/account_data/#{type_key}", query: query)
end

#get_room_aliases(room_id, **params) ⇒ Response

Gets a list of current aliases of a room

Examples:

Looking up aliases for a room

api.get_room_aliases('!QtykxKocfZaZOUrTwp:matrix.org')
# MatrixSdk::MatrixNotFoundError: HTTP 404 (M_NOT_FOUND): Event not found.
api.get_room_aliases('!QtykxKocfZaZOUrTwp:matrix.org', key: 'matrix.org')
# => {:aliases=>["#matrix:matrix.org"]}
api.get_room_aliases('!QtykxKocfZaZOUrTwp:matrix.org', key: 'kittenface.studio')
# => {:aliases=>["#worlddominationhq:kittenface.studio"]}

A way to find all aliases for a room

api.get_room_state('!mjbDjyNsRXndKLkHIe:matrix.org')
   .select { |ch| ch[:type] == 'm.room.aliases' }
   .map { |ch| ch[:content][:aliases] }
   .flatten
   .compact
# => ["#synapse:im.kabi.tk", "#synapse:matrix.org", "#synapse-community:matrix.org", "#synapse-ops:matrix.org", "#synops:matrix.org", ...

Parameters:

  • room_id (MXID, String) —

    The room ID to look up

  • params (Hash) —

    Extra options to provide to the request, see #get_room_state

Returns:

  • (Response) —

    A response hash with the array :aliases

Raises:

See Also:



600
601
602
 
# File 'lib/matrix_sdk/protocols/cs.rb', line 600

def get_room_aliases(room_id, **params)
  get_room_state(room_id, 'm.room.aliases', params)
end

#get_room_avatar(room_id, **params) ⇒ Response

Gets the current avatar URL of a room

Parameters:

  • room_id (MXID, String) —

    The room ID to look up

  • params (Hash) —

    Extra options to provide to the request, see #get_room_state

Returns:

  • (Response) —

    A response hash with the parameters :url and (optionally) :info

Raises:

See Also:



558
559
560
 
# File 'lib/matrix_sdk/protocols/cs.rb', line 558

def get_room_avatar(room_id, **params)
  get_room_state(room_id, 'm.room.avatar', params)
end

#get_room_creation_info(room_id, **params) ⇒ Response

Gets the creation configuration object for a room

Parameters:

  • room_id (MXID, String) —

    The room ID to look up

  • params (Hash) —

    Extra options to provide to the request, see #get_room_state

Returns:

  • (Response) —

    A response hash with the configuration the room was created for

See Also:



723
724
725
 
# File 'lib/matrix_sdk/protocols/cs.rb', line 723

def get_room_creation_info(room_id, **params)
  get_room_state(room_id, 'm.room.create', params)
end

#get_room_encryption_settings(room_id, **params) ⇒ Response

Gets the encryption configuration for a room

Parameters:

  • room_id (MXID, String) —

    The room ID to look up

  • params (Hash) —

    Extra options to provide to the request, see #get_room_state

Returns:

  • (Response) —

    A response hash with the configuration the room was created for

See Also:



735
736
737
 
# File 'lib/matrix_sdk/protocols/cs.rb', line 735

def get_room_encryption_settings(room_id, **params)
  get_room_state(room_id, 'm.room.encryption', params)
end

#get_room_guest_access(room_id, **params) ⇒ Response

Gets the guest access settings for a room

Parameters:

  • room_id (MXID, String) —

    The room ID to look up

  • params (Hash) —

    Extra options to provide to the request, see #get_room_state

Returns:

  • (Response) —

    A response hash with the key :guest_acces, either :can_join or :forbidden

See Also:



695
696
697
 
# File 'lib/matrix_sdk/protocols/cs.rb', line 695

def get_room_guest_access(room_id, **params)
  get_room_state(room_id, 'm.room.guest_access', params)
end

#get_room_history_visibility(room_id, **params) ⇒ Response

Gets the history availabiilty for a room

Parameters:

  • room_id (MXID, String) —

    The room ID to look up

  • params (Hash) —

    Extra options to provide to the request, see #get_room_state

Returns:

  • (Response) —

    A response hash with the key :history_visibility

See Also:



766
767
768
 
# File 'lib/matrix_sdk/protocols/cs.rb', line 766

def get_room_history_visibility(room_id, **params)
  get_room_state(room_id, 'm.room.history_visibility', params)
end

#get_room_id(room_alias, **params) ⇒ Response

Gets the room ID for an alias

Parameters:

  • room_alias (String, MXID) —

    The room alias to look up

Returns:

  • (Response) —

    An object containing the :room_id key and a key of :servers that know of the room

Raises:



1096
1097
1098
1099
1100
1101
1102
1103
 
# File 'lib/matrix_sdk/protocols/cs.rb', line 1096

def get_room_id(room_alias, **params)
  query = {}
  query[:user_id] = params.delete(:user_id) if protocol?(:AS) && params.key?(:user_id)

  room_alias = ERB::Util.url_encode room_alias.to_s

  request(:get, :client_r0, "/directory/room/#{room_alias}", query: query)
end

#get_room_join_rules(room_id, **params) ⇒ Response

Gets the join rules for a room

Parameters:

  • room_id (MXID, String) —

    The room ID to look up

  • params (Hash) —

    Extra options to provide to the request, see #get_room_state

Returns:

  • (Response) —

    A response hash with the key :join_rule

See Also:



667
668
669
 
# File 'lib/matrix_sdk/protocols/cs.rb', line 667

def get_room_join_rules(room_id, **params)
  get_room_state(room_id, 'm.room.join_rules', params)
end

#get_room_members(room_id, **params) ⇒ Object 



1134
1135
1136
1137
1138
1139
1140
1141
 
# File 'lib/matrix_sdk/protocols/cs.rb', line 1134

def get_room_members(room_id, **params)
  query = {}
  query[:user_id] = params.delete(:user_id) if protocol?(:AS) && params.key?(:user_id)

  room_id = ERB::Util.url_encode room_id.to_s

  request(:get, :client_r0, "/rooms/#{room_id}/members", query: query)
end

#get_room_messages(room_id, token, direction, limit: 10, **params) ⇒ Response

Retrieve additional messages in a room

Parameters:

  • room_id (MXID, String) —

    The room ID to retrieve messages for

  • token (String) —

    The token to start retrieving from, can be from a sync or from an earlier get_room_messages call

  • direction (:b, :f) —

    The direction to retrieve messages

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

    (10) The limit of messages to retrieve

  • params (Hash) —

    Additional options for the request

Options Hash (**params):

  • :to (String) —

    A token to limit retrieval to

  • :filter (String) —

    A filter to limit the retrieval to

Returns:

  • (Response) —

    A response hash with the message information containing :start, :end, and :chunk fields

See Also:



457
458
459
460
461
462
463
464
465
466
467
468
469
470
 
# File 'lib/matrix_sdk/protocols/cs.rb', line 457

def get_room_messages(room_id, token, direction, limit: 10, **params)
  query = {
    from: token,
    dir: direction,
    limit: limit
  }
  query[:to] = params[:to] if params.key? :to
  query[:filter] = params.fetch(:filter) if params.key? :filter
  query[:user_id] = params.delete(:user_id) if protocol?(:AS) && params.key?(:user_id)

  room_id = ERB::Util.url_encode room_id.to_s

  request(:get, :client_r0, "/rooms/#{room_id}/messages", query: query)
end

#get_room_name(room_id, **params) ⇒ Response

Gets the current display name of a room

Parameters:

  • room_id (MXID, String) —

    The room ID to look up

  • params (Hash) —

    Extra options to provide to the request, see #get_room_state

Returns:

  • (Response) —

    A response hash with the parameter :name

Raises:

See Also:



502
503
504
 
# File 'lib/matrix_sdk/protocols/cs.rb', line 502

def get_room_name(room_id, **params)
  get_room_state(room_id, 'm.room.name', params)
end

#get_room_pinned_events(room_id, **params) ⇒ Response

Gets a list of pinned events in a room

Parameters:

  • room_id (MXID, String) —

    The room ID to look up

  • params (Hash) —

    Extra options to provide to the request, see #get_room_state

Returns:

  • (Response) —

    A response hash with the array :pinned

Raises:

See Also:



613
614
615
 
# File 'lib/matrix_sdk/protocols/cs.rb', line 613

def get_room_pinned_events(room_id, **params)
  get_room_state(room_id, 'm.room.pinned_events', params)
end

#get_room_power_levels(room_id, **params) ⇒ Response Also known as: get_power_levels

Gets the configured power levels for a room

Parameters:

  • room_id (MXID, String) —

    The room ID to look up

  • params (Hash) —

    Extra options to provide to the request, see #get_room_state

Returns:

  • (Response) —

    A response hash with power level information

See Also:



640
641
642
 
# File 'lib/matrix_sdk/protocols/cs.rb', line 640

def get_room_power_levels(room_id, **params)
  get_room_state(room_id, 'm.room.power_levels', params)
end

#get_room_server_acl(room_id, **params) ⇒ Response

Gets the server ACLs for a room

Parameters:

  • room_id (MXID, String) —

    The room ID to look up

  • params (Hash) —

    Extra options to provide to the request, see #get_room_state

Returns:

  • (Response) —

    A response hash with server ACL information

See Also:



794
795
796
 
# File 'lib/matrix_sdk/protocols/cs.rb', line 794

def get_room_server_acl(room_id, **params)
  get_room_state(room_id, 'm.room.server_acl', params)
end

#get_room_state(room_id, state_type = nil, key: nil, **params) ⇒ Response

Reads the latest instance of a room state event

Parameters:

  • room_id (MXID, String) —

    The room ID to read from

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

    The state type to read

Returns:

  • (Response) —

    A response hash with the contents of the state event

See Also:



479
480
481
482
483
484
485
486
487
488
 
# File 'lib/matrix_sdk/protocols/cs.rb', line 479

def get_room_state(room_id, state_type = nil, key: nil, **params)
  query = {}
  query[:user_id] = params.delete(:user_id) if protocol?(:AS) && params.key?(:user_id)

  room_id = ERB::Util.url_encode room_id.to_s
  state_type = ERB::Util.url_encode state_type.to_s
  key = ERB::Util.url_encode key.to_s

  request(:get, :client_r0, "/rooms/#{room_id}/state#{state_type.empty? ? nil : "/#{state_type}"}#{key.empty? ? nil : "/#{key}"}", query: query)
end

#get_room_topic(room_id, **params) ⇒ Response

Gets the current topic of a room

Parameters:

  • room_id (MXID, String) —

    The room ID to look up

  • params (Hash) —

    Extra options to provide to the request, see #get_room_state

Returns:

  • (Response) —

    A response hash with the parameter :topic

Raises:

See Also:



530
531
532
 
# File 'lib/matrix_sdk/protocols/cs.rb', line 530

def get_room_topic(room_id, **params)
  get_room_state(room_id, 'm.room.topic', params)
end

#get_user_tags(user_id, room_id, **params) ⇒ Object 



908
909
910
911
912
913
914
915
916
 
# File 'lib/matrix_sdk/protocols/cs.rb', line 908

def get_user_tags(user_id, room_id, **params)
  query = {}
  query[:user_id] = params.delete(:user_id) if protocol?(:AS) && params.key?(:user_id)

  room_id = ERB::Util.url_encode room_id.to_s
  user_id = ERB::Util.url_encode user_id.to_s

  request(:get, :client_r0, "/user/#{user_id}/rooms/#{room_id}/tags", query: query)
end

#invite_user(room_id, user_id, **params) ⇒ Object 



836
837
838
839
840
841
842
843
844
845
846
847
 
# File 'lib/matrix_sdk/protocols/cs.rb', line 836

def invite_user(room_id, user_id, **params)
  query = {}
  query[:user_id] = params.delete(:user_id) if protocol?(:AS) && params.key?(:user_id)

  content = {
    user_id: user_id
  }

  room_id = ERB::Util.url_encode room_id.to_s

  request(:post, :client_r0, "/rooms/#{room_id}/invite", body: content, query: query)
end

#join_room(id_or_alias, **params) ⇒ Response

TODO:

Add support for 3rd-party signed objects

Joins a room

Parameters:

  • id_or_alias (MXID, String) —

    The room ID or Alias to join

  • params (Hash) —

    Extra room join options

Options Hash (**params):

  • :server_name (String[]) —

    A list of servers to perform the join through

Returns:

  • (Response) —

    A response hash with the parameter :room_id

See Also:



229
230
231
232
233
234
235
236
237
238
239
240
 
# File 'lib/matrix_sdk/protocols/cs.rb', line 229

def join_room(id_or_alias, **params)
  query = {}
  query[:server_name] = params[:server_name] if params[:server_name]
  query[:user_id] = params.delete(:user_id) if protocol?(:AS) && params.key?(:user_id)

  # id_or_alias = MXID.new id_or_alias.to_s unless id_or_alias.is_a? MXID
  # raise ArgumentError, 'Not a room ID or alias' unless id_or_alias.room?

  id_or_alias = ERB::Util.url_encode id_or_alias.to_s

  request(:post, :client_r0, "/join/#{id_or_alias}", query: query)
end

#keys_query(timeout: nil, device_keys:, token: nil, **params) ⇒ Object

Run a query for device keys

Examples:

Looking up all the device keys for a user

api.keys_query(device_keys: { '@alice:example.com': [] })
# => { :device_keys => { :'@alice:example.com' => { :JLAFKJWSCS => { ...

Looking up a specific device for a user

api.keys_query(device_keys: { '@alice:example.com': ['ABCDEFGHIJ'] })
# => { :device_keys => { :'@alice:example.com' => { :ABCDEFGHIJ => { ...

Parameters:

  • timeout (Numeric) (defaults to: nil) —

    The timeout - in seconds - for the query

  • device_keys (Array) —

    The list of devices to query

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

    The sync token that led to this query - if any

  • params (Hash) —

    Additional parameters

Options Hash (**params):

  • timeout_ms (Integer) —

    The timeout in milliseconds for the query, overrides timeout

See Also:



1200
1201
1202
1203
1204
1205
1206
1207
1208
1209
 
# File 'lib/matrix_sdk/protocols/cs.rb', line 1200

def keys_query(timeout: nil, device_keys:, token: nil, **params)
  body = {
    timeout: (timeout || 10) * 1000,
    device_keys: device_keys
  }
  body[:timeout] = params[:timeout_ms] if params.key? :timeout_ms
  body[:token] = token if token

  request(:post, :client_r0, '/keys/query', body: body)
end

#kick_user(room_id, user_id, reason: '', **params) ⇒ Object 



849
850
851
852
853
854
855
856
857
858
859
860
 
# File 'lib/matrix_sdk/protocols/cs.rb', line 849

def kick_user(room_id, user_id, reason: '', **params)
  query = {}
  query[:user_id] = params.delete(:user_id) if protocol?(:AS) && params.key?(:user_id)

  content = {
    user_id: user_id,
    reason: reason
  }
  room_id = ERB::Util.url_encode room_id.to_s

  request(:post, :client_r0, "/rooms/#{room_id}/kick", body: content, query: query)
end

#leave_room(room_id, **params) ⇒ Object 



818
819
820
821
822
823
824
825
 
# File 'lib/matrix_sdk/protocols/cs.rb', line 818

def leave_room(room_id, **params)
  query = {}
  query[:user_id] = params.delete(:user_id) if protocol?(:AS) && params.key?(:user_id)

  room_id = ERB::Util.url_encode room_id.to_s

  request(:post, :client_r0, "/rooms/#{room_id}/leave", query: query)
end

#login(login_type: 'm.login.password', **params) ⇒ Response

Logs in using the client API /login endpoint, and optionally stores the resulting access for API usage

Examples:

Logging in with username and password

api.(user: 'example', password: 'NotARealPass')
# => { user_id: '@example:matrix.org', access_token: '...', home_server: 'matrix.org', device_id: 'ABCD123' }
api.whoami?
# => { user_id: '@example:matrix.org' }

Advanced login, without storing details

api.whoami?
# => { user_id: '@example:matrix.org' }
api.(medium: 'email', address: '[email protected]', password: '...', store_token: false)
# => { user_id: '@someone:matrix.org', access_token: ...
api.whoami?.user_id
# => '@example:matrix.org'

Parameters:

  • login_type (String) (defaults to: 'm.login.password') —

    (‘m.login.password’) The type of login to attempt

  • params (Hash) —

    The login information to use, along with options for said log in

Options Hash (**params):

  • :store_token (Boolean) — default: true —

    Should the resulting access token be stored for the API

  • :store_device_id (Boolean) — default: store_token value —

    Should the resulting device ID be stored for the API

  • :initial_device_display_name (String) — default: USER_AGENT —

    The device display name to specify for this login attempt

  • :device_id (String) —

    The device ID to set on the login

Returns:

  • (Response) —

    A response hash with the parameters :user_id, :access_token, :home_server, and :device_id.

See Also:



124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
 
# File 'lib/matrix_sdk/protocols/cs.rb', line 124

def (login_type: 'm.login.password', **params)
  query = {}
  query[:user_id] = params.delete(:user_id) if protocol?(:AS) && params.key?(:user_id)

  options = {}
  options[:store_token] = params.delete(:store_token) { true }
  options[:store_device_id] = params.delete(:store_device_id) { options[:store_token] }

  data = {
    type: ,
    initial_device_display_name: params.delete(:initial_device_display_name) { MatrixSdk::Api::USER_AGENT }
  }.merge params
  data[:device_id] = device_id if device_id

  request(:post, :client_r0, '/login', body: data, query: query).tap do |resp|
    @access_token = resp.token if resp.key?(:token) && options[:store_token]
    @device_id = resp.device_id if resp.key?(:device_id) && options[:store_device_id]
  end
end

#logout(**params) ⇒ Response

Logs out the currently logged in user

Returns:

  • (Response) —

    An empty response if the logout was successful

See Also:



148
149
150
151
152
153
 
# File 'lib/matrix_sdk/protocols/cs.rb', line 148

def logout(**params)
  query = {}
  query[:user_id] = params.delete(:user_id) if protocol?(:AS) && params.key?(:user_id)

  request(:post, :client_r0, '/logout', query: query)
end

#media_upload(content, content_type, **params) ⇒ Object 



1008
1009
1010
1011
1012
1013
 
# File 'lib/matrix_sdk/protocols/cs.rb', line 1008

def media_upload(content, content_type, **params)
  query = {}
  query[:user_id] = params.delete(:user_id) if protocol?(:AS) && params.key?(:user_id)

  request(:post, :media_r0, '/upload', body: content, headers: { 'content-type' => content_type }, query: query)
end

#redact_event(room_id, event_id, **params) ⇒ Response

Redact an event in a room

Parameters:

  • room_id (MXID, String) —

    The room ID to send the message event to

  • event_id (String) —

    The event ID of the event to redact

  • params (Hash) —

    Options for the request

Options Hash (**params):

  • :reason (String) —

    The reason for the redaction

  • :txn_id (Integer) —

    The ID of the transaction, or automatically generated

Returns:

  • (Response) —

    A response hash with the parameter :event_id

See Also:



295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
 
# File 'lib/matrix_sdk/protocols/cs.rb', line 295

def redact_event(room_id, event_id, **params)
  query = {}
  query[:user_id] = params.delete(:user_id) if protocol?(:AS) && params.key?(:user_id)

  content = {}
  content[:reason] = params[:reason] if params[:reason]

  txn_id = transaction_id
  txn_id = params.fetch(:txn_id, "#{txn_id}#{Time.now.to_i}")

  room_id = ERB::Util.url_encode room_id.to_s
  event_id = ERB::Util.url_encode event_id.to_s
  txn_id = ERB::Util.url_encode txn_id.to_s

  request(:put, :client_r0, "/rooms/#{room_id}/redact/#{event_id}/#{txn_id}", body: content, query: query)
end

#register(kind: 'user', **params) ⇒ Response

Registers a user using the client API /register endpoint

Examples:

Regular user registration and login

api.register(username: 'example', password: 'NotARealPass')
# => { user_id: '@example:matrix.org', access_token: '...', home_server: 'matrix.org', device_id: 'ABCD123' }
api.whoami?
# => { user_id: '@example:matrix.org' }

Parameters:

  • kind (String, Symbol) (defaults to: 'user') —

    (‘user’) The kind of registration to use

  • params (Hash) —

    The registration information, all not handled by Ruby will be passed as JSON in the body

Options Hash (**params):

  • :store_token (Boolean) — default: true —

    Should the resulting access token be stored for the API

  • :store_device_id (Boolean) — default: store_token value —

    Should the resulting device ID be stored for the API

Returns:

See Also:



72
73
74
75
76
77
78
79
80
81
82
83
84
 
# File 'lib/matrix_sdk/protocols/cs.rb', line 72

def register(kind: 'user', **params)
  query = {}
  query[:kind] = kind
  query[:user_id] = params.delete(:user_id) if protocol?(:AS) && params.key?(:user_id)

  store_token = params.delete(:store_token) { !protocol?(:AS) }
  store_device_id = params.delete(:store_device_id) { store_token }

  request(:post, :client_r0, '/register', body: params, query: query).tap do |resp|
    @access_token = resp.token if resp.key?(:token) && store_token
    @device_id = resp.device_id if resp.key?(:device_id) && store_device_id
  end
end

#remove_room_alias(room_alias, **params) ⇒ Response

Remove an alias from its room

Parameters:

  • room_alias (String, MXID) —

    The alias to remove

Returns:

  • (Response) —

    An empty object denoting success



1125
1126
1127
1128
1129
1130
1131
1132
 
# File 'lib/matrix_sdk/protocols/cs.rb', line 1125

def remove_room_alias(room_alias, **params)
  query = {}
  query[:user_id] = params.delete(:user_id) if protocol?(:AS) && params.key?(:user_id)

  room_alias = ERB::Util.url_encode room_alias.to_s

  request(:delete, :client_r0, "/directory/room/#{room_alias}", query: query)
end

#remove_user_tag(user_id, room_id, tag, **params) ⇒ Object 



918
919
920
921
922
923
924
925
926
927
 
# File 'lib/matrix_sdk/protocols/cs.rb', line 918

def remove_user_tag(user_id, room_id, tag, **params)
  query = {}
  query[:user_id] = params.delete(:user_id) if protocol?(:AS) && params.key?(:user_id)

  room_id = ERB::Util.url_encode room_id.to_s
  user_id = ERB::Util.url_encode user_id.to_s
  tag = ERB::Util.url_encode tag.to_s

  request(:delete, :client_r0, "/user/#{user_id}/rooms/#{room_id}/tags/#{tag}", query: query)
end

#send_content(room_id, url, name, msg_type, **params) ⇒ Response

Send a content message to a room

Examples:

Sending an image to a room

send_content('!abcd123:localhost',
             'mxc://localhost/1234567',
             'An image of a cat',
             'm.image',
             extra_information: {
               h: 128,
               w: 128,
               mimetype: 'image/png',
               size: 1024
             })

Sending a file to a room

send_content('!example:localhost',
             'mxc://localhost/fileurl',
             'Contract.pdf',
             'm.file',
             extra_content: {
               filename: 'contract.pdf'
             },
             extra_information: {
               mimetype: 'application/pdf',
               size: 96674
             })

Parameters:

  • room_id (MXID, String) —

    The room ID to send the content to

  • url (URI, String) —

    The URL to the content

  • name (String) —

    The name of the content

  • msg_type (String) —

    The message type of the content

  • params (Hash) —

    Options for the request

Options Hash (**params):

  • :extra_information (Hash) — default: {} —

    Extra information for the content

  • :extra_content (Hash) —

    Extra data to insert into the content hash

Returns:

  • (Response) —

    A response hash with the parameter :event_id

See Also:



353
354
355
356
357
358
359
360
361
362
363
 
# File 'lib/matrix_sdk/protocols/cs.rb', line 353

def send_content(room_id, url, name, msg_type, **params)
  content = {
    url: url,
    msgtype: msg_type,
    body: name,
    info: params.delete(:extra_information) { {} }
  }
  content.merge!(params.fetch(:extra_content)) if params.key? :extra_content

  send_message_event(room_id, 'm.room.message', content, params)
end

#send_emote(room_id, emote, **params) ⇒ Response

Send a plaintext emote to a room

Parameters:

  • room_id (MXID, String) —

    The room ID to send the message to

  • emote (String) —

    The emote to send

  • params (Hash) —

    Options for the request

Options Hash (**params):

  • :msg_type (String) — default: 'm.emote' —

    The message type to send

Returns:

  • (Response) —

    A response hash with the parameter :event_id

See Also:



419
420
421
422
423
424
425
 
# File 'lib/matrix_sdk/protocols/cs.rb', line 419

def send_emote(room_id, emote, **params)
  content = {
    msgtype: params.delete(:msg_type) { 'm.emote' },
    body: emote
  }
  send_message_event(room_id, 'm.room.message', content, params)
end

#send_location(room_id, geo_uri, name, **params) ⇒ Response

Send a geographic location to a room

Parameters:

  • room_id (MXID, String) —

    The room ID to send the location to

  • geo_uri (URI, String) —

    The geographical URI to send

  • name (String) —

    The name of the location

  • params (Hash) —

    Options for the request

Options Hash (**params):

  • :extra_information (Hash) — default: {} —

    Extra information for the location

  • :thumbnail_url (URI, String) —

    The URL to a thumbnail of the location

  • :thumbnail_info (Hash) —

    Image information about the location thumbnail

Returns:

  • (Response) —

    A response hash with the parameter :event_id

See Also:



378
379
380
381
382
383
384
385
386
387
388
389
 
# File 'lib/matrix_sdk/protocols/cs.rb', line 378

def send_location(room_id, geo_uri, name, **params)
  content = {
    geo_uri: geo_uri,
    msgtype: 'm.location',
    body: name,
    info: params.delete(:extra_information) { {} }
  }
  content[:info][:thumbnail_url] = params.delete(:thumbnail_url) if params.key? :thumbnail_url
  content[:info][:thumbnail_info] = params.delete(:thumbnail_info) if params.key? :thumbnail_info

  send_message_event(room_id, 'm.room.message', content, params)
end

#send_message(room_id, message, **params) ⇒ Response

Send a plaintext message to a room

Parameters:

  • room_id (MXID, String) —

    The room ID to send the message to

  • message (String) —

    The message to send

  • params (Hash) —

    Options for the request

Options Hash (**params):

  • :msg_type (String) — default: 'm.text' —

    The message type to send

Returns:

  • (Response) —

    A response hash with the parameter :event_id

See Also:



401
402
403
404
405
406
407
 
# File 'lib/matrix_sdk/protocols/cs.rb', line 401

def send_message(room_id, message, **params)
  content = {
    msgtype: params.delete(:msg_type) { 'm.text' },
    body: message
  }
  send_message_event(room_id, 'm.room.message', content, params)
end

#send_message_event(room_id, event_type, content, **params) ⇒ Response

Sends a message event to a room

Parameters:

  • room_id (MXID, String) —

    The room ID to send the message event to

  • event_type (String) —

    The event type of the message

  • content (Hash) —

    The contents of the message

  • params (Hash) —

    Options for the request

Options Hash (**params):

  • :txn_id (Integer) —

    The ID of the transaction, or automatically generated

Returns:

  • (Response) —

    A response hash with the parameter :event_id

See Also:



272
273
274
275
276
277
278
279
280
281
282
283
284
 
# File 'lib/matrix_sdk/protocols/cs.rb', line 272

def send_message_event(room_id, event_type, content, **params)
  query = {}
  query[:user_id] = params.delete(:user_id) if protocol?(:AS) && params.key?(:user_id)

  txn_id = transaction_id
  txn_id = params.fetch(:txn_id, "#{txn_id}#{Time.now.to_i}")

  room_id = ERB::Util.url_encode room_id.to_s
  event_type = ERB::Util.url_encode event_type.to_s
  txn_id = ERB::Util.url_encode txn_id.to_s

  request(:put, :client_r0, "/rooms/#{room_id}/send/#{event_type}/#{txn_id}", body: content, query: query)
end

#send_notice(room_id, notice, **params) ⇒ Response

Send a plaintext notice to a room

Parameters:

  • room_id (MXID, String) —

    The room ID to send the message to

  • notice (String) —

    The notice to send

  • params (Hash) —

    Options for the request

Options Hash (**params):

  • :msg_type (String) — default: 'm.notice' —

    The message type to send

Returns:

  • (Response) —

    A response hash with the parameter :event_id

See Also:



437
438
439
440
441
442
443
 
# File 'lib/matrix_sdk/protocols/cs.rb', line 437

def send_notice(room_id, notice, **params)
  content = {
    msgtype: params.delete(:msg_type) { 'm.notice' },
    body: notice
  }
  send_message_event(room_id, 'm.room.message', content, params)
end

#send_state_event(room_id, event_type, content, **params) ⇒ Response

Sends a state event to a room

Parameters:

  • room_id (MXID, String) —

    The room ID to send the state event to

  • event_type (String) —

    The event type to send

  • content (Hash) —

    The contents of the state event

  • params (Hash) —

    Options for the request

Options Hash (**params):

  • :state_key (String) —

    The state key of the event, if there is one

Returns:

  • (Response) —

    A response hash with the parameter :event_id

See Also:



252
253
254
255
256
257
258
259
260
261
 
# File 'lib/matrix_sdk/protocols/cs.rb', line 252

def send_state_event(room_id, event_type, content, **params)
  query = {}
  query[:user_id] = params.delete(:user_id) if protocol?(:AS) && params.key?(:user_id)

  room_id = ERB::Util.url_encode room_id.to_s
  event_type = ERB::Util.url_encode event_type.to_s
  state_key = ERB::Util.url_encode params[:state_key].to_s if params.key? :state_key

  request(:put, :client_r0, "/rooms/#{room_id}/state/#{event_type}#{"/#{state_key}" unless state_key.nil?}", body: content, query: query)
end

#set_account_data(user_id, type_key, account_data, **params) ⇒ Object 



957
958
959
960
961
962
963
964
965
 
# File 'lib/matrix_sdk/protocols/cs.rb', line 957

def (user_id, type_key, , **params)
  query = {}
  query[:user_id] = params.delete(:user_id) if protocol?(:AS) && params.key?(:user_id)

  user_id = ERB::Util.url_encode user_id.to_s
  type_key = ERB::Util.url_encode type_key.to_s

  request(:put, :client_r0, "/user/#{user_id}/account_data/#{type_key}", body: , query: query)
end

#set_avatar_url(user_id, url, **params) ⇒ Object 



1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
 
# File 'lib/matrix_sdk/protocols/cs.rb', line 1046

def set_avatar_url(user_id, url, **params)
  query = {}
  query[:user_id] = params.delete(:user_id) if protocol?(:AS) && params.key?(:user_id)

  content = {
    avatar_url: url
  }

  user_id = ERB::Util.url_encode user_id.to_s

  request(:put, :client_r0, "/profile/#{user_id}/avatar_url", body: content, query: query)
end

#set_device(device_id, display_name:) ⇒ Object

Sets the metadata for a device

Parameters:

  • device_id (String) —

    The ID of the device to modify

  • display_name (String) —

    The new display name to set for the device

See Also:



1167
1168
1169
1170
1171
 
# File 'lib/matrix_sdk/protocols/cs.rb', line 1167

def set_device(device_id, display_name:)
  device_id = ERB::Util.url_encode device_id.to_s

  request(:put, :client_r0, "/devices/#{device_id}", body: { display_name: display_name })
end

#set_display_name(user_id, display_name, **params) ⇒ Object 



1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
 
# File 'lib/matrix_sdk/protocols/cs.rb', line 1024

def set_display_name(user_id, display_name, **params)
  query = {}
  query[:user_id] = params.delete(:user_id) if protocol?(:AS) && params.key?(:user_id)

  content = {
    displayname: display_name
  }

  user_id = ERB::Util.url_encode user_id.to_s

  request(:put, :client_r0, "/profile/#{user_id}/displayname", body: content, query: query)
end

#set_membership(room_id, user_id, membership, reason: '', **params) ⇒ Object 



872
873
874
875
876
877
878
879
880
881
 
# File 'lib/matrix_sdk/protocols/cs.rb', line 872

def set_membership(room_id, user_id, membership, reason: '', **params)
  content = {
    membership: membership,
    reason: reason
  }
  content[:displayname] = params.delete(:displayname) if params.key? :displayname
  content[:avatar_url] = params.delete(:avatar_url) if params.key? :avatar_url

  send_state_event(room_id, 'm.room.member', content, params.merge(state_key: user_id))
end

#set_room_account_data(user_id, room_id, type_key, account_data, **params) ⇒ Object 



978
979
980
981
982
983
984
985
986
987
 
# File 'lib/matrix_sdk/protocols/cs.rb', line 978

def (user_id, room_id, type_key, , **params)
  query = {}
  query[:user_id] = params.delete(:user_id) if protocol?(:AS) && params.key?(:user_id)

  user_id = ERB::Util.url_encode user_id.to_s
  room_id = ERB::Util.url_encode room_id.to_s
  type_key = ERB::Util.url_encode type_key.to_s

  request(:put, :client_r0, "/user/#{user_id}/rooms/#{room_id}/account_data/#{type_key}", body: , query: query)
end

#set_room_alias(room_id, room_alias, **params) ⇒ Response

Sets the room ID for an alias

Parameters:

  • room_id (String, MXID) —

    The room to set an alias for

  • room_alias (String, MXID) —

    The alias to configure for the room

Returns:

  • (Response) —

    An empty object denoting success

Raises:



1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
 
# File 'lib/matrix_sdk/protocols/cs.rb', line 1110

def set_room_alias(room_id, room_alias, **params)
  query = {}
  query[:user_id] = params.delete(:user_id) if protocol?(:AS) && params.key?(:user_id)

  content = {
    room_id: room_id
  }
  room_alias = ERB::Util.url_encode room_alias.to_s

  request(:put, :client_r0, "/directory/room/#{room_alias}", body: content, query: query)
end

#set_room_avatar(room_id, url, **params) ⇒ Response

Sets the avatar URL for a room

Parameters:

  • room_id (MXID, String) —

    The room ID to work on

  • url (String, URI) —

    The new avatar URL for the room

  • params (Hash) —

    Extra options to set on the request, see #send_state_event

Returns:

  • (Response) —

    The resulting state event

See Also:



570
571
572
573
574
575
 
# File 'lib/matrix_sdk/protocols/cs.rb', line 570

def set_room_avatar(room_id, url, **params)
  content = {
    url: url
  }
  send_state_event(room_id, 'm.room.avatar', content, params)
end

#set_room_encryption_settings(room_id, algorithm: 'm.megolm.v1.aes-sha2', rotation_period_ms: 1 * 7 * 24 * 60 * 60 * 1000, rotation_period_msgs: 100, **params) ⇒ Response

Sets the encryption configuration for a room

Parameters:

  • room_id (MXID, String) —

    The room ID to work on

  • algorithm ('m.megolm.v1.aes-sha2') (defaults to: 'm.megolm.v1.aes-sha2') —

    The encryption algorithm to use

  • rotation_period_ms (Integer) (defaults to: 1 * 7 * 24 * 60 * 60 * 1000) —

    The interval between key rotation in milliseconds

  • rotation_period_msgs (Integer) (defaults to: 100) —

    The interval between key rotation in messages

  • params (Hash) —

    Extra options to set on the request, see #send_state_event

Returns:

  • (Response) —

    The resulting state event

See Also:



749
750
751
752
753
754
755
756
 
# File 'lib/matrix_sdk/protocols/cs.rb', line 749

def set_room_encryption_settings(room_id, algorithm: 'm.megolm.v1.aes-sha2', rotation_period_ms: 1 * 7 * 24 * 60 * 60 * 1000, rotation_period_msgs: 100, **params)
  content = {
    algorithm: algorithm,
    rotation_period_ms: rotation_period_ms,
    rotation_period_msgs: rotation_period_msgs
  }
  send_state_event(room_id, 'm.room.encryption', content, params)
end

#set_room_guest_access(room_id, guest_access, **params) ⇒ Response

Sets the guest access settings for a room

Parameters:

  • room_id (MXID, String) —

    The room ID to work on

  • guest_access (:can_join, :forbidden) —

    The new guest access setting for the room

  • params (Hash) —

    Extra options to set on the request, see #send_state_event

Returns:

  • (Response) —

    The resulting state event

See Also:



707
708
709
710
711
712
713
 
# File 'lib/matrix_sdk/protocols/cs.rb', line 707

def set_room_guest_access(room_id, guest_access, **params)
  content = {
    guest_access: guest_access
  }

  send_state_event(room_id, 'm.room.guest_access', content, params)
end

#set_room_history_visibility(room_id, visibility, **params) ⇒ Response

Sets the history availability for a room

Parameters:

  • room_id (MXID, String) —

    The room ID to work on

  • visibility (:invited, :joined, :shared, :world_readable) —

    The new history visibility level

  • params (Hash) —

    Extra options to set on the request, see #send_state_event

Returns:

  • (Response) —

    The resulting state event

See Also:



778
779
780
781
782
783
784
 
# File 'lib/matrix_sdk/protocols/cs.rb', line 778

def set_room_history_visibility(room_id, visibility, **params)
  content = {
    history_visibility: visibility
  }

  send_state_event(room_id, 'm.room.history_visibility', content, params)
end

#set_room_join_rules(room_id, join_rule, **params) ⇒ Response

Sets the join rules for a room

Parameters:

  • room_id (MXID, String) —

    The room ID to work on

  • join_rule (String, Symbol) —

    The new join rule setting (Currently only public and invite are implemented)

  • params (Hash) —

    Extra options to set on the request, see #send_state_event

Returns:

  • (Response) —

    The resulting state event

See Also:



679
680
681
682
683
684
685
 
# File 'lib/matrix_sdk/protocols/cs.rb', line 679

def set_room_join_rules(room_id, join_rule, **params)
  content = {
    join_rule: join_rule
  }

  send_state_event(room_id, 'm.room.join_rules', content, params)
end

#set_room_name(room_id, name, **params) ⇒ Response

Sets the display name of a room

Parameters:

  • room_id (MXID, String) —

    The room ID to work on

  • name (String) —

    The new name of the room

  • params (Hash) —

    Extra options to set on the request, see #send_state_event

Returns:

  • (Response) —

    The resulting state event

See Also:



514
515
516
517
518
519
 
# File 'lib/matrix_sdk/protocols/cs.rb', line 514

def set_room_name(room_id, name, **params)
  content = {
    name: name
  }
  send_state_event(room_id, 'm.room.name', content, params)
end

#set_room_pinned_events(room_id, events, **params) ⇒ Response

Sets the list of pinned events in a room

Parameters:

  • room_id (MXID, String) —

    The room ID to work on

  • events (Array[String]) —

    The new list of events to set as pinned

  • params (Hash) —

    Extra options to set on the request, see #send_state_event

Returns:

  • (Response) —

    The resulting state event

See Also:



625
626
627
628
629
630
 
# File 'lib/matrix_sdk/protocols/cs.rb', line 625

def set_room_pinned_events(room_id, events, **params)
  content = {
    pinned: events
  }
  send_state_event(room_id, 'm.room.pinned_events', content, params)
end

#set_room_power_levels(room_id, content, **params) ⇒ Response Also known as: set_power_levels

Sets the configuration for power levels in a room

Parameters:

  • room_id (MXID, String) —

    The room ID to work on

  • content (Hash) —

    The new power level configuration

  • params (Hash) —

    Extra options to set on the request, see #send_state_event

Returns:

  • (Response) —

    The resulting state event

See Also:



653
654
655
656
 
# File 'lib/matrix_sdk/protocols/cs.rb', line 653

def set_room_power_levels(room_id, content, **params)
  content[:events] = {} unless content.key? :events
  send_state_event(room_id, 'm.room.power_levels', content, params)
end

#set_room_server_acl(room_id, allow_ip_literals: false, allow:, deny:, **params) ⇒ Response

Sets the server ACL configuration for a room

Parameters:

  • room_id (MXID, String) —

    The room ID to work on

  • allow_ip_literals (Boolean) (defaults to: false) —

    If HSes with literal IP domains should be allowed

  • allow (Array[String]) —

    A list of HS wildcards that are allowed to communicate with the room

  • deny (Array[String]) —

    A list of HS wildcards that are denied from communicating with the room

  • params (Hash) —

    Extra options to set on the request, see #send_state_event

Returns:

  • (Response) —

    The resulting state event

See Also:



808
809
810
811
812
813
814
815
816
 
# File 'lib/matrix_sdk/protocols/cs.rb', line 808

def set_room_server_acl(room_id, allow_ip_literals: false, allow:, deny:, **params)
  content = {
    allow_ip_literals: allow_ip_literals,
    allow: allow,
    deny: deny
  }

  send_state_event(room_id, 'm.room.server_acl', content, params)
end

#set_room_topic(room_id, topic, **params) ⇒ Response

Sets the topic of a room

Parameters:

  • room_id (MXID, String) —

    The room ID to work on

  • topic (String) —

    The new topic of the room

  • params (Hash) —

    Extra options to set on the request, see #send_state_event

Returns:

  • (Response) —

    The resulting state event

See Also:



542
543
544
545
546
547
 
# File 'lib/matrix_sdk/protocols/cs.rb', line 542

def set_room_topic(room_id, topic, **params)
  content = {
    topic: topic
  }
  send_state_event(room_id, 'm.room.topic', content, params)
end

#sync(timeout: 30.0, **params) ⇒ Response

Runs the client API /sync method

Parameters:

  • timeout (Numeric) (defaults to: 30.0) —

    (30.0) The timeout in seconds for the sync

  • params (Hash) —

    The sync options to use

Options Hash (**params):

  • :since (String) —

    The value of the batch token to base the sync from

  • :filter (String, Hash) —

    The filter to use on the sync

  • :full_state (Boolean) —

    Should the sync include the full state

  • :set_presence (Boolean) —

    Should the sync set the user status to online

Returns:

See Also:



45
46
47
48
49
50
51
52
53
54
55
 
# File 'lib/matrix_sdk/protocols/cs.rb', line 45

def sync(timeout: 30.0, **params)
  query = params.select do |k, _v|
    %i[since filter full_state set_presence].include? k
  end

  query[:timeout] = (timeout * 1000).to_i if timeout
  query[:timeout] = params.delete(:timeout_ms).to_i if params.key? :timeout_ms
  query[:user_id] = params.delete(:user_id) if protocol?(:AS) && params.key?(:user_id)

  request(:get, :client_r0, '/sync', query: query)
end

#unban_user(room_id, user_id, **params) ⇒ Object 



896
897
898
899
900
901
902
903
904
905
906
 
# File 'lib/matrix_sdk/protocols/cs.rb', line 896

def unban_user(room_id, user_id, **params)
  query = {}
  query[:user_id] = params.delete(:user_id) if protocol?(:AS) && params.key?(:user_id)

  content = {
    user_id: user_id
  }
  room_id = ERB::Util.url_encode room_id.to_s

  request(:post, :client_r0, "/rooms/#{room_id}/unban", body: content, query: query)
end

#username_available?(username) ⇒ Response

Checks if a given username is available and valid for registering

Examples:

Verifying a username

api.username_available?('example')
# => { available: true }

Parameters:

  • username (String) —

    The username to check

Returns:

See Also:



95
96
97
 
# File 'lib/matrix_sdk/protocols/cs.rb', line 95

def username_available?(username)
  request(:get, :client_r0, '/register/available', query: { username: username })
end

#whoami?(**params) ⇒ Response

Gets the MXID of the currently logged-in user

Returns:

  • (Response) —

    An object containing the key :user_id



1213
1214
1215
1216
1217
1218
 
# File 'lib/matrix_sdk/protocols/cs.rb', line 1213

def whoami?(**params)
  query = {}
  query[:user_id] = params.delete(:user_id) if protocol?(:AS) && params.key?(:user_id)

  request(:get, :client_r0, '/account/whoami', query: query)
end