openshift_openapi/v4_5/api/authorization/v1/
subject_access_review.rs

1// Generated from definition com.github.openshift.api.authorization.v1.SubjectAccessReview
2
3/// SubjectAccessReview is an object for requesting information about whether a user or group can perform an action
4#[derive(Clone, Debug, Default, PartialEq)]
5pub struct SubjectAccessReview {
6    /// Content is the actual content of the request for create and update
7    pub content: Option<k8s_openapi::apimachinery::pkg::runtime::RawExtension>,
8
9    /// GroupsSlice is optional. Groups is the list of groups to which the User belongs.
10    pub groups: Vec<String>,
11
12    /// IsNonResourceURL is true if this is a request for a non-resource URL (outside of the resource hieraarchy)
13    pub is_non_resource_url: bool,
14
15    /// Namespace is the namespace of the action being requested.  Currently, there is no distinction between no namespace and all namespaces
16    pub namespace: String,
17
18    /// Path is the path of a non resource URL
19    pub path: String,
20
21    /// Resource is one of the existing resource types
22    pub resource: String,
23
24    /// Group is the API group of the resource Serialized as resourceAPIGroup to avoid confusion with the 'groups' field when inlined
25    pub resource_api_group: String,
26
27    /// Version is the API version of the resource Serialized as resourceAPIVersion to avoid confusion with TypeMeta.apiVersion and ObjectMeta.resourceVersion when inlined
28    pub resource_api_version: String,
29
30    /// ResourceName is the name of the resource being requested for a "get" or deleted for a "delete"
31    pub resource_name: String,
32
33    /// Scopes to use for the evaluation.  Empty means "use the unscoped (full) permissions of the user/groups". Nil for a self-SAR, means "use the scopes on this request". Nil for a regular SAR, means the same as empty.
34    pub scopes: Vec<String>,
35
36    /// User is optional. If both User and Groups are empty, the current authenticated user is used.
37    pub user: String,
38
39    /// Verb is one of: get, list, watch, create, update, delete
40    pub verb: String,
41}
42
43// Begin authorization.openshift.io/v1/SubjectAccessReview
44
45// Generated from operation createAuthorizationOpenshiftIoV1SubjectAccessReview
46
47impl SubjectAccessReview {
48    /// create a SubjectAccessReview
49    ///
50    /// Use the returned [`k8s_openapi::ResponseBody`]`<`[`k8s_openapi::CreateResponse`]`<Self>>` constructor, or [`k8s_openapi::CreateResponse`]`<Self>` directly, to parse the HTTP response.
51    ///
52    /// # Arguments
53    ///
54    /// * `body`
55    ///
56    /// * `optional`
57    ///
58    ///     Optional parameters. Use `Default::default()` to not pass any.
59    #[cfg(feature = "api")]
60    pub fn create_subject_access_review(
61        body: &crate::api::authorization::v1::SubjectAccessReview,
62        optional: k8s_openapi::CreateOptional<'_>,
63    ) -> Result<(http::Request<Vec<u8>>, fn(http::StatusCode) -> k8s_openapi::ResponseBody<k8s_openapi::CreateResponse<Self>>), k8s_openapi::RequestError> {
64        let __url = "/apis/authorization.openshift.io/v1/subjectaccessreviews?".to_owned();
65        let mut __query_pairs = k8s_openapi::url::form_urlencoded::Serializer::new(__url);
66        optional.__serialize(&mut __query_pairs);
67        let __url = __query_pairs.finish();
68
69        let __request = http::Request::post(__url);
70        let __body = serde_json::to_vec(body).map_err(k8s_openapi::RequestError::Json)?;
71        let __request = __request.header(http::header::CONTENT_TYPE, http::header::HeaderValue::from_static("application/json"));
72        match __request.body(__body) {
73            Ok(request) => Ok((request, k8s_openapi::ResponseBody::new)),
74            Err(err) => Err(k8s_openapi::RequestError::Http(err)),
75        }
76    }
77}
78
79// End authorization.openshift.io/v1/SubjectAccessReview
80
81impl k8s_openapi::Resource for SubjectAccessReview {
82    const API_VERSION: &'static str = "authorization.openshift.io/v1";
83    const GROUP: &'static str = "authorization.openshift.io";
84    const KIND: &'static str = "SubjectAccessReview";
85    const VERSION: &'static str = "v1";
86}
87
88impl<'de> serde::Deserialize<'de> for SubjectAccessReview {
89    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: serde::Deserializer<'de> {
90        #[allow(non_camel_case_types)]
91        enum Field {
92            Key_api_version,
93            Key_kind,
94            Key_content,
95            Key_groups,
96            Key_is_non_resource_url,
97            Key_namespace,
98            Key_path,
99            Key_resource,
100            Key_resource_api_group,
101            Key_resource_api_version,
102            Key_resource_name,
103            Key_scopes,
104            Key_user,
105            Key_verb,
106            Other,
107        }
108
109        impl<'de> serde::Deserialize<'de> for Field {
110            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: serde::Deserializer<'de> {
111                struct Visitor;
112
113                impl<'de> serde::de::Visitor<'de> for Visitor {
114                    type Value = Field;
115
116                    fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
117                        f.write_str("field identifier")
118                    }
119
120                    fn visit_str<E>(self, v: &str) -> Result<Self::Value, E> where E: serde::de::Error {
121                        Ok(match v {
122                            "apiVersion" => Field::Key_api_version,
123                            "kind" => Field::Key_kind,
124                            "content" => Field::Key_content,
125                            "groups" => Field::Key_groups,
126                            "isNonResourceURL" => Field::Key_is_non_resource_url,
127                            "namespace" => Field::Key_namespace,
128                            "path" => Field::Key_path,
129                            "resource" => Field::Key_resource,
130                            "resourceAPIGroup" => Field::Key_resource_api_group,
131                            "resourceAPIVersion" => Field::Key_resource_api_version,
132                            "resourceName" => Field::Key_resource_name,
133                            "scopes" => Field::Key_scopes,
134                            "user" => Field::Key_user,
135                            "verb" => Field::Key_verb,
136                            _ => Field::Other,
137                        })
138                    }
139                }
140
141                deserializer.deserialize_identifier(Visitor)
142            }
143        }
144
145        struct Visitor;
146
147        impl<'de> serde::de::Visitor<'de> for Visitor {
148            type Value = SubjectAccessReview;
149
150            fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
151                f.write_str(<Self::Value as k8s_openapi::Resource>::KIND)
152            }
153
154            fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error> where A: serde::de::MapAccess<'de> {
155                let mut value_content: Option<k8s_openapi::apimachinery::pkg::runtime::RawExtension> = None;
156                let mut value_groups: Option<Vec<String>> = None;
157                let mut value_is_non_resource_url: Option<bool> = None;
158                let mut value_namespace: Option<String> = None;
159                let mut value_path: Option<String> = None;
160                let mut value_resource: Option<String> = None;
161                let mut value_resource_api_group: Option<String> = None;
162                let mut value_resource_api_version: Option<String> = None;
163                let mut value_resource_name: Option<String> = None;
164                let mut value_scopes: Option<Vec<String>> = None;
165                let mut value_user: Option<String> = None;
166                let mut value_verb: Option<String> = None;
167
168                while let Some(key) = serde::de::MapAccess::next_key::<Field>(&mut map)? {
169                    match key {
170                        Field::Key_api_version => {
171                            let value_api_version: String = serde::de::MapAccess::next_value(&mut map)?;
172                            if value_api_version != <Self::Value as k8s_openapi::Resource>::API_VERSION {
173                                return Err(serde::de::Error::invalid_value(serde::de::Unexpected::Str(&value_api_version), &<Self::Value as k8s_openapi::Resource>::API_VERSION));
174                            }
175                        },
176                        Field::Key_kind => {
177                            let value_kind: String = serde::de::MapAccess::next_value(&mut map)?;
178                            if value_kind != <Self::Value as k8s_openapi::Resource>::KIND {
179                                return Err(serde::de::Error::invalid_value(serde::de::Unexpected::Str(&value_kind), &<Self::Value as k8s_openapi::Resource>::KIND));
180                            }
181                        },
182                        Field::Key_content => value_content = serde::de::MapAccess::next_value(&mut map)?,
183                        Field::Key_groups => value_groups = Some(serde::de::MapAccess::next_value(&mut map)?),
184                        Field::Key_is_non_resource_url => value_is_non_resource_url = Some(serde::de::MapAccess::next_value(&mut map)?),
185                        Field::Key_namespace => value_namespace = Some(serde::de::MapAccess::next_value(&mut map)?),
186                        Field::Key_path => value_path = Some(serde::de::MapAccess::next_value(&mut map)?),
187                        Field::Key_resource => value_resource = Some(serde::de::MapAccess::next_value(&mut map)?),
188                        Field::Key_resource_api_group => value_resource_api_group = Some(serde::de::MapAccess::next_value(&mut map)?),
189                        Field::Key_resource_api_version => value_resource_api_version = Some(serde::de::MapAccess::next_value(&mut map)?),
190                        Field::Key_resource_name => value_resource_name = Some(serde::de::MapAccess::next_value(&mut map)?),
191                        Field::Key_scopes => value_scopes = Some(serde::de::MapAccess::next_value(&mut map)?),
192                        Field::Key_user => value_user = Some(serde::de::MapAccess::next_value(&mut map)?),
193                        Field::Key_verb => value_verb = Some(serde::de::MapAccess::next_value(&mut map)?),
194                        Field::Other => { let _: serde::de::IgnoredAny = serde::de::MapAccess::next_value(&mut map)?; },
195                    }
196                }
197
198                Ok(SubjectAccessReview {
199                    content: value_content,
200                    groups: value_groups.ok_or_else(|| serde::de::Error::missing_field("groups"))?,
201                    is_non_resource_url: value_is_non_resource_url.ok_or_else(|| serde::de::Error::missing_field("isNonResourceURL"))?,
202                    namespace: value_namespace.ok_or_else(|| serde::de::Error::missing_field("namespace"))?,
203                    path: value_path.ok_or_else(|| serde::de::Error::missing_field("path"))?,
204                    resource: value_resource.ok_or_else(|| serde::de::Error::missing_field("resource"))?,
205                    resource_api_group: value_resource_api_group.ok_or_else(|| serde::de::Error::missing_field("resourceAPIGroup"))?,
206                    resource_api_version: value_resource_api_version.ok_or_else(|| serde::de::Error::missing_field("resourceAPIVersion"))?,
207                    resource_name: value_resource_name.ok_or_else(|| serde::de::Error::missing_field("resourceName"))?,
208                    scopes: value_scopes.ok_or_else(|| serde::de::Error::missing_field("scopes"))?,
209                    user: value_user.ok_or_else(|| serde::de::Error::missing_field("user"))?,
210                    verb: value_verb.ok_or_else(|| serde::de::Error::missing_field("verb"))?,
211                })
212            }
213        }
214
215        deserializer.deserialize_struct(
216            <Self as k8s_openapi::Resource>::KIND,
217            &[
218                "apiVersion",
219                "kind",
220                "content",
221                "groups",
222                "isNonResourceURL",
223                "namespace",
224                "path",
225                "resource",
226                "resourceAPIGroup",
227                "resourceAPIVersion",
228                "resourceName",
229                "scopes",
230                "user",
231                "verb",
232            ],
233            Visitor,
234        )
235    }
236}
237
238impl serde::Serialize for SubjectAccessReview {
239    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: serde::Serializer {
240        let mut state = serializer.serialize_struct(
241            <Self as k8s_openapi::Resource>::KIND,
242            13 +
243            self.content.as_ref().map_or(0, |_| 1),
244        )?;
245        serde::ser::SerializeStruct::serialize_field(&mut state, "apiVersion", <Self as k8s_openapi::Resource>::API_VERSION)?;
246        serde::ser::SerializeStruct::serialize_field(&mut state, "kind", <Self as k8s_openapi::Resource>::KIND)?;
247        if let Some(value) = &self.content {
248            serde::ser::SerializeStruct::serialize_field(&mut state, "content", value)?;
249        }
250        serde::ser::SerializeStruct::serialize_field(&mut state, "groups", &self.groups)?;
251        serde::ser::SerializeStruct::serialize_field(&mut state, "isNonResourceURL", &self.is_non_resource_url)?;
252        serde::ser::SerializeStruct::serialize_field(&mut state, "namespace", &self.namespace)?;
253        serde::ser::SerializeStruct::serialize_field(&mut state, "path", &self.path)?;
254        serde::ser::SerializeStruct::serialize_field(&mut state, "resource", &self.resource)?;
255        serde::ser::SerializeStruct::serialize_field(&mut state, "resourceAPIGroup", &self.resource_api_group)?;
256        serde::ser::SerializeStruct::serialize_field(&mut state, "resourceAPIVersion", &self.resource_api_version)?;
257        serde::ser::SerializeStruct::serialize_field(&mut state, "resourceName", &self.resource_name)?;
258        serde::ser::SerializeStruct::serialize_field(&mut state, "scopes", &self.scopes)?;
259        serde::ser::SerializeStruct::serialize_field(&mut state, "user", &self.user)?;
260        serde::ser::SerializeStruct::serialize_field(&mut state, "verb", &self.verb)?;
261        serde::ser::SerializeStruct::end(state)
262    }
263}
openshift_openapi/v4_5/api/authorization/v1/subject_access_review.rs

openshift_openapi/v4_5/api/authorization/v1/
subject_access_review.rs
