Skip to main content

box_open_sdk/managers/
device_pinners.rs

1// Code generated by box-gantry. DO NOT EDIT.
2
3use crate::internal::path_escape;
4use crate::runtime::{self, Error};
5
6/// Optional parameters for [`DevicePinnersManager::list_enterprise`].
7#[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
14/// Async paginator over [`DevicePinnersManager::list_enterprise`], yielding one `crate::models::schemas::DevicePinner`
15/// per item across pages (FR-7.3).
16pub 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    /// The next item, advancing pages as needed; `None` at the end.
26    /// An error is yielded once, then iteration stops.
27    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
55/// Operations for the "device_pinners" API area.
56pub 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    /// Iterate every `crate::models::schemas::DevicePinner` across pages, threading the cursor.
119    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}