jenkins_sdk/api/
views.rs

1use crate::transport::request::{Request, RequestBody};
2use crate::{Error, JobPath, ViewName};
3use http::HeaderValue;
4use serde_json::Value;
5
6/// Jenkins views (core) APIs.
7#[derive(Clone)]
8#[cfg(feature = "async")]
9pub struct ViewsService {
10    client: crate::Client,
11}
12
13#[cfg(feature = "async")]
14impl ViewsService {
15    pub(crate) fn new(client: crate::Client) -> Self {
16        Self { client }
17    }
18}
19
20#[cfg(feature = "async")]
21impl ViewsService {
22    /// `GET /api/json?tree=views[name,url]`
23    pub async fn list(&self) -> Result<Value, Error> {
24        self.client
25            .send_json(Request::get(["api", "json"]).query_pair("tree", "views[name,url]"))
26            .await
27    }
28
29    /// `GET /view/<name>/api/json`
30    pub async fn get(&self, name: impl Into<ViewName>, tree: Option<&str>) -> Result<Value, Error> {
31        let name = name.into();
32        let mut req = Request::get(["view", name.as_str(), "api", "json"]);
33        if let Some(tree) = tree {
34            req = req.query_pair("tree", tree);
35        }
36        self.client.send_json(req).await
37    }
38
39    /// `POST /createView?name=<name>` with XML body.
40    pub async fn create_from_xml(
41        &self,
42        name: impl Into<ViewName>,
43        xml: impl Into<Vec<u8>>,
44    ) -> Result<(), Error> {
45        let name = name.into();
46        let req = Request::post(["createView"])
47            .query_pair("name", name.as_str())
48            .body(RequestBody::bytes_with_content_type(
49                xml.into(),
50                HeaderValue::from_static("application/xml"),
51            ));
52        self.client.send_unit(req).await
53    }
54
55    /// `POST /view/<name>/doDelete`
56    pub async fn delete(&self, name: impl Into<ViewName>) -> Result<(), Error> {
57        let name = name.into();
58        self.client
59            .send_unit(Request::post(["view", name.as_str(), "doDelete"]))
60            .await
61    }
62
63    /// `POST /view/<name>/doRename?newName=<new_name>`
64    pub async fn rename(
65        &self,
66        name: impl Into<ViewName>,
67        new_name: impl Into<ViewName>,
68    ) -> Result<(), Error> {
69        let name = name.into();
70        let new_name = new_name.into();
71        let req = Request::post(["view", name.as_str(), "doRename"])
72            .query_pair("newName", new_name.as_str());
73        self.client.send_unit(req).await
74    }
75
76    /// `POST /view/<view>/addJobToView?name=<job>`
77    pub async fn add_job(
78        &self,
79        view: impl Into<ViewName>,
80        job: impl Into<JobPath>,
81    ) -> Result<(), Error> {
82        let view = view.into();
83        let job = job.into();
84        let req =
85            Request::post(["view", view.as_str(), "addJobToView"]).query_pair("name", job.as_str());
86        self.client.send_unit(req).await
87    }
88
89    /// `POST /view/<view>/removeJobFromView?name=<job>`
90    pub async fn remove_job(
91        &self,
92        view: impl Into<ViewName>,
93        job: impl Into<JobPath>,
94    ) -> Result<(), Error> {
95        let view = view.into();
96        let job = job.into();
97        let req = Request::post(["view", view.as_str(), "removeJobFromView"])
98            .query_pair("name", job.as_str());
99        self.client.send_unit(req).await
100    }
101
102    /// `GET /view/<name>/config.xml`
103    pub async fn get_config_xml(&self, name: impl Into<ViewName>) -> Result<Vec<u8>, Error> {
104        let name = name.into();
105        self.client
106            .send_bytes(Request::get(["view", name.as_str(), "config.xml"]))
107            .await
108    }
109
110    /// `POST /view/<name>/config.xml` with XML body.
111    pub async fn update_config_xml(
112        &self,
113        name: impl Into<ViewName>,
114        xml: impl Into<Vec<u8>>,
115    ) -> Result<(), Error> {
116        let name = name.into();
117        self.client
118            .send_unit(Request::post(["view", name.as_str(), "config.xml"]).body(
119                RequestBody::bytes_with_content_type(
120                    xml.into(),
121                    HeaderValue::from_static("application/xml"),
122                ),
123            ))
124            .await
125    }
126}
127
128/// Jenkins views (core) APIs (blocking).
129#[cfg(feature = "blocking")]
130#[derive(Clone)]
131pub struct BlockingViewsService {
132    client: crate::BlockingClient,
133}
134
135#[cfg(feature = "blocking")]
136impl BlockingViewsService {
137    pub(crate) fn new(client: crate::BlockingClient) -> Self {
138        Self { client }
139    }
140}
141
142#[cfg(feature = "blocking")]
143impl BlockingViewsService {
144    /// `GET /api/json?tree=views[name,url]`
145    pub fn list(&self) -> Result<Value, Error> {
146        self.client
147            .send_json(Request::get(["api", "json"]).query_pair("tree", "views[name,url]"))
148    }
149
150    /// `GET /view/<name>/api/json`
151    pub fn get(&self, name: impl Into<ViewName>, tree: Option<&str>) -> Result<Value, Error> {
152        let name = name.into();
153        let mut req = Request::get(["view", name.as_str(), "api", "json"]);
154        if let Some(tree) = tree {
155            req = req.query_pair("tree", tree);
156        }
157        self.client.send_json(req)
158    }
159
160    /// `POST /createView?name=<name>` with XML body.
161    pub fn create_from_xml(
162        &self,
163        name: impl Into<ViewName>,
164        xml: impl Into<Vec<u8>>,
165    ) -> Result<(), Error> {
166        let name = name.into();
167        let req = Request::post(["createView"])
168            .query_pair("name", name.as_str())
169            .body(RequestBody::bytes_with_content_type(
170                xml.into(),
171                HeaderValue::from_static("application/xml"),
172            ));
173        self.client.send_unit(req)
174    }
175
176    /// `POST /view/<name>/doDelete`
177    pub fn delete(&self, name: impl Into<ViewName>) -> Result<(), Error> {
178        let name = name.into();
179        self.client
180            .send_unit(Request::post(["view", name.as_str(), "doDelete"]))
181    }
182
183    /// `POST /view/<name>/doRename?newName=<new_name>`
184    pub fn rename(
185        &self,
186        name: impl Into<ViewName>,
187        new_name: impl Into<ViewName>,
188    ) -> Result<(), Error> {
189        let name = name.into();
190        let new_name = new_name.into();
191        let req = Request::post(["view", name.as_str(), "doRename"])
192            .query_pair("newName", new_name.as_str());
193        self.client.send_unit(req)
194    }
195
196    /// `POST /view/<view>/addJobToView?name=<job>`
197    pub fn add_job(&self, view: impl Into<ViewName>, job: impl Into<JobPath>) -> Result<(), Error> {
198        let view = view.into();
199        let job = job.into();
200        let req =
201            Request::post(["view", view.as_str(), "addJobToView"]).query_pair("name", job.as_str());
202        self.client.send_unit(req)
203    }
204
205    /// `POST /view/<view>/removeJobFromView?name=<job>`
206    pub fn remove_job(
207        &self,
208        view: impl Into<ViewName>,
209        job: impl Into<JobPath>,
210    ) -> Result<(), Error> {
211        let view = view.into();
212        let job = job.into();
213        let req = Request::post(["view", view.as_str(), "removeJobFromView"])
214            .query_pair("name", job.as_str());
215        self.client.send_unit(req)
216    }
217
218    /// `GET /view/<name>/config.xml`
219    pub fn get_config_xml(&self, name: impl Into<ViewName>) -> Result<Vec<u8>, Error> {
220        let name = name.into();
221        self.client
222            .send_bytes(Request::get(["view", name.as_str(), "config.xml"]))
223    }
224
225    /// `POST /view/<name>/config.xml` with XML body.
226    pub fn update_config_xml(
227        &self,
228        name: impl Into<ViewName>,
229        xml: impl Into<Vec<u8>>,
230    ) -> Result<(), Error> {
231        let name = name.into();
232        self.client
233            .send_unit(Request::post(["view", name.as_str(), "config.xml"]).body(
234                RequestBody::bytes_with_content_type(
235                    xml.into(),
236                    HeaderValue::from_static("application/xml"),
237                ),
238            ))
239    }
240}