gewe_http/contact/
manage.rs

1use crate::client::GeweHttpClient;
2use gewe_core::{
3    AddContactsRequest, DeleteFriendRequest, GeweError, SetFriendPermissionsRequest,
4    SetFriendRemarkRequest, UploadPhoneAddressListRequest,
5};
6use tracing::instrument;
7
8impl GeweHttpClient {
9    #[instrument(skip(self))]
10    pub async fn add_contacts(&self, req: AddContactsRequest<'_>) -> Result<(), GeweError> {
11        let _ = self
12            .post_api::<_, ()>("gewe/v2/api/contacts/addContacts", &req)
13            .await?;
14        Ok(())
15    }
16
17    #[instrument(skip(self))]
18    pub async fn set_friend_remark(
19        &self,
20        req: SetFriendRemarkRequest<'_>,
21    ) -> Result<(), GeweError> {
22        let _ = self
23            .post_api::<_, ()>("gewe/v2/api/contacts/setFriendRemark", &req)
24            .await?;
25        Ok(())
26    }
27
28    #[instrument(skip(self))]
29    pub async fn set_friend_permissions(
30        &self,
31        req: SetFriendPermissionsRequest<'_>,
32    ) -> Result<(), GeweError> {
33        let _ = self
34            .post_api::<_, ()>("gewe/v2/api/contacts/setFriendPermissions", &req)
35            .await?;
36        Ok(())
37    }
38
39    #[instrument(skip(self))]
40    pub async fn upload_phone_address_list(
41        &self,
42        req: UploadPhoneAddressListRequest<'_>,
43    ) -> Result<(), GeweError> {
44        let _ = self
45            .post_api::<_, ()>("gewe/v2/api/contacts/uploadPhoneAddressList", &req)
46            .await?;
47        Ok(())
48    }
49
50    #[instrument(skip(self))]
51    pub async fn delete_friend(&self, req: DeleteFriendRequest<'_>) -> Result<(), GeweError> {
52        let _ = self
53            .post_api::<_, ()>("gewe/v2/api/contacts/deleteFriend", &req)
54            .await?;
55        Ok(())
56    }
57}
58
59#[cfg(test)]
60mod tests {
61    use super::*;
62
63    #[test]
64    fn test_add_contacts_request_serialization() {
65        let req = AddContactsRequest {
66            app_id: "test_app",
67            scene: 3,
68            option: 1,
69            v3: "stranger_v3_value",
70            v4: "stranger_v4_value",
71            content: "Hello",
72        };
73        let json = serde_json::to_string(&req).expect("Failed to serialize");
74        assert!(json.contains("appId"));
75        assert!(json.contains("test_app"));
76        assert!(json.contains("stranger_v3_value"));
77        assert!(json.contains("Hello"));
78    }
79
80    #[test]
81    fn test_add_contacts_request_with_scene() {
82        let req = AddContactsRequest {
83            app_id: "test_app",
84            scene: 1,
85            option: 0,
86            v3: "v3_data",
87            v4: "v4_data",
88            content: "content_data",
89        };
90        let json = serde_json::to_string(&req).expect("Failed to serialize");
91        assert!(json.contains("appId"));
92        assert!(json.contains("v3_data"));
93    }
94
95    #[test]
96    fn test_set_friend_remark_request_serialization() {
97        let req = SetFriendRemarkRequest {
98            app_id: "test_app",
99            wxid: "friend_wxid",
100            remark: "NewRemark",
101        };
102        let json = serde_json::to_string(&req).expect("Failed to serialize");
103        assert!(json.contains("appId"));
104        assert!(json.contains("test_app"));
105        assert!(json.contains("wxid"));
106        assert!(json.contains("friend_wxid"));
107        assert!(json.contains("remark"));
108        assert!(json.contains("NewRemark"));
109    }
110
111    #[test]
112    fn test_set_friend_remark_with_unicode() {
113        let req = SetFriendRemarkRequest {
114            app_id: "测试应用",
115            wxid: "wxid_123",
116            remark: "好友备注",
117        };
118        let json = serde_json::to_string(&req).expect("Failed to serialize");
119        assert!(json.contains("测试应用"));
120        assert!(json.contains("好友备注"));
121    }
122
123    #[test]
124    fn test_set_friend_permissions_request_serialization() {
125        let req = SetFriendPermissionsRequest {
126            app_id: "test_app",
127            wxid: "friend_wxid",
128            only_chat: true,
129        };
130        let json = serde_json::to_string(&req).expect("Failed to serialize");
131        assert!(json.contains("appId"));
132        assert!(json.contains("test_app"));
133        assert!(json.contains("wxid"));
134        assert!(json.contains("friend_wxid"));
135        assert!(json.contains("onlyChat"));
136    }
137
138    #[test]
139    fn test_upload_phone_address_list_request_serialization() {
140        let req = UploadPhoneAddressListRequest {
141            app_id: "test_app",
142            phones: vec!["+1234567890", "+9876543210"],
143            op_type: 1,
144        };
145        let json = serde_json::to_string(&req).expect("Failed to serialize");
146        assert!(json.contains("appId"));
147        assert!(json.contains("test_app"));
148        assert!(json.contains("+1234567890"));
149        assert!(json.contains("+9876543210"));
150    }
151
152    #[test]
153    fn test_upload_phone_address_list_empty() {
154        let req = UploadPhoneAddressListRequest {
155            app_id: "test_app",
156            phones: vec![],
157            op_type: 0,
158        };
159        let json = serde_json::to_string(&req).expect("Failed to serialize");
160        assert!(json.contains("appId"));
161        assert!(json.contains("[]"));
162    }
163
164    #[test]
165    fn test_delete_friend_request_serialization() {
166        let req = DeleteFriendRequest {
167            app_id: "test_app",
168            wxid: "friend_to_delete",
169        };
170        let json = serde_json::to_string(&req).expect("Failed to serialize");
171        assert!(json.contains("appId"));
172        assert!(json.contains("test_app"));
173        assert!(json.contains("wxid"));
174        assert!(json.contains("friend_to_delete"));
175    }
176
177    #[test]
178    fn test_set_friend_remark_with_empty_remark() {
179        let req = SetFriendRemarkRequest {
180            app_id: "test_app",
181            wxid: "friend_wxid",
182            remark: "",
183        };
184        let json = serde_json::to_string(&req).expect("Failed to serialize");
185        assert!(json.contains("appId"));
186        assert!(json.contains("remark"));
187    }
188
189    #[test]
190    fn test_set_friend_permissions_false() {
191        let req = SetFriendPermissionsRequest {
192            app_id: "test_app",
193            wxid: "friend_wxid",
194            only_chat: false,
195        };
196        let json = serde_json::to_string(&req).expect("Failed to serialize");
197        assert!(json.contains("appId"));
198        assert!(json.contains("wxid"));
199        assert!(json.contains("false"));
200    }
201}