Prepare utils for local rooms (#9084)

* Prepare utils for local rooms * Split up direct-messages module
2022-07-25 10:17:40 +02:00
parent 0a8adb6bfe
commit c5eaeafe8e
20 changed files with 1016 additions and 220 deletions
@@ -0,0 +1,123 @@
+/*
+Copyright 2022 The Matrix.org Foundation C.I.C.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+import { MEGOLM_ALGORITHM } from "matrix-js-sdk/src/crypto/olmlib";
+import { EventType, KNOWN_SAFE_ROOM_VERSION, MatrixClient, MatrixEvent } from "matrix-js-sdk/src/matrix";
+
+import { LocalRoom, LOCAL_ROOM_ID_PREFIX } from "../../../src/models/LocalRoom";
+import { determineCreateRoomEncryptionOption, Member } from "../../../src/utils/direct-messages";
+
+/**
+ * Create a DM local room. This room will not be send to the server and only exists inside the client.
+ * It sets up the local room with some artificial state events
+ * so that can be used in most components instead of a „real“ room.
+ *
+ * @async
+ * @param {MatrixClient} client
+ * @param {Member[]} targets DM partners
+ * @returns {Promise<LocalRoom>} Resolves to the new local room
+ */
+export async function createDmLocalRoom(
+    client: MatrixClient,
+    targets: Member[],
+): Promise<LocalRoom> {
+    const userId = client.getUserId();
+
+    const localRoom = new LocalRoom(LOCAL_ROOM_ID_PREFIX + client.makeTxnId(), client, userId);
+    const events = [];
+
+    events.push(new MatrixEvent({
+        event_id: `~${localRoom.roomId}:${client.makeTxnId()}`,
+        type: EventType.RoomCreate,
+        content: {
+            creator: userId,
+            room_version: KNOWN_SAFE_ROOM_VERSION,
+        },
+        state_key: "",
+        user_id: userId,
+        sender: userId,
+        room_id: localRoom.roomId,
+        origin_server_ts: Date.now(),
+    }));
+
+    if (await determineCreateRoomEncryptionOption(client, targets)) {
+        localRoom.encrypted = true;
+        events.push(
+            new MatrixEvent({
+                event_id: `~${localRoom.roomId}:${client.makeTxnId()}`,
+                type: EventType.RoomEncryption,
+                content: {
+                    algorithm: MEGOLM_ALGORITHM,
+                },
+                user_id: userId,
+                sender: userId,
+                state_key: "",
+                room_id: localRoom.roomId,
+                origin_server_ts: Date.now(),
+            }),
+        );
+    }
+
+    events.push(new MatrixEvent({
+        event_id: `~${localRoom.roomId}:${client.makeTxnId()}`,
+        type: EventType.RoomMember,
+        content: {
+            displayname: userId,
+            membership: "join",
+        },
+        state_key: userId,
+        user_id: userId,
+        sender: userId,
+        room_id: localRoom.roomId,
+    }));
+
+    targets.forEach((target: Member) => {
+        events.push(new MatrixEvent({
+            event_id: `~${localRoom.roomId}:${client.makeTxnId()}`,
+            type: EventType.RoomMember,
+            content: {
+                displayname: target.name,
+                avatar_url: target.getMxcAvatarUrl(),
+                membership: "invite",
+                isDirect: true,
+            },
+            state_key: target.userId,
+            sender: userId,
+            room_id: localRoom.roomId,
+        }));
+        events.push(new MatrixEvent({
+            event_id: `~${localRoom.roomId}:${client.makeTxnId()}`,
+            type: EventType.RoomMember,
+            content: {
+                displayname: target.name,
+                avatar_url: target.getMxcAvatarUrl(),
+                membership: "join",
+            },
+            state_key: target.userId,
+            sender: target.userId,
+            room_id: localRoom.roomId,
+        }));
+    });
+
+    localRoom.targets = targets;
+    localRoom.updateMyMembership("join");
+    localRoom.addLiveEvents(events);
+    localRoom.currentState.setStateEvents(events);
+    localRoom.name = localRoom.getDefaultRoomName(client.getUserId());
+    client.store.storeRoom(localRoom);
+
+    return localRoom;
+}
@@ -0,0 +1,55 @@
+/*
+Copyright 2022 The Matrix.org Foundation C.I.C.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+import { MatrixClient, Room } from "matrix-js-sdk/src/matrix";
+
+import DMRoomMap from "../DMRoomMap";
+import { isLocalRoom } from "../localRoom/isLocalRoom";
+import { isJoinedOrNearlyJoined } from "../membership";
+
+/**
+ * Tries to find a DM room with a specific user.
+ *
+ * @param {MatrixClient} client
+ * @param {string} userId ID of the user to find the DM for
+ * @returns {Room} Room if found
+ */
+export function findDMForUser(client: MatrixClient, userId: string): Room {
+    const roomIds = DMRoomMap.shared().getDMRoomsForUserId(userId);
+    const rooms = roomIds.map(id => client.getRoom(id));
+    const suitableDMRooms = rooms.filter(r => {
+        // Validate that we are joined and the other person is also joined. We'll also make sure
+        // that the room also looks like a DM (until we have canonical DMs to tell us). For now,
+        // a DM is a room of two people that contains those two people exactly. This does mean
+        // that bots, assistants, etc will ruin a room's DM-ness, though this is a problem for
+        // canonical DMs to solve.
+        if (r && r.getMyMembership() === "join") {
+            if (isLocalRoom(r)) return false;
+
+            const members = r.currentState.getMembers();
+            const joinedMembers = members.filter(m => isJoinedOrNearlyJoined(m.membership));
+            const otherMember = joinedMembers.find(m => m.userId === userId);
+            return otherMember && joinedMembers.length === 2;
+        }
+        return false;
+    }).sort((r1, r2) => {
+        return r2.getLastActiveTimestamp() -
+            r1.getLastActiveTimestamp();
+    });
+    if (suitableDMRooms.length) {
+        return suitableDMRooms[0];
+    }
+}
@@ -0,0 +1,42 @@
+/*
+Copyright 2022 The Matrix.org Foundation C.I.C.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+import { MatrixClient, Room } from "matrix-js-sdk/src/matrix";
+
+import { Member } from "../direct-messages";
+import DMRoomMap from "../DMRoomMap";
+import { findDMForUser } from "./findDMForUser";
+
+/**
+ * Tries to find a DM room with some other users.
+ *
+ * @param {MatrixClient} client
+ * @param {Member[]} targets The Members to try to find the room for
+ * @returns {Room | null} Resolved so the room if found, else null
+ */
+export function findDMRoom(client: MatrixClient, targets: Member[]): Room | null {
+    const targetIds = targets.map(t => t.userId);
+    let existingRoom: Room;
+    if (targetIds.length === 1) {
+        existingRoom = findDMForUser(client, targetIds[0]);
+    } else {
+        existingRoom = DMRoomMap.shared().getDMRoomForIdentifiers(targetIds);
+    }
+    if (existingRoom) {
+        return existingRoom;
+    }
+    return null;
+}
@@ -0,0 +1,90 @@
+/*
+Copyright 2022 The Matrix.org Foundation C.I.C.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+import { IInvite3PID, MatrixClient, Room } from "matrix-js-sdk/src/matrix";
+
+import { Action } from "../../dispatcher/actions";
+import { ViewRoomPayload } from "../../dispatcher/payloads/ViewRoomPayload";
+import { determineCreateRoomEncryptionOption, Member } from "../direct-messages";
+import DMRoomMap from "../DMRoomMap";
+import { isLocalRoom } from "../localRoom/isLocalRoom";
+import { findDMForUser } from "./findDMForUser";
+import dis from "../../dispatcher/dispatcher";
+import { getAddressType } from "../../UserAddress";
+import createRoom from "../../createRoom";
+
+/**
+ * Start a DM.
+ *
+ * @returns {Promise<string | null} Resolves to the room id.
+ */
+export async function startDm(client: MatrixClient, targets: Member[], showSpinner = true): Promise<string | null> {
+    const targetIds = targets.map(t => t.userId);
+
+    // Check if there is already a DM with these people and reuse it if possible.
+    let existingRoom: Room;
+    if (targetIds.length === 1) {
+        existingRoom = findDMForUser(client, targetIds[0]);
+    } else {
+        existingRoom = DMRoomMap.shared().getDMRoomForIdentifiers(targetIds);
+    }
+    if (existingRoom && !isLocalRoom(existingRoom)) {
+        dis.dispatch<ViewRoomPayload>({
+            action: Action.ViewRoom,
+            room_id: existingRoom.roomId,
+            should_peek: false,
+            joining: false,
+            metricsTrigger: "MessageUser",
+        });
+        return Promise.resolve(existingRoom.roomId);
+    }
+
+    const createRoomOptions = { inlineErrors: true } as any; // XXX: Type out `createRoomOptions`
+
+    if (await determineCreateRoomEncryptionOption(client, targets)) {
+        createRoomOptions.encryption = true;
+    }
+
+    // Check if it's a traditional DM and create the room if required.
+    // TODO: [Canonical DMs] Remove this check and instead just create the multi-person DM
+    const isSelf = targetIds.length === 1 && targetIds[0] === client.getUserId();
+    if (targetIds.length === 1 && !isSelf) {
+        createRoomOptions.dmUserId = targetIds[0];
+    }
+
+    if (targetIds.length > 1) {
+        createRoomOptions.createOpts = targetIds.reduce(
+            (roomOptions, address) => {
+                const type = getAddressType(address);
+                if (type === 'email') {
+                    const invite: IInvite3PID = {
+                        id_server: client.getIdentityServerUrl(true),
+                        medium: 'email',
+                        address,
+                    };
+                    roomOptions.invite_3pid.push(invite);
+                } else if (type === 'mx-user-id') {
+                    roomOptions.invite.push(address);
+                }
+                return roomOptions;
+            },
+            { invite: [], invite_3pid: [] },
+        );
+    }
+
+    createRoomOptions.spinner = showSpinner;
+    return createRoom(createRoomOptions);
+}