use serde::de::{Error, MapAccess, Visitor};
use serde::{Deserialize, Deserializer, Serialize};
use serde_with::skip_serializing_none;
use std::fmt::{self, Formatter};
#[non_exhaustive]
#[skip_serializing_none]
#[derive(Clone, Debug, PartialEq, Serialize)]
pub struct DatadogAPIKey {
#[serde(rename = "api_key")]
pub api_key: String,
#[serde(rename = "app_key")]
pub app_key: String,
#[serde(rename = "datacenter")]
pub datacenter: String,
#[serde(rename = "subdomain")]
pub subdomain: Option<String>,
#[serde(rename = "type")]
pub type_: crate::datadogV2::model::DatadogAPIKeyType,
#[serde(flatten)]
pub additional_properties: std::collections::BTreeMap<String, serde_json::Value>,
#[serde(skip)]
#[serde(default)]
pub(crate) _unparsed: bool,
}
impl DatadogAPIKey {
pub fn new(
api_key: String,
app_key: String,
datacenter: String,
type_: crate::datadogV2::model::DatadogAPIKeyType,
) -> DatadogAPIKey {
DatadogAPIKey {
api_key,
app_key,
datacenter,
subdomain: None,
type_,
additional_properties: std::collections::BTreeMap::new(),
_unparsed: false,
}
}
pub fn subdomain(mut self, value: String) -> Self {
self.subdomain = Some(value);
self
}
pub fn additional_properties(
mut self,
value: std::collections::BTreeMap<String, serde_json::Value>,
) -> Self {
self.additional_properties = value;
self
}
}
impl<'de> Deserialize<'de> for DatadogAPIKey {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: Deserializer<'de>,
{
struct DatadogAPIKeyVisitor;
impl<'a> Visitor<'a> for DatadogAPIKeyVisitor {
type Value = DatadogAPIKey;
fn expecting(&self, f: &mut Formatter<'_>) -> fmt::Result {
f.write_str("a mapping")
}
fn visit_map<M>(self, mut map: M) -> Result<Self::Value, M::Error>
where
M: MapAccess<'a>,
{
let mut api_key: Option<String> = None;
let mut app_key: Option<String> = None;
let mut datacenter: Option<String> = None;
let mut subdomain: Option<String> = None;
let mut type_: Option<crate::datadogV2::model::DatadogAPIKeyType> = None;
let mut additional_properties: std::collections::BTreeMap<
String,
serde_json::Value,
> = std::collections::BTreeMap::new();
let mut _unparsed = false;
while let Some((k, v)) = map.next_entry::<String, serde_json::Value>()? {
match k.as_str() {
"api_key" => {
api_key = Some(serde_json::from_value(v).map_err(M::Error::custom)?);
}
"app_key" => {
app_key = Some(serde_json::from_value(v).map_err(M::Error::custom)?);
}
"datacenter" => {
datacenter = Some(serde_json::from_value(v).map_err(M::Error::custom)?);
}
"subdomain" => {
if v.is_null() {
continue;
}
subdomain = Some(serde_json::from_value(v).map_err(M::Error::custom)?);
}
"type" => {
type_ = Some(serde_json::from_value(v).map_err(M::Error::custom)?);
if let Some(ref _type_) = type_ {
match _type_ {
crate::datadogV2::model::DatadogAPIKeyType::UnparsedObject(
_type_,
) => {
_unparsed = true;
}
_ => {}
}
}
}
&_ => {
if let Ok(value) = serde_json::from_value(v.clone()) {
additional_properties.insert(k, value);
}
}
}
}
let api_key = api_key.ok_or_else(|| M::Error::missing_field("api_key"))?;
let app_key = app_key.ok_or_else(|| M::Error::missing_field("app_key"))?;
let datacenter = datacenter.ok_or_else(|| M::Error::missing_field("datacenter"))?;
let type_ = type_.ok_or_else(|| M::Error::missing_field("type_"))?;
let content = DatadogAPIKey {
api_key,
app_key,
datacenter,
subdomain,
type_,
additional_properties,
_unparsed,
};
Ok(content)
}
}
deserializer.deserialize_any(DatadogAPIKeyVisitor)
}
}