@abtnode/core 1.17.8-beta-20260109-075740-5f484e08 → 1.17.8-beta-20260113-015027-32a1cec4

package/lib/api/team/user-query-manager.js

@@ -0,0 +1,299 @@
+const pick = require('lodash/pick');
+const pMap = require('p-map');
+const { MAX_USER_PAGE_SIZE, PASSPORT_STATUS } = require('@abtnode/constant');
+
+/**
+ * Get users
+ * @param {Object} api - TeamAPI instance
+ * @param {Object} params
+ * @param {string} params.teamDid - Team DID
+ * @param {Object} params.query - Query
+ * @param {Object} params.paging - Paging
+ * @param {Object} params.sort - Sort
+ * @param {Array} params.dids - DIDs
+ * @param {Object} context
+ * @returns {Promise<Object>}
+ */
+async function getUsers(api, { teamDid, query, paging: inputPaging, sort, dids }, context = {}) {
+  const state = await api.getUserState(teamDid);
+  const nodeInfo = await api.node.read();
+
+  // HACK: 如果查询的是 server 的数据库，则不应该查询 userSession 表
+  if (teamDid === nodeInfo.did) {
+    if (query) {
+      delete query.includeUserSessions;
+    }
+  }
+
+  if (inputPaging?.pageSize > MAX_USER_PAGE_SIZE) {
+    throw new Error(`Length of users should not exceed ${MAX_USER_PAGE_SIZE} per page`);
+  }
+
+  if (dids && dids.length > MAX_USER_PAGE_SIZE) {
+    throw new Error(`Length of users should not exceed ${MAX_USER_PAGE_SIZE}`);
+  }
+
+  let list;
+  let paging;
+
+  if (dids) {
+    list = await state.getUsersByDids({ query, dids }, context);
+    paging = {
+      total: list.length,
+      pageSize: dids.length,
+      pageCount: 1,
+      page: 1,
+    };
+  } else {
+    const doc = await state.getUsers({ query, sort, paging: { pageSize: 20, ...inputPaging } }, context);
+    list = doc.list;
+    paging = doc.paging;
+  }
+
+  let userSessionsCountList = [];
+  if (teamDid !== nodeInfo.did && query?.includeUserSessions) {
+    userSessionsCountList = await pMap(
+      list,
+      async (x) => {
+        const { count: userSessionsCount } = await api.getUserSessionsCount({
+          teamDid,
+          query: {
+            userDid: x.did,
+            appPid: teamDid,
+          },
+        });
+        return userSessionsCount;
+      },
+      { concurrency: 10 }
+    );
+  }
+  const users = list.map(
+    (d, index) => {
+      const pickData = pick(d, [
+        'did',
+        'pk',
+        'role',
+        'email',
+        'phone',
+        'fullName',
+        'approved',
+        'createdAt',
+        'updatedAt',
+        'passports',
+        'firstLoginAt',
+        'lastLoginAt',
+        'lastLoginIp',
+        'remark',
+        'avatar',
+        'locale',
+        'tags',
+        'url',
+        'inviter',
+        'generation',
+        'emailVerified',
+        'phoneVerified',
+        // oauth relate fields
+        'sourceProvider',
+        'sourceAppPid',
+        'connectedAccounts',
+
+        'metadata',
+        'isFollowing',
+      ]);
+
+      return {
+        ...pickData,
+        userSessions: [],
+        userSessionsCount: userSessionsCountList[index] || 0,
+      };
+    }
+
+    // eslint-disable-next-line function-paren-newline
+  );
+  return {
+    // FIXME: @zhanghan 这里做字段过滤的目的是？gql 本身已经对字段做了过滤了
+    users,
+    paging,
+  };
+}
+
+/**
+ * Get users count
+ * @param {Object} api - TeamAPI instance
+ * @param {Object} params
+ * @param {string} params.teamDid - Team DID
+ * @returns {Promise<number>}
+ */
+async function getUsersCount(api, { teamDid }) {
+  const state = await api.getUserState(teamDid);
+  return state.count();
+}
+
+/**
+ * Get users count per role
+ * @param {Object} api - TeamAPI instance
+ * @param {Object} params
+ * @param {string} params.teamDid - Team DID
+ * @returns {Promise<Array>}
+ */
+async function getUsersCountPerRole(api, { teamDid }) {
+  const roles = await api.getRoles({ teamDid });
+  const state = await api.getUserState(teamDid);
+  const names = ['$all', ...roles.filter((x) => !x.orgId).map((x) => x.name), '$none', '$blocked'];
+  return Promise.all(
+    names.map(async (name) => {
+      const count = await state.countByPassport({ name, status: PASSPORT_STATUS.VALID });
+      return { key: name, value: count };
+    })
+  );
+}
+
+/**
+ * Get user
+ * @param {Object} api - TeamAPI instance
+ * @param {Object} params
+ * @param {string} params.teamDid - Team DID
+ * @param {Object} params.user - User
+ * @param {Object} params.options - Options
+ * @returns {Promise<Object>}
+ */
+async function getUser(api, { teamDid, user, options = {} }) {
+  const state = await api.getUserState(teamDid);
+  return state.getUser(user.did, options);
+}
+
+/**
+ * Get connected account
+ * @param {Object} api - TeamAPI instance
+ * @param {Object} params
+ * @param {string} params.teamDid - Team DID
+ * @param {string} params.id - Account ID
+ * @returns {Promise<Object>}
+ */
+async function getConnectedAccount(api, { teamDid, id }) {
+  const state = await api.getUserState(teamDid);
+  return state.getConnectedAccount(id);
+}
+
+/**
+ * Check if email is used
+ * @param {Object} api - TeamAPI instance
+ * @param {Object} params
+ * @param {string} params.teamDid - Team DID
+ * @param {string} params.email - Email
+ * @param {boolean} params.verified - Verified
+ * @param {string} params.sourceProvider - Source provider
+ * @returns {Promise<boolean>}
+ */
+async function isEmailUsed(api, { teamDid, email, verified = false, sourceProvider = '' }) {
+  const state = await api.getUserState(teamDid);
+  return state.isEmailUsed(email, verified, sourceProvider);
+}
+
+/**
+ * Check if phone is used
+ * @param {Object} api - TeamAPI instance
+ * @param {Object} params
+ * @param {string} params.teamDid - Team DID
+ * @param {string} params.phone - Phone
+ * @param {boolean} params.verified - Verified
+ * @returns {Promise<boolean>}
+ */
+async function isPhoneUsed(api, { teamDid, phone, verified = false }) {
+  const state = await api.getUserState(teamDid);
+  return state.isPhoneUsed(phone, verified);
+}
+
+/**
+ * Get user by DID
+ * @param {Object} api - TeamAPI instance
+ * @param {Object} params
+ * @param {string} params.teamDid - Team DID
+ * @param {string} params.userDid - User DID
+ * @param {Array} params.attributes - Attributes
+ * @returns {Promise<Object>}
+ */
+async function getUserByDid(api, { teamDid, userDid, attributes = [] }) {
+  const state = await api.getUserState(teamDid);
+  return state.getUserByDid(userDid, attributes);
+}
+
+/**
+ * Check if user is valid
+ * @param {Object} api - TeamAPI instance
+ * @param {Object} params
+ * @param {string} params.teamDid - Team DID
+ * @param {string} params.userDid - User DID
+ * @returns {Promise<boolean>}
+ */
+async function isUserValid(api, { teamDid, userDid }) {
+  const state = await api.getUserState(teamDid);
+  return state.isUserValid(userDid);
+}
+
+/**
+ * Check if passport is valid
+ * @param {Object} api - TeamAPI instance
+ * @param {Object} params
+ * @param {string} params.teamDid - Team DID
+ * @param {string} params.passportId - Passport ID
+ * @returns {Promise<boolean>}
+ */
+async function isPassportValid(api, { teamDid, passportId }) {
+  const state = await api.getUserState(teamDid);
+  return state.isPassportValid(passportId);
+}
+
+/**
+ * Check if is connected account
+ * @param {Object} api - TeamAPI instance
+ * @param {Object} params
+ * @param {string} params.teamDid - Team DID
+ * @param {string} params.did - DID
+ * @returns {Promise<boolean>}
+ */
+async function isConnectedAccount(api, { teamDid, did }) {
+  const state = await api.getUserState(teamDid);
+  return state.isConnectedAccount(did);
+}
+
+/**
+ * Get owner
+ * @param {Object} api - TeamAPI instance
+ * @param {Object} params
+ * @param {string} params.teamDid - Team DID
+ * @returns {Promise<Object>}
+ */
+async function getOwner(api, { teamDid }) {
+  let owner = await api.teamManager.getOwner(teamDid);
+  const state = await api.getUserState(teamDid);
+  if (!owner) {
+    const ownerDids = await state.getOwnerDids();
+    if (ownerDids.length > 0) {
+      owner = { did: ownerDids[0] };
+    }
+  }
+
+  if (!owner) {
+    return null;
+  }
+
+  // NOTICE: 目前 owner 只能为 did-wallet，无需查询 connectedAccount
+  const full = await state.getUser(owner.did);
+  return full || owner;
+}
+
+module.exports = {
+  getUsers,
+  getUsersCount,
+  getUsersCountPerRole,
+  getUser,
+  getConnectedAccount,
+  isEmailUsed,
+  isPhoneUsed,
+  getUserByDid,
+  isUserValid,
+  isPassportValid,
+  isConnectedAccount,
+  getOwner,
+};

package/lib/api/team/user-social-manager.js

@@ -0,0 +1,354 @@
+const omit = require('lodash/omit');
+const { joinURL } = require('ufo');
+const logger = require('@abtnode/logger')('@abtnode/core:api:team:user-social');
+const {
+  MAX_USER_PAGE_SIZE,
+  USER_AVATAR_URL_PREFIX,
+  WELLKNOWN_SERVICE_PATH_PREFIX,
+  NOTIFICATION_SEND_CHANNEL,
+  WEBHOOK_CONSECUTIVE_FAILURES_THRESHOLD,
+} = require('@abtnode/constant');
+const { CustomError } = require('@blocklet/error');
+const { getUserAvatarUrl: getFederatedUserAvatarUrl } = require('@abtnode/auth/lib/util/federated');
+
+const { getBlocklet } = require('../../util/blocklet');
+
+// 关注取消关注相关接口
+const USER_RELATION_ACTIONS = {
+  follow: (state, followerDid, userDid, options) => state.followUser(followerDid, userDid, options),
+  unfollow: (state, followerDid, userDid, options) => state.unfollowUser(followerDid, userDid, options),
+};
+
+// 获取用户相关接口
+const USER_RELATION_QUERIES = {
+  followers: (state, userDid, options, context) => state.getFollowers(userDid, options, context),
+  following: (state, userDid, options, context) => state.getFollowing(userDid, options, context),
+};
+
+/**
+ * User follow action
+ * @param {Object} api - TeamAPI instance
+ * @param {Object} params
+ * @param {string} params.teamDid - Team DID
+ * @param {string} params.userDid - User DID
+ * @param {string} params.followerDid - Follower DID
+ * @param {string} params.action - Action
+ * @param {Object} params.options - Options
+ * @param {Object} context
+ * @returns {Promise<Object>}
+ */
+async function userFollowAction(api, { teamDid, userDid, followerDid, action = 'follow', options = {} }, context = {}) {
+  const targetDid = followerDid || context.userDid;
+
+  if (!USER_RELATION_ACTIONS[action]) {
+    throw new CustomError(
+      400,
+      `Invalid action: ${action}. Supported: ${Object.keys(USER_RELATION_ACTIONS).join(', ')}`
+    );
+  }
+  let result;
+  try {
+    const state = await api.getUserState(teamDid);
+    result = await USER_RELATION_ACTIONS[action](state, targetDid, userDid, options);
+  } catch (error) {
+    logger.error(`Failed to ${action} user`, {
+      followerDid: targetDid,
+      userDid,
+      error,
+    });
+    throw error;
+  }
+
+  try {
+    if (action === 'follow' && !options.skipNotification) {
+      const state = await api.getUserState(teamDid);
+      const currentUser = await state.getUser(targetDid);
+      await api.createNotification({
+        teamDid,
+        receiver: userDid,
+        title: 'Followed',
+        description: `<${currentUser.fullName}(did:abt:${currentUser.did})> followed you`,
+        activity: {
+          type: 'follow',
+          actor: followerDid,
+          target: {
+            type: 'user',
+            id: followerDid,
+          },
+        },
+        entityId: teamDid,
+        source: 'system',
+        severity: 'success',
+      });
+    }
+  } catch (error) {
+    // 消息创建失败，不影响 follow 操作
+    logger.error('Failed to create notification', { error });
+  }
+
+  return result;
+}
+
+/**
+ * Get user follows
+ * @param {Object} api - TeamAPI instance
+ * @param {Object} params
+ * @param {string} params.teamDid - Team DID
+ * @param {string} params.userDid - User DID
+ * @param {string} params.type - Type
+ * @param {Object} params.paging - Paging
+ * @param {Object} params.sort - Sort
+ * @param {Object} params.options - Options
+ * @param {Object} context
+ * @returns {Promise<Object>}
+ */
+async function getUserFollows(api, { teamDid, userDid, type = 'following', paging, sort, options = {} }, context = {}) {
+  const state = await api.getUserState(teamDid);
+
+  const blocklet = await getBlocklet({ did: teamDid, states: api.states, dataDirs: api.dataDirs });
+
+  if (paging?.pageSize > MAX_USER_PAGE_SIZE) {
+    throw new Error(`Length of users should not exceed ${MAX_USER_PAGE_SIZE} per page`);
+  }
+
+  if (!USER_RELATION_QUERIES[type]) {
+    throw new CustomError(400, `Invalid type: ${type}. Supported: ${Object.keys(USER_RELATION_QUERIES).join(', ')}`);
+  }
+
+  try {
+    const { list, paging: resultPaging } = await USER_RELATION_QUERIES[type](
+      state,
+      userDid,
+      {
+        paging,
+        sort,
+        ...options,
+      },
+      context
+    );
+
+    list.forEach((item) => {
+      const { user } = item;
+      if (user && user?.avatar && user?.avatar?.startsWith(USER_AVATAR_URL_PREFIX)) {
+        user.avatar = `${getFederatedUserAvatarUrl(user.avatar, blocklet)}?imageFilter=resize&w=48&h=48`;
+      }
+    });
+
+    return {
+      data: list,
+      paging: resultPaging,
+    };
+  } catch (error) {
+    logger.error('Failed to get user follows', { error });
+    throw error;
+  }
+}
+
+/**
+ * Get user follow stats
+ * @param {Object} api - TeamAPI instance
+ * @param {Object} params
+ * @param {string} params.teamDid - Team DID
+ * @param {Array} params.userDids - User DIDs
+ * @param {Object} params.options - Options
+ * @param {Object} context
+ * @returns {Promise<Object>}
+ */
+async function getUserFollowStats(api, { teamDid, userDids, options = {} }, context = {}) {
+  const state = await api.getUserState(teamDid);
+  const info = await api.node.read();
+  const prefix = process.env.NODE_ENV === 'production' ? info.routing.adminPath : '';
+  return state.getFollowStats({ userDids, teamDid, prefix, options }, context);
+}
+
+/**
+ * Check following
+ * @param {Object} api - TeamAPI instance
+ * @param {Object} params
+ * @param {string} params.teamDid - Team DID
+ * @param {Array} params.userDids - User DIDs
+ * @param {string} params.followerDid - Follower DID
+ * @returns {Promise<Object>}
+ */
+async function checkFollowing(api, { teamDid, userDids = [], followerDid }) {
+  if (!followerDid) {
+    throw new CustomError(400, 'Follower DID is required');
+  }
+  const state = await api.getUserState(teamDid);
+  return state.isFollowing(followerDid, userDids);
+}
+
+/**
+ * Get user invites
+ * @param {Object} api - TeamAPI instance
+ * @param {Object} params
+ * @param {string} params.teamDid - Team DID
+ * @param {string} params.userDid - User DID
+ * @param {Object} params.paging - Paging
+ * @param {Object} params.sort - Sort
+ * @param {Object} params.options - Options
+ * @param {Object} context
+ * @returns {Promise<Object>}
+ */
+async function getUserInvites(api, { teamDid, userDid, paging, sort, options = {} }, context = {}) {
+  try {
+    if (paging?.pageSize > MAX_USER_PAGE_SIZE) {
+      throw new CustomError(400, `Length of users should not exceed ${MAX_USER_PAGE_SIZE} per page`);
+    }
+    const state = await api.getUserState(teamDid);
+    const { users, paging: resultPaging } = await state.getInvitees(userDid, { paging, sort, ...options }, context);
+    // 处理头像
+    const blocklet = await getBlocklet({ did: teamDid, states: api.states, dataDirs: api.dataDirs });
+    users.forEach((user) => {
+      if (user && user?.avatar && user?.avatar?.startsWith(USER_AVATAR_URL_PREFIX)) {
+        user.avatar = `${getFederatedUserAvatarUrl(user.avatar, blocklet)}?imageFilter=resize&w=48&h=48`;
+      }
+    });
+    return {
+      users,
+      paging: resultPaging,
+    };
+  } catch (error) {
+    logger.error('Failed to get user invites', { teamDid, userDid, error });
+    throw error;
+  }
+}
+
+/**
+ * Create webhook disabled notification
+ * @param {Object} api - TeamAPI instance
+ * @param {Object} params
+ * @param {string} params.teamDid - Team DID
+ * @param {string} params.userDid - User DID
+ * @param {Object} params.webhook - Webhook
+ * @param {string} params.action - Action
+ * @param {string} params.locale - Locale
+ * @returns {Promise<void>}
+ */
+async function createWebhookDisabledNotification(api, { teamDid, userDid, webhook, action = '', locale = 'en' }) {
+  const notification = {
+    en: {
+      title: 'Your webhook has been temporarily disabled',
+      description: `Your Webhook has been temporarily disabled after ${WEBHOOK_CONSECUTIVE_FAILURES_THRESHOLD} consecutive failed message delivery attempts. Please check its availability and you can click the button below to reactivate it if needed.`,
+      failureCount: 'Number of failures',
+      failureUrl: 'Failed Webhook URL',
+    },
+    zh: {
+      title: '您的 webhook 已被暂时禁用',
+      description: `您的 Webhook 在连续 ${WEBHOOK_CONSECUTIVE_FAILURES_THRESHOLD} 次消息投递失败后已被暂时禁用。请检查其可用性，如果需要重新激活，请点击下方按钮。`,
+      failureCount: '失败次数',
+      failureUrl: '失败的 Webhook URL',
+    },
+  };
+
+  try {
+    const nodeInfo = await api.node.read();
+    // server 的 webhook 页面地址
+    const actionPath = '/settings/integration';
+    let _action = process.env.NODE_ENV === 'production' ? joinURL(nodeInfo.routing.adminPath, actionPath) : actionPath;
+    const channels = [NOTIFICATION_SEND_CHANNEL.WALLET, NOTIFICATION_SEND_CHANNEL.PUSH];
+    if (teamDid && !api.teamManager.isNodeTeam(teamDid)) {
+      channels.push(NOTIFICATION_SEND_CHANNEL.EMAIL);
+      _action = action || `${WELLKNOWN_SERVICE_PATH_PREFIX}/user/settings`; // 默认返回用户中心页面设置页面
+    }
+    await api.teamManager.createNotification({
+      title: notification[locale].title,
+      description: notification[locale].description,
+      attachments: [
+        {
+          type: 'section',
+          fields: [
+            {
+              type: 'text',
+              data: {
+                type: 'plain',
+                color: '#9397A1',
+                text: notification[locale].failureUrl,
+              },
+            },
+            {
+              type: 'text',
+              data: {
+                type: 'plain',
+                color: '#9397A1',
+                text: webhook.url,
+              },
+            },
+            {
+              type: 'text',
+              data: {
+                type: 'plain',
+                color: '#9397A1',
+                text: notification[locale].failureCount,
+              },
+            },
+            {
+              type: 'text',
+              data: {
+                type: 'plain',
+                color: '#9397A1',
+                text: `${WEBHOOK_CONSECUTIVE_FAILURES_THRESHOLD}`,
+              },
+            },
+          ],
+        },
+      ],
+      source: 'system',
+      severity: 'warning',
+      action: _action,
+      channels,
+      ...(teamDid ? { teamDid } : {}),
+      ...(userDid ? { receiver: userDid } : {}),
+    });
+  } catch (error) {
+    logger.error('Failed to create webhook disabled notification', { teamDid, userDid, webhook, error });
+  }
+}
+
+/**
+ * Update webhook state
+ * @param {Object} api - TeamAPI instance
+ * @param {Object} params
+ * @param {string} params.teamDid - Team DID
+ * @param {Array} params.userDids - User DIDs
+ * @param {Object} params.webhook - Webhook
+ * @param {boolean} params.enabled - Enabled
+ * @param {number} params.consecutiveFailures - Consecutive failures
+ * @returns {Promise<Array>}
+ */
+async function updateWebHookState(api, { teamDid, userDids, webhook, enabled, consecutiveFailures }) {
+  const state = await api.getUserState(teamDid);
+  return Promise.all(
+    userDids.map(async (userDid) => {
+      const webhookParams =
+        consecutiveFailures === undefined
+          ? omit(
+              {
+                ...webhook,
+                enabled: enabled ?? webhook.enabled,
+              },
+              ['consecutiveFailures']
+            )
+          : {
+              ...webhook,
+              enabled: enabled ?? webhook.enabled,
+              consecutiveFailures,
+            };
+      await state.updateWebhook(userDid, webhookParams, (updated) => {
+        createWebhookDisabledNotification(api, { teamDid, userDid, webhook: updated });
+      });
+    })
+  );
+}
+
+module.exports = {
+  USER_RELATION_ACTIONS,
+  USER_RELATION_QUERIES,
+  userFollowAction,
+  getUserFollows,
+  getUserFollowStats,
+  checkFollowing,
+  getUserInvites,
+  createWebhookDisabledNotification,
+  updateWebHookState,
+};