box_open_sdk/managers/
comments.rs1use crate::internal::path_escape;
4use crate::runtime::{self, Error};
5
6#[derive(Clone, Debug, Default)]
8pub struct CommentsListFileOptions {
9 pub fields: Option<Vec<String>>,
10 pub limit: Option<i64>,
11 pub offset: Option<i64>,
12}
13
14#[derive(Clone, Debug, Default)]
16pub struct CommentsGetOptions {
17 pub fields: Option<Vec<String>>,
18}
19
20#[derive(Clone, Debug, Default)]
22pub struct CommentsUpdateOptions {
23 pub fields: Option<Vec<String>>,
24}
25
26#[derive(Clone, Debug, Default)]
28pub struct CommentsCreateOptions {
29 pub fields: Option<Vec<String>>,
30}
31
32pub struct CommentsListFilePaginator {
35 manager: CommentsManager,
36 file_id: String,
37 options: CommentsListFileOptions,
38 buffer: std::vec::IntoIter<crate::models::schemas::CommentFull>,
39 done: bool,
40}
41
42impl CommentsListFilePaginator {
43 pub async fn next(&mut self) -> Option<Result<crate::models::schemas::CommentFull, Error>> {
46 loop {
47 if let Some(item) = self.buffer.next() {
48 return Some(Ok(item));
49 }
50 if self.done {
51 return None;
52 }
53 let page = match self
54 .manager
55 .list_file_page(self.file_id.clone(), Some(self.options.clone()))
56 .await
57 {
58 Ok(page) => page,
59 Err(err) => {
60 self.done = true;
61 return Some(Err(err));
62 }
63 };
64 let items = page.entries.unwrap_or_default();
65 if items.is_empty() {
66 self.done = true;
67 } else {
68 let next = self.options.offset.unwrap_or(0) + items.len() as i64;
69 self.options.offset = Some(next);
70 }
71 self.buffer = items.into_iter();
72 }
73 }
74}
75
76pub struct CommentsManager {
78 session: std::sync::Arc<runtime::Client>,
79}
80
81impl CommentsManager {
82 pub(crate) fn new(session: std::sync::Arc<runtime::Client>) -> Self {
83 Self { session }
84 }
85
86 async fn list_file_page(
87 &self,
88 file_id: String,
89 opts: Option<CommentsListFileOptions>,
90 ) -> Result<crate::models::schemas::Comments, Error> {
91 let mut url = self.session.base_url("api");
92 url.push_str("/files");
93 url.push('/');
94 let seg = path_escape(&file_id);
95 url.push_str(&seg);
96 url.push_str("/comments");
97 let mut req = self.session.new_request("GET", &url);
98 let opts = opts.unwrap_or_default();
99 if let Some(value) = opts.fields {
100 req = runtime::with_query(req, "fields", &value.join(","));
101 }
102 if let Some(value) = opts.limit {
103 req = runtime::with_query(req, "limit", &value.to_string());
104 }
105 if let Some(value) = opts.offset {
106 req = runtime::with_query(req, "offset", &value.to_string());
107 }
108 let resp = self.session.fetch(req).await?;
109 let data = runtime::response_bytes(&resp)?;
110 Ok(serde_json::from_slice(&data)?)
111 }
112
113 pub fn list_file(
115 &self,
116 file_id: String,
117 opts: Option<CommentsListFileOptions>,
118 ) -> CommentsListFilePaginator {
119 CommentsListFilePaginator {
120 manager: CommentsManager::new(self.session.clone()),
121 file_id,
122 options: opts.unwrap_or_default(),
123 buffer: Vec::new().into_iter(),
124 done: false,
125 }
126 }
127
128 pub async fn get(
129 &self,
130 comment_id: String,
131 opts: Option<CommentsGetOptions>,
132 ) -> Result<crate::models::schemas::CommentFull, Error> {
133 let mut url = self.session.base_url("api");
134 url.push_str("/comments");
135 url.push('/');
136 let seg = path_escape(&comment_id);
137 url.push_str(&seg);
138 let mut req = self.session.new_request("GET", &url);
139 let opts = opts.unwrap_or_default();
140 if let Some(value) = opts.fields {
141 req = runtime::with_query(req, "fields", &value.join(","));
142 }
143 let resp = self.session.fetch(req).await?;
144 let data = runtime::response_bytes(&resp)?;
145 Ok(serde_json::from_slice(&data)?)
146 }
147
148 pub async fn update(
149 &self,
150 comment_id: String,
151 body: crate::models::schemas::CommentUpdateRequest,
152 opts: Option<CommentsUpdateOptions>,
153 ) -> Result<crate::models::schemas::CommentFull, Error> {
154 let mut url = self.session.base_url("api");
155 url.push_str("/comments");
156 url.push('/');
157 let seg = path_escape(&comment_id);
158 url.push_str(&seg);
159 let mut req = self.session.new_request("PUT", &url);
160 let opts = opts.unwrap_or_default();
161 if let Some(value) = opts.fields {
162 req = runtime::with_query(req, "fields", &value.join(","));
163 }
164 let payload = serde_json::to_vec(&body)?;
165 req = runtime::with_json_body(req, &payload);
166 let resp = self.session.fetch(req).await?;
167 let data = runtime::response_bytes(&resp)?;
168 Ok(serde_json::from_slice(&data)?)
169 }
170
171 pub async fn delete(&self, comment_id: String) -> Result<(), Error> {
172 let mut url = self.session.base_url("api");
173 url.push_str("/comments");
174 url.push('/');
175 let seg = path_escape(&comment_id);
176 url.push_str(&seg);
177 let req = self.session.new_request("DELETE", &url);
178 let _ = self.session.fetch(req).await?;
179 Ok(())
180 }
181
182 pub async fn create(
183 &self,
184 body: crate::models::schemas::CommentCreateRequest,
185 opts: Option<CommentsCreateOptions>,
186 ) -> Result<crate::models::schemas::CommentFull, Error> {
187 let mut url = self.session.base_url("api");
188 url.push_str("/comments");
189 let mut req = self.session.new_request("POST", &url);
190 let opts = opts.unwrap_or_default();
191 if let Some(value) = opts.fields {
192 req = runtime::with_query(req, "fields", &value.join(","));
193 }
194 let payload = serde_json::to_vec(&body)?;
195 req = runtime::with_json_body(req, &payload);
196 let resp = self.session.fetch(req).await?;
197 let data = runtime::response_bytes(&resp)?;
198 Ok(serde_json::from_slice(&data)?)
199 }
200}