box_open_sdk/managers/
device_pinners.rs1use crate::internal::path_escape;
4use crate::runtime::{self, Error};
5
6#[derive(Clone, Debug, Default)]
8pub struct DevicePinnersListEnterpriseOptions {
9 pub marker: Option<String>,
10 pub limit: Option<i64>,
11 pub direction: Option<crate::models::schemas::OrderDirection>,
12}
13
14pub struct DevicePinnersListEnterprisePaginator {
17 manager: DevicePinnersManager,
18 enterprise_id: String,
19 options: DevicePinnersListEnterpriseOptions,
20 buffer: std::vec::IntoIter<crate::models::schemas::DevicePinner>,
21 done: bool,
22}
23
24impl DevicePinnersListEnterprisePaginator {
25 pub async fn next(&mut self) -> Option<Result<crate::models::schemas::DevicePinner, 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
36 .manager
37 .list_enterprise_page(self.enterprise_id.clone(), Some(self.options.clone()))
38 .await
39 {
40 Ok(page) => page,
41 Err(err) => {
42 self.done = true;
43 return Some(Err(err));
44 }
45 };
46 self.buffer = page.entries.unwrap_or_default().into_iter();
47 match page.next_marker {
48 Some(cursor) => self.options.marker = Some(cursor.to_string()),
49 _ => self.done = true,
50 }
51 }
52 }
53}
54
55pub struct DevicePinnersManager {
57 session: std::sync::Arc<runtime::Client>,
58}
59
60impl DevicePinnersManager {
61 pub(crate) fn new(session: std::sync::Arc<runtime::Client>) -> Self {
62 Self { session }
63 }
64
65 pub async fn get(
66 &self,
67 device_pinner_id: String,
68 ) -> Result<crate::models::schemas::DevicePinner, Error> {
69 let mut url = self.session.base_url("api");
70 url.push_str("/device_pinners");
71 url.push('/');
72 let seg = path_escape(&device_pinner_id);
73 url.push_str(&seg);
74 let req = self.session.new_request("GET", &url);
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 delete(&self, device_pinner_id: String) -> Result<(), Error> {
81 let mut url = self.session.base_url("api");
82 url.push_str("/device_pinners");
83 url.push('/');
84 let seg = path_escape(&device_pinner_id);
85 url.push_str(&seg);
86 let req = self.session.new_request("DELETE", &url);
87 let _ = self.session.fetch(req).await?;
88 Ok(())
89 }
90
91 async fn list_enterprise_page(
92 &self,
93 enterprise_id: String,
94 opts: Option<DevicePinnersListEnterpriseOptions>,
95 ) -> Result<crate::models::schemas::DevicePinners, Error> {
96 let mut url = self.session.base_url("api");
97 url.push_str("/enterprises");
98 url.push('/');
99 let seg = path_escape(&enterprise_id);
100 url.push_str(&seg);
101 url.push_str("/device_pinners");
102 let mut req = self.session.new_request("GET", &url);
103 let opts = opts.unwrap_or_default();
104 if let Some(value) = opts.marker {
105 req = runtime::with_query(req, "marker", &value);
106 }
107 if let Some(value) = opts.limit {
108 req = runtime::with_query(req, "limit", &value.to_string());
109 }
110 if let Some(value) = opts.direction {
111 req = runtime::with_query(req, "direction", &value.0);
112 }
113 let resp = self.session.fetch(req).await?;
114 let data = runtime::response_bytes(&resp)?;
115 Ok(serde_json::from_slice(&data)?)
116 }
117
118 pub fn list_enterprise(
120 &self,
121 enterprise_id: String,
122 opts: Option<DevicePinnersListEnterpriseOptions>,
123 ) -> DevicePinnersListEnterprisePaginator {
124 DevicePinnersListEnterprisePaginator {
125 manager: DevicePinnersManager::new(self.session.clone()),
126 enterprise_id,
127 options: opts.unwrap_or_default(),
128 buffer: Vec::new().into_iter(),
129 done: false,
130 }
131 }
132}