gewe_http/group/
member.rs

1use crate::client::GeweHttpClient;
2use gewe_core::{
3    AddGroupMemberAsFriendRequest, AgreeJoinRoomRequest, GetChatroomInfoRequest,
4    GetChatroomInfoResponse, GetChatroomMemberDetailRequest, GetChatroomMemberDetailResponse,
5    GetChatroomMemberListRequest, GetChatroomMemberListResponse, InviteAddEnterRoomRequest,
6    InviteMemberRequest, JoinRoomUsingQrCodeRequest, RemoveMemberRequest,
7    RoomAccessApplyCheckApproveRequest,
8};
9use tracing::instrument;
10
11impl GeweHttpClient {
12    #[instrument(skip(self))]
13    pub async fn invite_member(
14        &self,
15        req: InviteMemberRequest<'_>,
16    ) -> Result<(), gewe_core::GeweError> {
17        let _ = self
18            .post_api::<_, ()>("gewe/v2/api/group/inviteMember", &req)
19            .await?;
20        Ok(())
21    }
22
23    #[instrument(skip(self))]
24    pub async fn remove_member(
25        &self,
26        req: RemoveMemberRequest<'_>,
27    ) -> Result<(), gewe_core::GeweError> {
28        let _ = self
29            .post_api::<_, ()>("gewe/v2/api/group/removeMember", &req)
30            .await?;
31        Ok(())
32    }
33
34    #[instrument(skip(self))]
35    pub async fn join_room_using_qr_code(
36        &self,
37        req: JoinRoomUsingQrCodeRequest<'_>,
38    ) -> Result<(), gewe_core::GeweError> {
39        let _ = self
40            .post_api::<_, ()>("gewe/v2/api/group/joinRoomUsingQRCode", &req)
41            .await?;
42        Ok(())
43    }
44
45    #[instrument(skip(self))]
46    pub async fn agree_join_room(
47        &self,
48        req: AgreeJoinRoomRequest<'_>,
49    ) -> Result<(), gewe_core::GeweError> {
50        let _ = self
51            .post_api::<_, ()>("gewe/v2/api/group/agreeJoinRoom", &req)
52            .await?;
53        Ok(())
54    }
55
56    #[instrument(skip(self))]
57    pub async fn room_access_apply_check_approve(
58        &self,
59        req: RoomAccessApplyCheckApproveRequest<'_>,
60    ) -> Result<(), gewe_core::GeweError> {
61        let _ = self
62            .post_api::<_, ()>("gewe/v2/api/group/roomAccessApplyCheckApprove", &req)
63            .await?;
64        Ok(())
65    }
66
67    #[instrument(skip(self))]
68    pub async fn invite_add_enter_room(
69        &self,
70        req: InviteAddEnterRoomRequest<'_>,
71    ) -> Result<(), gewe_core::GeweError> {
72        let _ = self
73            .post_api::<_, ()>("gewe/v2/api/group/inviteAddEnterRoom", &req)
74            .await?;
75        Ok(())
76    }
77
78    #[instrument(skip(self))]
79    pub async fn add_group_member_as_friend(
80        &self,
81        req: AddGroupMemberAsFriendRequest<'_>,
82    ) -> Result<(), gewe_core::GeweError> {
83        let _ = self
84            .post_api::<_, ()>("gewe/v2/api/group/addGroupMemberAsFriend", &req)
85            .await?;
86        Ok(())
87    }
88
89    #[instrument(skip(self))]
90    pub async fn get_chatroom_member_list(
91        &self,
92        req: GetChatroomMemberListRequest<'_>,
93    ) -> Result<GetChatroomMemberListResponse, gewe_core::GeweError> {
94        let env = self
95            .post_api::<_, GetChatroomMemberListResponse>(
96                "gewe/v2/api/group/getChatroomMemberList",
97                &req,
98            )
99            .await?;
100        env.data.ok_or(gewe_core::GeweError::MissingData)
101    }
102
103    #[instrument(skip(self))]
104    pub async fn get_chatroom_member_detail(
105        &self,
106        req: GetChatroomMemberDetailRequest<'_>,
107    ) -> Result<GetChatroomMemberDetailResponse, gewe_core::GeweError> {
108        let env = self
109            .post_api::<_, GetChatroomMemberDetailResponse>(
110                "gewe/v2/api/group/getChatroomMemberDetail",
111                &req,
112            )
113            .await?;
114        env.data.ok_or(gewe_core::GeweError::MissingData)
115    }
116
117    #[instrument(skip(self))]
118    pub async fn get_chatroom_info(
119        &self,
120        req: GetChatroomInfoRequest<'_>,
121    ) -> Result<GetChatroomInfoResponse, gewe_core::GeweError> {
122        let env = self
123            .post_api::<_, GetChatroomInfoResponse>("gewe/v2/api/group/getChatroomInfo", &req)
124            .await?;
125        env.data.ok_or(gewe_core::GeweError::MissingData)
126    }
127}
128
129#[cfg(test)]
130mod tests {
131    use super::*;
132
133    #[test]
134    fn test_invite_member_request_serialization() {
135        let req = InviteMemberRequest {
136            app_id: "test_app",
137            chatroom_id: "chatroom_123",
138            reason: "Join us!",
139            wxids: vec!["wxid1", "wxid2"],
140        };
141        let json = serde_json::to_string(&req).expect("Failed to serialize");
142        assert!(json.contains("appId"));
143        assert!(json.contains("wxids"));
144        assert!(json.contains("reason"));
145    }
146
147    #[test]
148    fn test_remove_member_request_serialization() {
149        let req = RemoveMemberRequest {
150            app_id: "test_app",
151            chatroom_id: "chatroom_123",
152            wxids: vec!["wxid1"],
153        };
154        let json = serde_json::to_string(&req).expect("Failed to serialize");
155        assert!(json.contains("appId"));
156        assert!(json.contains("chatroomId"));
157    }
158
159    #[test]
160    fn test_get_chatroom_member_list_request_serialization() {
161        let req = GetChatroomMemberListRequest {
162            app_id: "test_app",
163            chatroom_id: "chatroom_123",
164        };
165        let json = serde_json::to_string(&req).expect("Failed to serialize");
166        assert!(json.contains("appId"));
167        assert!(json.contains("chatroomId"));
168    }
169
170    #[test]
171    fn test_get_chatroom_info_request_serialization() {
172        let req = GetChatroomInfoRequest {
173            app_id: "test_app",
174            chatroom_id: "chatroom_123",
175        };
176        let json = serde_json::to_string(&req).expect("Failed to serialize");
177        assert!(json.contains("appId"));
178        assert!(json.contains("chatroomId"));
179    }
180}