gewe_http/video_account/
interact.rs

1use crate::client::GeweHttpClient;
2use gewe_core::{
3    BrowseFinderRequest, CommentFinderRequest, CommentFinderResponse, CommentListRequest,
4    CommentListResponse, FinderOptRequest, GeweError, IdFavRequest, IdLikeRequest,
5    LikeFavListRequest, LikeFavListResponse,
6};
7use tracing::instrument;
8
9impl GeweHttpClient {
10    #[instrument(skip(self))]
11    pub async fn finder_opt(&self, req: FinderOptRequest<'_>) -> Result<(), GeweError> {
12        self.post_api::<_, serde_json::Value>("gewe/v2/api/finder/finderOpt", &req)
13            .await?;
14        Ok(())
15    }
16
17    #[instrument(skip(self))]
18    pub async fn browse_finder(&self, req: BrowseFinderRequest<'_>) -> Result<(), GeweError> {
19        self.post_api::<_, serde_json::Value>("gewe/v2/api/finder/browse", &req)
20            .await?;
21        Ok(())
22    }
23
24    #[instrument(skip(self))]
25    pub async fn id_fav(&self, req: IdFavRequest<'_>) -> Result<(), GeweError> {
26        self.post_api::<_, serde_json::Value>("gewe/v2/api/finder/idFav", &req)
27            .await?;
28        Ok(())
29    }
30
31    #[instrument(skip(self))]
32    pub async fn id_like(&self, req: IdLikeRequest<'_>) -> Result<(), GeweError> {
33        self.post_api::<_, serde_json::Value>("gewe/v2/api/finder/idLike", &req)
34            .await?;
35        Ok(())
36    }
37
38    #[instrument(skip(self))]
39    pub async fn like_fav_list(
40        &self,
41        req: LikeFavListRequest<'_>,
42    ) -> Result<LikeFavListResponse, GeweError> {
43        let env = self
44            .post_api::<_, LikeFavListResponse>("gewe/v2/api/finder/likeFavList", &req)
45            .await?;
46        env.data.ok_or(GeweError::MissingData)
47    }
48
49    #[instrument(skip(self))]
50    pub async fn comment_finder(
51        &self,
52        req: CommentFinderRequest<'_>,
53    ) -> Result<CommentFinderResponse, GeweError> {
54        let env = self
55            .post_api::<_, CommentFinderResponse>("gewe/v2/api/finder/comment", &req)
56            .await?;
57        env.data.ok_or(GeweError::MissingData)
58    }
59
60    #[instrument(skip(self))]
61    pub async fn comment_list(
62        &self,
63        req: CommentListRequest<'_>,
64    ) -> Result<CommentListResponse, GeweError> {
65        let env = self
66            .post_api::<_, CommentListResponse>("gewe/v2/api/finder/commentList", &req)
67            .await?;
68        env.data.ok_or(GeweError::MissingData)
69    }
70}
71
72#[cfg(test)]
73mod tests {
74    use super::*;
75
76    #[test]
77    fn test_id_like_request() {
78        let req = IdLikeRequest {
79            app_id: "test_app",
80            object_id: 123456,
81            session_buffer: None,
82            object_nonce_id: "nonce_123",
83            op_type: 1,
84            my_user_name: "my_user",
85            my_role_type: 1,
86            to_user_name: "to_user",
87        };
88        let json = serde_json::to_string(&req).expect("Failed to serialize");
89        assert!(json.contains("appId"));
90        assert!(json.contains("objectId"));
91        assert!(json.contains("opType"));
92    }
93
94    #[test]
95    fn test_comment_finder_request() {
96        let req = CommentFinderRequest {
97            app_id: "test_app",
98            proxy_ip: "",
99            my_user_name: "my_user",
100            op_type: 1,
101            object_nonce_id: "nonce_123",
102            session_buffer: "buffer",
103            object_id: 123456,
104            my_role_type: 1,
105            content: "Nice video!",
106            comment_id: "",
107            reply_user_name: "",
108            ref_comment_id: 0,
109            root_comment_id: 0,
110        };
111        let json = serde_json::to_string(&req).expect("Failed to serialize");
112        assert!(json.contains("appId"));
113        assert!(json.contains("content"));
114        assert!(json.contains("Nice video!"));
115    }
116
117    #[test]
118    fn test_comment_list_request() {
119        let req = CommentListRequest {
120            app_id: "test_app",
121            object_id: 123456,
122            last_buffer: None,
123            session_buffer: "buffer",
124            object_nonce_id: Some("nonce_123"),
125            ref_comment_id: None,
126            root_comment_id: None,
127        };
128        let json = serde_json::to_string(&req).expect("Failed to serialize");
129        assert!(json.contains("appId"));
130        assert!(json.contains("objectId"));
131    }
132}