datadog-api-client 0.32.0

// Unless explicitly stated otherwise all files in this repository are licensed under the Apache-2.0 License.
// This product includes software developed at Datadog (https://www.datadoghq.com/).
// Copyright 2019-Present Datadog, Inc.
use serde::de::{Error, MapAccess, Visitor};
use serde::{Deserialize, Deserializer, Serialize};
use serde_with::skip_serializing_none;
use std::fmt::{self, Formatter};

/// Defines the configurable attributes of a routing rule, such as actions, query, time restriction, and urgency.
#[non_exhaustive]
#[skip_serializing_none]
#[derive(Clone, Debug, PartialEq, Serialize)]
pub struct RoutingRuleAttributes {
    /// Specifies the list of actions to perform when the routing rule matches.
    #[serde(rename = "actions")]
    pub actions: Option<Vec<crate::datadogV2::model::RoutingRuleAction>>,
    /// Defines the query or condition that triggers this routing rule.
    #[serde(rename = "query")]
    pub query: Option<String>,
    /// Time restrictions during which the routing rule is active. Outside of these hours, the rule does not match and routing continues to subsequent rules. This is mutually exclusive with the action-level `support_hours` field.
    #[serde(rename = "time_restriction")]
    pub time_restriction: Option<crate::datadogV2::model::TimeRestrictions>,
    /// Specifies the level of urgency for a routing rule (low, high, or dynamic).
    #[serde(rename = "urgency")]
    pub urgency: Option<crate::datadogV2::model::Urgency>,
    #[serde(flatten)]
    pub additional_properties: std::collections::BTreeMap<String, serde_json::Value>,
    #[serde(skip)]
    #[serde(default)]
    pub(crate) _unparsed: bool,
}

impl RoutingRuleAttributes {
    pub fn new() -> RoutingRuleAttributes {
        RoutingRuleAttributes {
            actions: None,
            query: None,
            time_restriction: None,
            urgency: None,
            additional_properties: std::collections::BTreeMap::new(),
            _unparsed: false,
        }
    }

    pub fn actions(mut self, value: Vec<crate::datadogV2::model::RoutingRuleAction>) -> Self {
        self.actions = Some(value);
        self
    }

    pub fn query(mut self, value: String) -> Self {
        self.query = Some(value);
        self
    }

    pub fn time_restriction(mut self, value: crate::datadogV2::model::TimeRestrictions) -> Self {
        self.time_restriction = Some(value);
        self
    }

    pub fn urgency(mut self, value: crate::datadogV2::model::Urgency) -> Self {
        self.urgency = Some(value);
        self
    }

    pub fn additional_properties(
        mut self,
        value: std::collections::BTreeMap<String, serde_json::Value>,
    ) -> Self {
        self.additional_properties = value;
        self
    }
}

impl Default for RoutingRuleAttributes {
    fn default() -> Self {
        Self::new()
    }
}

impl<'de> Deserialize<'de> for RoutingRuleAttributes {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: Deserializer<'de>,
    {
        struct RoutingRuleAttributesVisitor;
        impl<'a> Visitor<'a> for RoutingRuleAttributesVisitor {
            type Value = RoutingRuleAttributes;

            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 actions: Option<Vec<crate::datadogV2::model::RoutingRuleAction>> = None;
                let mut query: Option<String> = None;
                let mut time_restriction: Option<crate::datadogV2::model::TimeRestrictions> = None;
                let mut urgency: Option<crate::datadogV2::model::Urgency> = 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() {
                        "actions" => {
                            if v.is_null() {
                                continue;
                            }
                            actions = Some(serde_json::from_value(v).map_err(M::Error::custom)?);
                        }
                        "query" => {
                            if v.is_null() {
                                continue;
                            }
                            query = Some(serde_json::from_value(v).map_err(M::Error::custom)?);
                        }
                        "time_restriction" => {
                            if v.is_null() {
                                continue;
                            }
                            time_restriction =
                                Some(serde_json::from_value(v).map_err(M::Error::custom)?);
                        }
                        "urgency" => {
                            if v.is_null() {
                                continue;
                            }
                            urgency = Some(serde_json::from_value(v).map_err(M::Error::custom)?);
                            if let Some(ref _urgency) = urgency {
                                match _urgency {
                                    crate::datadogV2::model::Urgency::UnparsedObject(_urgency) => {
                                        _unparsed = true;
                                    }
                                    _ => {}
                                }
                            }
                        }
                        &_ => {
                            if let Ok(value) = serde_json::from_value(v.clone()) {
                                additional_properties.insert(k, value);
                            }
                        }
                    }
                }

                let content = RoutingRuleAttributes {
                    actions,
                    query,
                    time_restriction,
                    urgency,
                    additional_properties,
                    _unparsed,
                };

                Ok(content)
            }
        }

        deserializer.deserialize_any(RoutingRuleAttributesVisitor)
    }
}