openshift_openapi/v4_5/api/project/v1/
project_request.rs

1// Generated from definition com.github.openshift.api.project.v1.ProjectRequest
2
3/// ProjecRequest is the set of options necessary to fully qualify a project request
4#[derive(Clone, Debug, Default, PartialEq)]
5pub struct ProjectRequest {
6    /// Description is the description to apply to a project
7    pub description: Option<String>,
8
9    /// DisplayName is the display name to apply to a project
10    pub display_name: Option<String>,
11
12    /// Standard object's metadata.
13    pub metadata: k8s_openapi::apimachinery::pkg::apis::meta::v1::ObjectMeta,
14}
15
16// Begin project.openshift.io/v1/ProjectRequest
17
18// Generated from operation createProjectOpenshiftIoV1ProjectRequest
19
20impl ProjectRequest {
21    /// create a ProjectRequest
22    ///
23    /// Use the returned [`k8s_openapi::ResponseBody`]`<`[`k8s_openapi::CreateResponse`]`<Self>>` constructor, or [`k8s_openapi::CreateResponse`]`<Self>` directly, to parse the HTTP response.
24    ///
25    /// # Arguments
26    ///
27    /// * `body`
28    ///
29    /// * `optional`
30    ///
31    ///     Optional parameters. Use `Default::default()` to not pass any.
32    #[cfg(feature = "api")]
33    pub fn create_project_request(
34        body: &crate::api::project::v1::ProjectRequest,
35        optional: k8s_openapi::CreateOptional<'_>,
36    ) -> Result<(http::Request<Vec<u8>>, fn(http::StatusCode) -> k8s_openapi::ResponseBody<k8s_openapi::CreateResponse<Self>>), k8s_openapi::RequestError> {
37        let __url = "/apis/project.openshift.io/v1/projectrequests?".to_owned();
38        let mut __query_pairs = k8s_openapi::url::form_urlencoded::Serializer::new(__url);
39        optional.__serialize(&mut __query_pairs);
40        let __url = __query_pairs.finish();
41
42        let __request = http::Request::post(__url);
43        let __body = serde_json::to_vec(body).map_err(k8s_openapi::RequestError::Json)?;
44        let __request = __request.header(http::header::CONTENT_TYPE, http::header::HeaderValue::from_static("application/json"));
45        match __request.body(__body) {
46            Ok(request) => Ok((request, k8s_openapi::ResponseBody::new)),
47            Err(err) => Err(k8s_openapi::RequestError::Http(err)),
48        }
49    }
50}
51
52// Generated from operation listProjectOpenshiftIoV1ProjectRequest
53
54impl ProjectRequest {
55    /// list objects of kind ProjectRequest
56    ///
57    /// This operation only supports listing all items of this type.
58    ///
59    /// Use the returned [`k8s_openapi::ResponseBody`]`<`[`ListProjectRequestResponse`]`>` constructor, or [`ListProjectRequestResponse`] directly, to parse the HTTP response.
60    ///
61    /// # Arguments
62    ///
63    /// * `optional`
64    ///
65    ///     Optional parameters. Use `Default::default()` to not pass any.
66    #[cfg(feature = "api")]
67    pub fn list_project_request(
68        optional: k8s_openapi::ListOptional<'_>,
69    ) -> Result<(http::Request<Vec<u8>>, fn(http::StatusCode) -> k8s_openapi::ResponseBody<ListProjectRequestResponse>), k8s_openapi::RequestError> {
70        let __url = "/apis/project.openshift.io/v1/projectrequests?".to_owned();
71        let mut __query_pairs = k8s_openapi::url::form_urlencoded::Serializer::new(__url);
72        optional.__serialize(&mut __query_pairs);
73        let __url = __query_pairs.finish();
74
75        let __request = http::Request::get(__url);
76        let __body = vec![];
77        match __request.body(__body) {
78            Ok(request) => Ok((request, k8s_openapi::ResponseBody::new)),
79            Err(err) => Err(k8s_openapi::RequestError::Http(err)),
80        }
81    }
82}
83
84/// Use `<ListProjectRequestResponse as Response>::try_from_parts` to parse the HTTP response body of [`ProjectRequest::list_project_request`]
85#[cfg(feature = "api")]
86#[derive(Debug)]
87pub enum ListProjectRequestResponse {
88    Ok(k8s_openapi::apimachinery::pkg::apis::meta::v1::Status),
89    Other(Result<Option<serde_json::Value>, serde_json::Error>),
90}
91
92#[cfg(feature = "api")]
93impl k8s_openapi::Response for ListProjectRequestResponse {
94    fn try_from_parts(status_code: http::StatusCode, buf: &[u8]) -> Result<(Self, usize), k8s_openapi::ResponseError> {
95        match status_code {
96            http::StatusCode::OK => {
97                let result = match serde_json::from_slice(buf) {
98                    Ok(value) => value,
99                    Err(ref err) if err.is_eof() => return Err(k8s_openapi::ResponseError::NeedMoreData),
100                    Err(err) => return Err(k8s_openapi::ResponseError::Json(err)),
101                };
102                Ok((ListProjectRequestResponse::Ok(result), buf.len()))
103            },
104            _ => {
105                let (result, read) =
106                    if buf.is_empty() {
107                        (Ok(None), 0)
108                    }
109                    else {
110                        match serde_json::from_slice(buf) {
111                            Ok(value) => (Ok(Some(value)), buf.len()),
112                            Err(ref err) if err.is_eof() => return Err(k8s_openapi::ResponseError::NeedMoreData),
113                            Err(err) => (Err(err), 0),
114                        }
115                    };
116                Ok((ListProjectRequestResponse::Other(result), read))
117            },
118        }
119    }
120}
121
122// Generated from operation watchProjectOpenshiftIoV1ProjectRequest
123
124impl ProjectRequest {
125    /// list objects of kind ProjectRequest
126    ///
127    /// This operation only supports watching one item, or a list of items, of this type for changes.
128    ///
129    /// Use the returned [`k8s_openapi::ResponseBody`]`<`[`k8s_openapi::WatchResponse`]`<Self>>` constructor, or [`k8s_openapi::WatchResponse`]`<Self>` directly, to parse the HTTP response.
130    ///
131    /// # Arguments
132    ///
133    /// * `optional`
134    ///
135    ///     Optional parameters. Use `Default::default()` to not pass any.
136    #[cfg(feature = "api")]
137    pub fn watch_project_request(
138        optional: k8s_openapi::WatchOptional<'_>,
139    ) -> Result<(http::Request<Vec<u8>>, fn(http::StatusCode) -> k8s_openapi::ResponseBody<k8s_openapi::WatchResponse<Self>>), k8s_openapi::RequestError> {
140        let __url = "/apis/project.openshift.io/v1/projectrequests?".to_owned();
141        let mut __query_pairs = k8s_openapi::url::form_urlencoded::Serializer::new(__url);
142        optional.__serialize(&mut __query_pairs);
143        let __url = __query_pairs.finish();
144
145        let __request = http::Request::get(__url);
146        let __body = vec![];
147        match __request.body(__body) {
148            Ok(request) => Ok((request, k8s_openapi::ResponseBody::new)),
149            Err(err) => Err(k8s_openapi::RequestError::Http(err)),
150        }
151    }
152}
153
154// End project.openshift.io/v1/ProjectRequest
155
156impl k8s_openapi::Resource for ProjectRequest {
157    const API_VERSION: &'static str = "project.openshift.io/v1";
158    const GROUP: &'static str = "project.openshift.io";
159    const KIND: &'static str = "ProjectRequest";
160    const VERSION: &'static str = "v1";
161}
162
163impl k8s_openapi::Metadata for ProjectRequest {
164    type Ty = k8s_openapi::apimachinery::pkg::apis::meta::v1::ObjectMeta;
165
166    fn metadata(&self) -> &<Self as k8s_openapi::Metadata>::Ty {
167        &self.metadata
168    }
169
170    fn metadata_mut(&mut self) -> &mut<Self as k8s_openapi::Metadata>::Ty {
171        &mut self.metadata
172    }
173}
174
175impl<'de> serde::Deserialize<'de> for ProjectRequest {
176    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: serde::Deserializer<'de> {
177        #[allow(non_camel_case_types)]
178        enum Field {
179            Key_api_version,
180            Key_kind,
181            Key_description,
182            Key_display_name,
183            Key_metadata,
184            Other,
185        }
186
187        impl<'de> serde::Deserialize<'de> for Field {
188            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: serde::Deserializer<'de> {
189                struct Visitor;
190
191                impl<'de> serde::de::Visitor<'de> for Visitor {
192                    type Value = Field;
193
194                    fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
195                        f.write_str("field identifier")
196                    }
197
198                    fn visit_str<E>(self, v: &str) -> Result<Self::Value, E> where E: serde::de::Error {
199                        Ok(match v {
200                            "apiVersion" => Field::Key_api_version,
201                            "kind" => Field::Key_kind,
202                            "description" => Field::Key_description,
203                            "displayName" => Field::Key_display_name,
204                            "metadata" => Field::Key_metadata,
205                            _ => Field::Other,
206                        })
207                    }
208                }
209
210                deserializer.deserialize_identifier(Visitor)
211            }
212        }
213
214        struct Visitor;
215
216        impl<'de> serde::de::Visitor<'de> for Visitor {
217            type Value = ProjectRequest;
218
219            fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
220                f.write_str(<Self::Value as k8s_openapi::Resource>::KIND)
221            }
222
223            fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error> where A: serde::de::MapAccess<'de> {
224                let mut value_description: Option<String> = None;
225                let mut value_display_name: Option<String> = None;
226                let mut value_metadata: Option<k8s_openapi::apimachinery::pkg::apis::meta::v1::ObjectMeta> = None;
227
228                while let Some(key) = serde::de::MapAccess::next_key::<Field>(&mut map)? {
229                    match key {
230                        Field::Key_api_version => {
231                            let value_api_version: String = serde::de::MapAccess::next_value(&mut map)?;
232                            if value_api_version != <Self::Value as k8s_openapi::Resource>::API_VERSION {
233                                return Err(serde::de::Error::invalid_value(serde::de::Unexpected::Str(&value_api_version), &<Self::Value as k8s_openapi::Resource>::API_VERSION));
234                            }
235                        },
236                        Field::Key_kind => {
237                            let value_kind: String = serde::de::MapAccess::next_value(&mut map)?;
238                            if value_kind != <Self::Value as k8s_openapi::Resource>::KIND {
239                                return Err(serde::de::Error::invalid_value(serde::de::Unexpected::Str(&value_kind), &<Self::Value as k8s_openapi::Resource>::KIND));
240                            }
241                        },
242                        Field::Key_description => value_description = serde::de::MapAccess::next_value(&mut map)?,
243                        Field::Key_display_name => value_display_name = serde::de::MapAccess::next_value(&mut map)?,
244                        Field::Key_metadata => value_metadata = Some(serde::de::MapAccess::next_value(&mut map)?),
245                        Field::Other => { let _: serde::de::IgnoredAny = serde::de::MapAccess::next_value(&mut map)?; },
246                    }
247                }
248
249                Ok(ProjectRequest {
250                    description: value_description,
251                    display_name: value_display_name,
252                    metadata: value_metadata.ok_or_else(|| serde::de::Error::missing_field("metadata"))?,
253                })
254            }
255        }
256
257        deserializer.deserialize_struct(
258            <Self as k8s_openapi::Resource>::KIND,
259            &[
260                "apiVersion",
261                "kind",
262                "description",
263                "displayName",
264                "metadata",
265            ],
266            Visitor,
267        )
268    }
269}
270
271impl serde::Serialize for ProjectRequest {
272    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: serde::Serializer {
273        let mut state = serializer.serialize_struct(
274            <Self as k8s_openapi::Resource>::KIND,
275            3 +
276            self.description.as_ref().map_or(0, |_| 1) +
277            self.display_name.as_ref().map_or(0, |_| 1),
278        )?;
279        serde::ser::SerializeStruct::serialize_field(&mut state, "apiVersion", <Self as k8s_openapi::Resource>::API_VERSION)?;
280        serde::ser::SerializeStruct::serialize_field(&mut state, "kind", <Self as k8s_openapi::Resource>::KIND)?;
281        if let Some(value) = &self.description {
282            serde::ser::SerializeStruct::serialize_field(&mut state, "description", value)?;
283        }
284        if let Some(value) = &self.display_name {
285            serde::ser::SerializeStruct::serialize_field(&mut state, "displayName", value)?;
286        }
287        serde::ser::SerializeStruct::serialize_field(&mut state, "metadata", &self.metadata)?;
288        serde::ser::SerializeStruct::end(state)
289    }
290}
openshift_openapi/v4_5/api/project/v1/project_request.rs

openshift_openapi/v4_5/api/project/v1/
project_request.rs
