mirror of
https://github.com/matrix-construct/construct
synced 2024-08-20 00:24:44 +02:00
2055 lines
40 KiB
JavaScript
2055 lines
40 KiB
JavaScript
/*
|
|
// Matrix Construct
|
|
//
|
|
// Copyright (C) Matrix Construct Developers, Authors & Contributors
|
|
// Copyright (C) 2016-2018 Jason Volk <jason@zemos.net>
|
|
//
|
|
// Permission to use, copy, modify, and/or distribute this software for any
|
|
// purpose with or without fee is hereby granted, provided that the above
|
|
// copyright notice and this permission notice is present in all copies. The
|
|
// full license for this software is available in the LICENSE file.
|
|
*/
|
|
|
|
'use strict';
|
|
|
|
/**
|
|
******************************************************************************
|
|
*
|
|
* MATRIX PROTOCOL
|
|
*
|
|
*/
|
|
mc.m = {}
|
|
|
|
/**************************************
|
|
*
|
|
* Matrix utilities
|
|
*
|
|
*/
|
|
|
|
/** local part of id
|
|
*/
|
|
mc.m.local = (mxid) =>
|
|
typeif(mxid, "string", () => mxid.split(':')[0]);
|
|
|
|
/** domain part of id - Chops off the domain and other non-name characters from an mxid
|
|
*/
|
|
mc.m.domid = (mxid) =>
|
|
typeif(mxid, "string", () => mxid.split(':')[1]);
|
|
|
|
/** short id - Chops off the domain and other non-name characters from an mxid
|
|
*/
|
|
mc.m.sid = (mxid) =>
|
|
typeif(mxid, "string", () => mc.m.local(mxid).replace(/^[\@\!\$]/, ''));
|
|
|
|
/** pretty_errcode
|
|
*/
|
|
mc.m.pretty_errcode = (errcode) =>
|
|
typeif(errcode, "string", () => errcode.replace(/^M_/, "").replace(/_/g, " "));
|
|
|
|
/** Randomness
|
|
*
|
|
* This is a library to generate various elements of the matrix protocol
|
|
* when they need to have random content.
|
|
*/
|
|
mc.m.random = {}
|
|
|
|
/** Generate a random mxid */
|
|
mc.m.random.mxid = (prefix = "$", domain = "localhost") =>
|
|
prefix + (new Date).getTime() + mc.random.string(5) + "@" + domain;
|
|
|
|
/** Sigil specification
|
|
*/
|
|
mc.m.sigil =
|
|
{
|
|
'@': "user_id",
|
|
'!': "room_id",
|
|
'$': "event_id",
|
|
'#': "room_alias",
|
|
};
|
|
|
|
/** Find sigil reverse lookup
|
|
*/
|
|
Object.defineProperty(mc.m.sigil, 'find', {
|
|
enumerable: false,
|
|
valud: function(what)
|
|
{
|
|
return Object.keys(this).find((key) =>
|
|
{
|
|
return (this)[key] == what;
|
|
});
|
|
}});
|
|
|
|
/** Validators
|
|
*
|
|
* This is a library of various validator functions for the matrix protocol
|
|
*/
|
|
mc.m.valid = {};
|
|
|
|
mc.m.valid["user_id"] = function(mxid)
|
|
{
|
|
return mc.m.valid.mxid(mxid, "@");
|
|
};
|
|
|
|
mc.m.valid["room_id"] = function(mxid)
|
|
{
|
|
return mc.m.valid.mxid(mxid, "!");
|
|
};
|
|
|
|
mc.m.valid["event_id"] = function(mxid)
|
|
{
|
|
return mc.m.valid.mxid(mxid, "!");
|
|
};
|
|
|
|
mc.m.valid["room_alias"] = function(mxid)
|
|
{
|
|
return mc.m.valid.mxid(mxid, "#");
|
|
};
|
|
|
|
mc.m.valid.mxid = function(mxid, sigil = undefined, opts = {})
|
|
{
|
|
if(!this.sigil.valid(mxid))
|
|
return false;
|
|
|
|
let [local, domain] = mxid.split(':');
|
|
if(local.length <= 1)
|
|
return false;
|
|
|
|
if(sigil !== undefined)
|
|
if(local[0] != sigil)
|
|
return false;
|
|
|
|
if(opts.valid_domain === true)
|
|
if(!valid_domain(domain))
|
|
return false;
|
|
|
|
return true;
|
|
};
|
|
|
|
mc.m.valid.sigil = function(string)
|
|
{
|
|
if(typeof(string) != "string")
|
|
return false;
|
|
|
|
if(!this.expr.test(string))
|
|
return false;
|
|
|
|
return true;
|
|
};
|
|
|
|
mc.m.valid.sigil.expr = /^(\@|\!|\$|\@)/;
|
|
|
|
/** Translates an mxc:// when the registered window protocol handler isn't relevant
|
|
*/
|
|
mc.m.xc = (url) =>
|
|
{
|
|
if(typeof(url) != "string")
|
|
return url;
|
|
|
|
if(!url.startsWith("mxc://"))
|
|
return url;
|
|
|
|
let mxc_protocol_path = mc.opts.base_url + "/_matrix/media/r0/download/";
|
|
return url.replace("mxc://", mxc_protocol_path);
|
|
};
|
|
|
|
/** ???
|
|
*
|
|
*/
|
|
mc.m.error = async function(path)
|
|
{
|
|
let ret =
|
|
{
|
|
error: await path.error,
|
|
};
|
|
|
|
if(!ret.error)
|
|
return false;
|
|
|
|
ret.errcode = await path.errcode;
|
|
return ret;
|
|
};
|
|
|
|
|
|
/**************************************
|
|
*
|
|
* Matrix Protocol Specification / IO
|
|
*
|
|
*/
|
|
|
|
/**
|
|
******************************************************************************
|
|
* 2 API Standards
|
|
*
|
|
*/
|
|
|
|
/** 2.1 Versions
|
|
*
|
|
* Gets the versions of the specification supported by the server. Values will take
|
|
* the form rX.Y.Z. Only the latest Z value will be reported for each supported X.Y
|
|
* value. i.e. if the server implements r0.0.0, r0.0.1, and r1.2.0, it will report
|
|
* r0.0.1 and r1.2.0.
|
|
*/
|
|
mc.m.versions = {};
|
|
|
|
mc.m.versions.get = function(opts = {})
|
|
{
|
|
Object.update(opts,
|
|
{
|
|
method: "GET",
|
|
resource: "versions",
|
|
prefix: "/_matrix/client/",
|
|
version: null,
|
|
});
|
|
|
|
return new mc.io.request(opts, (error, data) =>
|
|
{
|
|
return callback(arguments, error, data);
|
|
});
|
|
};
|
|
|
|
/**
|
|
******************************************************************************
|
|
* 3 Client Authentication
|
|
*
|
|
*/
|
|
|
|
/**
|
|
* 3.2 Login
|
|
*/
|
|
mc.m.login = {};
|
|
|
|
/** 3.2 Login Flows
|
|
*/
|
|
mc.m.login.get = function(opts = {})
|
|
{
|
|
Object.update(opts,
|
|
{
|
|
method: "GET",
|
|
resource: "login",
|
|
prefix: "/_matrix/client/",
|
|
version: 0,
|
|
});
|
|
|
|
return new mc.io.request(opts, (error, data) =>
|
|
{
|
|
return callback(arguments, error, data);
|
|
});
|
|
};
|
|
|
|
/** 3.2.1 Login
|
|
*/
|
|
mc.m.login.post = function(opts = {})
|
|
{
|
|
Object.defaults(opts,
|
|
{
|
|
content:
|
|
{
|
|
type: "m.login.dummy"
|
|
},
|
|
});
|
|
|
|
Object.update(opts,
|
|
{
|
|
method: "POST",
|
|
resource: "login",
|
|
prefix: "/_matrix/client/",
|
|
version: 0,
|
|
});
|
|
|
|
return new mc.io.request(opts, (error, data) => callback(arguments, error, data));
|
|
};
|
|
|
|
/** 3.1.2.1 Password-based
|
|
*
|
|
*/
|
|
mc.m.login.password = function(username, password, opts = {})
|
|
{
|
|
Object.defaults(opts,
|
|
{
|
|
content:
|
|
{
|
|
user: username,
|
|
password: password,
|
|
type: "m.login.password",
|
|
},
|
|
});
|
|
|
|
return mc.m.login.post(opts, (error, data) => callback(arguments, error, data));
|
|
};
|
|
|
|
/** 3.1.2.3 Token-based
|
|
*
|
|
*/
|
|
mc.m.login.token = function(username, token, opts = {})
|
|
{
|
|
Object.defaults(opts,
|
|
{
|
|
query:
|
|
{
|
|
access_token: mc.session.access_token,
|
|
},
|
|
|
|
content:
|
|
{
|
|
user: username,
|
|
token: token,
|
|
type: "m.login.token",
|
|
txn_id: mc.local.txnid++,
|
|
},
|
|
});
|
|
|
|
return mc.m.login.post(opts, (error, data) => callback(arguments, error, data));
|
|
};
|
|
|
|
/** 3.2.2 tokenrefresh
|
|
*
|
|
*/
|
|
mc.m.tokenrefresh = {};
|
|
|
|
mc.m.tokenrefresh.post = function(opts = {})
|
|
{
|
|
Object.defaults(opts,
|
|
{
|
|
query:
|
|
{
|
|
access_token: mc.session.access_token,
|
|
},
|
|
|
|
content:
|
|
{
|
|
refresh_token: mc.local.refresh_token,
|
|
},
|
|
});
|
|
|
|
Object.update(opts,
|
|
{
|
|
method: "POST",
|
|
resource: "tokenrefresh",
|
|
prefix: "/_matrix/client/",
|
|
});
|
|
|
|
return new mc.io.request(opts, (error, data) => callback(arguments, error, data));
|
|
};
|
|
|
|
/** 3.2.3 logout
|
|
*
|
|
*/
|
|
mc.m.logout = {};
|
|
|
|
mc.m.logout.post = function(opts = {})
|
|
{
|
|
Object.defaults(opts,
|
|
{
|
|
query:
|
|
{
|
|
access_token: mc.session.access_token,
|
|
},
|
|
});
|
|
|
|
Object.update(opts,
|
|
{
|
|
method: "POST",
|
|
resource: "logout",
|
|
prefix: "/_matrix/client/",
|
|
});
|
|
|
|
return new mc.io.request(opts, (error, data) => callback(arguments, error, data));
|
|
};
|
|
|
|
/** 3.3 Account registration and management
|
|
*
|
|
*/
|
|
|
|
mc.m.register = {};
|
|
mc.m.account = {};
|
|
|
|
/** 3.3.1 register
|
|
*
|
|
*/
|
|
mc.m.register.post = function(opts = {})
|
|
{
|
|
Object.defaults(opts,
|
|
{
|
|
query:
|
|
{
|
|
// The kind of account to register. Defaults to user. One of: ["guest", "user"]
|
|
kind: "guest",
|
|
},
|
|
|
|
content:
|
|
{
|
|
// The local part of the desired Matrix ID. If omitted, the homeserver MUST
|
|
// generate a Matrix ID local part.
|
|
username: undefined,
|
|
|
|
// If true, the server binds the email used for authentication to the Matrix ID
|
|
// with the ID Server.
|
|
bind_email: undefined,
|
|
|
|
// Required. The desired password for the account.
|
|
password: undefined,
|
|
|
|
// Additional authentication information for the user-interactive authentication API.
|
|
auth:
|
|
{
|
|
// The value of the session key given by the homeserver.
|
|
session: undefined,
|
|
|
|
// Required. The login type that the client is attempting to complete.
|
|
type: "m.login.dummy",
|
|
}
|
|
},
|
|
});
|
|
|
|
Object.update(opts,
|
|
{
|
|
method: "POST",
|
|
resource: "register",
|
|
prefix: "/_matrix/client/",
|
|
});
|
|
|
|
return new mc.io.request(opts, (error, data) => callback(arguments, error, data));
|
|
};
|
|
|
|
/** 3.4 Account Administrative contact information
|
|
*
|
|
*/
|
|
mc.m.account['3pid'] = {};
|
|
|
|
/** 3.4.1 POST 3pid
|
|
*
|
|
*/
|
|
|
|
/** 3.4.2 GET 3pid
|
|
*
|
|
*/
|
|
mc.m.account['3pid'].get = function(opts = {})
|
|
{
|
|
Object.defaults(opts,
|
|
{
|
|
query:
|
|
{
|
|
access_token: mc.session.access_token,
|
|
},
|
|
});
|
|
|
|
Object.update(opts,
|
|
{
|
|
method: "GET",
|
|
resource: "account/3pid",
|
|
prefix: "/_matrix/client/",
|
|
});
|
|
|
|
return new mc.io.request(opts, (error, data) => callback(arguments, error, data));
|
|
};
|
|
|
|
/**
|
|
******************************************************************************
|
|
* 5 Filtering
|
|
*
|
|
* Filters can be created on the server and can be passed as as a parameter to APIs
|
|
* which return events. These filters alter the data returned from those APIs. Not
|
|
* all APIs accept filters.
|
|
*
|
|
*/
|
|
|
|
// Protocol suite
|
|
mc.m.filter = {};
|
|
|
|
/** 5.1 GET Filter
|
|
*
|
|
* Download a filter
|
|
*/
|
|
mc.m.filter.get = function(filter_id, opts = {})
|
|
{
|
|
let user_id = mc.uri(mc.session.user_id);
|
|
let resource = "user/" + user_id + "/filter/" + mc.uri(filter_id);
|
|
Object.defaults(opts,
|
|
{
|
|
query:
|
|
{
|
|
access_token: mc.session.access_token,
|
|
},
|
|
});
|
|
|
|
Object.update(opts,
|
|
{
|
|
method: "GET",
|
|
resource: resource,
|
|
prefix: "/_matrix/client/",
|
|
});
|
|
|
|
return new mc.io.request(opts, (error, data) => callback(arguments, error, data));
|
|
};
|
|
|
|
/** 5.2 POST Filter
|
|
*
|
|
* Uploads a new filter definition to the homeserver. Returns a filter ID that may be used in
|
|
* future requests to restrict which events are returned to the mc.
|
|
*/
|
|
mc.m.filter.post = function(content = {}, opts = {})
|
|
{
|
|
if(!mc.instance.authentic)
|
|
throw new mc.error("Posting a filter requires authentication");
|
|
|
|
let filter =
|
|
{
|
|
// A list of event types to exclude. If this list is absent then no event types are
|
|
// excluded. A matching type will be excluded even if it is listed in the 'types'
|
|
// filter. A '*' can be used as a wildcard to match any sequence of characters.
|
|
not_types: [],
|
|
|
|
// The maximum number of events to return.
|
|
limit: undefined,
|
|
|
|
// A list of senders IDs to include. If this list is absent then all senders are included.
|
|
senders: [],
|
|
|
|
// A list of event types to include. If this list is absent then all event types are
|
|
// included. A '*' can be used as a wildcard to match any sequence of characters.
|
|
types: [],
|
|
|
|
// A list of sender IDs to exclude. If this list is absent then no senders are excluded.
|
|
// A matching sender will be excluded even if it is listed in the 'senders' filter.
|
|
not_senders: [],
|
|
};
|
|
|
|
let room_event_filter =
|
|
{
|
|
// A list of event types to exclude. If this list is absent then no event types are
|
|
// excluded. A matching type will be excluded even if it is listed in the 'types'
|
|
// filter. A '*' can be used as a wildcard to match any sequence of characters.
|
|
not_types: [],
|
|
|
|
// A list of room IDs to exclude. If this list is absent then no rooms are excluded.
|
|
// A matching room will be excluded even if it is listed in the 'rooms' filter.
|
|
not_rooms: [],
|
|
|
|
// The maximum number of events to return.
|
|
limit: undefined,
|
|
|
|
// A list of room IDs to include. If this list is absent then all rooms are included.
|
|
rooms: [],
|
|
|
|
// A list of sender IDs to exclude. If this list is absent then no senders are excluded.
|
|
// A matching sender will be excluded even if it is listed in the 'senders' filter.
|
|
not_senders: [],
|
|
|
|
// A list of senders IDs to include. If this list is absent then all senders are included.
|
|
senders: [],
|
|
|
|
// A list of event types to include. If this list is absent then all event types are
|
|
// included. A '*' can be used as a wildcard to match any sequence of characters.
|
|
types: [],
|
|
};
|
|
|
|
let room_filter =
|
|
{
|
|
// Include rooms that the user has left in the sync, default false
|
|
include_leave: undefined,
|
|
|
|
// The per user account data to include for rooms.
|
|
account_data: undefined, //filter,
|
|
|
|
// The message and state update events to include for rooms.
|
|
timeline: undefined, //room_event_filter,
|
|
|
|
// The events that aren't recorded in the room history, e.g. typing and receipts,
|
|
// to include for rooms.
|
|
ephemeral: undefined, //room_event_filter,
|
|
|
|
// The state events to include for rooms.
|
|
state: undefined, //room_event_filter,
|
|
|
|
// A list of room IDs to exclude. If this list is absent then no rooms are
|
|
// excluded. A matching room will be excluded even if it is listed in the
|
|
// 'rooms' filter. This filter is applied before the filters in ephemeral,
|
|
// state, timeline or account_data
|
|
not_rooms: undefined, //[],
|
|
|
|
// A list of room IDs to include. If this list is absent then all rooms are
|
|
// included. This filter is applied before the filters in ephemeral, state,
|
|
// timeline or account_data
|
|
rooms: undefined, //[],
|
|
};
|
|
|
|
Object.defaults(content,
|
|
{
|
|
// List of event fields to include. If this list is absent then all fields are included.
|
|
// The entries may include '.' charaters to indicate sub-fields. So ['content.body'] will
|
|
// include the 'body' field of the 'content' object. A literal '.' character in a field
|
|
// name may be escaped using a '\'. A server may include more fields than were requested.
|
|
event_fields: undefined, //[],
|
|
|
|
// The format to use for events. 'client' will return the events in a format suitable for
|
|
// clients. 'federation' will return the raw event as receieved over federation. The default
|
|
// is 'client'. One of: ["client", "federation"]
|
|
event_format: undefined,
|
|
|
|
// The user account data that isn't associated with rooms to include.
|
|
account_data: undefined, //filter,
|
|
|
|
// Filters to be applied to room data.
|
|
room: undefined, //room_filter,
|
|
|
|
// The presence updates to include.
|
|
presence: undefined, //filter,
|
|
});
|
|
|
|
Object.defaults(opts,
|
|
{
|
|
query:
|
|
{
|
|
access_token: mc.session.access_token,
|
|
},
|
|
content: content,
|
|
});
|
|
|
|
Object.update(opts,
|
|
{
|
|
method: "POST",
|
|
resource: "user/" + mc.uri(mc.my.mxid) + "/filter",
|
|
prefix: "/_matrix/client/",
|
|
});
|
|
|
|
return new mc.io.request(opts, (error, data) => callback(arguments, error, data));
|
|
};
|
|
|
|
/**
|
|
******************************************************************************
|
|
* 6 Events
|
|
*
|
|
*/
|
|
|
|
/** 6.2 Syncing
|
|
*
|
|
*/
|
|
mc.m.sync = {};
|
|
|
|
/** 6.2.1 get sync
|
|
*
|
|
*/
|
|
mc.m.sync.get = function(opts = {})
|
|
{
|
|
Object.defaults(opts, mc.m.sync.get.opts);
|
|
Object.defaults(opts,
|
|
{
|
|
query:
|
|
{
|
|
access_token: mc.session.access_token,
|
|
}
|
|
});
|
|
|
|
Object.update(opts,
|
|
{
|
|
method: "GET",
|
|
resource: "sync",
|
|
prefix: "/_matrix/client/",
|
|
});
|
|
|
|
return new mc.io.request(opts, (error, data) => callback(arguments, error, data));
|
|
};
|
|
|
|
mc.m.sync.get.opts =
|
|
{
|
|
// This timeout is our XHR timeout, not the longpoll timeout sent to the server in the
|
|
// query string. This only fires if there's a real connection problem. Set this to
|
|
// something higher than the longpoll timeout.
|
|
timeout: 305 * 1000,
|
|
};
|
|
|
|
mc.m.sync.get.opts.query =
|
|
{
|
|
// The maximum time to poll in milliseconds before returning this request.
|
|
timeout: 300 * 1000,
|
|
|
|
// The ID of a filter created using the filter API or a filter JSON object
|
|
// encoded as a string. The server will detect whether it is an ID or a JSON
|
|
// object by whether the first character is a "{" open brace. Passing the JSON
|
|
// inline is best suited to one off requests. Creating a filter using the filter
|
|
// API is recommended for clients that reuse the same filter multiple times, for
|
|
// example in long poll requests.
|
|
filter: undefined,
|
|
|
|
// Controls whether the client is automatically marked as online by polling this API.
|
|
// If this parameter is omitted then the client is automatically marked as online
|
|
// when it uses this API. Otherwise if the parameter is set to "offline" then the
|
|
// client is not marked as being online when it uses this API. One of: ["offline"]
|
|
set_presence: undefined, //"online",
|
|
|
|
// Controls whether to include the full state for all rooms the user is a member of.
|
|
// If this is set to true, then all state events will be returned, even if since is
|
|
// non-empty. The timeline will still be limited by the since parameter. In this case,
|
|
// the timeout parameter will be ignored and the query will return immediately,
|
|
// possibly with an empty timeline.
|
|
// If false, and since is non-empty, only state which has changed since the point
|
|
// indicated by since will be returned. By default, this is false.
|
|
full_state: false,
|
|
};
|
|
|
|
/**
|
|
* 6.3 Getting events for a room
|
|
* 6.4 Sending events to a room
|
|
* 6.5 Redactions
|
|
*/
|
|
mc.m.rooms = {};
|
|
mc.m.rooms.state = {};
|
|
mc.m.rooms.members = {};
|
|
mc.m.rooms.messages = {};
|
|
mc.m.rooms.send = {};
|
|
mc.m.rooms.redact = {};
|
|
|
|
// abstract
|
|
mc.m.rooms.request = function(room_id, resource, opts = {})
|
|
{
|
|
Object.defaults(opts,
|
|
{
|
|
method: "GET",
|
|
query:
|
|
{
|
|
access_token: mc.session.access_token,
|
|
},
|
|
});
|
|
|
|
let uri = mc.uri(room_id);
|
|
Object.update(opts,
|
|
{
|
|
resource: "rooms/" + uri + "/" + resource,
|
|
prefix: "/_matrix/client/",
|
|
});
|
|
|
|
return new mc.io.request(opts, (error, data) => callback(arguments, error, data));
|
|
};
|
|
|
|
// abstract
|
|
mc.m.rooms.state.request = function(room_id, type = undefined, state_key = undefined, opts = {})
|
|
{
|
|
let resource = "state";
|
|
if(type !== undefined)
|
|
{
|
|
resource += "/" + type;
|
|
if(state_key !== undefined && state_key.length)
|
|
resource += "/" + state_key;
|
|
}
|
|
|
|
let handler = (error, data) => callback(arguments, error, data);
|
|
return mc.m.rooms.request(room_id, resource, opts, handler);
|
|
};
|
|
|
|
/** 6.3 Getting events for a room
|
|
*/
|
|
|
|
/** 6.3.1 GET state
|
|
*+ 6.3.2 GET state eventType
|
|
*+ 6.3.3 GET state eventType stateKey
|
|
*/
|
|
mc.m.rooms.state.get = function(room_id, type = undefined, state_key = undefined, opts = {})
|
|
{
|
|
Object.update(opts,
|
|
{
|
|
method: "GET",
|
|
});
|
|
|
|
let handler = (error, data) => callback(arguments, error, data);
|
|
return mc.m.rooms.state.request(room_id, type, state_key, opts, handler);
|
|
};
|
|
|
|
/** 6.3.4 GET members
|
|
*/
|
|
mc.m.rooms.members.get = function(room_id, opts = {})
|
|
{
|
|
let resource = "members";
|
|
Object.update(opts,
|
|
{
|
|
method: "GET",
|
|
});
|
|
|
|
Object.defaults(opts,
|
|
{
|
|
query:
|
|
{
|
|
filter: mc.filter("members"),
|
|
},
|
|
});
|
|
|
|
let handler = (error, data) => callback(arguments, error, data);
|
|
return mc.m.rooms.request(room_id, resource, opts, handler);
|
|
};
|
|
|
|
/** 6.3.5 GET messages
|
|
*/
|
|
mc.m.rooms.messages.get = function(room_id, opts = {})
|
|
{
|
|
let resource = "messages";
|
|
Object.update(opts,
|
|
{
|
|
method: "GET",
|
|
});
|
|
|
|
Object.defaults(opts,
|
|
{
|
|
query:
|
|
{
|
|
//from: undefined,
|
|
//to: undefined,
|
|
//dir: "b",
|
|
limit: 128,
|
|
},
|
|
});
|
|
|
|
let handler = (error, data) =>
|
|
{
|
|
if(error || !data)
|
|
return callback(arguments, error, data);
|
|
|
|
switch(opts.query.dir)
|
|
{
|
|
case 'b':
|
|
opts.query.from = data.start;
|
|
opts.query.to = undefined;
|
|
break;
|
|
|
|
case 'f':
|
|
opts.query.from = data.end;
|
|
opts.query.to = undefined;
|
|
break;
|
|
}
|
|
|
|
return callback(arguments, error, data);
|
|
};
|
|
|
|
return mc.m.rooms.request(room_id, resource, opts, handler);
|
|
};
|
|
|
|
|
|
/** 6.4 Sending events to a room
|
|
*/
|
|
|
|
/** 6.4.1 PUT state eventType
|
|
*+ 6.4.2 PUT state eventType stateKey
|
|
*/
|
|
mc.m.rooms.state.put = function(room_id, type, state_key = "", content = {}, opts = {})
|
|
{
|
|
Object.defaults(opts,
|
|
{
|
|
content: content,
|
|
});
|
|
|
|
Object.update(opts,
|
|
{
|
|
method: "PUT",
|
|
});
|
|
|
|
let handler = (error, data) => callback(arguments, error, data);
|
|
return mc.m.rooms.state.request(room_id, type, state_key, opts, handler);
|
|
}
|
|
|
|
/** 6.4.3 PUT send eventType txnId
|
|
*
|
|
* Content of the event passed in opts.content
|
|
*/
|
|
mc.m.rooms.send.put = function(room_id, type, opts = {})
|
|
{
|
|
Object.update(opts,
|
|
{
|
|
method: "PUT",
|
|
txnid: mc.local.txnid++,
|
|
});
|
|
|
|
let resource = "send/" + type + "/" + opts.txnid;
|
|
let handler = (error, data) => callback(arguments, error, data);
|
|
return mc.m.rooms.request(room_id, resource, opts, handler);
|
|
};
|
|
|
|
/**
|
|
******************************************************************************
|
|
* 7 Rooms
|
|
*
|
|
*/
|
|
|
|
/** 7.1 Creation
|
|
*
|
|
*/
|
|
mc.m.createRoom = {};
|
|
|
|
mc.m.createRoom.post = function(opts = {})
|
|
{
|
|
Object.defaults(opts, mc.m.createRoom.post.opts);
|
|
Object.defaults(opts,
|
|
{
|
|
query:
|
|
{
|
|
access_token: mc.session.access_token,
|
|
},
|
|
});
|
|
|
|
Object.update(opts,
|
|
{
|
|
method: "POST",
|
|
resource: "createRoom",
|
|
prefix: "/_matrix/client/",
|
|
});
|
|
|
|
return new mc.io.request(opts, (error, data) => callback(arguments, error, data));
|
|
};
|
|
|
|
mc.m.createRoom.post.opts = {};
|
|
|
|
mc.m.createRoom.post.opts.content =
|
|
{
|
|
// A list of user IDs to invite to the room. This will tell the server to invite everyone in the list
|
|
// to the newly created room.
|
|
invite: undefined,
|
|
|
|
// If this is included, an m.room.name event will be sent into the room to indicate the name of the
|
|
// room. See Room Events for more information on m.room.name.
|
|
name: undefined,
|
|
|
|
// A public visibility indicates that the room will be shown in the published room list. A private
|
|
// visibility will hide the room from the published room list. Rooms default to private visibility if this key is not included. NB: This should not be confused with join_rules which also uses the word public.
|
|
// One of: ["public", "private"]
|
|
visibility: undefined,
|
|
|
|
// A list of objects representing third party IDs to invite into the room.
|
|
invite_3pid: undefined,
|
|
|
|
// If this is included, an m.room.topic event will be sent into the room to indicate the topic for
|
|
// the room. See Room Events for more information on m.room.topic.
|
|
topic: undefined,
|
|
|
|
// Extra keys to be added to the content of the m.room.create. The server will clober the following
|
|
// keys: creator. Future versions of the specification may allow the server to clobber other keys.
|
|
creation_content: undefined,
|
|
|
|
// A list of state events to set in the new room. This allows the user to override the default
|
|
// state events set in the new room. The expected format of the state events are an object with
|
|
// 'type', 'state_key' and 'content' keys set. Takes precedence over events set by presets, but gets
|
|
// overriden by name and topic keys.
|
|
initial_state: undefined,
|
|
|
|
// The desired room alias local part. If this is included, a room alias will be created and mapped to
|
|
// the newly created room. The alias will belong on the same homeserver which created the room. For
|
|
// example, if this was set to "foo" and sent to the homeserver "example.com" the complete room alias
|
|
// would be #foo:example.com.
|
|
room_alias_name: undefined,
|
|
};
|
|
|
|
|
|
/** 7.2 Room aliases
|
|
*
|
|
*/
|
|
mc.m.directory = {};
|
|
|
|
/** 7.2.1 PUT
|
|
*
|
|
*/
|
|
mc.m.directory.put = function(alias, room_id, opts = {})
|
|
{
|
|
Object.update(opts,
|
|
{
|
|
method: "PUT",
|
|
content:
|
|
{
|
|
room_id: room_id,
|
|
},
|
|
});
|
|
|
|
return mc.m.directory.request(alias, opts, (error, data) => callback(arguments, error, data));
|
|
};
|
|
|
|
/** 7.2.2 DELETE
|
|
*
|
|
*/
|
|
mc.m.directory.del = function(alias, opts = {})
|
|
{
|
|
Object.update(opts,
|
|
{
|
|
method: "DELETE",
|
|
});
|
|
|
|
return mc.m.directory.request(alias, opts, (error, data) => callback(arguments, error, data));
|
|
};
|
|
|
|
/** 7.2.3 GET
|
|
*
|
|
*/
|
|
mc.m.directory.get = function(alias, opts = {})
|
|
{
|
|
Object.update(opts,
|
|
{
|
|
method: "GET",
|
|
});
|
|
|
|
return mc.m.directory.request(alias, opts, (error, data) => callback(arguments, error, data));
|
|
};
|
|
|
|
/** Abstract
|
|
*/
|
|
mc.m.directory.request = function(alias, opts = {})
|
|
{
|
|
Object.defaults(opts,
|
|
{
|
|
query:
|
|
{
|
|
access_token: mc.session.access_token,
|
|
},
|
|
});
|
|
|
|
Object.update(opts,
|
|
{
|
|
resource: "directory/room/" + mc.uri(alias),
|
|
prefix: "/_matrix/client/",
|
|
});
|
|
|
|
return new mc.io.request(opts, (error, data) => callback(arguments, error, data));
|
|
};
|
|
|
|
/** 7.4 Room Membership
|
|
*
|
|
*/
|
|
|
|
/** 7.4.1 Joining Rooms
|
|
*
|
|
*/
|
|
|
|
/** 7.4.1.1 POST invite
|
|
*/
|
|
mc.m.rooms.invite = {};
|
|
mc.m.rooms.invite.post = function(room_id, user_id, opts = {})
|
|
{
|
|
let resource = "invite";
|
|
Object.defaults(opts,
|
|
{
|
|
content:
|
|
{
|
|
user_id: user_id,
|
|
},
|
|
});
|
|
|
|
Object.update(opts,
|
|
{
|
|
method: "POST",
|
|
});
|
|
|
|
let handler = (error, data) => callback(arguments, error, data);
|
|
return mc.m.rooms.request(room_id, resource, opts, handler);
|
|
}
|
|
|
|
/** 7.4.1.2 POST join
|
|
*/
|
|
mc.m.join = {};
|
|
mc.m.join.post = function(room_id_or_alias, opts = {})
|
|
{
|
|
Object.defaults(opts,
|
|
{
|
|
query:
|
|
{
|
|
access_token: mc.session.access_token,
|
|
},
|
|
|
|
content:
|
|
{
|
|
third_party_signed: undefined,
|
|
},
|
|
});
|
|
|
|
Object.update(opts,
|
|
{
|
|
method: "POST",
|
|
resource: "join/" + mc.uri(room_id_or_alias),
|
|
prefix: "/_matrix/client/",
|
|
});
|
|
|
|
let handler = (error, data) => callback(arguments, error, data);
|
|
return new mc.io.request(opts, handler);
|
|
}
|
|
|
|
/** 7.4.1.3 POST join
|
|
*/
|
|
mc.m.rooms.join = {};
|
|
mc.m.rooms.join.post = function(room_id, opts = {})
|
|
{
|
|
let resource = "join";
|
|
Object.defaults(opts,
|
|
{
|
|
content:
|
|
{
|
|
third_party_signed: undefined,
|
|
},
|
|
});
|
|
|
|
Object.update(opts,
|
|
{
|
|
method: "POST",
|
|
});
|
|
|
|
let handler = (error, data) => callback(arguments, error, data);
|
|
return mc.m.rooms.request(room_id, resource, opts, handler);
|
|
}
|
|
|
|
/** 7.4.2 Leaving rooms
|
|
*
|
|
*/
|
|
|
|
/** 7.4.2.1 POST forget
|
|
*/
|
|
mc.m.rooms.forget = {};
|
|
mc.m.rooms.forget.post = function(room_id, opts = {})
|
|
{
|
|
let resource = "forget";
|
|
Object.update(opts,
|
|
{
|
|
method: "POST",
|
|
});
|
|
|
|
let handler = (error, data) => callback(arguments, error, data);
|
|
return mc.m.rooms.request(room_id, resource, opts, handler);
|
|
}
|
|
|
|
/** 7.4.2.2 POST leave
|
|
*/
|
|
mc.m.rooms.leave = {};
|
|
mc.m.rooms.leave.post = function(room_id, opts = {})
|
|
{
|
|
let resource = "leave";
|
|
Object.update(opts,
|
|
{
|
|
method: "POST",
|
|
});
|
|
|
|
let handler = (error, data) => callback(arguments, error, data);
|
|
return mc.m.rooms.request(room_id, resource, opts, handler);
|
|
}
|
|
|
|
/** 7.4.2.3 POST kick
|
|
*/
|
|
mc.m.rooms.kick = {};
|
|
mc.m.rooms.kick.post = function(room_id, user_id, reason = undefined, opts = {})
|
|
{
|
|
let resource = "kick";
|
|
Object.defaults(opts,
|
|
{
|
|
content:
|
|
{
|
|
user_id: user_id,
|
|
reason: reason,
|
|
},
|
|
});
|
|
|
|
Object.update(opts,
|
|
{
|
|
method: "POST",
|
|
});
|
|
|
|
let handler = (error, data) => callback(arguments, error, data);
|
|
return mc.m.rooms.request(room_id, resource, opts, handler);
|
|
}
|
|
|
|
/** 7.4.3 Banning users in a room
|
|
*
|
|
*/
|
|
|
|
/** 7.4.3.1 POST unban
|
|
*/
|
|
mc.m.rooms.unban = {};
|
|
mc.m.rooms.unban.post = function(room_id, user_id, opts = {})
|
|
{
|
|
let resource = "unban";
|
|
Object.defaults(opts,
|
|
{
|
|
content:
|
|
{
|
|
user_id: user_id,
|
|
},
|
|
});
|
|
|
|
Object.update(opts,
|
|
{
|
|
method: "POST",
|
|
});
|
|
|
|
let handler = (error, data) => callback(arguments, error, data);
|
|
return mc.m.rooms.request(room_id, resource, opts, handler);
|
|
}
|
|
|
|
/** 7.4.3.2 POST ban
|
|
*/
|
|
mc.m.rooms.ban = {};
|
|
mc.m.rooms.ban.post = function(room_id, user_id, reason = undefined, opts = {})
|
|
{
|
|
let resource = "ban";
|
|
Object.defaults(opts,
|
|
{
|
|
content:
|
|
{
|
|
user_id: user_id,
|
|
reason: reason,
|
|
},
|
|
});
|
|
|
|
Object.update(opts,
|
|
{
|
|
method: "POST",
|
|
});
|
|
|
|
let handler = (error, data) => callback(arguments, error, data);
|
|
return mc.m.rooms.request(room_id, resource, opts, handler);
|
|
}
|
|
|
|
/** 7.5 Listing rooms
|
|
*
|
|
*/
|
|
mc.m.publicRooms = {};
|
|
|
|
/** 7.5.1
|
|
*
|
|
*/
|
|
mc.m.publicRooms.get = function(opts = {})
|
|
{
|
|
Object.update(opts,
|
|
{
|
|
method: "GET",
|
|
resource: "publicRooms",
|
|
prefix: "/_matrix/client/",
|
|
});
|
|
|
|
Object.defaults(opts,
|
|
{
|
|
query:
|
|
{
|
|
limit: 64,
|
|
access_token: mc.session.access_token,
|
|
},
|
|
});
|
|
|
|
return new mc.io.request(opts);
|
|
};
|
|
|
|
/** EXPERIMENTAL
|
|
*
|
|
*/
|
|
mc.m.publicRooms.post = function(opts = {})
|
|
{
|
|
Object.defaults(opts,
|
|
{
|
|
query:
|
|
{
|
|
server: undefined,
|
|
access_token: mc.session.access_token,
|
|
},
|
|
|
|
content:
|
|
{
|
|
// limit param (content?)
|
|
limit: 128,
|
|
|
|
// since param (content?)
|
|
since: undefined,
|
|
|
|
// filter_id (content?)
|
|
filter: undefined,
|
|
|
|
// boolean
|
|
include_all_networks: undefined,
|
|
|
|
third_party_instance_id: undefined,
|
|
},
|
|
});
|
|
|
|
Object.update(opts,
|
|
{
|
|
method: "POST",
|
|
resource: "publicRooms",
|
|
prefix: "/_matrix/client/",
|
|
});
|
|
|
|
return new mc.io.request(opts);
|
|
};
|
|
|
|
/**
|
|
******************************************************************************
|
|
* 8 Profiles
|
|
*
|
|
*/
|
|
mc.m.profile = {};
|
|
mc.m.profile.displayname = {};
|
|
mc.m.profile.avatar_url = {};
|
|
|
|
/** 8.1 PUT displayname
|
|
*/
|
|
mc.m.profile.displayname.put = function(user_id, displayname, opts = {})
|
|
{
|
|
Object.defaults(opts,
|
|
{
|
|
query:
|
|
{
|
|
access_token: mc.session.access_token,
|
|
},
|
|
});
|
|
|
|
Object.update(opts,
|
|
{
|
|
content:
|
|
{
|
|
displayname: displayname,
|
|
},
|
|
});
|
|
|
|
Object.update(opts,
|
|
{
|
|
method: "PUT",
|
|
resource: "profile/" + mc.uri(user_id) + "/displayname",
|
|
prefix: "/_matrix/client/",
|
|
});
|
|
|
|
return new mc.io.request(opts);
|
|
};
|
|
|
|
/** 8.2 GET displayname
|
|
*/
|
|
mc.m.profile.displayname.get = function(user_id, opts = {})
|
|
{
|
|
Object.defaults(opts,
|
|
{
|
|
query:
|
|
{
|
|
access_token: mc.session.access_token,
|
|
},
|
|
});
|
|
|
|
Object.update(opts,
|
|
{
|
|
method: "GET",
|
|
resource: "profile/" + mc.uri(user_id) + "/displayname",
|
|
prefix: "/_matrix/client/",
|
|
});
|
|
|
|
return new mc.io.request(opts);
|
|
};
|
|
|
|
/** 8.3 PUT avatar_url
|
|
*/
|
|
mc.m.profile.avatar_url.put = function(user_id, avatar_url, opts = {})
|
|
{
|
|
Object.defaults(opts,
|
|
{
|
|
query:
|
|
{
|
|
access_token: mc.session.access_token,
|
|
},
|
|
});
|
|
|
|
Object.update(opts,
|
|
{
|
|
content:
|
|
{
|
|
avatar_url: avatar_url,
|
|
},
|
|
});
|
|
|
|
Object.update(opts,
|
|
{
|
|
method: "PUT",
|
|
resource: "profile/" + mc.uri(user_id) + "/avatar_url",
|
|
prefix: "/_matrix/client/",
|
|
});
|
|
|
|
return new mc.io.request(opts);
|
|
};
|
|
|
|
/** 8.4 GET avatar_url
|
|
*/
|
|
mc.m.profile.avatar_url.get = function(user_id, opts = {})
|
|
{
|
|
Object.defaults(opts,
|
|
{
|
|
query:
|
|
{
|
|
access_token: mc.session.access_token,
|
|
},
|
|
});
|
|
|
|
Object.update(opts,
|
|
{
|
|
method: "GET",
|
|
resource: "profile/" + mc.uri(user_id) + "/avatar_url",
|
|
prefix: "/_matrix/client/",
|
|
});
|
|
|
|
return new mc.io.request(opts);
|
|
};
|
|
|
|
/** 8.5 GET profile
|
|
*
|
|
*/
|
|
mc.m.profile.get = function(user_id, opts = {})
|
|
{
|
|
Object.defaults(opts,
|
|
{
|
|
query:
|
|
{
|
|
access_token: mc.session.access_token,
|
|
},
|
|
});
|
|
|
|
Object.update(opts,
|
|
{
|
|
method: "GET",
|
|
resource: "profile/" + mc.uri(user_id),
|
|
prefix: "/_matrix/client/",
|
|
});
|
|
|
|
return new mc.io.request(opts, (error, data) => callback(arguments, error, data));
|
|
};
|
|
|
|
/**
|
|
******************************************************************************
|
|
* 11 Modules
|
|
*
|
|
*/
|
|
|
|
/**
|
|
**************************************
|
|
* 11.4 Typing notifications
|
|
*
|
|
*/
|
|
mc.m.rooms.typing = {};
|
|
|
|
/** 11.4.2.1 PUT typing
|
|
*/
|
|
mc.m.rooms.typing.put = function(room_id, user_id, opts = {})
|
|
{
|
|
Object.defaults(opts,
|
|
{
|
|
content:
|
|
{
|
|
timeout: 15 * 1000,
|
|
typing: true,
|
|
},
|
|
});
|
|
|
|
Object.update(opts,
|
|
{
|
|
method: "PUT",
|
|
resource: "typing" + "/" + mc.uri(user_id),
|
|
prefix: "/_matrix/client/",
|
|
});
|
|
|
|
let handler = (error, data) => callback(arguments, error, data);
|
|
return mc.m.rooms.request(room_id, opts.resource, opts, handler);
|
|
}
|
|
|
|
/**
|
|
**************************************
|
|
* 11.5 Receipts
|
|
*
|
|
*/
|
|
mc.m.rooms.receipt = {};
|
|
|
|
/** 11.5.2.1 POST receipt
|
|
*/
|
|
mc.m.rooms.receipt.post = function(room_id, event_id, type = "m.read", opts = {})
|
|
{
|
|
Object.update(opts,
|
|
{
|
|
method: "POST",
|
|
resource: "receipt/" + mc.uri(type) + "/" + mc.uri(event_id),
|
|
prefix: "/_matrix/client/",
|
|
});
|
|
|
|
return mc.m.rooms.request(room_id, opts.resource, opts);
|
|
}
|
|
|
|
/**
|
|
**************************************
|
|
* 11.6 Presence
|
|
*
|
|
*/
|
|
mc.m.presence = {};
|
|
|
|
mc.m.presence.list = {};
|
|
mc.m.presence.status = {};
|
|
|
|
/** 11.6.2
|
|
*/
|
|
|
|
/** 11.6.2.1 PUT status
|
|
*/
|
|
mc.m.presence.status.put = function(user_id, presence, status_msg = undefined, opts = {})
|
|
{
|
|
if(user_id === undefined)
|
|
user_id = mc.session.user_id;
|
|
|
|
if(presence === undefined)
|
|
presence = mc.instance.presence;
|
|
|
|
Object.defaults(opts,
|
|
{
|
|
query:
|
|
{
|
|
access_token: mc.session.access_token,
|
|
},
|
|
|
|
content:
|
|
{
|
|
// The status message to attach to this state.
|
|
status_msg: status_msg,
|
|
|
|
// Required. The new presence state. One of: ["online", "offline", "unavailable"]
|
|
presence: presence,
|
|
},
|
|
});
|
|
|
|
let resource = "presence";
|
|
resource += "/" + mc.uri(user_id);
|
|
resource += "/" + "status";
|
|
|
|
Object.update(opts,
|
|
{
|
|
method: "PUT",
|
|
resource: resource,
|
|
prefix: "/_matrix/client/",
|
|
});
|
|
|
|
return new mc.io.request(opts);
|
|
};
|
|
|
|
/** 11.6.2.2 GET status
|
|
*/
|
|
mc.m.presence.status.get = function(user_id, opts = {})
|
|
{
|
|
if(user_id === undefined)
|
|
user_id = mc.session.user_id;
|
|
|
|
Object.defaults(opts,
|
|
{
|
|
query:
|
|
{
|
|
access_token: mc.session.access_token,
|
|
},
|
|
});
|
|
|
|
Object.update(opts,
|
|
{
|
|
method: "GET",
|
|
resource: "presence/" + mc.uri(user_id) + "/status",
|
|
prefix: "/_matrix/client/",
|
|
});
|
|
|
|
return new mc.io.request(opts);
|
|
};
|
|
|
|
/** 11.6.2.3 POST list
|
|
*
|
|
*/
|
|
mc.m.presence.list.post = function(user_id, delta = { drop: [], invite: [] }, opts = {})
|
|
{
|
|
if(user_id === undefined)
|
|
user_id = mc.session.user_id;
|
|
|
|
Object.defaults(opts,
|
|
{
|
|
query:
|
|
{
|
|
access_token: mc.session.access_token,
|
|
},
|
|
});
|
|
|
|
Object.update(opts,
|
|
{
|
|
content:
|
|
{
|
|
drop: delta.drop,
|
|
invite: delta.invite,
|
|
},
|
|
});
|
|
|
|
Object.update(opts,
|
|
{
|
|
method: "POST",
|
|
resource: "presence/list/" + mc.uri(user_id),
|
|
prefix: "/_matrix/client/",
|
|
});
|
|
|
|
return new mc.io.request(opts);
|
|
};
|
|
|
|
/** 11.6.2.4 GET list
|
|
*/
|
|
mc.m.presence.list.get = function(user_id, opts = {})
|
|
{
|
|
if(user_id === undefined)
|
|
user_id = mc.session.user_id;
|
|
|
|
Object.defaults(opts,
|
|
{
|
|
query:
|
|
{
|
|
access_token: mc.session.access_token,
|
|
},
|
|
});
|
|
|
|
Object.update(opts,
|
|
{
|
|
method: "GET",
|
|
resource: "presence/list/" + mc.uri(user_id),
|
|
prefix: "/_matrix/client/",
|
|
});
|
|
|
|
return new mc.io.request(opts);
|
|
};
|
|
|
|
/**
|
|
**************************************
|
|
* 11.7 Content Repository
|
|
*
|
|
*/
|
|
mc.m.media = {};
|
|
|
|
/**
|
|
* Register the mxc:// protocol with the browser for href's.
|
|
*/
|
|
//let mxc_protocol_path = mc.opts.base_url + "/_matrix/media/r0/download/%s";
|
|
//window.navigator.registerProtocolHandler("web+mxc", mxc_protocol_path, "Matrix Content");
|
|
|
|
/**
|
|
* 11.7.1 Client Behavior
|
|
*
|
|
*/
|
|
mc.m.media.download = {};
|
|
mc.m.media.upload = {};
|
|
|
|
/** 11.7.1.1 GET media
|
|
*
|
|
*/
|
|
mc.m.media.download.get = function(server_name, media_id, opts = {})
|
|
{
|
|
Object.defaults(opts,
|
|
{
|
|
query:
|
|
{
|
|
access_token: mc.session.access_token,
|
|
},
|
|
|
|
// This IO request is a corner-case. Setting these is required
|
|
// to override the mc.io.request()'s defaulting to JSON.
|
|
responseType: "arraybuffer",
|
|
});
|
|
|
|
//XXX: have to restore prefix clobber
|
|
let their_prefix = opts.prefix;
|
|
Object.update(opts,
|
|
{
|
|
method: "GET",
|
|
prefix: "/_matrix/media/",
|
|
resource: "download/" + server_name + "/" + media_id,
|
|
});
|
|
|
|
let handler = (error, data, xhr) =>
|
|
{
|
|
opts.prefix = their_prefix;
|
|
|
|
if(error)
|
|
return callback(arguments, error, data, undefined);
|
|
|
|
let type = xhr.getResponseHeader("content-type");
|
|
return callback(arguments, error, data, type);
|
|
};
|
|
|
|
return new mc.io.request(opts, handler);
|
|
}
|
|
|
|
/** 11.7.1.2 POST media
|
|
*
|
|
* All arguments in opts.
|
|
* opts.contentType
|
|
* opts.content -> xhr.send()
|
|
*
|
|
*/
|
|
mc.m.media.upload.post = function(opts = {})
|
|
{
|
|
Object.defaults(opts,
|
|
{
|
|
query:
|
|
{
|
|
access_token: mc.session.access_token,
|
|
},
|
|
});
|
|
|
|
//XXX: have to restore prefix clobber
|
|
let their_prefix = opts.prefix;
|
|
Object.update(opts,
|
|
{
|
|
method: "POST",
|
|
resource: "upload",
|
|
prefix: "/_matrix/media/",
|
|
});
|
|
|
|
return new mc.io.request(opts, (error, data) =>
|
|
{
|
|
opts.prefix = their_prefix;
|
|
callback(arguments, error, data);
|
|
});
|
|
}
|
|
|
|
/**
|
|
**************************************
|
|
* 11.10 Push Notifications
|
|
*
|
|
*/
|
|
|
|
/** 11.10.1 pushers
|
|
*
|
|
*/
|
|
mc.m.pushers = {};
|
|
|
|
/** 11.10.1.2 GET pushers
|
|
*
|
|
*/
|
|
mc.m.pushers.get = function(opts = {})
|
|
{
|
|
Object.defaults(opts,
|
|
{
|
|
query:
|
|
{
|
|
access_token: mc.session.access_token,
|
|
},
|
|
});
|
|
|
|
Object.update(opts,
|
|
{
|
|
method: "GET",
|
|
resource: "pushers",
|
|
prefix: "/_matrix/client/",
|
|
});
|
|
|
|
return new mc.io.request(opts, (error, data) => callback(arguments, error, data));
|
|
};
|
|
|
|
/**
|
|
**************************************
|
|
* 11.12 Server Side Search
|
|
*
|
|
*/
|
|
mc.m.search = {};
|
|
|
|
/** 11.12.1.1 search
|
|
*
|
|
*/
|
|
mc.m.search.post = function(opts = {})
|
|
{
|
|
Object.defaults(opts, mc.m.search.post.opts);
|
|
Object.defaults(opts,
|
|
{
|
|
query:
|
|
{
|
|
access_token: mc.session.access_token,
|
|
},
|
|
});
|
|
|
|
Object.update(opts,
|
|
{
|
|
method: "POST",
|
|
resource: "search",
|
|
prefix: "/_matrix/client/",
|
|
});
|
|
|
|
let remain = opts.query.limit;
|
|
opts.query.limit = Math.min(remain, opts.chunk_size);
|
|
|
|
///TODO: XXX
|
|
// We continue to paginate automatically until finished or the user
|
|
// callback returns false.
|
|
let handler = (error, data) =>
|
|
{
|
|
if(callback(arguments, error, data) === false)
|
|
return;
|
|
|
|
if(maybe(() => data.search_categories.room_events.next_batch) === undefined)
|
|
return;
|
|
|
|
//remain -= data.search_categories.room_events.
|
|
//opts.query.limit = Math.min(remain, opts.chunk_size);
|
|
opts.query.since = data.search_categories.room_events.next_batch;
|
|
return new mc.io.request(opts, handler);
|
|
};
|
|
|
|
return new mc.io.request(opts, handler);
|
|
};
|
|
|
|
mc.m.search.post.opts =
|
|
{
|
|
chunk_size: 10,
|
|
query:
|
|
{
|
|
limit: 10,
|
|
},
|
|
};
|
|
|
|
mc.m.search.post.opts.content =
|
|
{
|
|
search_categories:
|
|
{
|
|
room_events:
|
|
{
|
|
// Required. The string to search events for.
|
|
search_term: "",
|
|
|
|
// Takes a section 5 filter
|
|
filter: undefined,
|
|
|
|
// The keys to search. Defaults to all.
|
|
// One of: ["content.body", "content.name", "content.topic"]
|
|
keys: undefined,
|
|
|
|
// Requests that the server partitions the result set based on the
|
|
// provided list of keys.
|
|
groupings:
|
|
{
|
|
// List of groups to request.
|
|
group_by: undefined,
|
|
},
|
|
|
|
// The order in which to search for results. One of: ["recent", "rank"]
|
|
order_by: undefined,
|
|
|
|
// Requests the server return the current state for each room returned.
|
|
include_state: undefined,
|
|
|
|
// Configures whether any context for the events returned are included
|
|
// in the response.
|
|
event_context:
|
|
{
|
|
// How many events before the result are returned.
|
|
before_limit: undefined, // integer
|
|
|
|
// How many events after the result are returned.
|
|
after_limit: undefined, // integer
|
|
|
|
// Requests that the server returns the historic profile
|
|
// information for the users that sent the events that were
|
|
// returned.
|
|
include_profile: undefined, // boolean
|
|
},
|
|
},
|
|
},
|
|
};
|
|
|
|
|
|
/**
|
|
**************************************
|
|
* 11.14 Room Previews
|
|
*
|
|
*/
|
|
|
|
/** 11.14.1
|
|
*
|
|
*/
|
|
|
|
/** 11.14.1.1 GET events
|
|
*
|
|
*/
|
|
mc.m.events = {};
|
|
mc.m.events.get = function(room_id, opts = {})
|
|
{
|
|
Object.defaults(opts,
|
|
{
|
|
query:
|
|
{
|
|
room_id: room_id,
|
|
from: undefined,
|
|
timeout: 60 * 1000,
|
|
access_token: mc.session.access_token,
|
|
},
|
|
});
|
|
|
|
Object.update(opts,
|
|
{
|
|
method: "GET",
|
|
resource: "events",
|
|
prefix: "/_matrix/client/",
|
|
});
|
|
|
|
return new mc.io.request(opts);
|
|
};
|
|
|
|
/**
|
|
**************************************
|
|
* 11.16 Client Config
|
|
*
|
|
*/
|
|
|
|
/** 11.16.2
|
|
*
|
|
*/
|
|
mc.m.user = {};
|
|
mc.m.user.account_data = {};
|
|
mc.m.user.rooms = {};
|
|
mc.m.user.rooms.account_data = {};
|
|
|
|
/** 11.16.2.1 PUT per room account data
|
|
*
|
|
*/
|
|
mc.m.user.rooms.account_data.put = function(user_id, room_id, type, content, opts = {})
|
|
{
|
|
Object.defaults(opts,
|
|
{
|
|
query:
|
|
{
|
|
access_token: mc.session.access_token,
|
|
},
|
|
});
|
|
|
|
let resource;
|
|
resource = "user/" + mc.uri(user_id);
|
|
resource +="/rooms/" + mc.uri(room_id);
|
|
resource += "/account_data/" + mc.uri(type);
|
|
|
|
Object.update(opts,
|
|
{
|
|
method: "PUT",
|
|
resource: resource,
|
|
prefix: "/_matrix/client/",
|
|
});
|
|
|
|
return new mc.io.request(opts);
|
|
};
|
|
|
|
mc.m.user.rooms.account_data.del = function(user_id, room_id, type, opts = {})
|
|
{
|
|
Object.defaults(opts,
|
|
{
|
|
query:
|
|
{
|
|
access_token: mc.session.access_token,
|
|
},
|
|
});
|
|
|
|
let resource;
|
|
resource = "user/" + mc.uri(user_id);
|
|
resource +="/rooms/" + mc.uri(room_id);
|
|
resource += "/account_data/" + mc.uri(type);
|
|
|
|
Object.update(opts,
|
|
{
|
|
method: "DELETE",
|
|
resource: resource,
|
|
prefix: "/_matrix/client/",
|
|
});
|
|
|
|
return new mc.io.request(opts);
|
|
};
|
|
|
|
/** 11.16.2.2 PUT per room account data
|
|
*
|
|
*/
|
|
mc.m.user.account_data.put = function(user_id, type, content, opts = {})
|
|
{
|
|
Object.defaults(opts,
|
|
{
|
|
query:
|
|
{
|
|
access_token: mc.session.access_token,
|
|
},
|
|
});
|
|
|
|
let resource;
|
|
resource = "user/" + mc.uri(user_id);
|
|
resource += "/account_data/" + mc.uri(type);
|
|
|
|
Object.update(opts,
|
|
{
|
|
method: "PUT",
|
|
resource: resource,
|
|
prefix: "/_matrix/client/",
|
|
});
|
|
|
|
return new mc.io.request(opts);
|
|
};
|
|
|
|
mc.m.user.account_data.del = function(user_id, type, opts = {})
|
|
{
|
|
Object.defaults(opts,
|
|
{
|
|
query:
|
|
{
|
|
access_token: mc.session.access_token,
|
|
},
|
|
});
|
|
|
|
let resource;
|
|
resource = "user/" + mc.uri(user_id);
|
|
resource += "/account_data/" + mc.uri(type);
|
|
|
|
Object.update(opts,
|
|
{
|
|
method: "DELETE",
|
|
resource: resource,
|
|
prefix: "/_matrix/client/",
|
|
});
|
|
|
|
return new mc.io.request(opts);
|
|
};
|
|
|
|
/**
|
|
**************************************
|
|
* 11.17 Server Administration
|
|
*
|
|
*/
|
|
mc.m.admin = {};
|
|
mc.m.admin.whois = {};
|
|
|
|
/** 11.17.1
|
|
*
|
|
*/
|
|
|
|
/** 11.17.1.1 GET whois
|
|
*
|
|
*/
|
|
mc.m.admin.whois.get = function(user_id, opts = {})
|
|
{
|
|
Object.defaults(opts,
|
|
{
|
|
query:
|
|
{
|
|
access_token: mc.session.access_token,
|
|
},
|
|
});
|
|
|
|
Object.update(opts,
|
|
{
|
|
method: "GET",
|
|
resource: "admin/whois/" + mc.uri(user_id),
|
|
prefix: "/_matrix/client/",
|
|
});
|
|
|
|
return new mc.io.request(opts);
|
|
};
|
|
|
|
/**
|
|
**************************************
|
|
* 11.18 Event Context
|
|
*
|
|
*/
|
|
|
|
/** 11.18.1 GET context
|
|
*
|
|
*/
|
|
mc.m.rooms.context = {};
|
|
mc.m.rooms.context.get = function(room_id, event_id, opts = {})
|
|
{
|
|
let resource = "context/" + event_id;
|
|
Object.defaults(opts,
|
|
{
|
|
query:
|
|
{
|
|
//from: undefined,
|
|
//to: undefined,
|
|
limit: 0,
|
|
},
|
|
});
|
|
|
|
let handler = (error, data) => callback(arguments, error, data);
|
|
return mc.m.rooms.request(room_id, resource, opts, handler);
|
|
};
|