box_open_sdk/managers/
sign_requests.rs1use crate::internal::path_escape;
4use crate::runtime::{self, Error};
5
6#[derive(Clone, Debug, Default)]
8pub struct SignRequestsListOptions {
9 pub marker: Option<String>,
10 pub limit: Option<i64>,
11 pub senders: Option<Vec<String>>,
12 pub shared_requests: Option<bool>,
13}
14
15pub struct SignRequestsListPaginator {
18 manager: SignRequestsManager,
19 options: SignRequestsListOptions,
20 buffer: std::vec::IntoIter<crate::models::schemas::SignRequest>,
21 done: bool,
22}
23
24impl SignRequestsListPaginator {
25 pub async fn next(&mut self) -> Option<Result<crate::models::schemas::SignRequest, Error>> {
28 loop {
29 if let Some(item) = self.buffer.next() {
30 return Some(Ok(item));
31 }
32 if self.done {
33 return None;
34 }
35 let page = match self.manager.list_page(Some(self.options.clone())).await {
36 Ok(page) => page,
37 Err(err) => {
38 self.done = true;
39 return Some(Err(err));
40 }
41 };
42 self.buffer = page.entries.unwrap_or_default().into_iter();
43 match page.next_marker.flatten() {
44 Some(cursor) if !cursor.is_empty() => self.options.marker = Some(cursor),
45 _ => self.done = true,
46 }
47 }
48 }
49}
50
51pub struct SignRequestsManager {
53 session: std::sync::Arc<runtime::Client>,
54}
55
56impl SignRequestsManager {
57 pub(crate) fn new(session: std::sync::Arc<runtime::Client>) -> Self {
58 Self { session }
59 }
60
61 pub async fn cancel(
62 &self,
63 sign_request_id: String,
64 body: crate::models::schemas::SignRequestCancelRequest,
65 ) -> Result<crate::models::schemas::SignRequest, Error> {
66 let mut url = self.session.base_url("api");
67 url.push_str("/sign_requests");
68 url.push('/');
69 let seg = path_escape(&sign_request_id);
70 url.push_str(&seg);
71 url.push_str("/cancel");
72 let mut req = self.session.new_request("POST", &url);
73 let payload = serde_json::to_vec(&body)?;
74 req = runtime::with_json_body(req, &payload);
75 let resp = self.session.fetch(req).await?;
76 let data = runtime::response_bytes(&resp)?;
77 Ok(serde_json::from_slice(&data)?)
78 }
79
80 pub async fn resend(&self, sign_request_id: String) -> Result<(), Error> {
81 let mut url = self.session.base_url("api");
82 url.push_str("/sign_requests");
83 url.push('/');
84 let seg = path_escape(&sign_request_id);
85 url.push_str(&seg);
86 url.push_str("/resend");
87 let req = self.session.new_request("POST", &url);
88 let _ = self.session.fetch(req).await?;
89 Ok(())
90 }
91
92 pub async fn get(
93 &self,
94 sign_request_id: String,
95 ) -> Result<crate::models::schemas::SignRequest, Error> {
96 let mut url = self.session.base_url("api");
97 url.push_str("/sign_requests");
98 url.push('/');
99 let seg = path_escape(&sign_request_id);
100 url.push_str(&seg);
101 let req = self.session.new_request("GET", &url);
102 let resp = self.session.fetch(req).await?;
103 let data = runtime::response_bytes(&resp)?;
104 Ok(serde_json::from_slice(&data)?)
105 }
106
107 async fn list_page(
108 &self,
109 opts: Option<SignRequestsListOptions>,
110 ) -> Result<crate::models::schemas::SignRequests, Error> {
111 let mut url = self.session.base_url("api");
112 url.push_str("/sign_requests");
113 let mut req = self.session.new_request("GET", &url);
114 let opts = opts.unwrap_or_default();
115 if let Some(value) = opts.marker {
116 req = runtime::with_query(req, "marker", &value);
117 }
118 if let Some(value) = opts.limit {
119 req = runtime::with_query(req, "limit", &value.to_string());
120 }
121 if let Some(value) = opts.senders {
122 req = runtime::with_query(req, "senders", &value.join(","));
123 }
124 if let Some(value) = opts.shared_requests {
125 req = runtime::with_query(req, "shared_requests", &value.to_string());
126 }
127 let resp = self.session.fetch(req).await?;
128 let data = runtime::response_bytes(&resp)?;
129 Ok(serde_json::from_slice(&data)?)
130 }
131
132 pub fn list(&self, opts: Option<SignRequestsListOptions>) -> SignRequestsListPaginator {
134 SignRequestsListPaginator {
135 manager: SignRequestsManager::new(self.session.clone()),
136 options: opts.unwrap_or_default(),
137 buffer: Vec::new().into_iter(),
138 done: false,
139 }
140 }
141
142 pub async fn create(
143 &self,
144 body: crate::models::schemas::SignRequestCreateRequest,
145 ) -> Result<crate::models::schemas::SignRequest, Error> {
146 let mut url = self.session.base_url("api");
147 url.push_str("/sign_requests");
148 let mut req = self.session.new_request("POST", &url);
149 let payload = serde_json::to_vec(&body)?;
150 req = runtime::with_json_body(req, &payload);
151 let resp = self.session.fetch(req).await?;
152 let data = runtime::response_bytes(&resp)?;
153 Ok(serde_json::from_slice(&data)?)
154 }
155}