fix leave of opengroupv2 logic

ts/data/opengroups.ts

@@ -69,14 +69,11 @@ export async function saveV2OpenGroupRoom(opengroupsv2Room: OpenGroupV2Room): Pr
   ) {
     throw new Error('Cannot save v2 room, invalid data');
   }
-  console.warn('saving roomInfo', opengroupsv2Room);
 
   await channels.saveV2OpenGroupRoom(opengroupsv2Room);
 }
 
 export async function removeV2OpenGroupRoom(conversationId: string): Promise<void> {
-  console.warn('removing roomInfo', conversationId);
-
   await channels.removeV2OpenGroupRoom(conversationId);
 }
 

ts/models/conversation.ts

@@ -4,7 +4,7 @@ import { getMessageQueue } from '../session';
 import { ConversationController } from '../session/conversations';
 import { ClosedGroupVisibleMessage } from '../session/messages/outgoing/visibleMessage/ClosedGroupVisibleMessage';
 import { PubKey } from '../session/types';
-import { ToastUtils, UserUtils } from '../session/utils';
+import { UserUtils } from '../session/utils';
 import { BlockedNumberController } from '../util';
 import { MessageController } from '../session/messages';
 import { leaveClosedGroup } from '../session/group';
@@ -37,12 +37,7 @@ import {
 import { GroupInvitationMessage } from '../session/messages/outgoing/visibleMessage/GroupInvitationMessage';
 import { ReadReceiptMessage } from '../session/messages/outgoing/controlMessage/receipt/ReadReceiptMessage';
 import { OpenGroup } from '../opengroup/opengroupV1/OpenGroup';
-import {
-  openGroupPrefixRegex,
-  openGroupV1ConversationIdRegex,
-  openGroupV2ConversationIdRegex,
-} from '../opengroup/utils/OpenGroupUtils';
-import { getV2OpenGroupRoom } from '../data/opengroups';
+import { OpenGroupUtils } from '../opengroup/utils';
 import { ConversationInteraction } from '../interactions';
 
 export enum ConversationType {
@@ -194,10 +189,13 @@ export class ConversationModel extends Backbone.Model<ConversationAttributes> {
     return UserUtils.isUsFromCache(this.id);
   }
   public isPublic(): boolean {
-    return Boolean(this.id && this.id.match(openGroupPrefixRegex));
+    return Boolean(this.id && this.id.match(OpenGroupUtils.openGroupPrefixRegex));
   }
   public isOpenGroupV2(): boolean {
-    return Boolean(this.id && this.id.match(openGroupV2ConversationIdRegex));
+    return OpenGroupUtils.isOpenGroupV2(this.id);
+  }
+  public isOpenGroupV1(): boolean {
+    return OpenGroupUtils.isOpenGroupV1(this.id);
   }
   public isClosedGroup() {
     return this.get('type') === ConversationType.GROUP && !this.isPublic();

ts/opengroup/opengroupV2/JoinOpenGroupV2.ts

@@ -12,7 +12,7 @@ import {
   prefixify,
   publicKeyParam,
 } from '../utils/OpenGroupUtils';
-import { attemptConnectionV2OneAtATime } from './OpenGroupManagerV2';
+import { OpenGroupManagerV2 } from './OpenGroupManagerV2';
 
 // Inputs that should work:
 // https://sessionopengroup.co/main?public_key=658d29b91892a2389505596b135e76a53db6e11d613a51dbd3d0816adffb231c
@@ -78,8 +78,8 @@ export async function joinOpenGroupV2(
   if (alreadyExist && existingConvo) {
     window.log.warn('Skipping join opengroupv2: already exists');
     return;
-  } else if (alreadyExist) {
-    // we don't have a convo associated with it. Remove everything related to it so we start fresh
+  } else if (existingConvo) {
+    // we already have a convo associated with it. Remove everything related to it so we start fresh
     window.log.warn('leaving before rejoining open group v2 room', conversationId);
     await ConversationController.getInstance().deleteContact(conversationId);
   }
@@ -87,7 +87,11 @@ export async function joinOpenGroupV2(
   // Try to connect to server
   try {
     const conversation = await PromiseUtils.timeout(
-      attemptConnectionV2OneAtATime(prefixedServer, roomId, publicKey),
+      OpenGroupManagerV2.getInstance().attemptConnectionV2OneAtATime(
+        prefixedServer,
+        roomId,
+        publicKey
+      ),
       20000
     );
 

ts/opengroup/opengroupV2/OpenGroupAPIV2.ts

@@ -44,7 +44,6 @@ async function sendOpenGroupV2Request(request: OpenGroupV2Request): Promise<Obje
   const headers = request.headers || {};
   headers.Room = request.room;
 
-  console.warn(`sending request: ${builtUrl}`);
   let body = '';
   if (request.method !== 'GET') {
     body = JSON.stringify(request.queryParams);

ts/opengroup/opengroupV2/OpenGroupManagerV2.ts

@@ -15,85 +15,6 @@ import { OpenGroupServerPoller } from './OpenGroupServerPoller';
 
 import _ from 'lodash';
 
-/**
- * When we get our configuration from the network, we might get a few times the same open group on two different messages.
- * If we don't do anything, we will join them multiple times.
- * Even if the convo exists only once, the lokiPublicChat API will have several instances polling for the same open group.
- * Which will cause a lot of duplicate messages as they will be merged on a single conversation.
- *
- * To avoid this issue, we allow only a single join of a specific opengroup at a time.
- */
-export async function attemptConnectionV2OneAtATime(
-  serverUrl: string,
-  roomId: string,
-  publicKey: string
-): Promise<ConversationModel> {
-  const oneAtaTimeStr = `oneAtaTimeOpenGroupV2Join:${serverUrl}${roomId}`;
-  return allowOnlyOneAtATime(oneAtaTimeStr, async () => {
-    return attemptConnectionV2(serverUrl, roomId, publicKey);
-  });
-}
-
-/**
- *
- * @param serverUrl with protocol, hostname and port included
- */
-async function attemptConnectionV2(
-  serverUrl: string,
-  roomId: string,
-  serverPublicKey: string
-): Promise<ConversationModel | undefined> {
-  const conversationId = getOpenGroupV2ConversationId(serverUrl, roomId);
-
-  if (ConversationController.getInstance().get(conversationId)) {
-    // Url incorrect or server not compatible
-    throw new Error(window.i18n('publicChatExists'));
-  }
-
-  // here, the convo does not exist. Make sure the db is clean too
-  await removeV2OpenGroupRoom(conversationId);
-
-  const room: OpenGroupV2Room = {
-    serverUrl,
-    roomId,
-    conversationId,
-    serverPublicKey,
-  };
-
-  try {
-    // save the pubkey to the db right now, the request for room Info
-    // will need it and access it from the db
-    await saveV2OpenGroupRoom(room);
-    const roomInfos = await openGroupV2GetRoomInfo({ roomId, serverUrl });
-    if (!roomInfos) {
-      throw new Error('Invalid open group roomInfo result');
-    }
-    const conversation = await ConversationController.getInstance().getOrCreateAndWait(
-      conversationId,
-      ConversationType.GROUP
-    );
-    room.imageID = roomInfos.imageId || undefined;
-    room.roomName = roomInfos.name || undefined;
-    await saveV2OpenGroupRoom(room);
-
-    console.warn('openGroupRoom info', roomInfos);
-
-    // mark active so it's not in the contacts list but in the conversation list
-    conversation.set({
-      active_at: Date.now(),
-      name: room.roomName,
-      avatarPath: room.roomName,
-    });
-    await conversation.commit();
-
-    return conversation;
-  } catch (e) {
-    window.log.warn('Failed to join open group v2', e);
-    await removeV2OpenGroupRoom(conversationId);
-    throw new Error(window.i18n('connectToServerFail'));
-  }
-}
-
 export class OpenGroupManagerV2 {
   public static readonly useV2OpenGroups = false;
 
@@ -104,6 +25,7 @@ export class OpenGroupManagerV2 {
 
   private constructor() {
     this.startPollingBouncy = this.startPollingBouncy.bind(this);
+    this.attemptConnectionV2 = this.attemptConnectionV2.bind(this);
   }
 
   public static getInstance() {
@@ -113,6 +35,25 @@ export class OpenGroupManagerV2 {
     return OpenGroupManagerV2.instance;
   }
 
+  /**
+   * When we get our configuration from the network, we might get a few times the same open group on two different messages.
+   * If we don't do anything, we will join them multiple times.
+   * Even if the convo exists only once, the lokiPublicChat API will have several instances polling for the same open group.
+   * Which will cause a lot of duplicate messages as they will be merged on a single conversation.
+   *
+   * To avoid this issue, we allow only a single join of a specific opengroup at a time.
+   */
+  public async attemptConnectionV2OneAtATime(
+    serverUrl: string,
+    roomId: string,
+    publicKey: string
+  ): Promise<ConversationModel> {
+    const oneAtaTimeStr = `oneAtaTimeOpenGroupV2Join:${serverUrl}${roomId}`;
+    return allowOnlyOneAtATime(oneAtaTimeStr, async () => {
+      return this.attemptConnectionV2(serverUrl, roomId, publicKey);
+    });
+  }
+
   public async startPolling() {
     await allowOnlyOneAtATime('V2ManagerStartPolling', this.startPollingBouncy);
   }
@@ -201,4 +142,67 @@ export class OpenGroupManagerV2 {
 
     this.isPolling = true;
   }
+
+  /**
+   *
+   * @param serverUrl with protocol, hostname and port included
+   */
+  private async attemptConnectionV2(
+    serverUrl: string,
+    roomId: string,
+    serverPublicKey: string
+  ): Promise<ConversationModel | undefined> {
+    const conversationId = getOpenGroupV2ConversationId(serverUrl, roomId);
+
+    if (ConversationController.getInstance().get(conversationId)) {
+      // Url incorrect or server not compatible
+      throw new Error(window.i18n('publicChatExists'));
+    }
+
+    // here, the convo does not exist. Make sure the db is clean too
+    await removeV2OpenGroupRoom(conversationId);
+
+    const room: OpenGroupV2Room = {
+      serverUrl,
+      roomId,
+      conversationId,
+      serverPublicKey,
+    };
+
+    try {
+      // save the pubkey to the db right now, the request for room Info
+      // will need it and access it from the db
+      await saveV2OpenGroupRoom(room);
+      const roomInfos = await openGroupV2GetRoomInfo({ roomId, serverUrl });
+      if (!roomInfos) {
+        throw new Error('Invalid open group roomInfo result');
+      }
+      const conversation = await ConversationController.getInstance().getOrCreateAndWait(
+        conversationId,
+        ConversationType.GROUP
+      );
+      room.imageID = roomInfos.imageId || undefined;
+      room.roomName = roomInfos.name || undefined;
+      await saveV2OpenGroupRoom(room);
+
+      console.warn('openGroupRoom info', roomInfos);
+
+      // mark active so it's not in the contacts list but in the conversation list
+      conversation.set({
+        active_at: Date.now(),
+        name: room.roomName,
+        avatarPath: room.roomName,
+      });
+      await conversation.commit();
+
+      // start polling this room
+      this.addRoomToPolledRooms(room);
+
+      return conversation;
+    } catch (e) {
+      window.log.warn('Failed to join open group v2', e);
+      await removeV2OpenGroupRoom(conversationId);
+      throw new Error(window.i18n('connectToServerFail'));
+    }
+  }
 }

ts/opengroup/utils/OpenGroupUtils.ts

@@ -24,16 +24,6 @@ export const openGroupV2CompleteURLRegex = new RegExp(
   'gm'
 );
 
-/**
- * This function returns a full url on an open group v2 room used for sync messages for instance.
- * This is basically what the QRcode encodes
- *
- */
-export function getCompleteUrlFromRoom(roomInfos: OpenGroupV2Room) {
-  // serverUrl has the port and protocol already
-  return `${roomInfos.serverUrl}/${roomInfos.roomId}?${publicKeyParam}${roomInfos.serverPublicKey}`;
-}
-
 /**
  * Just a constant to have less `publicChat:` everywhere.
  * This is the prefix used to identify our open groups in the conversation database (v1 or v2)
@@ -50,13 +40,23 @@ export const openGroupPrefixRegex = new RegExp(`^${openGroupPrefix}`);
  * An open group v1 conversation id can only have the char '1' as roomId
  */
 export const openGroupV1ConversationIdRegex = new RegExp(
-  `${openGroupPrefix}1@${protocolRegex}${hostnameRegex}`
+  `${openGroupPrefix}1@${protocolRegex.source}${hostnameRegex.source}`
 );
 
 export const openGroupV2ConversationIdRegex = new RegExp(
-  `${openGroupPrefix}${roomIdV2Regex}@${protocolRegex}${hostnameRegex}${portRegex}`
+  `${openGroupPrefix}${roomIdV2Regex}@${protocolRegex.source}${hostnameRegex.source}${portRegex}`
 );
 
+/**
+ * This function returns a full url on an open group v2 room used for sync messages for instance.
+ * This is basically what the QRcode encodes
+ *
+ */
+export function getCompleteUrlFromRoom(roomInfos: OpenGroupV2Room) {
+  // serverUrl has the port and protocol already
+  return `${roomInfos.serverUrl}/${roomInfos.roomId}?${publicKeyParam}${roomInfos.serverPublicKey}`;
+}
+
 /**
  * Tries to establish a connection with the specified open group url.
  *
@@ -163,6 +163,16 @@ export function getOpenGroupV2ConversationId(serverUrl: string, roomId: string)
   return `${openGroupPrefix}${roomId}@${serverUrl}`;
 }
 
+/**
+ * Check if this conversation id corresponds to an OpenGroupV1 conversation.
+ * No access to database are made. Only regex matches
+ * @param conversationId the convo id to evaluate
+ * @returns true if this conversation id matches the Opengroupv1 conversation id regex
+ */
+export function isOpenGroupV1(conversationId: string) {
+  return openGroupV1ConversationIdRegex.test(conversationId);
+}
+
 /**
  * Check if this conversation id corresponds to an OpenGroupV2 conversation.
  * No access to database are made. Only regex matches
@@ -170,16 +180,10 @@ export function getOpenGroupV2ConversationId(serverUrl: string, roomId: string)
  * @returns true if this conversation id matches the Opengroupv2 conversation id regex
  */
 export function isOpenGroupV2(conversationId: string) {
-  if (!conversationId?.match(openGroupPrefixRegex)) {
-    // this is not even an open group
-    return false;
-  }
-
-  if (!conversationId?.match(openGroupV1ConversationIdRegex)) {
+  if (openGroupV1ConversationIdRegex.test(conversationId)) {
     // this is an open group v1
-    console.warn('this is an open group v1:', conversationId);
     return false;
   }
 
-  return conversationId.match(openGroupV2ConversationIdRegex);
+  return openGroupV2ConversationIdRegex.test(conversationId);
 }

ts/opengroup/utils/index.ts

@@ -0,0 +1,3 @@
+import * as OpenGroupUtils from './OpenGroupUtils';
+
+export { OpenGroupUtils };

ts/session/conversations/ConversationController.ts

@@ -203,9 +203,17 @@ export class ConversationController {
       if (roomInfos) {
         OpenGroupManagerV2.getInstance().removeRoomFromPolledRooms(roomInfos);
         // leave the group on the remote server
-        await deleteAuthToken(_.pick(roomInfos, 'serverUrl', 'roomId'));
+        try {
+          await deleteAuthToken(_.pick(roomInfos, 'serverUrl', 'roomId'));
+        } catch (e) {
+          window.log.info('deleteAuthToken failed:', e);
+        }
         // remove the roomInfos locally for this open group room
-        await removeV2OpenGroupRoom(conversation.id);
+        try {
+          await removeV2OpenGroupRoom(conversation.id);
+        } catch (e) {
+          window.log.info('removeV2OpenGroupRoom failed:', e);
+        }
       }
     }
 

ts/session/utils/syncUtils.ts

@@ -26,6 +26,8 @@ import {
   VisibleMessage,
 } from '../messages/outgoing/visibleMessage/VisibleMessage';
 import { ExpirationTimerUpdateMessage } from '../messages/outgoing/controlMessage/ExpirationTimerUpdateMessage';
+import { getV2OpenGroupRoom } from '../../data/opengroups';
+import { getCompleteUrlFromRoom } from '../../opengroup/utils/OpenGroupUtils';
 
 const ITEM_ID_LAST_SYNC_TIMESTAMP = 'lastSyncedTimestamp';
 
@@ -88,14 +90,29 @@ export const forceSyncConfigurationNowIfNeeded = async (waitForMessageSent = fal
       });
   });
 
-export const getCurrentConfigurationMessage = async (convos: Array<ConversationModel>) => {
-  const ourPubKey = UserUtils.getOurPubKeyStrFromCache();
-  const ourConvo = convos.find(convo => convo.id === ourPubKey);
+const getActiveOpenGroupV2CompleteUrls = async (
+  convos: Array<ConversationModel>
+): Promise<Array<string>> => {
+  // Filter open groups v2
+  const openGroupsV2ConvoIds = convos
+    .filter(c => !!c.get('active_at') && c.isOpenGroupV2() && !c.get('left'))
+    .map(c => c.id) as Array<string>;
 
-  // Filter open groups
-  const openGroupsIds = convos
-    .filter(c => !!c.get('active_at') && c.isPublic() && !c.get('left'))
-    .map(c => c.id.substring((c.id as string).lastIndexOf('@') + 1)) as Array<string>;
+  const urls = await Promise.all(
+    openGroupsV2ConvoIds.map(async opengroup => {
+      const roomInfos = await getV2OpenGroupRoom(opengroup);
+      if (roomInfos) {
+        return getCompleteUrlFromRoom(roomInfos);
+      }
+      return null;
+    })
+  );
+
+  return _.compact(urls) || [];
+};
+
+const getValidClosedGroups = async (convos: Array<ConversationModel>) => {
+  const ourPubKey = UserUtils.getOurPubKeyStrFromCache();
 
   // Filter Closed/Medium groups
   const closedGroupModels = convos.filter(
@@ -130,7 +147,10 @@ export const getCurrentConfigurationMessage = async (convos: Array<ConversationM
   const onlyValidClosedGroup = closedGroups.filter(m => m !== null) as Array<
     ConfigurationMessageClosedGroup
   >;
+  return onlyValidClosedGroup;
+};
 
+const getValidContacts = (convos: Array<ConversationModel>) => {
   // Filter contacts
   const contactsModels = convos.filter(
     c => !!c.get('active_at') && c.getLokiProfile()?.displayName && c.isPrivate() && !c.isBlocked()
@@ -148,6 +168,21 @@ export const getCurrentConfigurationMessage = async (convos: Array<ConversationM
       profileKey: profileKeyForContact,
     });
   });
+  return contacts;
+};
+
+export const getCurrentConfigurationMessage = async (convos: Array<ConversationModel>) => {
+  const ourPubKey = UserUtils.getOurPubKeyStrFromCache();
+  const ourConvo = convos.find(convo => convo.id === ourPubKey);
+
+  // Filter open groups v1
+  const openGroupsV1Ids = convos
+    .filter(c => !!c.get('active_at') && c.isOpenGroupV1() && !c.get('left'))
+    .map(c => c.id.substring((c.id as string).lastIndexOf('@') + 1)) as Array<string>;
+
+  const opengroupV2CompleteUrls = await getActiveOpenGroupV2CompleteUrls(convos);
+  const onlyValidClosedGroup = await getValidClosedGroups(convos);
+  const validContacts = getValidContacts(convos);
 
   if (!ourConvo) {
     window.log.error('Could not find our convo while building a configuration message.');
@@ -158,15 +193,19 @@ export const getCurrentConfigurationMessage = async (convos: Array<ConversationM
   const profilePicture = ourConvo?.get('avatarPointer') || undefined;
   const displayName = ourConvo?.getLokiProfile()?.displayName || undefined;
 
+  const activeOpenGroups = [...openGroupsV1Ids, ...opengroupV2CompleteUrls];
+
+  console.warn('SyncConfiguration', activeOpenGroups);
+
   return new ConfigurationMessage({
     identifier: uuid(),
     timestamp: Date.now(),
-    activeOpenGroups: openGroupsIds,
+    activeOpenGroups,
     activeClosedGroups: onlyValidClosedGroup,
     displayName,
     profilePicture,
     profileKey,
-    contacts,
+    contacts: validContacts,
   });
 };