XuqmGroup-Server/im-sdk/src/main/java/com/xuqm/im/sdk/XuqmImServerSdk.java

1010 行
34 KiB
Java

package com.xuqm.im.sdk;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule;
import com.xuqm.common.model.ApiResponse;
import com.xuqm.common.security.AppRequestSignatureUtil;
import java.io.IOException;
import java.net.URI;
import java.net.URLEncoder;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.nio.charset.StandardCharsets;
import java.time.Instant;
import java.time.LocalDateTime;
import java.time.ZoneOffset;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.UUID;
import java.util.function.Supplier;
public final class XuqmImServerSdk {
private final HttpClient httpClient;
private final ObjectMapper objectMapper;
private final String baseUrl;
private final String appId;
private final String appSecret;
private final Supplier<String> bearerTokenSupplier;
private XuqmImServerSdk(Builder builder) {
this.httpClient = HttpClient.newHttpClient();
this.objectMapper = new ObjectMapper()
.registerModule(new JavaTimeModule())
.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
this.baseUrl = trimTrailingSlash(Objects.requireNonNull(builder.baseUrl, "baseUrl"));
this.appId = Objects.requireNonNull(builder.appId, "appId");
this.appSecret = Objects.requireNonNull(builder.appSecret, "appSecret");
this.bearerTokenSupplier = builder.bearerTokenSupplier;
}
public static Builder builder() {
return new Builder();
}
public LoginResponse login(String userId, String nickname, String avatar) {
long timestamp = System.currentTimeMillis();
String nonce = UUID.randomUUID().toString().replace("-", "");
String payload = AppRequestSignatureUtil.payload(appId, userId, nickname, avatar, timestamp, nonce);
String signature = AppRequestSignatureUtil.sign(appSecret, payload);
URI uri = buildUri(
"/api/im/auth/login",
loginQuery(userId, nickname, avatar, timestamp, nonce)
);
ApiResponse<LoginResponse> response = request(
"POST",
uri,
null,
Map.of(
"X-App-Id", appId,
"X-App-Timestamp", String.valueOf(timestamp),
"X-App-Nonce", nonce,
"X-App-Signature", signature
),
new TypeReference<>() {}
);
return response.data();
}
public ImMessage sendMessage(SendMessageRequest request) {
ApiResponse<ImMessage> response = request(
"POST",
buildUri("/api/im/messages/send", Map.of("appId", appId)),
request,
authorizedHeaders(),
new TypeReference<>() {}
);
return response.data();
}
public ImMessage revokeMessage(String messageId) {
ApiResponse<ImMessage> response = request(
"POST",
buildUri("/api/im/messages/" + encode(messageId) + "/revoke", Map.of("appId", appId)),
null,
authorizedHeaders(),
new TypeReference<>() {}
);
return response.data();
}
public List<ConversationView> listConversations(int size) {
ApiResponse<List<ConversationView>> response = request(
"GET",
buildUri("/api/im/conversations", Map.of("appId", appId, "page", "0", "size", String.valueOf(size))),
null,
authorizedHeaders(),
new TypeReference<>() {}
);
return response.data();
}
public PageResult<ImMessage> fetchHistory(String toId, HistoryQuery query) {
HistoryQuery effective = query == null ? new HistoryQuery() : query;
ApiResponse<PageResult<ImMessage>> response = request(
"GET",
buildUri(
"/api/im/messages/history/" + encode(toId),
queryParams(
effective.msgType(),
effective.keyword(),
effective.startTime(),
effective.endTime(),
effective.page() == null ? 0 : effective.page(),
effective.size() == null ? 20 : effective.size()
)
),
null,
authorizedHeaders(),
new TypeReference<>() {}
);
return response.data();
}
public PageResult<ImMessage> fetchGroupHistory(String groupId, HistoryQuery query) {
HistoryQuery effective = query == null ? new HistoryQuery() : query;
ApiResponse<PageResult<ImMessage>> response = request(
"GET",
buildUri(
"/api/im/messages/group-history/" + encode(groupId),
queryParams(
effective.msgType(),
effective.keyword(),
effective.startTime(),
effective.endTime(),
effective.page() == null ? 0 : effective.page(),
effective.size() == null ? 20 : effective.size()
)
),
null,
authorizedHeaders(),
new TypeReference<>() {}
);
return response.data();
}
public List<ConversationView> listConversations() {
return listConversations(20);
}
public AccountView getProfile(String userId) {
ApiResponse<AccountView> response = request(
"GET",
buildUri("/api/im/accounts/" + encode(userId), appQuery()),
null,
authorizedHeaders(),
new TypeReference<>() {}
);
return response.data();
}
public AccountView updateProfile(String userId, String nickname, String avatar, String gender) {
Map<String, String> query = appQuery();
if (nickname != null) {
query.put("nickname", nickname);
}
if (avatar != null) {
query.put("avatar", avatar);
}
if (gender != null) {
query.put("gender", gender);
}
ApiResponse<AccountView> response = request(
"PUT",
buildUri("/api/im/accounts/" + encode(userId), query),
null,
authorizedHeaders(),
new TypeReference<>() {}
);
return response.data();
}
public PageResult<AccountView> listUsers(int page, int size) {
ApiResponse<PageResult<AccountView>> response = request(
"GET",
buildUri("/api/im/admin/users", queryWithPage(page, size)),
null,
authorizedHeaders(),
new TypeReference<>() {}
);
return response.data();
}
public AccountView registerUser(String userId, String nickname, String avatar) {
Map<String, String> body = new LinkedHashMap<>();
body.put("userId", userId);
if (nickname != null) {
body.put("nickname", nickname);
}
if (avatar != null) {
body.put("avatar", avatar);
}
ApiResponse<AccountView> response = request(
"POST",
buildUri("/api/im/admin/users", appQuery()),
body,
authorizedHeaders(),
new TypeReference<>() {}
);
return response.data();
}
public AccountView updateUserStatus(String userId, String status) {
ApiResponse<AccountView> response = request(
"PUT",
buildUri("/api/im/admin/users/" + encode(userId) + "/status", appQuery()),
Map.of("status", status),
authorizedHeaders(),
new TypeReference<>() {}
);
return response.data();
}
public List<AccountView> searchUsers(String keyword, int size) {
ApiResponse<List<AccountView>> response = request(
"GET",
buildUri("/api/im/admin/users/search", queryWithSize("keyword", keyword, size)),
null,
authorizedHeaders(),
new TypeReference<>() {}
);
return response.data();
}
public StatsView stats() {
ApiResponse<StatsView> response = request(
"GET",
buildUri("/api/im/admin/stats", appQuery()),
null,
authorizedHeaders(),
new TypeReference<>() {}
);
return response.data();
}
public List<String> listFriends() {
ApiResponse<List<String>> response = request(
"GET",
buildUri("/api/im/friends", appQuery()),
null,
authorizedHeaders(),
new TypeReference<>() {}
);
return response.data();
}
public FriendLinkView addFriend(String friendId) {
Map<String, String> query = appQuery();
query.put("friendId", friendId);
ApiResponse<FriendLinkView> response = request(
"POST",
buildUri("/api/im/friends", query),
null,
authorizedHeaders(),
new TypeReference<>() {}
);
return response.data();
}
public void removeFriend(String friendId) {
Map<String, String> query = appQuery();
query.put("friendId", friendId);
request(
"DELETE",
buildUri("/api/im/friends/" + encode(friendId), query),
null,
authorizedHeaders(),
new TypeReference<ApiResponse<Void>>() {}
);
}
public List<FriendRequestView> listFriendRequests(String direction) {
Map<String, String> query = appQuery();
if (direction != null) {
query.put("direction", direction);
}
ApiResponse<List<FriendRequestView>> response = request(
"GET",
buildUri("/api/im/friend-requests", query),
null,
authorizedHeaders(),
new TypeReference<>() {}
);
return response.data();
}
public FriendRequestView sendFriendRequest(String toUserId, String remark) {
Map<String, String> query = appQuery();
query.put("toUserId", toUserId);
if (remark != null) {
query.put("remark", remark);
}
ApiResponse<FriendRequestView> response = request(
"POST",
buildUri("/api/im/friend-requests", query),
null,
authorizedHeaders(),
new TypeReference<>() {}
);
return response.data();
}
public FriendRequestView acceptFriendRequest(String requestId) {
ApiResponse<FriendRequestView> response = request(
"POST",
buildUri("/api/im/friend-requests/" + encode(requestId) + "/accept", appQuery()),
null,
authorizedHeaders(),
new TypeReference<>() {}
);
return response.data();
}
public FriendRequestView rejectFriendRequest(String requestId) {
ApiResponse<FriendRequestView> response = request(
"POST",
buildUri("/api/im/friend-requests/" + encode(requestId) + "/reject", appQuery()),
null,
authorizedHeaders(),
new TypeReference<>() {}
);
return response.data();
}
public List<BlacklistView> listBlacklist() {
ApiResponse<List<BlacklistView>> response = request(
"GET",
buildUri("/api/im/blacklist", appQuery()),
null,
authorizedHeaders(),
new TypeReference<>() {}
);
return response.data();
}
public BlacklistView addBlacklist(String blockedUserId) {
Map<String, String> query = appQuery();
query.put("blockedUserId", blockedUserId);
ApiResponse<BlacklistView> response = request(
"POST",
buildUri("/api/im/blacklist", query),
null,
authorizedHeaders(),
new TypeReference<>() {}
);
return response.data();
}
public void removeBlacklist(String blockedUserId) {
Map<String, String> query = appQuery();
query.put("blockedUserId", blockedUserId);
request(
"DELETE",
buildUri("/api/im/blacklist", query),
null,
authorizedHeaders(),
new TypeReference<ApiResponse<Void>>() {}
);
}
public List<GroupView> listGroups() {
ApiResponse<List<GroupView>> response = request(
"GET",
buildUri("/api/im/groups", appQuery()),
null,
authorizedHeaders(),
new TypeReference<>() {}
);
return response.data();
}
public List<GroupView> listPublicGroups(String keyword) {
Map<String, String> query = appQuery();
if (keyword != null) {
query.put("keyword", keyword);
}
ApiResponse<List<GroupView>> response = request(
"GET",
buildUri("/api/im/groups/public", query),
null,
authorizedHeaders(),
new TypeReference<>() {}
);
return response.data();
}
public GroupView getGroup(String groupId) {
ApiResponse<GroupView> response = request(
"GET",
buildUri("/api/im/groups/" + encode(groupId), appQuery()),
null,
authorizedHeaders(),
new TypeReference<>() {}
);
return response.data();
}
public GroupView createGroup(String name, List<String> memberIds, String groupType) {
ApiResponse<GroupView> response = request(
"POST",
buildUri("/api/im/groups", appQuery()),
new CreateGroupRequest(name, memberIds, groupType),
authorizedHeaders(),
new TypeReference<>() {}
);
return response.data();
}
public GroupView updateGroup(String groupId, String name, String announcement) {
ApiResponse<GroupView> response = request(
"PUT",
buildUri("/api/im/groups/" + encode(groupId), appQuery()),
new UpdateGroupRequest(name, announcement),
authorizedHeaders(),
new TypeReference<>() {}
);
return response.data();
}
public GroupView addGroupMember(String groupId, String userId) {
ApiResponse<GroupView> response = request(
"POST",
buildUri("/api/im/groups/" + encode(groupId) + "/members", appQuery()),
new MemberRequest(userId),
authorizedHeaders(),
new TypeReference<>() {}
);
return response.data();
}
public GroupView removeGroupMember(String groupId, String targetUserId) {
ApiResponse<GroupView> response = request(
"DELETE",
buildUri("/api/im/groups/" + encode(groupId) + "/members/" + encode(targetUserId), appQuery()),
null,
authorizedHeaders(),
new TypeReference<>() {}
);
return response.data();
}
public GroupView setGroupRole(String groupId, String userId, String role) {
ApiResponse<GroupView> response = request(
"POST",
buildUri("/api/im/groups/" + encode(groupId) + "/roles", appQuery()),
new SetRoleRequest(userId, role),
authorizedHeaders(),
new TypeReference<>() {}
);
return response.data();
}
public GroupView muteGroupMember(String groupId, String userId, long minutes) {
ApiResponse<GroupView> response = request(
"POST",
buildUri("/api/im/groups/" + encode(groupId) + "/mute", appQuery()),
new MuteMemberRequest(userId, minutes),
authorizedHeaders(),
new TypeReference<>() {}
);
return response.data();
}
public void dismissGroup(String groupId) {
request(
"DELETE",
buildUri("/api/im/groups/" + encode(groupId), appQuery()),
null,
authorizedHeaders(),
new TypeReference<ApiResponse<Void>>() {}
);
}
public GroupJoinRequestView sendGroupJoinRequest(String groupId, String remark) {
Map<String, String> query = appQuery();
if (remark != null) {
query.put("remark", remark);
}
ApiResponse<GroupJoinRequestView> response = request(
"POST",
buildUri("/api/im/groups/" + encode(groupId) + "/join-requests", query),
null,
authorizedHeaders(),
new TypeReference<>() {}
);
return response.data();
}
public List<GroupJoinRequestView> listGroupJoinRequests(String groupId) {
ApiResponse<List<GroupJoinRequestView>> response = request(
"GET",
buildUri("/api/im/groups/" + encode(groupId) + "/join-requests", appQuery()),
null,
authorizedHeaders(),
new TypeReference<>() {}
);
return response.data();
}
public GroupJoinRequestView acceptGroupJoinRequest(String groupId, String requestId) {
ApiResponse<GroupJoinRequestView> response = request(
"POST",
buildUri("/api/im/groups/" + encode(groupId) + "/join-requests/" + encode(requestId) + "/accept", appQuery()),
null,
authorizedHeaders(),
new TypeReference<>() {}
);
return response.data();
}
public GroupJoinRequestView rejectGroupJoinRequest(String groupId, String requestId) {
ApiResponse<GroupJoinRequestView> response = request(
"POST",
buildUri("/api/im/groups/" + encode(groupId) + "/join-requests/" + encode(requestId) + "/reject", appQuery()),
null,
authorizedHeaders(),
new TypeReference<>() {}
);
return response.data();
}
public void setConversationPinned(String targetId, String chatType, boolean pinned) {
Map<String, String> query = appQuery();
query.put("chatType", chatType);
query.put("pinned", String.valueOf(pinned));
request(
"PUT",
buildUri("/api/im/conversations/" + encode(targetId) + "/pinned", query),
null,
authorizedHeaders(),
new TypeReference<ApiResponse<Void>>() {}
);
}
public void setConversationMuted(String targetId, String chatType, boolean muted) {
Map<String, String> query = appQuery();
query.put("chatType", chatType);
query.put("muted", String.valueOf(muted));
request(
"PUT",
buildUri("/api/im/conversations/" + encode(targetId) + "/muted", query),
null,
authorizedHeaders(),
new TypeReference<ApiResponse<Void>>() {}
);
}
public void markRead(String targetId, String chatType) {
Map<String, String> query = appQuery();
query.put("chatType", chatType);
request(
"PUT",
buildUri("/api/im/conversations/" + encode(targetId) + "/read", query),
null,
authorizedHeaders(),
new TypeReference<ApiResponse<Void>>() {}
);
}
public void setDraft(String targetId, String chatType, String draft) {
Map<String, String> query = appQuery();
query.put("chatType", chatType);
if (draft != null) {
query.put("draft", draft);
}
request(
"PUT",
buildUri("/api/im/conversations/" + encode(targetId) + "/draft", query),
null,
authorizedHeaders(),
new TypeReference<ApiResponse<Void>>() {}
);
}
public void deleteConversation(String targetId, String chatType) {
Map<String, String> query = appQuery();
query.put("chatType", chatType);
request(
"DELETE",
buildUri("/api/im/conversations/" + encode(targetId), query),
null,
authorizedHeaders(),
new TypeReference<ApiResponse<Void>>() {}
);
}
public PageResult<ImMessage> queryAdminMessages(
String userA,
String userB,
String msgType,
String keyword,
LocalDateTime startTime,
LocalDateTime endTime,
int page,
int size) {
Map<String, String> query = appQuery();
query.put("userA", userA);
query.put("userB", userB);
if (msgType != null) {
query.put("msgType", msgType);
}
if (keyword != null) {
query.put("keyword", keyword);
}
if (startTime != null) {
query.put("startTime", startTime.toInstant(ZoneOffset.UTC).toString());
}
if (endTime != null) {
query.put("endTime", endTime.toInstant(ZoneOffset.UTC).toString());
}
query.put("page", String.valueOf(page));
query.put("size", String.valueOf(size));
ApiResponse<PageResult<ImMessage>> response = request(
"GET",
buildUri("/api/im/admin/messages", query),
null,
authorizedHeaders(),
new TypeReference<>() {}
);
return response.data();
}
public ImMessage revokeAdminMessage(String messageId) {
ApiResponse<ImMessage> response = request(
"POST",
buildUri("/api/im/admin/messages/" + encode(messageId) + "/revoke", appQuery()),
null,
authorizedHeaders(),
new TypeReference<>() {}
);
return response.data();
}
public void dismissAdminGroup(String groupId) {
request(
"DELETE",
buildUri("/api/im/admin/groups/" + encode(groupId), appQuery()),
null,
authorizedHeaders(),
new TypeReference<ApiResponse<Void>>() {}
);
}
private Map<String, String> authorizedHeaders() {
String token = bearerTokenSupplier == null ? null : bearerTokenSupplier.get();
if (token == null || token.isBlank()) {
throw new ImSdkException("Bearer token is required for this call");
}
return Map.of("Authorization", "Bearer " + token);
}
private <T> ApiResponse<T> request(
String method,
URI uri,
Object body,
Map<String, String> headers,
TypeReference<ApiResponse<T>> responseType
) {
try {
HttpRequest.Builder builder = HttpRequest.newBuilder(uri)
.header("Content-Type", "application/json")
.headers(flatten(headers));
if (body != null) {
builder.method(method, HttpRequest.BodyPublishers.ofString(objectMapper.writeValueAsString(body)));
} else if ("GET".equalsIgnoreCase(method) || "DELETE".equalsIgnoreCase(method)) {
builder.method(method, HttpRequest.BodyPublishers.noBody());
} else {
builder.method(method, HttpRequest.BodyPublishers.noBody());
}
HttpResponse<String> response = httpClient.send(builder.build(), HttpResponse.BodyHandlers.ofString());
if (response.statusCode() >= 400) {
throw new ImSdkException("HTTP " + response.statusCode() + ": " + response.body());
}
ApiResponse<T> apiResponse = objectMapper.readValue(response.body(), responseType);
if (apiResponse.code() != 200) {
throw new ImSdkException(apiResponse.message());
}
return apiResponse;
} catch (IOException e) {
throw new ImSdkException("Request failed: " + e.getMessage(), e);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
throw new ImSdkException("Request interrupted", e);
}
}
private URI buildUri(String path, Map<String, String> query) {
StringBuilder builder = new StringBuilder(baseUrl).append(path);
if (query != null && !query.isEmpty()) {
builder.append('?');
boolean first = true;
for (Map.Entry<String, String> entry : query.entrySet()) {
String value = entry.getValue();
if (value == null) {
continue;
}
if (!first) {
builder.append('&');
}
builder.append(encode(entry.getKey())).append('=').append(encode(value));
first = false;
}
}
return URI.create(builder.toString());
}
private Map<String, String> loginQuery(String userId, String nickname, String avatar, long timestamp, String nonce) {
Map<String, String> query = new LinkedHashMap<>();
query.put("appId", appId);
query.put("userId", userId);
query.put("timestamp", String.valueOf(timestamp));
query.put("nonce", nonce);
if (nickname != null && !nickname.isBlank()) {
query.put("nickname", nickname);
}
if (avatar != null && !avatar.isBlank()) {
query.put("avatar", avatar);
}
return query;
}
private Map<String, String> appQuery() {
Map<String, String> query = new LinkedHashMap<>();
query.put("appId", appId);
return query;
}
private Map<String, String> queryWithPage(int page, int size) {
Map<String, String> query = appQuery();
query.put("page", String.valueOf(page));
query.put("size", String.valueOf(size));
return query;
}
private Map<String, String> queryWithSize(String key, String value, int size) {
Map<String, String> query = appQuery();
query.put(key, value);
query.put("size", String.valueOf(size));
return query;
}
private Map<String, String> queryParams(String msgType, String keyword, LocalDateTime startTime, LocalDateTime endTime, int page, int size) {
Map<String, String> query = new LinkedHashMap<>();
query.put("appId", appId);
if (msgType != null && !msgType.isBlank()) {
query.put("msgType", msgType);
}
if (keyword != null && !keyword.isBlank()) {
query.put("keyword", keyword);
}
if (startTime != null) {
query.put("startTime", startTime.toInstant(ZoneOffset.UTC).toString());
}
if (endTime != null) {
query.put("endTime", endTime.toInstant(ZoneOffset.UTC).toString());
}
query.put("page", String.valueOf(page));
query.put("size", String.valueOf(size));
return query;
}
private String[] flatten(Map<String, String> headers) {
String[] pairs = new String[headers.size() * 2];
int index = 0;
for (Map.Entry<String, String> entry : headers.entrySet()) {
pairs[index++] = entry.getKey();
pairs[index++] = entry.getValue();
}
return pairs;
}
private String encode(String value) {
return URLEncoder.encode(value, StandardCharsets.UTF_8);
}
private String trimTrailingSlash(String value) {
return value.endsWith("/") ? value.substring(0, value.length() - 1) : value;
}
public static final class Builder {
private String baseUrl;
private String appId;
private String appSecret;
private Supplier<String> bearerTokenSupplier;
private Builder() {}
public Builder baseUrl(String baseUrl) {
this.baseUrl = baseUrl;
return this;
}
public Builder appId(String appId) {
this.appId = appId;
return this;
}
public Builder appSecret(String appSecret) {
this.appSecret = appSecret;
return this;
}
public Builder bearerTokenSupplier(Supplier<String> bearerTokenSupplier) {
this.bearerTokenSupplier = bearerTokenSupplier;
return this;
}
public XuqmImServerSdk build() {
return new XuqmImServerSdk(this);
}
}
public record LoginResponse(String token, long expiresAt) {}
public record ConversationView(
String targetId,
String chatType,
String lastMsgContent,
String lastMsgType,
Long lastMsgTime,
int unreadCount,
boolean isMuted,
boolean isPinned
) {}
public record AccountView(
String id,
String appId,
String userId,
String nickname,
String gender,
String avatar,
String status,
LocalDateTime createdAt
) {}
public record FriendLinkView(
Long id,
String appId,
String userId,
String friendId,
Instant createdAt
) {}
public record FriendRequestView(
String id,
String appId,
String fromUserId,
String toUserId,
String remark,
String status,
LocalDateTime createdAt,
LocalDateTime reviewedAt
) {}
public record BlacklistView(
String id,
String appId,
String userId,
String blockedUserId,
LocalDateTime createdAt
) {}
public record GroupView(
String id,
String appId,
String name,
String groupType,
String creatorId,
String memberIds,
String adminIds,
String announcement,
LocalDateTime createdAt
) {
public List<String> memberIdList() {
return parseJsonStringList(memberIds);
}
public List<String> adminIdList() {
return parseJsonStringList(adminIds);
}
}
public record GroupJoinRequestView(
String id,
String appId,
String groupId,
String requesterId,
String remark,
String status,
LocalDateTime createdAt,
LocalDateTime reviewedAt
) {}
public record StatsView(
long totalMessages,
long totalUsers,
long totalGroups,
long todayMessages
) {}
public record HistoryQuery(
String msgType,
String keyword,
LocalDateTime startTime,
LocalDateTime endTime,
Integer page,
Integer size
) {
public HistoryQuery() {
this(null, null, null, null, null, null);
}
}
public record PageResult<T>(
List<T> content,
long totalElements,
int totalPages,
int size,
int number,
int numberOfElements,
boolean first,
boolean last,
boolean empty
) {}
public record ImMessage(
String id,
String appId,
String fromUserId,
String toId,
String chatType,
String msgType,
String content,
String status,
String mentionedUserIds,
Integer groupReadCount,
Long createdAt
) {}
public record SendMessageRequest(
String messageId,
String toId,
String chatType,
String msgType,
String content,
String mentionedUserIds
) {}
public record CreateGroupRequest(
String name,
List<String> memberIds,
String groupType
) {}
public record UpdateGroupRequest(
String name,
String announcement
) {}
public record MemberRequest(String userId) {}
public record SetRoleRequest(String userId, String role) {}
public record MuteMemberRequest(String userId, long minutes) {}
public static final class ImSdkException extends RuntimeException {
public ImSdkException(String message) {
super(message);
}
public ImSdkException(String message, Throwable cause) {
super(message, cause);
}
}
private static List<String> parseJsonStringList(String value) {
if (value == null || value.isBlank()) {
return List.of();
}
String trimmed = value.trim();
if (!trimmed.startsWith("[")) {
return trimmed.isEmpty() ? List.of() : List.of(trimmed.split(","));
}
try {
ObjectMapper mapper = new ObjectMapper();
return mapper.readValue(trimmed, new TypeReference<List<String>>() {});
} catch (IOException e) {
return new ArrayList<>(List.of(trimmed));
}
}
}