Source: components/intent.js

  1. "use strict";
  2. const Promise = require("bluebird");
  3. const MatrixUser = require("../models/users/matrix");
  4. const MatrixEvent = require("matrix-js-sdk").MatrixEvent;
  5. const RoomMember = require("matrix-js-sdk").RoomMember;
  6. const ClientRequestCache = require("./client-request-cache");
  8. const STATE_EVENT_TYPES = [
  9.     "m.room.name", "m.room.topic", "m.room.power_levels", "m.room.member",
  10.     "m.room.join_rules", "m.room.history_visibility"
  11. ];
  12. const DEFAULT_CACHE_TTL = 90000;
  13. const DEFAULT_CACHE_SIZE = 1024;
  15. /**
  16.  * Create an entity which can fulfil the intent of a given user.
  17.  * @constructor
  18.  * @param {MatrixClient} client The matrix client instance whose intent is being
  19.  * fulfilled e.g. the entity joining the room when you call intent.join(roomId).
  20.  * @param {MatrixClient} botClient The client instance for the AS bot itself.
  21.  * This will be used to perform more priveleged actions such as creating new
  22.  * rooms, sending invites, etc.
  23.  * @param {Object} opts Options for this Intent instance.
  24.  * @param {boolean} opts.registered True to inform this instance that the client
  25.  * is already registered. No registration requests will be made from this Intent.
  26.  * Default: false.
  27.  * @param {boolean} opts.dontCheckPowerLevel True to not check for the right power
  28.  * level before sending events. Default: false.
  29.  *
  30.  * @param {Object=} opts.backingStore An object with 4 functions, outlined below.
  31.  * If this Object is supplied, ALL 4 functions must be supplied. If this Object
  32.  * is not supplied, the Intent will maintain its own backing store for membership
  33.  * and power levels, which may scale badly for lots of users.
  34.  *
  35.  * @param {Function} opts.backingStore.getMembership A function which is called with a
  36.  * room ID and user ID which should return the membership status of this user as
  37.  * a string e.g "join". `null` should be returned if the membership is unknown.
  38.  *
  39.  * @param {Function} opts.backingStore.getPowerLevelContent A function which is called
  40.  * with a room ID which should return the power level content for this room, as an Object.
  41.  * `null` should be returned if there is no known content.
  42.  *
  43.  * @param {Function} opts.backingStore.setMembership A function with the signature:
  44.  * function(roomId, userId, membership) which will set the membership of the given user in
  45.  * the given room. This has no return value.
  46.  *
  47.  * @param {Function} opts.backingStore.setPowerLevelContent A function with the signature:
  48.  * function(roomId, content) which will set the power level content in the given room.
  49.  * This has no return value.
  50.  *
  51.  * @param {boolean} opts.dontJoin True to not attempt to join a room before
  52.  * sending messages into it. The surrounding code will have to ensure the correct
  53.  * membership state itself in this case. Default: false.
  54.  *
  55.  * @param {boolean} [opts.enablePresence=true] True to send presence, false to no-op.
  56.  *
  57.  * @param {Number} opts.caching.ttl How long requests can stay in the cache, in milliseconds.
  58.  * @param {Number} opts.caching.size How many entries should be kept in the cache, before the oldest is dropped.
  59.  */
  60. function Intent(client, botClient, opts) {
  61.     this.client = client;
  62.     this.botClient = botClient;
  63.     opts = opts || {};
  65.     opts.enablePresence = opts.enablePresence !== false;
  67.     if (opts.backingStore) {
  68.         if (!opts.backingStore.setPowerLevelContent ||
  69.                 !opts.backingStore.getPowerLevelContent ||
  70.                 !opts.backingStore.setMembership ||
  71.                 !opts.backingStore.getMembership) {
  72.             throw new Error("Intent backingStore missing required functions");
  73.         }
  74.     }
  75.     else {
  76.         this._membershipStates = {
  77.         //  room_id : "join|invite|leave|null"   null=unknown
  78.         };
  79.         this._powerLevels = {
  80.         //  room_id: event.content
  81.         };
  82.         var self = this;
  84.         opts.backingStore = {
  85.             getMembership: function(roomId, userId) {
  86.                 if (userId !== self.client.credentials.userId) {
  87.                     return null;
  88.                 }
  89.                 return self._membershipStates[roomId];
  90.             },
  91.             setMembership: function(roomId, userId, membership) {
  92.                 if (userId !== self.client.credentials.userId) {
  93.                     return;
  94.                 }
  95.                 self._membershipStates[roomId] = membership;
  96.             },
  97.             setPowerLevelContent: function(roomId, content) {
  98.                 self._powerLevels[roomId] = content;
  99.             },
  100.             getPowerLevelContent: function(roomId) {
  101.                 return self._powerLevels[roomId];
  102.             }
  103.         }
  104.     }
  106.     if (!opts.caching) {
  107.         opts.caching = { };
  108.     }
  110.     opts.caching.ttl = opts.caching.ttl === undefined ? DEFAULT_CACHE_TTL : opts.caching.ttl;
  111.     opts.caching.size = opts.caching.size === undefined ? DEFAULT_CACHE_SIZE : opts.caching.ttl;
  112.     this._requestCaches = {};
  113.     this._requestCaches.profile = new ClientRequestCache(
  114.         opts.caching.ttl,
  115.         opts.caching.size,
  116.         (_, userId, info) => {
  117.             return this.getProfileInfo(userId, info, false);
  118.         }
  119.     );
  120.     this._requestCaches.roomstate = new ClientRequestCache(
  121.         opts.caching.ttl,
  122.         opts.caching.size,
  123.         (roomId) => {
  124.         return this.roomState(roomId, false);
  125.         }
  126.     );
  127.     this._requestCaches.event = new ClientRequestCache(
  128.         opts.caching.ttl,
  129.         opts.caching.size,
  130.         (_, roomId, eventId) => {
  131.         return this.getEvent(roomId, eventId, false);
  132.         }
  133.     );
  135.     this.opts = opts;
  136. }
  138. /**
  139.  * Return the client this Intent is acting on behalf of.
  140.  * @return {MatrixClient} The client
  141.  */
  142. Intent.prototype.getClient = function() {
  143.     return this.client;
  144. };
  146. /**
  147.  * <p>Send a plaintext message to a room.</p>
  148.  * This will automatically make the client join the room so they can send the
  149.  * message if they are not already joined. It will also make sure that the client
  150.  * has sufficient power level to do this.
  151.  * @param {string} roomId The room to send to.
  152.  * @param {string} text The text string to send.
  153.  * @return {Promise}
  154.  */
  155. Intent.prototype.sendText = function(roomId, text) {
  156.     return this.sendMessage(roomId, {
  157.         body: text,
  158.         msgtype: "m.text"
  159.     });
  160. };
  162. /**
  163.  * <p>Set the name of a room.</p>
  164.  * This will automatically make the client join the room so they can set the
  165.  * name if they are not already joined. It will also make sure that the client
  166.  * has sufficient power level to do this.
  167.  * @param {string} roomId The room to send to.
  168.  * @param {string} name The room name.
  169.  * @return {Promise}
  170.  */
  171. Intent.prototype.setRoomName = function(roomId, name) {
  172.     return this.sendStateEvent(roomId, "m.room.name", "", {
  173.         name: name
  174.     });
  175. };
  177. /**
  178.  * <p>Set the topic of a room.</p>
  179.  * This will automatically make the client join the room so they can set the
  180.  * topic if they are not already joined. It will also make sure that the client
  181.  * has sufficient power level to do this.
  182.  * @param {string} roomId The room to send to.
  183.  * @param {string} topic The room topic.
  184.  * @return {Promise}
  185.  */
  186. Intent.prototype.setRoomTopic = function(roomId, topic) {
  187.     return this.sendStateEvent(roomId, "m.room.topic", "", {
  188.         topic: topic
  189.     });
  190. };
  192. /**
  193.  * <p>Set the avatar of a room.</p>
  194.  * This will automatically make the client join the room so they can set the
  195.  * topic if they are not already joined. It will also make sure that the client
  196.  * has sufficient power level to do this.
  197.  * @param {string} roomId The room to send to.
  198.  * @param {string} avatar The url of the avatar.
  199.  * @param {string} info Extra information about the image. See m.room.avatar for details.
  200.  * @return {Promise}
  201.  */
  202. Intent.prototype.setRoomAvatar = function(roomId, avatar, info) {
  203.     var content = {
  204.         url: avatar
  205.     };
  206.     if (info) {
  207.         content.info = info;
  208.     }
  209.     return this.sendStateEvent(roomId, "m.room.avatar", "", content);
  210. };
  212. /**
  213.  * <p>Send a typing event to a room.</p>
  214.  * This will automatically make the client join the room so they can send the
  215.  * typing event if they are not already joined.
  216.  * @param {string} roomId The room to send to.
  217.  * @param {boolean} isTyping True if typing
  218.  * @return {Promise}
  219.  */
  220. Intent.prototype.sendTyping = function(roomId, isTyping) {
  221.     var self = this;
  222.     return self._ensureJoined(roomId).then(function() {
  223.         return self._ensureHasPowerLevelFor(roomId, "m.typing");
  224.     }).then(function() {
  225.         return self.client.sendTyping(roomId, isTyping);
  226.     });
  227. };
  229. /**
  230.  * <p>Send a read receipt to a room.</p>
  231.  * This will automatically make the client join the room so they can send the
  232.  * receipt event if they are not already joined.
  233.  * @param{string} roomId The room to send to.
  234.  * @param{string} eventId The event ID to set the receipt mark to.
  235.  * @return {Promise}
  236.  */
  237. Intent.prototype.sendReadReceipt = function(roomId, eventId) {
  238.     var self = this;
  239.     var event = new MatrixEvent({
  240.         room_id: roomId,
  241.         event_id: eventId,
  242.     });
  243.     return self._ensureJoined(roomId).then(function() {
  244.         return self.client.sendReadReceipt(event);
  245.     });
  246. }
  248. /**
  249.  * Set the power level of the given target.
  250.  * @param {string} roomId The room to set the power level in.
  251.  * @param {string} target The target user ID
  252.  * @param {number} level The desired level
  253.  * @return {Promise}
  254.  */
  255. Intent.prototype.setPowerLevel = function(roomId, target, level) {
  256.     var self = this;
  257.     return self._ensureJoined(roomId).then(function() {
  258.         return self._ensureHasPowerLevelFor(roomId, "m.room.power_levels");
  259.     }).then(function(event) {
  260.         return self.client.setPowerLevel(roomId, target, level, event);
  261.     });
  262. };
  264. /**
  265.  * <p>Send an <code>m.room.message</code> event to a room.</p>
  266.  * This will automatically make the client join the room so they can send the
  267.  * message if they are not already joined. It will also make sure that the client
  268.  * has sufficient power level to do this.
  269.  * @param {string} roomId The room to send to.
  270.  * @param {Object} content The event content
  271.  * @return {Promise}
  272.  */
  273. Intent.prototype.sendMessage = function(roomId, content) {
  274.     return this.sendEvent(roomId, "m.room.message", content);
  275. };
  277. /**
  278.  * <p>Send a message event to a room.</p>
  279.  * This will automatically make the client join the room so they can send the
  280.  * message if they are not already joined. It will also make sure that the client
  281.  * has sufficient power level to do this.
  282.  * @param {string} roomId The room to send to.
  283.  * @param {string} type The event type
  284.  * @param {Object} content The event content
  285.  * @return {Promise}
  286.  */
  287. Intent.prototype.sendEvent = function(roomId, type, content) {
  288.     var self = this;
  289.     return self._ensureJoined(roomId).then(function() {
  290.         return self._ensureHasPowerLevelFor(roomId, type);
  291.     }).then(self._joinGuard(roomId, function() {
  292.         return self.client.sendEvent(roomId, type, content);
  293.     }));
  294. };
  296. /**
  297.  * <p>Send a state event to a room.</p>
  298.  * This will automatically make the client join the room so they can send the
  299.  * state if they are not already joined. It will also make sure that the client
  300.  * has sufficient power level to do this.
  301.  * @param {string} roomId The room to send to.
  302.  * @param {string} type The event type
  303.  * @param {string} skey The state key
  304.  * @param {Object} content The event content
  305.  * @return {Promise}
  306.  */
  307. Intent.prototype.sendStateEvent = function(roomId, type, skey, content) {
  308.     var self = this;
  309.     return self._ensureJoined(roomId).then(function() {
  310.         return self._ensureHasPowerLevelFor(roomId, type);
  311.     }).then(self._joinGuard(roomId, function() {
  312.         return self.client.sendStateEvent(roomId, type, content, skey);
  313.     }));
  314. };
  316. /**
  317.  * <p>Get the current room state for a room.</p>
  318.  * This will automatically make the client join the room so they can get the
  319.  * state if they are not already joined.
  320.  * @param {string} roomId The room to get the state from.
  321.  * @param {boolean} [useCache=false] Should the request attempt to lookup
  322.  * state from the cache.
  323.  * @return {Promise}
  324.  */
  325. Intent.prototype.roomState = function(roomId, useCache=false) {
  326.     return this._ensureJoined(roomId).then(() => {
  327.         if (useCache) {
  328.             return this._requestCaches.roomstate.get(roomId);
  329.         }
  330.         return this.client.roomState(roomId);
  331.     });
  332. };
  334. /**
  335.  * Create a room with a set of options.
  336.  * @param {Object} opts Options.
  337.  * @param {boolean} opts.createAsClient True to create this room as a client and
  338.  * not the bot: the bot will not join. False to create this room as the bot and
  339.  * auto-join the client. Default: false.
  340.  * @param {Object} opts.options Options to pass to the client SDK /createRoom API.
  341.  * @return {Promise}
  342.  */
  343. Intent.prototype.createRoom = function(opts) {
  344.     var self = this;
  345.     var cli = opts.createAsClient ? this.client : this.botClient;
  346.     var options = opts.options || {};
  347.     if (!opts.createAsClient) {
  348.         // invite the client if they aren't already
  349.         options.invite = options.invite || [];
  350.         if (options.invite.indexOf(this.client.credentials.userId) === -1) {
  351.             options.invite.push(this.client.credentials.userId);
  352.         }
  353.     }
  354.     // make sure that the thing doing the room creation isn't inviting itself
  355.     // else Synapse hard fails the operation with M_FORBIDDEN
  356.     if (options.invite && options.invite.indexOf(cli.credentials.userId) !== -1) {
  357.         options.invite.splice(options.invite.indexOf(cli.credentials.userId), 1);
  358.     }
  360.     return this._ensureRegistered().then(function() {
  361.         return cli.createRoom(options);
  362.     }).then(function(res) {
  363.         // create a fake power level event to give the room creator ops if we
  364.         // don't yet have a power level event.
  365.         if (self.opts.backingStore.getPowerLevelContent(res.room_id)) {
  366.             return res;
  367.         }
  368.         var users = {};
  369.         users[cli.credentials.userId] = 100;
  370.         self.opts.backingStore.setPowerLevelContent(res.room_id, {
  371.             users_default: 0,
  372.             events_default: 0,
  373.             state_default: 50,
  374.             users: users,
  375.             events: {}
  376.         });
  377.         return res;
  378.     });
  379. };
  381. /**
  382.  * <p>Invite a user to a room.</p>
  383.  * This will automatically make the client join the room so they can send the
  384.  * invite if they are not already joined.
  385.  * @param {string} roomId The room to invite the user to.
  386.  * @param {string} target The user ID to invite.
  387.  * @return {Promise} Resolved when invited, else rejected with an error.
  388.  */
  389. Intent.prototype.invite = function(roomId, target) {
  390.     var self = this;
  391.     return this._ensureJoined(roomId).then(function() {
  392.         return self.client.invite(roomId, target);
  393.     });
  394. };
  396. /**
  397.  * <p>Kick a user from a room.</p>
  398.  * This will automatically make the client join the room so they can send the
  399.  * kick if they are not already joined.
  400.  * @param {string} roomId The room to kick the user from.
  401.  * @param {string} target The target of the kick operation.
  402.  * @param {string} reason Optional. The reason for the kick.
  403.  * @return {Promise} Resolved when kickked, else rejected with an error.
  404.  */
  405. Intent.prototype.kick = function(roomId, target, reason) {
  406.     var self = this;
  407.     return this._ensureJoined(roomId).then(function() {
  408.         return self.client.kick(roomId, target, reason);
  409.     });
  410. };
  412. /**
  413.  * <p>Ban a user from a room.</p>
  414.  * This will automatically make the client join the room so they can send the
  415.  * ban if they are not already joined.
  416.  * @param {string} roomId The room to ban the user from.
  417.  * @param {string} target The target of the ban operation.
  418.  * @param {string} reason Optional. The reason for the ban.
  419.  * @return {Promise} Resolved when banned, else rejected with an error.
  420.  */
  421. Intent.prototype.ban = function(roomId, target, reason) {
  422.     var self = this;
  423.     return this._ensureJoined(roomId).then(function() {
  424.         return self.client.ban(roomId, target, reason);
  425.     });
  426. };
  428. /**
  429.  * <p>Unban a user from a room.</p>
  430.  * This will automatically make the client join the room so they can send the
  431.  * unban if they are not already joined.
  432.  * @param {string} roomId The room to unban the user from.
  433.  * @param {string} target The target of the unban operation.
  434.  * @return {Promise} Resolved when unbanned, else rejected with an error.
  435.  */
  436. Intent.prototype.unban = function(roomId, target) {
  437.     var self = this;
  438.     return this._ensureJoined(roomId).then(function() {
  439.         return self.client.unban(roomId, target);
  440.     });
  441. };
  443. /**
  444.  * <p>Join a room</p>
  445.  * This will automatically send an invite from the bot if it is an invite-only
  446.  * room, which may make the bot attempt to join the room if it isn't already.
  447.  * @param {string} roomId The room to join.
  448.  * @param {string[]} viaServers The server names to try and join through in
  449.  * addition to those that are automatically chosen.
  450.  * @return {Promise}
  451.  */
  452. Intent.prototype.join = function(roomId, viaServers) {
  453.     return this._ensureJoined(roomId, false, viaServers);
  454. };
  456. /**
  457.  * <p>Leave a room</p>
  458.  * This will no-op if the user isn't in the room.
  459.  * @param {string} roomId The room to leave.
  460.  * @return {Promise}
  461.  */
  462. Intent.prototype.leave = function(roomId) {
  463.     return this.client.leave(roomId);
  464. };
  466. /**
  467.  * <p>Get a user's profile information</p>
  468.  * @param {string} userId The ID of the user whose profile to return
  469.  * @param {string} info The profile field name to retrieve (e.g. 'displayname'
  470.  * or 'avatar_url'), or null to fetch the entire profile information.
  471.  * @param {boolean} [useCache=true] Should the request attempt to lookup
  472.  * state from the cache.
  473.  * @return {Promise} A Promise that resolves with the requested user's profile
  474.  * information
  475.  */
  476. Intent.prototype.getProfileInfo = function(userId, info, useCache=true) {
  477.     return this._ensureRegistered().then(() => {
  478.         if (useCache) {
  479.             return this._requestCaches.profile.get(`${userId}:${info}`, userId, info);
  480.         }
  481.         return this.client.getProfileInfo(userId, info);
  482.     });
  483. };
  485. /**
  486.  * <p>Set the user's display name</p>
  487.  * @param {string} name The new display name
  488.  * @return {Promise}
  489.  */
  490. Intent.prototype.setDisplayName = function(name) {
  491.     var self = this;
  492.     return self._ensureRegistered().then(function() {
  493.         return self.client.setDisplayName(name);
  494.     });
  495. };
  497. /**
  498.  * <p>Set the user's avatar URL</p>
  499.  * @param {string} url The new avatar URL
  500.  * @return {Promise}
  501.  */
  502. Intent.prototype.setAvatarUrl = function(url) {
  503.     var self = this;
  504.     return self._ensureRegistered().then(function() {
  505.         return self.client.setAvatarUrl(url);
  506.     });
  507. };
  509. /**
  510.  * Create a new alias mapping.
  511.  * @param {string} alias The room alias to create
  512.  * @param {string} roomId The room ID the alias should point at.
  513.  * @return {Promise}
  514.  */
  515. Intent.prototype.createAlias = function(alias, roomId) {
  516.     var self = this;
  517.     return self._ensureRegistered().then(function() {
  518.         return self.client.createAlias(alias, roomId);
  519.     });
  520. };
  522. /**
  523.  * Set the presence of this user.
  524.  * @param {string} presence One of "online", "offline" or "unavailable".
  525.  * @param {string} status_msg The status message to attach.
  526.  * @return {Promise} Resolves if the presence was set or no-oped, rejects otherwise.
  527.  */
  528. Intent.prototype.setPresence = function(presence, status_msg=undefined) {
  529.     if (!this.opts.enablePresence) {
  530.         return Promise.resolve();
  531.     }
  533.     return this._ensureRegistered().then(() => {
  534.         return this.client.setPresence({presence, status_msg});
  535.     });
  536. };
  538. /**
  539.  * @typedef {
  540.  *       "m.event_not_handled"
  541.  *     | "m.event_too_old"
  542.  *     | "m.internal_error"
  543.  *     | "m.foreign_network_error"
  544.  *     | "m.event_unknown"
  545.  * } BridgeErrorReason
  546.  */
  548. /**
  549.  * Signals that an error occured while handling an event by the bridge.
  550.  *
  551.  * **Warning**: This function is unstable and is likely to change pending the outcome
  552.  * of https://github.com/matrix-org/matrix-doc/pull/2162.
  553.  * @param {string} roomID ID of the room in which the error occured.
  554.  * @param {string} eventID ID of the event for which the error occured.
  555.  * @param {string} networkName Name of the bridged network.
  556.  * @param {BridgeErrorReason} reason The reason why the bridge error occured.
  557.  * @param {string} reason_body A human readable string d
  558.  * @param {string[]} affectedUsers Array of regex matching all affected users.
  559.  * @return {Promise}
  560.  */
  561. Intent.prototype.unstableSignalBridgeError = function(
  562.     roomID,
  563.     eventID,
  564.     networkName,
  565.     reason,
  566.     affectedUsers
  567. ) {
  568.     return this.sendEvent(
  569.         roomID,
  570.         "de.nasnotfound.bridge_error",
  571.         {
  572.             network_name: networkName,
  573.             reason: reason,
  574.             affected_users: affectedUsers,
  575.             "m.relates_to": {
  576.                 rel_type: "m.reference",
  577.                 event_id: eventID,
  578.             },
  579.         }
  580.     );
  581. }
  583. /**
  584.  * Get an event in a room.
  585.  * This will automatically make the client join the room so they can get the
  586.  * event if they are not already joined.
  587.  * @param {string} roomId The room to fetch the event from.
  588.  * @param {string} eventId The eventId of the event to fetch.
  589.  * @param {boolean} [useCache=true] Should the request attempt to lookup from the cache.
  590.  * @return {Promise} Resolves with the content of the event, or rejects if not found.
  591.  */
  592. Intent.prototype.getEvent = function(roomId, eventId, useCache=true) {
  593.     return this._ensureRegistered().then(() => {
  594.         if (useCache) {
  595.             return this._requestCaches.event.get(`${roomId}:${eventId}`, roomId, eventId);
  596.         }
  597.         return this.client.fetchRoomEvent(roomId, eventId);
  598.     });
  599. };
  601. /**
  602.  * Get a state event in a room.
  603.  * This will automatically make the client join the room so they can get the
  604.  * state if they are not already joined.
  605.  * @param {string} roomId The room to get the state from.
  606.  * @param {string} eventType The event type to fetch.
  607.  * @param {string} [stateKey=""] The state key of the event to fetch.
  608.  * @return {Promise}
  609.  */
  610. Intent.prototype.getStateEvent = function(roomId, eventType, stateKey = "") {
  611.     return this._ensureJoined(roomId).then(() => {
  612.         return this.client.getStateEvent(roomId, eventType, stateKey);
  613.     });
  614. };
  616. /**
  617.  * Inform this Intent class of an incoming event. Various optimisations will be
  618.  * done if this is provided. For example, a /join request won't be sent out if
  619.  * it knows you've already been joined to the room. This function does nothing
  620.  * if a backing store was provided to the Intent.
  621.  * @param {Object} event The incoming event JSON
  622.  */
  623. Intent.prototype.onEvent = function(event) {
  624.     if (!this._membershipStates || !this._powerLevels) {
  625.         return;
  626.     }
  627.     if (event.type === "m.room.member" &&
  628.             event.state_key === this.client.credentials.userId) {
  629.         this._membershipStates[event.room_id] = event.content.membership;
  630.     }
  631.     else if (event.type === "m.room.power_levels") {
  632.         this._powerLevels[event.room_id] = event.content;
  633.     }
  634. };
  636. // Guard a function which returns a promise which may reject if the user is not
  637. // in the room. If the promise rejects, join the room and retry the function.
  638. Intent.prototype._joinGuard = function(roomId, promiseFn) {
  639.     var self = this;
  640.     return function() {
  641.         return promiseFn().catch(function(err) {
  642.             if (err.errcode !== "M_FORBIDDEN") {
  643.                 // not a guardable error
  644.                 throw err;
  645.             }
  646.             return self._ensureJoined(roomId, true).then(function() {
  647.                 return promiseFn();
  648.             })
  649.         });
  650.     };
  651. };
  653. Intent.prototype._ensureJoined = function(
  654.     roomId, ignoreCache = false, viaServers = undefined, passthroughError = false
  655. ) {
  656.     var self = this;
  657.     var userId = self.client.credentials.userId;
  658.     const opts = {
  659.         syncRoom: false,
  660.     };
  661.     if (viaServers) {
  662.         opts.viaServers = viaServers;
  663.     }
  664.     if (this.opts.backingStore.getMembership(roomId, userId) === "join" && !ignoreCache) {
  665.         return Promise.resolve();
  666.     }
  668.     /* Logic:
  669.     if client /join:
  670.       SUCCESS
  671.     else if bot /invite client:
  672.       if client /join:
  673.         SUCCESS
  674.       else:
  675.         FAIL (client couldn't join)
  676.     else if bot /join:
  677.       if bot /invite client and client /join:
  678.         SUCCESS
  679.       else:
  680.         FAIL (bot couldn't invite)
  681.     else:
  682.       FAIL (bot can't get into the room)
  683.     */
  685.     var d = new Promise.defer();
  687.     function mark(r, state) {
  688.         self.opts.backingStore.setMembership(r, userId, state);
  689.         if (state === "join") {
  690.             d.resolve();
  691.         }
  692.     }
  694.     var dontJoin = this.opts.dontJoin;
  696.     self._ensureRegistered().done(function() {
  697.         if (dontJoin) {
  698.             d.resolve();
  699.             return;
  700.         }
  702.         self.client.joinRoom(roomId, opts).then(function() {
  703.             mark(roomId, "join");
  704.         }, function(e) {
  705.             if (e.errcode !== "M_FORBIDDEN" || self.botClient === self) {
  706.                 d.reject(passthroughError ? e : new Error("Failed to join room"));
  707.                 return;
  708.             }
  710.             // Try bot inviting client
  711.             self.botClient.invite(roomId, userId).then(function() {
  712.                 return self.client.joinRoom(roomId, opts);
  713.             }).done(function() {
  714.                 mark(roomId, "join");
  715.             }, function(invErr) {
  716.                 // Try bot joining
  717.                 self.botClient.joinRoom(roomId, opts)
  718.                 .then(function() {
  719.                     return self.botClient.invite(roomId, userId);
  720.                 }).then(function() {
  721.                     return self.client.joinRoom(roomId, opts);
  722.                 }).done(function() {
  723.                     mark(roomId, "join");
  724.                 }, function(finalErr) {
  725.                     d.reject(passthroughError ? e : new Error("Failed to join room"));
  726.                     return;
  727.                 });
  728.             });
  729.         });
  730.     }, function(e) {
  731.         d.reject(e);
  732.     });
  734.     return d.promise;
  735. };
  737. Intent.prototype._ensureHasPowerLevelFor = function(roomId, eventType) {
  738.     if (this.opts.dontCheckPowerLevel && eventType !== "m.room.power_levels") {
  739.         return Promise.resolve();
  740.     }
  741.     var self = this;
  742.     var userId = this.client.credentials.userId;
  743.     var plContent = this.opts.backingStore.getPowerLevelContent(roomId);
  744.     var promise = Promise.resolve(plContent);
  745.     if (!plContent) {
  746.         promise = this.client.getStateEvent(roomId, "m.room.power_levels", "");
  747.     }
  748.     return promise.then(function(eventContent) {
  749.         self.opts.backingStore.setPowerLevelContent(roomId, eventContent);
  750.         var event = {
  751.             content: eventContent,
  752.             room_id: roomId,
  753.             user_id: "",
  754.             event_id: "_",
  755.             state_key: "",
  756.             type: "m.room.power_levels"
  757.         }
  758.         var powerLevelEvent = new MatrixEvent(event);
  759.         // What level do we need for this event type?
  760.         var defaultLevel = event.content.events_default;
  761.         if (STATE_EVENT_TYPES.indexOf(eventType) !== -1) {
  762.             defaultLevel = event.content.state_default;
  763.         }
  764.         var requiredLevel = event.content.events[eventType] || defaultLevel;
  766.         // Parse out what level the client has by abusing the JS SDK
  767.         var roomMember = new RoomMember(roomId, userId);
  768.         roomMember.setPowerLevelEvent(powerLevelEvent);
  770.         if (requiredLevel > roomMember.powerLevel) {
  771.             // can the bot update our power level?
  772.             var bot = new RoomMember(roomId, self.botClient.credentials.userId);
  773.             bot.setPowerLevelEvent(powerLevelEvent);
  774.             var levelRequiredToModifyPowerLevels = event.content.events[
  775.                 "m.room.power_levels"
  776.             ] || event.content.state_default;
  777.             if (levelRequiredToModifyPowerLevels > bot.powerLevel) {
  778.                 // even the bot has no power here.. give up.
  779.                 throw new Error(
  780.                     "Cannot ensure client has power level for event " + eventType +
  781.                     " : client has " + roomMember.powerLevel + " and we require " +
  782.                     requiredLevel + " and the bot doesn't have permission to " +
  783.                     "edit the client's power level."
  784.                 );
  785.             }
  786.             // update the client's power level first
  787.             return self.botClient.setPowerLevel(
  788.                 roomId, userId, requiredLevel, powerLevelEvent
  789.             ).then(function() {
  790.                 // tweak the level for the client to reflect the new reality
  791.                 var userLevels = powerLevelEvent.getContent().users || {};
  792.                 userLevels[userId] = requiredLevel;
  793.                 powerLevelEvent.getContent().users = userLevels;
  794.                 return Promise.resolve(powerLevelEvent);
  795.             });
  796.         }
  797.         return Promise.resolve(powerLevelEvent);
  798.     });
  799. };
  801. Intent.prototype._ensureRegistered = function() {
  802.     if (this.opts.registered) {
  803.         return Promise.resolve("registered=true");
  804.     }
  805.     const userId = this.client.credentials.userId;
  806.     const localpart = new MatrixUser(userId).localpart;
  807.     return this.botClient.register(localpart).then((res) => {
  808.         this.opts.registered = true;
  809.         return res;
  810.     }).catch((err) => {
  811.         if (err.errcode === "M_USER_IN_USE") {
  812.             this.opts.registered = true;
  813.             return null;
  814.         }
  815.         throw err;
  816.     });
  817. };
  819. module.exports = Intent;