@arcblock/did-connect-react 3.1.0

package/src/Connect/hooks/use-apps.js

@@ -0,0 +1,69 @@
+import { useCreation } from 'ahooks';
+import { getApps, getFederatedEnabled, getMaster } from '@arcblock/ux/lib/Util/federated';
+import isUndefined from 'lodash/isUndefined';
+import { use } from 'react';
+import { SessionContext } from '../../Session/context';
+
+/**
+ *
+ * @param {object} param
+ * @param {object} param.blocklet
+ * @param {string} param.action
+ * @param {string} [param.sourceAppPid]
+ * @param {object} param.connectState
+ * @param {boolean} [param.enableSwitchApp]
+ * @returns
+ */
+export default function useApps({ blocklet, action, sourceAppPid, connectState, enableSwitchApp }) {
+  const sessionContext = use(SessionContext);
+
+  const canSwitchApp = useCreation(() => {
+    if (enableSwitchApp === true) {
+      return true;
+    }
+    if (enableSwitchApp === false) {
+      return false;
+    }
+
+    if (sessionContext?.session?.user) {
+      if (!['login', 'invite', 'connect-to-did-space', 'connect-to-did-domain'].includes(action)) {
+        return false;
+      }
+    }
+    return true;
+  }, [action, sessionContext?.session?.user]);
+
+  const autoGenerateSourceAppPid = useCreation(() => {
+    if (isUndefined(sourceAppPid)) {
+      const federatedEnabled = getFederatedEnabled(blocklet);
+      const master = getMaster(blocklet);
+      if (federatedEnabled && master?.appPid) {
+        return master.appPid;
+      }
+    }
+    return sourceAppPid;
+  }, [sourceAppPid, blocklet]);
+
+  const appInfoList = useCreation(() => {
+    const appList = getApps(blocklet);
+
+    return appList.filter((x) => {
+      if (canSwitchApp) {
+        return true;
+      }
+
+      if (!isUndefined(sourceAppPid)) {
+        return x.sourceAppPid === sourceAppPid;
+      }
+      if (!isUndefined(connectState.sourceAppPid)) {
+        return x.sourceAppPid === connectState.sourceAppPid;
+      }
+      if (sessionContext?.session?.user) {
+        return x.sourceAppPid === sessionContext.session.user.sourceAppPid;
+      }
+      return x.sourceAppPid === autoGenerateSourceAppPid;
+    });
+  }, [canSwitchApp, sourceAppPid, connectState.sourceAppPid, autoGenerateSourceAppPid, sessionContext?.session?.user]);
+
+  return { appInfoList, autoGenerateSourceAppPid, canSwitchApp };
+}

package/src/Connect/hooks/use-quick-connect.js

@@ -0,0 +1,130 @@
+import { useCreation, useMemoizedFn, useReactive, useRequest } from 'ahooks';
+import { joinURL } from 'ufo';
+import pick from 'lodash/pick';
+import unionBy from 'lodash/unionBy';
+import sortBy from 'lodash/sortBy';
+import Toast from '@arcblock/ux/lib/Toast';
+import { getFederatedEnabled, getMaster } from '@arcblock/ux/lib/Util/federated';
+
+import { BLOCKLET_SERVICE_PATH_PREFIX } from '../../constant';
+import { createAxios, logger } from '../../utils';
+
+const prefix = joinURL(BLOCKLET_SERVICE_PATH_PREFIX, '/api/user-session');
+
+export default function useQuickConnect({
+  appPid,
+  sourceAppPid,
+  loginAppPid,
+  autoFetch = true,
+  baseUrl = '/',
+  fetchAll = false,
+} = {}) {
+  const api = useCreation(() => {
+    return createAxios(
+      {
+        baseURL: joinURL(baseUrl, prefix),
+      },
+      { lazy: true, lazyTime: 500 }
+    );
+  }, [baseUrl]);
+
+  const getUserSessions = useMemoizedFn(async () => {
+    if (!window.blocklet) {
+      return [];
+    }
+
+    let selfUserSessions = [];
+    try {
+      ({ data: selfUserSessions = [] } = await api.get(''));
+    } catch (err) {
+      logger.error('Failed to get user-sessions', err);
+    }
+    const result = selfUserSessions.map((x) => ({
+      ...x,
+      appUrl: baseUrl,
+    }));
+    const enabledFederated = getFederatedEnabled();
+    const master = getMaster();
+    // NOTICE: 联合查询 master 中的会话列表
+    if (fetchAll && enabledFederated) {
+      if (master) {
+        let masterUserSessions = [];
+        try {
+          ({ data: masterUserSessions = [] } = await api.get(joinURL(master.appUrl, prefix)));
+        } catch (err) {
+          logger.error('Failed to get master user-sessions', err);
+        }
+
+        return result.concat(masterUserSessions.map((x) => ({ ...x, appUrl: master.appUrl })));
+      }
+    }
+    if (!enabledFederated || !master) {
+      return result.filter((x) => x?.user?.sourceAppPid === null);
+    }
+    return result;
+  });
+  const currentState = useReactive({
+    loaded: false,
+    loadingId: null,
+  });
+  const userSessionsState = useRequest(getUserSessions, {
+    manual: !autoFetch,
+    onFinally() {
+      currentState.loaded = true;
+    },
+    refreshDeps: [baseUrl],
+  });
+
+  const loginUserSession = async (userSession) => {
+    const params = pick(userSession, ['userDid', 'visitorId', 'passportId', 'id']);
+    try {
+      currentState.loadingId = userSession.id;
+      const { data } = await api.post(
+        'login',
+        { ...params, appPid: loginAppPid },
+        {
+          baseURL: joinURL(userSession.appUrl || '/', prefix),
+        }
+      );
+      return data;
+    } catch (err) {
+      const errorMsg = err.response ? err.response?.data?.error || err.response?.data : err.message;
+      Toast.error(errorMsg);
+      logger.error('Quick login error', err);
+      throw err;
+    } finally {
+      currentState.loadingId = null;
+    }
+  };
+
+  const onlineUserSessions = useCreation(() => {
+    if (!userSessionsState.data) return [];
+    return userSessionsState.data.filter((x) => x.status !== 'expired');
+  }, [userSessionsState.data]);
+
+  const uniqueUserSessions = useCreation(() => {
+    const now = new Date().getTime();
+    const sortedUserSessions = sortBy(onlineUserSessions, (x) => now - new Date(x.updatedAt).getTime());
+    return unionBy(sortedUserSessions, (x) =>
+      [
+        x.userDid,
+        // 暂不以用户角色来做去重的因子
+        // x.user.role
+      ].join('_')
+    );
+  }, [onlineUserSessions, sourceAppPid, appPid]);
+
+  const quickLoginEnabled = useCreation(() => {
+    return Boolean(uniqueUserSessions && uniqueUserSessions.length > 0);
+  }, [uniqueUserSessions]);
+
+  return {
+    loadingId: currentState.loadingId,
+    userSessions: uniqueUserSessions,
+    quickLoginEnabled,
+    loginUserSession,
+    loading: userSessionsState.loading,
+    loaded: userSessionsState.loaded,
+    refresh: userSessionsState.refreshAsync,
+  };
+}