[MS] Janky implementation of multi-org on Electron only

client/src/components/organizations/OrganizationCard.vue

@@ -11,6 +11,7 @@
           <ion-card-title class="card-title">
             <span class="subtitles-normal">{{ device.organizationId }}</span>
             <span class="subtitles-sm">{{ device.humanHandle.label }}</span>
+            <span v-show="isDeviceLoggedIn(device)">Connected!</span>
           </ion-card-title>
         </div>
       </div>
@@ -19,7 +20,7 @@
 </template>
 
 <script setup lang="ts">
-import { AvailableDevice } from '@/parsec';
+import { AvailableDevice, isDeviceLoggedIn } from '@/parsec';
 import { IonAvatar, IonCard, IonCardHeader, IonCardTitle } from '@ionic/vue';
 
 defineProps<{

client/src/parsec/invitation.ts

@@ -68,8 +68,9 @@ export async function listUserInvitations(): Promise<Result<Array<UserInvitation
     });
     return result as any;
   } else {
-    return new Promise<Result<Array<UserInvitation>, ListInvitationsError>>((resolve, _reject) => {
-      const ret: Array<UserInvitation> = [
+    return {
+      ok: true,
+      value: [
         {
           tag: InviteListItemTag.User,
           addr: 'parsec://parsec.example.com/MyOrg?action=claim_device&token=12346565645645654645645645645645',
@@ -86,9 +87,8 @@ export async function listUserInvitations(): Promise<Result<Array<UserInvitation
           claimerEmail: '[email protected]',
           status: InvitationStatus.Ready,
         },
-      ];
-      resolve({ ok: true, value: ret });
-    });
+      ],
+    };
   }
 }
 

client/src/parsec/login.ts

@@ -25,6 +25,29 @@ import {
   UserProfile,
 } from '@/parsec/types';
 
+export interface LoggedInDeviceInfo {
+  handle: ConnectionHandle;
+  device: AvailableDevice;
+}
+
+const loggedInDevices: Array<LoggedInDeviceInfo> = [];
+
+export async function getLoggedInDevices(): Promise<Array<LoggedInDeviceInfo>> {
+  return loggedInDevices;
+}
+
+export function isDeviceLoggedIn(device: AvailableDevice): boolean {
+  return loggedInDevices.find((info) => info.device.slug === device.slug) !== undefined;
+}
+
+export function getDeviceHandle(device: AvailableDevice): ConnectionHandle | null {
+  const info = loggedInDevices.find((info) => info.device.slug === device.slug);
+  if (info) {
+    return info.handle;
+  }
+  return null;
+}
+
 export async function listAvailableDevices(): Promise<Array<AvailableDevice>> {
   return await libparsec.listAvailableDevices(window.getConfigDir());
 }
@@ -34,16 +57,26 @@ export async function login(device: AvailableDevice, password: string): Promise<
     console.log('Event received', event);
   }
 
+  const info = loggedInDevices.find((info) => info.device.slug === device.slug);
+  if (info !== undefined) {
+    return { ok: true, value: info.handle };
+  }
+
   if (!needsMocks()) {
     const clientConfig = getClientConfig();
     const strategy: DeviceAccessStrategyPassword = {
       tag: DeviceAccessStrategyTag.Password,
       password: password,
       keyFile: device.keyFilePath,
     };
-    return await libparsec.clientStart(clientConfig, parsecEventCallback, strategy);
+    const result = await libparsec.clientStart(clientConfig, parsecEventCallback, strategy);
+    if (result.ok) {
+      loggedInDevices.push({ handle: result.value, device: device });
+    }
+    return result;
   } else {
     if (password === 'P@ssw0rd.' || password === 'AVeryL0ngP@ssw0rd') {
+      loggedInDevices.push({ handle: DEFAULT_HANDLE, device: device });
       return { ok: true, value: DEFAULT_HANDLE };
     }
     return {
@@ -60,8 +93,19 @@ export async function logout(): Promise<Result<null, ClientStopError>> {
   const handle = getParsecHandle();
 
   if (handle !== null && !needsMocks()) {
-    return await libparsec.clientStop(handle);
+    const result = await libparsec.clientStop(handle);
+    if (result.ok) {
+      const index = loggedInDevices.findIndex((info) => info.handle === handle);
+      if (index !== -1) {
+        loggedInDevices.splice(index, 1);
+      }
+    }
+    return result;
   } else {
+    const index = loggedInDevices.findIndex((info) => info.handle === handle);
+    if (index !== -1) {
+      loggedInDevices.splice(index, 1);
+    }
     return { ok: true, value: null };
   }
 }

client/src/router/index.ts

@@ -12,3 +12,4 @@ export {
   getWorkspaceId,
 } from '@/router/params';
 export * from '@/router/types';
+export { watchOrganizationSwitch, watchRoute } from '@/router/watchers';

client/src/router/navigation.ts

@@ -1,8 +1,9 @@
 // Parsec Cloud (https://parsec.cloud) Copyright (c) BUSL-1.1 2016-present Scille SAS
 
-import { startWorkspace, WorkspaceID } from '@/parsec';
+import { ConnectionHandle, startWorkspace, WorkspaceID } from '@/parsec';
 import { getConnectionHandle } from '@/router/params';
-import { getRouter, Routes } from '@/router/types';
+import { getCurrentRoute, getRouter, Routes } from '@/router/types';
+import { organizationKey } from '@/router/watchers';
 import { LocationQueryRaw, RouteParamsRaw } from 'vue-router';
 
 export interface NavigationOptions {
@@ -51,3 +52,59 @@ export async function routerGoBack(): Promise<void> {
   const router = getRouter();
   router.go(-1);
 }
+
+interface RouteBackup {
+  handle: ConnectionHandle;
+  data: {
+    route: Routes;
+    params: object;
+    query: object;
+  };
+}
+
+const routesBackup: Array<RouteBackup> = [];
+
+export async function switchOrganization(handle: ConnectionHandle | null, backup = true): Promise<void> {
+  if (backup) {
+    const currentHandle = getConnectionHandle();
+
+    if (currentHandle === null) {
+      console.error('No current handle');
+      return;
+    }
+    if (handle === currentHandle) {
+      console.error('Cannot switch to same organization');
+      return;
+    }
+    // Backup the current route
+    const currentRoute = getCurrentRoute();
+    const index = routesBackup.findIndex((bk) => bk.handle === currentHandle);
+    if (index !== -1) {
+      routesBackup.splice(index, 1);
+    }
+    console.log('Saving', currentRoute.value.name, currentRoute.value.params, currentRoute.value.query);
+    routesBackup.push({
+      handle: currentHandle,
+      data: {
+        route: currentRoute.value.name as Routes,
+        params: currentRoute.value.params,
+        query: currentRoute.value.query,
+      },
+    });
+  }
+
+  // No handle, navigate to organization list
+  if (!handle) {
+    await navigateTo(Routes.Home, { skipHandle: true, replace: true });
+    organizationKey.value += 1;
+  } else {
+    const backup = routesBackup.find((bk) => bk.handle === handle);
+    if (!backup) {
+      console.error('No backup, organization was not connected');
+      return;
+    }
+    console.log('Restoring', backup.data.route, backup.data.params, backup.data.query);
+    await navigateTo(backup.data.route, { params: backup.data.params, query: backup.data.query, skipHandle: true, replace: true });
+    organizationKey.value += 1;
+  }
+}

client/src/router/types.ts

@@ -1,7 +1,7 @@
 // Parsec Cloud (https://parsec.cloud) Copyright (c) BUSL-1.1 2016-present Scille SAS
 
 import { createRouter, createWebHistory } from '@ionic/vue-router';
-import { Ref, WatchStopHandle, watch } from 'vue';
+import { Ref } from 'vue';
 import { RouteLocationNormalizedLoaded, RouteRecordRaw, Router } from 'vue-router';
 
 export enum Routes {
@@ -128,8 +128,3 @@ export function getRouter(): Router {
 export function getCurrentRoute(): Ref<RouteLocationNormalizedLoaded> {
   return (router as Router).currentRoute;
 }
-
-export function watchRoute(callback: () => Promise<void>): WatchStopHandle {
-  const currentRoute = getCurrentRoute();
-  return watch(currentRoute, callback);
-}

client/src/router/watchers.ts

@@ -0,0 +1,15 @@
+// Parsec Cloud (https://parsec.cloud) Copyright (c) BUSL-1.1 2016-present Scille SAS
+
+import { getCurrentRoute } from '@/router/types';
+import { Ref, WatchStopHandle, ref, watch } from 'vue';
+
+export const organizationKey: Ref<number> = ref(0);
+
+export function watchRoute(callback: () => Promise<void>): WatchStopHandle {
+  const currentRoute = getCurrentRoute();
+  return watch(currentRoute, callback);
+}
+
+export function watchOrganizationSwitch(callback: () => Promise<void>): WatchStopHandle {
+  return watch(organizationKey, callback);
+}

client/src/views/files/FoldersPage.vue

@@ -207,6 +207,9 @@ const allFilesSelected = ref(false);
 
 const routeWatchCancel = watchRoute(async () => {
   const newPath = getDocumentPath();
+  if (newPath === '') {
+    return;
+  }
   if (newPath !== currentPath.value) {
     currentPath.value = newPath;
   }
@@ -226,6 +229,10 @@ let callbackId: string | null = null;
 
 onMounted(async () => {
   callbackId = await importManager.registerCallback(onFileImportState);
+  const path = getDocumentPath();
+  if (path !== '') {
+    currentPath.value = path;
+  }
   await listFolder();
 });
 

client/src/views/header/HeaderPage.vue

@@ -144,6 +144,12 @@ const userInfo: Ref<ClientInfo | null> = ref(null);
 const fullPath: Ref<RouterPathNode[]> = ref([]);
 
 const routeWatchCancel = watchRoute(async () => {
+  const result = await getClientInfo();
+  if (result.ok) {
+    userInfo.value = result.value;
+  } else {
+    console.log('Could not get user info', result.error);
+  }
   await updateRoute();
 });
 

client/src/views/home/HomePage.vue

@@ -57,8 +57,8 @@
 <script setup lang="ts">
 import { Validity, claimDeviceLinkValidator, claimLinkValidator, claimUserLinkValidator } from '@/common/validators';
 import { MsModalResult, getTextInputFromUser } from '@/components/core';
-import { AvailableDevice, login as parsecLogin } from '@/parsec';
-import { NavigationOptions, Routes, getCurrentRouteQuery, navigateTo, watchRoute } from '@/router';
+import { AvailableDevice, getDeviceHandle, isDeviceLoggedIn, login as parsecLogin } from '@/parsec';
+import { NavigationOptions, Routes, getCurrentRouteQuery, navigateTo, switchOrganization, watchRoute } from '@/router';
 import { Notification, NotificationKey, NotificationLevel, NotificationManager } from '@/services/notificationManager';
 import { StorageManager, StorageManagerKey, StoredDeviceData } from '@/services/storageManager';
 import { translate } from '@/services/translation';
@@ -155,8 +155,13 @@ async function backToOrganizations(): Promise<void> {
 }
 
 function onOrganizationSelected(device: AvailableDevice): void {
-  selectedDevice.value = device;
-  state.value = HomePageState.Login;
+  if (isDeviceLoggedIn(device)) {
+    const handle = getDeviceHandle(device);
+    switchOrganization(handle, false);
+  } else {
+    selectedDevice.value = device;
+    state.value = HomePageState.Login;
+  }
 }
 
 async function login(device: AvailableDevice, password: string): Promise<void> {