openshift_openapi/v4_5/api/user/v1/
group.rs

1// Generated from definition com.github.openshift.api.user.v1.Group
2
3/// Group represents a referenceable set of Users
4#[derive(Clone, Debug, Default, PartialEq)]
5pub struct Group {
6    /// Standard object's metadata.
7    pub metadata: k8s_openapi::apimachinery::pkg::apis::meta::v1::ObjectMeta,
8
9    /// Users is the list of users in this group.
10    pub users: Vec<String>,
11}
12
13// Begin user.openshift.io/v1/Group
14
15// Generated from operation createUserOpenshiftIoV1Group
16
17impl Group {
18    /// create a Group
19    ///
20    /// Use the returned [`k8s_openapi::ResponseBody`]`<`[`k8s_openapi::CreateResponse`]`<Self>>` constructor, or [`k8s_openapi::CreateResponse`]`<Self>` directly, to parse the HTTP response.
21    ///
22    /// # Arguments
23    ///
24    /// * `body`
25    ///
26    /// * `optional`
27    ///
28    ///     Optional parameters. Use `Default::default()` to not pass any.
29    #[cfg(feature = "api")]
30    pub fn create_group(
31        body: &crate::api::user::v1::Group,
32        optional: k8s_openapi::CreateOptional<'_>,
33    ) -> Result<(http::Request<Vec<u8>>, fn(http::StatusCode) -> k8s_openapi::ResponseBody<k8s_openapi::CreateResponse<Self>>), k8s_openapi::RequestError> {
34        let __url = "/apis/user.openshift.io/v1/groups?".to_owned();
35        let mut __query_pairs = k8s_openapi::url::form_urlencoded::Serializer::new(__url);
36        optional.__serialize(&mut __query_pairs);
37        let __url = __query_pairs.finish();
38
39        let __request = http::Request::post(__url);
40        let __body = serde_json::to_vec(body).map_err(k8s_openapi::RequestError::Json)?;
41        let __request = __request.header(http::header::CONTENT_TYPE, http::header::HeaderValue::from_static("application/json"));
42        match __request.body(__body) {
43            Ok(request) => Ok((request, k8s_openapi::ResponseBody::new)),
44            Err(err) => Err(k8s_openapi::RequestError::Http(err)),
45        }
46    }
47}
48
49// Generated from operation deleteUserOpenshiftIoV1CollectionGroup
50
51impl Group {
52    /// delete collection of Group
53    ///
54    /// Use the returned [`k8s_openapi::ResponseBody`]`<`[`k8s_openapi::DeleteResponse`]`<`[`k8s_openapi::List`]`<Self>>>` constructor, or [`k8s_openapi::DeleteResponse`]`<`[`k8s_openapi::List`]`<Self>>` directly, to parse the HTTP response.
55    ///
56    /// # Arguments
57    ///
58    /// * `delete_optional`
59    ///
60    ///     Delete options. Use `Default::default()` to not pass any.
61    ///
62    /// * `list_optional`
63    ///
64    ///     List options. Use `Default::default()` to not pass any.
65    #[cfg(feature = "api")]
66    pub fn delete_collection_group(
67        delete_optional: k8s_openapi::DeleteOptional<'_>,
68        list_optional: k8s_openapi::ListOptional<'_>,
69    ) -> Result<(http::Request<Vec<u8>>, fn(http::StatusCode) -> k8s_openapi::ResponseBody<k8s_openapi::DeleteResponse<k8s_openapi::List<Self>>>), k8s_openapi::RequestError> {
70        let __url = "/apis/user.openshift.io/v1/groups?".to_owned();
71        let mut __query_pairs = k8s_openapi::url::form_urlencoded::Serializer::new(__url);
72        list_optional.__serialize(&mut __query_pairs);
73        let __url = __query_pairs.finish();
74
75        let __request = http::Request::delete(__url);
76        let __body = serde_json::to_vec(&delete_optional).map_err(k8s_openapi::RequestError::Json)?;
77        let __request = __request.header(http::header::CONTENT_TYPE, http::header::HeaderValue::from_static("application/json"));
78        match __request.body(__body) {
79            Ok(request) => Ok((request, k8s_openapi::ResponseBody::new)),
80            Err(err) => Err(k8s_openapi::RequestError::Http(err)),
81        }
82    }
83}
84
85// Generated from operation deleteUserOpenshiftIoV1Group
86
87impl Group {
88    /// delete a Group
89    ///
90    /// Use the returned [`k8s_openapi::ResponseBody`]`<`[`k8s_openapi::DeleteResponse`]`<Self>>` constructor, or [`k8s_openapi::DeleteResponse`]`<Self>` directly, to parse the HTTP response.
91    ///
92    /// # Arguments
93    ///
94    /// * `name`
95    ///
96    ///     name of the Group
97    ///
98    /// * `optional`
99    ///
100    ///     Optional parameters. Use `Default::default()` to not pass any.
101    #[cfg(feature = "api")]
102    pub fn delete_group(
103        name: &str,
104        optional: k8s_openapi::DeleteOptional<'_>,
105    ) -> Result<(http::Request<Vec<u8>>, fn(http::StatusCode) -> k8s_openapi::ResponseBody<k8s_openapi::DeleteResponse<Self>>), k8s_openapi::RequestError> {
106        let __url = format!("/apis/user.openshift.io/v1/groups/{name}",
107            name = k8s_openapi::percent_encoding::percent_encode(name.as_bytes(), k8s_openapi::percent_encoding2::PATH_SEGMENT_ENCODE_SET),
108        );
109
110        let __request = http::Request::delete(__url);
111        let __body = serde_json::to_vec(&optional).map_err(k8s_openapi::RequestError::Json)?;
112        let __request = __request.header(http::header::CONTENT_TYPE, http::header::HeaderValue::from_static("application/json"));
113        match __request.body(__body) {
114            Ok(request) => Ok((request, k8s_openapi::ResponseBody::new)),
115            Err(err) => Err(k8s_openapi::RequestError::Http(err)),
116        }
117    }
118}
119
120// Generated from operation listUserOpenshiftIoV1Group
121
122impl Group {
123    /// list or watch objects of kind Group
124    ///
125    /// This operation only supports listing all items of this type.
126    ///
127    /// Use the returned [`k8s_openapi::ResponseBody`]`<`[`k8s_openapi::ListResponse`]`<Self>>` constructor, or [`k8s_openapi::ListResponse`]`<Self>` directly, to parse the HTTP response.
128    ///
129    /// # Arguments
130    ///
131    /// * `optional`
132    ///
133    ///     Optional parameters. Use `Default::default()` to not pass any.
134    #[cfg(feature = "api")]
135    pub fn list_group(
136        optional: k8s_openapi::ListOptional<'_>,
137    ) -> Result<(http::Request<Vec<u8>>, fn(http::StatusCode) -> k8s_openapi::ResponseBody<k8s_openapi::ListResponse<Self>>), k8s_openapi::RequestError> {
138        let __url = "/apis/user.openshift.io/v1/groups?".to_owned();
139        let mut __query_pairs = k8s_openapi::url::form_urlencoded::Serializer::new(__url);
140        optional.__serialize(&mut __query_pairs);
141        let __url = __query_pairs.finish();
142
143        let __request = http::Request::get(__url);
144        let __body = vec![];
145        match __request.body(__body) {
146            Ok(request) => Ok((request, k8s_openapi::ResponseBody::new)),
147            Err(err) => Err(k8s_openapi::RequestError::Http(err)),
148        }
149    }
150}
151
152// Generated from operation patchUserOpenshiftIoV1Group
153
154impl Group {
155    /// partially update the specified Group
156    ///
157    /// Use the returned [`k8s_openapi::ResponseBody`]`<`[`k8s_openapi::PatchResponse`]`<Self>>` constructor, or [`k8s_openapi::PatchResponse`]`<Self>` directly, to parse the HTTP response.
158    ///
159    /// # Arguments
160    ///
161    /// * `name`
162    ///
163    ///     name of the Group
164    ///
165    /// * `body`
166    ///
167    /// * `optional`
168    ///
169    ///     Optional parameters. Use `Default::default()` to not pass any.
170    #[cfg(feature = "api")]
171    pub fn patch_group(
172        name: &str,
173        body: &k8s_openapi::apimachinery::pkg::apis::meta::v1::Patch,
174        optional: k8s_openapi::PatchOptional<'_>,
175    ) -> Result<(http::Request<Vec<u8>>, fn(http::StatusCode) -> k8s_openapi::ResponseBody<k8s_openapi::PatchResponse<Self>>), k8s_openapi::RequestError> {
176        let __url = format!("/apis/user.openshift.io/v1/groups/{name}?",
177            name = k8s_openapi::percent_encoding::percent_encode(name.as_bytes(), k8s_openapi::percent_encoding2::PATH_SEGMENT_ENCODE_SET),
178        );
179        let mut __query_pairs = k8s_openapi::url::form_urlencoded::Serializer::new(__url);
180        optional.__serialize(&mut __query_pairs);
181        let __url = __query_pairs.finish();
182
183        let __request = http::Request::patch(__url);
184        let __body = serde_json::to_vec(body).map_err(k8s_openapi::RequestError::Json)?;
185        let __request = __request.header(http::header::CONTENT_TYPE, http::header::HeaderValue::from_static(match body {
186            k8s_openapi::apimachinery::pkg::apis::meta::v1::Patch::Json(_) => "application/json-patch+json",
187            k8s_openapi::apimachinery::pkg::apis::meta::v1::Patch::Merge(_) => "application/merge-patch+json",
188            k8s_openapi::apimachinery::pkg::apis::meta::v1::Patch::StrategicMerge(_) => "application/strategic-merge-patch+json",
189        }));
190        match __request.body(__body) {
191            Ok(request) => Ok((request, k8s_openapi::ResponseBody::new)),
192            Err(err) => Err(k8s_openapi::RequestError::Http(err)),
193        }
194    }
195}
196
197// Generated from operation readUserOpenshiftIoV1Group
198
199impl Group {
200    /// read the specified Group
201    ///
202    /// Use the returned [`k8s_openapi::ResponseBody`]`<`[`ReadGroupResponse`]`>` constructor, or [`ReadGroupResponse`] directly, to parse the HTTP response.
203    ///
204    /// # Arguments
205    ///
206    /// * `name`
207    ///
208    ///     name of the Group
209    ///
210    /// * `optional`
211    ///
212    ///     Optional parameters. Use `Default::default()` to not pass any.
213    #[cfg(feature = "api")]
214    pub fn read_group(
215        name: &str,
216        optional: ReadGroupOptional<'_>,
217    ) -> Result<(http::Request<Vec<u8>>, fn(http::StatusCode) -> k8s_openapi::ResponseBody<ReadGroupResponse>), k8s_openapi::RequestError> {
218        let ReadGroupOptional {
219            exact,
220            export,
221            pretty,
222        } = optional;
223        let __url = format!("/apis/user.openshift.io/v1/groups/{name}?",
224            name = k8s_openapi::percent_encoding::percent_encode(name.as_bytes(), k8s_openapi::percent_encoding2::PATH_SEGMENT_ENCODE_SET),
225        );
226        let mut __query_pairs = k8s_openapi::url::form_urlencoded::Serializer::new(__url);
227        if let Some(exact) = exact {
228            __query_pairs.append_pair("exact", &exact.to_string());
229        }
230        if let Some(export) = export {
231            __query_pairs.append_pair("export", &export.to_string());
232        }
233        if let Some(pretty) = pretty {
234            __query_pairs.append_pair("pretty", pretty);
235        }
236        let __url = __query_pairs.finish();
237
238        let __request = http::Request::get(__url);
239        let __body = vec![];
240        match __request.body(__body) {
241            Ok(request) => Ok((request, k8s_openapi::ResponseBody::new)),
242            Err(err) => Err(k8s_openapi::RequestError::Http(err)),
243        }
244    }
245}
246
247/// Optional parameters of [`Group::read_group`]
248#[cfg(feature = "api")]
249#[derive(Clone, Copy, Debug, Default)]
250pub struct ReadGroupOptional<'a> {
251    /// Should the export be exact.  Exact export maintains cluster-specific fields like 'Namespace'.
252    pub exact: Option<bool>,
253    /// Should this value be exported.  Export strips fields that a user can not specify.
254    pub export: Option<bool>,
255    /// If 'true', then the output is pretty printed.
256    pub pretty: Option<&'a str>,
257}
258
259/// Use `<ReadGroupResponse as Response>::try_from_parts` to parse the HTTP response body of [`Group::read_group`]
260#[cfg(feature = "api")]
261#[derive(Debug)]
262pub enum ReadGroupResponse {
263    Ok(crate::api::user::v1::Group),
264    Other(Result<Option<serde_json::Value>, serde_json::Error>),
265}
266
267#[cfg(feature = "api")]
268impl k8s_openapi::Response for ReadGroupResponse {
269    fn try_from_parts(status_code: http::StatusCode, buf: &[u8]) -> Result<(Self, usize), k8s_openapi::ResponseError> {
270        match status_code {
271            http::StatusCode::OK => {
272                let result = match serde_json::from_slice(buf) {
273                    Ok(value) => value,
274                    Err(ref err) if err.is_eof() => return Err(k8s_openapi::ResponseError::NeedMoreData),
275                    Err(err) => return Err(k8s_openapi::ResponseError::Json(err)),
276                };
277                Ok((ReadGroupResponse::Ok(result), buf.len()))
278            },
279            _ => {
280                let (result, read) =
281                    if buf.is_empty() {
282                        (Ok(None), 0)
283                    }
284                    else {
285                        match serde_json::from_slice(buf) {
286                            Ok(value) => (Ok(Some(value)), buf.len()),
287                            Err(ref err) if err.is_eof() => return Err(k8s_openapi::ResponseError::NeedMoreData),
288                            Err(err) => (Err(err), 0),
289                        }
290                    };
291                Ok((ReadGroupResponse::Other(result), read))
292            },
293        }
294    }
295}
296
297// Generated from operation replaceUserOpenshiftIoV1Group
298
299impl Group {
300    /// replace the specified Group
301    ///
302    /// Use the returned [`k8s_openapi::ResponseBody`]`<`[`k8s_openapi::ReplaceResponse`]`<Self>>` constructor, or [`k8s_openapi::ReplaceResponse`]`<Self>` directly, to parse the HTTP response.
303    ///
304    /// # Arguments
305    ///
306    /// * `name`
307    ///
308    ///     name of the Group
309    ///
310    /// * `body`
311    ///
312    /// * `optional`
313    ///
314    ///     Optional parameters. Use `Default::default()` to not pass any.
315    #[cfg(feature = "api")]
316    pub fn replace_group(
317        name: &str,
318        body: &crate::api::user::v1::Group,
319        optional: k8s_openapi::ReplaceOptional<'_>,
320    ) -> Result<(http::Request<Vec<u8>>, fn(http::StatusCode) -> k8s_openapi::ResponseBody<k8s_openapi::ReplaceResponse<Self>>), k8s_openapi::RequestError> {
321        let __url = format!("/apis/user.openshift.io/v1/groups/{name}?",
322            name = k8s_openapi::percent_encoding::percent_encode(name.as_bytes(), k8s_openapi::percent_encoding2::PATH_SEGMENT_ENCODE_SET),
323        );
324        let mut __query_pairs = k8s_openapi::url::form_urlencoded::Serializer::new(__url);
325        optional.__serialize(&mut __query_pairs);
326        let __url = __query_pairs.finish();
327
328        let __request = http::Request::put(__url);
329        let __body = serde_json::to_vec(body).map_err(k8s_openapi::RequestError::Json)?;
330        let __request = __request.header(http::header::CONTENT_TYPE, http::header::HeaderValue::from_static("application/json"));
331        match __request.body(__body) {
332            Ok(request) => Ok((request, k8s_openapi::ResponseBody::new)),
333            Err(err) => Err(k8s_openapi::RequestError::Http(err)),
334        }
335    }
336}
337
338// Generated from operation watchUserOpenshiftIoV1Group
339
340impl Group {
341    /// list or watch objects of kind Group
342    ///
343    /// This operation only supports watching one item, or a list of items, of this type for changes.
344    ///
345    /// Use the returned [`k8s_openapi::ResponseBody`]`<`[`k8s_openapi::WatchResponse`]`<Self>>` constructor, or [`k8s_openapi::WatchResponse`]`<Self>` directly, to parse the HTTP response.
346    ///
347    /// # Arguments
348    ///
349    /// * `optional`
350    ///
351    ///     Optional parameters. Use `Default::default()` to not pass any.
352    #[cfg(feature = "api")]
353    pub fn watch_group(
354        optional: k8s_openapi::WatchOptional<'_>,
355    ) -> Result<(http::Request<Vec<u8>>, fn(http::StatusCode) -> k8s_openapi::ResponseBody<k8s_openapi::WatchResponse<Self>>), k8s_openapi::RequestError> {
356        let __url = "/apis/user.openshift.io/v1/groups?".to_owned();
357        let mut __query_pairs = k8s_openapi::url::form_urlencoded::Serializer::new(__url);
358        optional.__serialize(&mut __query_pairs);
359        let __url = __query_pairs.finish();
360
361        let __request = http::Request::get(__url);
362        let __body = vec![];
363        match __request.body(__body) {
364            Ok(request) => Ok((request, k8s_openapi::ResponseBody::new)),
365            Err(err) => Err(k8s_openapi::RequestError::Http(err)),
366        }
367    }
368}
369
370// End user.openshift.io/v1/Group
371
372impl k8s_openapi::Resource for Group {
373    const API_VERSION: &'static str = "user.openshift.io/v1";
374    const GROUP: &'static str = "user.openshift.io";
375    const KIND: &'static str = "Group";
376    const VERSION: &'static str = "v1";
377}
378
379impl k8s_openapi::ListableResource for Group {
380    const LIST_KIND: &'static str = concat!("Group", "List");
381}
382
383impl k8s_openapi::Metadata for Group {
384    type Ty = k8s_openapi::apimachinery::pkg::apis::meta::v1::ObjectMeta;
385
386    fn metadata(&self) -> &<Self as k8s_openapi::Metadata>::Ty {
387        &self.metadata
388    }
389
390    fn metadata_mut(&mut self) -> &mut<Self as k8s_openapi::Metadata>::Ty {
391        &mut self.metadata
392    }
393}
394
395impl<'de> serde::Deserialize<'de> for Group {
396    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: serde::Deserializer<'de> {
397        #[allow(non_camel_case_types)]
398        enum Field {
399            Key_api_version,
400            Key_kind,
401            Key_metadata,
402            Key_users,
403            Other,
404        }
405
406        impl<'de> serde::Deserialize<'de> for Field {
407            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: serde::Deserializer<'de> {
408                struct Visitor;
409
410                impl<'de> serde::de::Visitor<'de> for Visitor {
411                    type Value = Field;
412
413                    fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
414                        f.write_str("field identifier")
415                    }
416
417                    fn visit_str<E>(self, v: &str) -> Result<Self::Value, E> where E: serde::de::Error {
418                        Ok(match v {
419                            "apiVersion" => Field::Key_api_version,
420                            "kind" => Field::Key_kind,
421                            "metadata" => Field::Key_metadata,
422                            "users" => Field::Key_users,
423                            _ => Field::Other,
424                        })
425                    }
426                }
427
428                deserializer.deserialize_identifier(Visitor)
429            }
430        }
431
432        struct Visitor;
433
434        impl<'de> serde::de::Visitor<'de> for Visitor {
435            type Value = Group;
436
437            fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
438                f.write_str(<Self::Value as k8s_openapi::Resource>::KIND)
439            }
440
441            fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error> where A: serde::de::MapAccess<'de> {
442                let mut value_metadata: Option<k8s_openapi::apimachinery::pkg::apis::meta::v1::ObjectMeta> = None;
443                let mut value_users: Option<Vec<String>> = None;
444
445                while let Some(key) = serde::de::MapAccess::next_key::<Field>(&mut map)? {
446                    match key {
447                        Field::Key_api_version => {
448                            let value_api_version: String = serde::de::MapAccess::next_value(&mut map)?;
449                            if value_api_version != <Self::Value as k8s_openapi::Resource>::API_VERSION {
450                                return Err(serde::de::Error::invalid_value(serde::de::Unexpected::Str(&value_api_version), &<Self::Value as k8s_openapi::Resource>::API_VERSION));
451                            }
452                        },
453                        Field::Key_kind => {
454                            let value_kind: String = serde::de::MapAccess::next_value(&mut map)?;
455                            if value_kind != <Self::Value as k8s_openapi::Resource>::KIND {
456                                return Err(serde::de::Error::invalid_value(serde::de::Unexpected::Str(&value_kind), &<Self::Value as k8s_openapi::Resource>::KIND));
457                            }
458                        },
459                        Field::Key_metadata => value_metadata = Some(serde::de::MapAccess::next_value(&mut map)?),
460                        Field::Key_users => value_users = Some(serde::de::MapAccess::next_value(&mut map)?),
461                        Field::Other => { let _: serde::de::IgnoredAny = serde::de::MapAccess::next_value(&mut map)?; },
462                    }
463                }
464
465                Ok(Group {
466                    metadata: value_metadata.ok_or_else(|| serde::de::Error::missing_field("metadata"))?,
467                    users: value_users.ok_or_else(|| serde::de::Error::missing_field("users"))?,
468                })
469            }
470        }
471
472        deserializer.deserialize_struct(
473            <Self as k8s_openapi::Resource>::KIND,
474            &[
475                "apiVersion",
476                "kind",
477                "metadata",
478                "users",
479            ],
480            Visitor,
481        )
482    }
483}
484
485impl serde::Serialize for Group {
486    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: serde::Serializer {
487        let mut state = serializer.serialize_struct(
488            <Self as k8s_openapi::Resource>::KIND,
489            4,
490        )?;
491        serde::ser::SerializeStruct::serialize_field(&mut state, "apiVersion", <Self as k8s_openapi::Resource>::API_VERSION)?;
492        serde::ser::SerializeStruct::serialize_field(&mut state, "kind", <Self as k8s_openapi::Resource>::KIND)?;
493        serde::ser::SerializeStruct::serialize_field(&mut state, "metadata", &self.metadata)?;
494        serde::ser::SerializeStruct::serialize_field(&mut state, "users", &self.users)?;
495        serde::ser::SerializeStruct::end(state)
496    }
497}
openshift_openapi/v4_5/api/user/v1/group.rs

openshift_openapi/v4_5/api/user/v1/
group.rs
