跳到主要内容

共享群组

本节介绍与其他用户共享群组以及管理共享请求的操作，可通过 ESPRMUser 实例（用于用户级操作）或 ESPRMGroup 实例（用于群组级操作）执行。

说明

使用 ESPRMAuth.getLoggedInUser 方法获取用户实例：

try {
  const authInstance = ESPRMBase.getAuthInstance();
  const userInstance = await authInstance.getLoggedInUser();

  if (userInstance) {
    // 使用 userInstance 进行群组操作
  } else {
    console.log("No user is currently logged in");
  }
} catch (error) {
  console.error("Error getting logged in user:", error);
}

用户级操作​

共享群组​

使用 shareGroups 方法与其他用户共享一个或多个群组。

try {
  const shareRequest = {
    username: "target_username",
    groupIds: ["group_id_1", "group_id_2"],
    makePrimary: false,
    metadata: {
      description: "Shared for home automation access",
    },
  };

  const requestId = await userInstance.shareGroups(shareRequest);
  console.log("Group sharing request created:", requestId);
} catch (error) {
  console.error("Error sharing groups:", error);
}

转移群组​

使用 transferGroups 方法将一个或多个群组的所有权转移给其他用户。

try {
  const transferRequest = {
    toUserName: "new_owner@example.com",
    groupIds: ["group_id_1", "group_id_2"],
    selfToSecondary: false,
  };

  const requestId = await userInstance.transferGroups(transferRequest);
  console.log("Group transfer request created:", requestId);
} catch (error) {
  console.error("Error transferring groups:", error);
}

获取已发出的群组共享请求​

使用 getIssuedGroupSharingRequests 方法检索已发出的群组共享请求。

try {
  const response = await userInstance.getIssuedGroupSharingRequests(10);
  console.log("Issued sharing requests:", response.sharedRequests);
  console.log("Has more requests:", response.hasNext);
} catch (error) {
  console.error("Error getting issued sharing requests:", error);
}

获取已收到的群组共享请求​

使用 getReceivedGroupSharingRequests 方法检索已收到的群组共享请求。

try {
  const response = await userInstance.getReceivedGroupSharingRequests(10);
  console.log("Received sharing requests:", response.sharedRequests);
  console.log("Has more requests:", response.hasNext);
} catch (error) {
  console.error("Error getting received sharing requests:", error);
}

群组级操作​

共享群组​

使用 share 方法将当前群组共享给其他用户。

try {
  const shareRequest = {
    username: "target_username",
    makePrimary: false,
    metadata: {
      description: "Shared for home automation access",
    },
  };

  const requestId = await group.share(shareRequest);
  console.log("Group sharing request created:", requestId);
} catch (error) {
  console.error("Error sharing group:", error);
}

转移群组​

使用 transfer 方法将当前群组转移给其他用户。

try {
  const transferRequest = {
    toUserName: "new_owner@example.com",
    selfToSecondary: false,
  };

  const requestId = await group.transfer(transferRequest);
  console.log("Group transfer request created:", requestId);
} catch (error) {
  console.error("Error transferring group:", error);
}

移除共享​

使用 removeSharingFor 方法移除当前群组中指定用户的共享权限。

try {
  const username = "target_username";
  const response = await group.removeSharingFor(username);
  console.log("Sharing removed successfully:", response);
} catch (error) {
  console.error("Error removing sharing:", error);
}

获取共享信息​

使用 getSharingInfo 方法检索当前群组的共享信息。

try {
  const sharingInfo = await group.getSharingInfo({
    groupId: group.id,
    subGroups: true,
    parentGroups: true,
    metadata: true,
  });
  console.log("Sharing information:", sharingInfo);
} catch (error) {
  console.error("Error getting sharing info:", error);
}

管理共享请求​

使用 ESPGroupSharingRequest 类管理群组共享请求。共享请求分为两种类型：

  • 已收到的请求：其他用户发送给你的邀请
  • 已发出的请求：你发送给其他用户的邀请

获取已收到的群组共享请求​

使用 getReceivedGroupSharingRequests 方法获取发送给你的群组共享请求（即你收到的邀请）。

try {
  // 获取所有已收到的共享请求，支持可选分页
  const response = await userInstance.getReceivedGroupSharingRequests();

  console.log("Received requests:", response.sharedRequests);
  console.log("Has more requests:", response.hasNext);
} catch (error) {
  console.error("Error fetching received requests:", error);
}

getReceivedGroupSharingRequests API​

参数类型是否必填描述
countnumber否每次请求获取的结果数量。如未提供，则使用默认值。

返回值： Promise<ESPGroupSharingResponse> - 返回一个 Promise，解析为包含已接收群组共享请求的分页结果。

获取已发出的群组共享请求​

使用 getIssuedGroupSharingRequests 方法获取你发送给其他用户的群组共享请求。

try {
  // 获取所有已发出的共享请求，支持可选分页
  const response = await userInstance.getIssuedGroupSharingRequests();

  console.log("Issued requests:", response.sharedRequests);
  console.log("Has more requests:", response.hasNext);
} catch (error) {
  console.error("Error fetching issued requests:", error);
}

getIssuedGroupSharingRequests API​

参数类型是否必填描述
countnumber否每次请求获取的结果数量。如未提供，则使用默认值。

返回值： Promise<ESPGroupSharingResponse> - 返回一个 Promise，解析为包含已发出群组共享请求的分页结果。

接受共享请求​

使用 accept 方法接受发送给你的群组共享请求。

try {
  // 获取已收到的共享请求
  const response = await userInstance.getReceivedGroupSharingRequests();
  const receivedRequests = response.sharedRequests;

  // 查找并接受指定请求
  const requestToAccept = receivedRequests.find((req) => req.id === requestId);

  if (requestToAccept) {
    const acceptResponse = await requestToAccept.accept();
    console.log("Sharing request accepted:", acceptResponse);
  }
} catch (error) {
  console.error("Error accepting sharing request:", error);
}

accept API​

返回值： Promise<ESPAPIResponse> - 返回一个 Promise，在成功接受后解析为成功响应。

信息

用户只能接受共享给自己的邀请（已收到的请求）。

拒绝共享请求​

使用 decline 方法拒绝发送给你的群组共享请求。

try {
  // 获取已收到的共享请求
  const response = await userInstance.getReceivedGroupSharingRequests();
  const receivedRequests = response.sharedRequests;

  // 查找并拒绝指定请求
  const requestToDecline = receivedRequests.find((req) => req.id === requestId);

  if (requestToDecline) {
    const declineResponse = await requestToDecline.decline();
    console.log("Sharing request declined:", declineResponse);
  }
} catch (error) {
  console.error("Error declining sharing request:", error);
}

decline API​

返回值： Promise<ESPAPIResponse> - 返回一个 Promise，在成功拒绝后解析为成功响应。

信息

用户只能拒绝共享给自己的邀请（已收到的请求）。

移除共享请求​

使用 remove 方法移除你之前发送给其他用户的群组共享请求，用于发送者取消待处理的共享请求。

try {
  // 获取已发出的共享请求
  const response = await userInstance.getIssuedGroupSharingRequests();
  const issuedRequests = response.sharedRequests;

  // 查找并移除指定请求
  const requestToRemove = issuedRequests.find((req) => req.id === requestId);

  if (requestToRemove) {
    const removeResponse = await requestToRemove.remove();
    console.log("Sharing request removed:", removeResponse);
  }
} catch (error) {
  console.error("Error removing sharing request:", error);
}

remove API​

返回值： Promise<ESPAPIResponse> - 返回一个 Promise，在成功移除后解析为成功响应。

信息

用户只能移除自己发出的请求（已发出的请求）。

示例：完整的共享请求流程​

以下是展示发送方和接收方如何管理共享请求的完整示例：

// ==================== 发送方 ====================

// 步骤 1：发送方共享群组
try {
  const shareRequest = {
    username: "recipient@example.com",
    groupIds: ["group_id_1", "group_id_2"],
    makePrimary: false,
    metadata: {
      description: "Sharing home automation groups",
    },
  };

  const requestId = await userInstance.shareGroups(shareRequest);
  console.log("Group sharing request sent with ID:", requestId);
} catch (error) {
  console.error("Error sending sharing request:", error);
}

// 步骤 2：发送方可查看已发出的请求
try {
  const response = await userInstance.getIssuedGroupSharingRequests();
  console.log("My issued requests:", response.sharedRequests);

  // 发送方可在请求被接受前取消
  const requestToCancel = response.sharedRequests.find(
    (req) => req.id === requestId
  );

  if (requestToCancel) {
    await requestToCancel.remove();
    console.log("Sharing request cancelled");
  }
} catch (error) {
  console.error("Error managing issued requests:", error);
}

// ==================== 接收方 ====================

// 步骤 1：接收方查看收到的共享请求
try {
  const response = await userInstance.getReceivedGroupSharingRequests();
  console.log("Received sharing requests:", response.sharedRequests);

  // 查找指定请求
  const incomingRequest = response.sharedRequests.find(
    (req) => req.id === requestId
  );

  if (incomingRequest) {
    console.log("Found sharing request from:", incomingRequest.username);
    console.log("Groups:", incomingRequest.groupnames);
    console.log("Metadata:", incomingRequest.metadata);
  }
} catch (error) {
  console.error("Error fetching received requests:", error);
}

// 步骤 2：接收方接受共享请求
try {
  const response = await userInstance.getReceivedGroupSharingRequests();
  const incomingRequest = response.sharedRequests.find(
    (req) => req.id === requestId
  );

  if (incomingRequest) {
    const acceptResponse = await incomingRequest.accept();
    console.log("Sharing request accepted:", acceptResponse);

    // 接收方现在可以访问这些群组
    console.log("Group access granted");
  }
} catch (error) {
  console.error("Error accepting sharing request:", error);
}

// 备选方案：接收方拒绝共享请求
try {
  const response = await userInstance.getReceivedGroupSharingRequests();
  const incomingRequest = response.sharedRequests.find(
    (req) => req.id === requestId
  );

  if (incomingRequest) {
    const declineResponse = await incomingRequest.decline();
    console.log("Sharing request declined:", declineResponse);
  }
} catch (error) {
  console.error("Error declining sharing request:", error);
}

示例：使用分页管理已发出的请求​

获取并管理带分页的已发出请求：

try {
  // 获取已发出的请求，分页（每页 10 条）
  const response = await userInstance.getIssuedGroupSharingRequests(10);

  console.log(`Has more requests: ${response.hasNext}`);
  console.log(`Showing ${response.sharedRequests.length} requests`);

  // 显示所有已发出的请求
  response.sharedRequests.forEach((request, index) => {
    console.log(`${index + 1}. Request to: ${request.username}`);
    console.log(`   Group IDs: ${request.groupIds.join(", ")}`);
    console.log(`   Group Names: ${request.groupnames.join(", ")}`);
    console.log(`   Status: ${request.status}`);
    console.log(`   Transfer: ${request.transfer}`);
  });

  // 移除超过 7 天的待处理请求
  const sevenDaysAgo = Date.now() - 7 * 24 * 60 * 60 * 1000;

  for (const request of response.sharedRequests) {
    if (request.status === "pending" && request.timestamp < sevenDaysAgo) {
      await request.remove();
      console.log(`Removed old request to ${request.username}`);
    }
  }

  // 如有更多数据，获取下一页
  if (response.hasNext && response.fetchNext) {
    const nextResponse = await response.fetchNext();
    console.log(`Fetched ${nextResponse.sharedRequests.length} more requests`);
  }
} catch (error) {
  console.error("Error managing issued requests:", error);
}

On this page