From d8552a0d6c71678f728289dd881285f3e9d82b73 Mon Sep 17 00:00:00 2001 From: "ci.datadog-api-spec" Date: Mon, 8 Jun 2026 14:22:53 +0000 Subject: [PATCH] Regenerate client from commit d890c19 of spec repo --- .generator/schemas/v1/openapi.yaml | 70 +++++++++ src/datadogV1/model/mod.rs | 14 +- src/datadogV1/model/model_dashboard.rs | 34 +++++ ...del_dashboard_default_timeframe_setting.rs | 44 ++++++ .../model/model_dashboard_fixed_timeframe.rs | 124 ++++++++++++++++ .../model_dashboard_fixed_timeframe_type.rs | 48 +++++++ .../model/model_dashboard_live_timeframe.rs | 134 ++++++++++++++++++ .../model_dashboard_live_timeframe_type.rs | 48 +++++++ .../scenarios/features/v1/dashboards.feature | 6 +- 9 files changed, 517 insertions(+), 5 deletions(-) create mode 100644 src/datadogV1/model/model_dashboard_default_timeframe_setting.rs create mode 100644 src/datadogV1/model/model_dashboard_fixed_timeframe.rs create mode 100644 src/datadogV1/model/model_dashboard_fixed_timeframe_type.rs create mode 100644 src/datadogV1/model/model_dashboard_live_timeframe.rs create mode 100644 src/datadogV1/model/model_dashboard_live_timeframe_type.rs diff --git a/.generator/schemas/v1/openapi.yaml b/.generator/schemas/v1/openapi.yaml index e922a2a26a..a6d35cbd21 100644 --- a/.generator/schemas/v1/openapi.yaml +++ b/.generator/schemas/v1/openapi.yaml @@ -1443,6 +1443,8 @@ components: format: date-time readOnly: true type: string + default_timeframe: + $ref: "#/components/schemas/DashboardDefaultTimeframeSetting" description: description: Description of the dashboard. nullable: true @@ -1557,6 +1559,18 @@ components: required: - data type: object + DashboardDefaultTimeframeSetting: + description: The default timeframe applied when opening the dashboard. Set to `null` to clear the dashboard's default timeframe. + discriminator: + mapping: + fixed: "#/components/schemas/DashboardFixedTimeframe" + live: "#/components/schemas/DashboardLiveTimeframe" + propertyName: type + nullable: true + oneOf: + - $ref: "#/components/schemas/DashboardLiveTimeframe" + - $ref: "#/components/schemas/DashboardFixedTimeframe" + type: object DashboardDeleteResponse: description: Response from the delete dashboard call. properties: @@ -1564,6 +1578,36 @@ components: description: ID of the deleted dashboard. type: string type: object + DashboardFixedTimeframe: + description: A fixed dashboard timeframe. + properties: + from: + description: Start time in milliseconds since epoch. + example: 1712080128000 + format: int64 + minimum: 0 + type: integer + to: + description: End time in milliseconds since epoch. + example: 1712083128000 + format: int64 + minimum: 0 + type: integer + type: + $ref: "#/components/schemas/DashboardFixedTimeframeType" + required: + - type + - from + - to + type: object + DashboardFixedTimeframeType: + description: Type of fixed timeframe. + enum: + - fixed + example: fixed + type: string + x-enum-varnames: + - FIXED DashboardGlobalTime: description: Object containing the live span selection for the dashboard. properties: @@ -1672,6 +1716,32 @@ components: $ref: "#/components/schemas/DashboardList" type: array type: object + DashboardLiveTimeframe: + description: A live dashboard timeframe. + properties: + type: + $ref: "#/components/schemas/DashboardLiveTimeframeType" + unit: + $ref: "#/components/schemas/WidgetLiveSpanUnit" + value: + description: Value of the live timeframe span. + example: 4 + format: int64 + minimum: 1 + type: integer + required: + - type + - value + - unit + type: object + DashboardLiveTimeframeType: + description: Type of live timeframe. + enum: + - live + example: live + type: string + x-enum-varnames: + - LIVE DashboardReflowType: description: |- Reflow type for a **new dashboard layout** dashboard. Set this only when layout type is 'ordered'. diff --git a/src/datadogV1/model/mod.rs b/src/datadogV1/model/mod.rs index 49b0c8fbc3..2e9e4cb4ec 100644 --- a/src/datadogV1/model/mod.rs +++ b/src/datadogV1/model/mod.rs @@ -88,6 +88,18 @@ pub mod model_dashboard_restore_request; pub use self::model_dashboard_restore_request::DashboardRestoreRequest; pub mod model_dashboard; pub use self::model_dashboard::Dashboard; +pub mod model_dashboard_live_timeframe; +pub use self::model_dashboard_live_timeframe::DashboardLiveTimeframe; +pub mod model_dashboard_live_timeframe_type; +pub use self::model_dashboard_live_timeframe_type::DashboardLiveTimeframeType; +pub mod model_widget_live_span_unit; +pub use self::model_widget_live_span_unit::WidgetLiveSpanUnit; +pub mod model_dashboard_fixed_timeframe; +pub use self::model_dashboard_fixed_timeframe::DashboardFixedTimeframe; +pub mod model_dashboard_fixed_timeframe_type; +pub use self::model_dashboard_fixed_timeframe_type::DashboardFixedTimeframeType; +pub mod model_dashboard_default_timeframe_setting; +pub use self::model_dashboard_default_timeframe_setting::DashboardDefaultTimeframeSetting; pub mod model_dashboard_reflow_type; pub use self::model_dashboard_reflow_type::DashboardReflowType; pub mod model_dashboard_tab; @@ -110,8 +122,6 @@ pub mod model_widget_new_live_span; pub use self::model_widget_new_live_span::WidgetNewLiveSpan; pub mod model_widget_new_live_span_type; pub use self::model_widget_new_live_span_type::WidgetNewLiveSpanType; -pub mod model_widget_live_span_unit; -pub use self::model_widget_live_span_unit::WidgetLiveSpanUnit; pub mod model_widget_new_fixed_span; pub use self::model_widget_new_fixed_span::WidgetNewFixedSpan; pub mod model_widget_new_fixed_span_type; diff --git a/src/datadogV1/model/model_dashboard.rs b/src/datadogV1/model/model_dashboard.rs index cd7ec16819..b078a968f9 100644 --- a/src/datadogV1/model/model_dashboard.rs +++ b/src/datadogV1/model/model_dashboard.rs @@ -25,6 +25,14 @@ pub struct Dashboard { /// Creation date of the dashboard. #[serde(rename = "created_at")] pub created_at: Option>, + /// The default timeframe applied when opening the dashboard. Set to `null` to clear the dashboard's default timeframe. + #[serde( + rename = "default_timeframe", + default, + with = "::serde_with::rust::double_option" + )] + pub default_timeframe: + Option>, /// Description of the dashboard. #[serde( rename = "description", @@ -110,6 +118,7 @@ impl Dashboard { author_handle: None, author_name: None, created_at: None, + default_timeframe: None, description: None, id: None, is_read_only: None, @@ -148,6 +157,15 @@ impl Dashboard { self } + #[allow(deprecated)] + pub fn default_timeframe( + mut self, + value: Option, + ) -> Self { + self.default_timeframe = Some(value); + self + } + #[allow(deprecated)] pub fn description(mut self, value: Option) -> Self { self.description = Some(value); @@ -255,6 +273,9 @@ impl<'de> Deserialize<'de> for Dashboard { let mut author_handle: Option = None; let mut author_name: Option> = None; let mut created_at: Option> = None; + let mut default_timeframe: Option< + Option, + > = None; let mut description: Option> = None; let mut id: Option = None; let mut is_read_only: Option = None; @@ -299,6 +320,18 @@ impl<'de> Deserialize<'de> for Dashboard { } created_at = Some(serde_json::from_value(v).map_err(M::Error::custom)?); } + "default_timeframe" => { + default_timeframe = + Some(serde_json::from_value(v).map_err(M::Error::custom)?); + if let Some(ref _default_timeframe) = default_timeframe { + match _default_timeframe { + Some(crate::datadogV1::model::DashboardDefaultTimeframeSetting::UnparsedObject(_default_timeframe)) => { + _unparsed = true; + }, + _ => {} + } + } + } "description" => { description = Some(serde_json::from_value(v).map_err(M::Error::custom)?); @@ -404,6 +437,7 @@ impl<'de> Deserialize<'de> for Dashboard { author_handle, author_name, created_at, + default_timeframe, description, id, is_read_only, diff --git a/src/datadogV1/model/model_dashboard_default_timeframe_setting.rs b/src/datadogV1/model/model_dashboard_default_timeframe_setting.rs new file mode 100644 index 0000000000..5de64383f9 --- /dev/null +++ b/src/datadogV1/model/model_dashboard_default_timeframe_setting.rs @@ -0,0 +1,44 @@ +// 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::{Deserialize, Deserializer, Serialize}; + +/// The default timeframe applied when opening the dashboard. Set to `null` to clear the dashboard's default timeframe. +#[non_exhaustive] +#[derive(Clone, Debug, PartialEq, Serialize)] +#[serde(untagged)] +pub enum DashboardDefaultTimeframeSetting { + DashboardLiveTimeframe(Box), + DashboardFixedTimeframe(Box), + UnparsedObject(crate::datadog::UnparsedObject), +} + +impl<'de> Deserialize<'de> for DashboardDefaultTimeframeSetting { + fn deserialize(deserializer: D) -> Result + where + D: Deserializer<'de>, + { + let value: serde_json::Value = Deserialize::deserialize(deserializer)?; + if let Ok(_v) = serde_json::from_value::>( + value.clone(), + ) { + if !_v._unparsed { + return Ok(DashboardDefaultTimeframeSetting::DashboardLiveTimeframe(_v)); + } + } + if let Ok(_v) = serde_json::from_value::< + Box, + >(value.clone()) + { + if !_v._unparsed { + return Ok(DashboardDefaultTimeframeSetting::DashboardFixedTimeframe( + _v, + )); + } + } + + return Ok(DashboardDefaultTimeframeSetting::UnparsedObject( + crate::datadog::UnparsedObject { value }, + )); + } +} diff --git a/src/datadogV1/model/model_dashboard_fixed_timeframe.rs b/src/datadogV1/model/model_dashboard_fixed_timeframe.rs new file mode 100644 index 0000000000..a6dbc700f8 --- /dev/null +++ b/src/datadogV1/model/model_dashboard_fixed_timeframe.rs @@ -0,0 +1,124 @@ +// 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}; + +/// A fixed dashboard timeframe. +#[non_exhaustive] +#[skip_serializing_none] +#[derive(Clone, Debug, PartialEq, Serialize)] +pub struct DashboardFixedTimeframe { + /// Start time in milliseconds since epoch. + #[serde(rename = "from")] + pub from: i64, + /// End time in milliseconds since epoch. + #[serde(rename = "to")] + pub to: i64, + /// Type of fixed timeframe. + #[serde(rename = "type")] + pub type_: crate::datadogV1::model::DashboardFixedTimeframeType, + #[serde(flatten)] + pub additional_properties: std::collections::BTreeMap, + #[serde(skip)] + #[serde(default)] + pub(crate) _unparsed: bool, +} + +impl DashboardFixedTimeframe { + pub fn new( + from: i64, + to: i64, + type_: crate::datadogV1::model::DashboardFixedTimeframeType, + ) -> DashboardFixedTimeframe { + DashboardFixedTimeframe { + from, + to, + type_, + additional_properties: std::collections::BTreeMap::new(), + _unparsed: false, + } + } + + pub fn additional_properties( + mut self, + value: std::collections::BTreeMap, + ) -> Self { + self.additional_properties = value; + self + } +} + +impl<'de> Deserialize<'de> for DashboardFixedTimeframe { + fn deserialize(deserializer: D) -> Result + where + D: Deserializer<'de>, + { + struct DashboardFixedTimeframeVisitor; + impl<'a> Visitor<'a> for DashboardFixedTimeframeVisitor { + type Value = DashboardFixedTimeframe; + + fn expecting(&self, f: &mut Formatter<'_>) -> fmt::Result { + f.write_str("a mapping") + } + + fn visit_map(self, mut map: M) -> Result + where + M: MapAccess<'a>, + { + let mut from: Option = None; + let mut to: Option = None; + let mut type_: Option = 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::()? { + match k.as_str() { + "from" => { + from = Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + "to" => { + to = 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::datadogV1::model::DashboardFixedTimeframeType::UnparsedObject(_type_) => { + _unparsed = true; + }, + _ => {} + } + } + } + &_ => { + if let Ok(value) = serde_json::from_value(v.clone()) { + additional_properties.insert(k, value); + } + } + } + } + let from = from.ok_or_else(|| M::Error::missing_field("from"))?; + let to = to.ok_or_else(|| M::Error::missing_field("to"))?; + let type_ = type_.ok_or_else(|| M::Error::missing_field("type_"))?; + + let content = DashboardFixedTimeframe { + from, + to, + type_, + additional_properties, + _unparsed, + }; + + Ok(content) + } + } + + deserializer.deserialize_any(DashboardFixedTimeframeVisitor) + } +} diff --git a/src/datadogV1/model/model_dashboard_fixed_timeframe_type.rs b/src/datadogV1/model/model_dashboard_fixed_timeframe_type.rs new file mode 100644 index 0000000000..31aa6c0480 --- /dev/null +++ b/src/datadogV1/model/model_dashboard_fixed_timeframe_type.rs @@ -0,0 +1,48 @@ +// 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::{Deserialize, Deserializer, Serialize, Serializer}; + +#[non_exhaustive] +#[derive(Clone, Debug, Eq, PartialEq)] +pub enum DashboardFixedTimeframeType { + FIXED, + UnparsedObject(crate::datadog::UnparsedObject), +} + +impl ToString for DashboardFixedTimeframeType { + fn to_string(&self) -> String { + match self { + Self::FIXED => String::from("fixed"), + Self::UnparsedObject(v) => v.value.to_string(), + } + } +} + +impl Serialize for DashboardFixedTimeframeType { + fn serialize(&self, serializer: S) -> Result + where + S: Serializer, + { + match self { + Self::UnparsedObject(v) => v.serialize(serializer), + _ => serializer.serialize_str(self.to_string().as_str()), + } + } +} + +impl<'de> Deserialize<'de> for DashboardFixedTimeframeType { + fn deserialize(deserializer: D) -> Result + where + D: Deserializer<'de>, + { + let s: String = String::deserialize(deserializer)?; + Ok(match s.as_str() { + "fixed" => Self::FIXED, + _ => Self::UnparsedObject(crate::datadog::UnparsedObject { + value: serde_json::Value::String(s.into()), + }), + }) + } +} diff --git a/src/datadogV1/model/model_dashboard_live_timeframe.rs b/src/datadogV1/model/model_dashboard_live_timeframe.rs new file mode 100644 index 0000000000..8d85d0cfe7 --- /dev/null +++ b/src/datadogV1/model/model_dashboard_live_timeframe.rs @@ -0,0 +1,134 @@ +// 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}; + +/// A live dashboard timeframe. +#[non_exhaustive] +#[skip_serializing_none] +#[derive(Clone, Debug, PartialEq, Serialize)] +pub struct DashboardLiveTimeframe { + /// Type of live timeframe. + #[serde(rename = "type")] + pub type_: crate::datadogV1::model::DashboardLiveTimeframeType, + /// Unit of the time span. + #[serde(rename = "unit")] + pub unit: crate::datadogV1::model::WidgetLiveSpanUnit, + /// Value of the live timeframe span. + #[serde(rename = "value")] + pub value: i64, + #[serde(flatten)] + pub additional_properties: std::collections::BTreeMap, + #[serde(skip)] + #[serde(default)] + pub(crate) _unparsed: bool, +} + +impl DashboardLiveTimeframe { + pub fn new( + type_: crate::datadogV1::model::DashboardLiveTimeframeType, + unit: crate::datadogV1::model::WidgetLiveSpanUnit, + value: i64, + ) -> DashboardLiveTimeframe { + DashboardLiveTimeframe { + type_, + unit, + value, + additional_properties: std::collections::BTreeMap::new(), + _unparsed: false, + } + } + + pub fn additional_properties( + mut self, + value: std::collections::BTreeMap, + ) -> Self { + self.additional_properties = value; + self + } +} + +impl<'de> Deserialize<'de> for DashboardLiveTimeframe { + fn deserialize(deserializer: D) -> Result + where + D: Deserializer<'de>, + { + struct DashboardLiveTimeframeVisitor; + impl<'a> Visitor<'a> for DashboardLiveTimeframeVisitor { + type Value = DashboardLiveTimeframe; + + fn expecting(&self, f: &mut Formatter<'_>) -> fmt::Result { + f.write_str("a mapping") + } + + fn visit_map(self, mut map: M) -> Result + where + M: MapAccess<'a>, + { + let mut type_: Option = None; + let mut unit: Option = None; + let mut value: Option = 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::()? { + match k.as_str() { + "type" => { + type_ = Some(serde_json::from_value(v).map_err(M::Error::custom)?); + if let Some(ref _type_) = type_ { + match _type_ { + crate::datadogV1::model::DashboardLiveTimeframeType::UnparsedObject(_type_) => { + _unparsed = true; + }, + _ => {} + } + } + } + "unit" => { + unit = Some(serde_json::from_value(v).map_err(M::Error::custom)?); + if let Some(ref _unit) = unit { + match _unit { + crate::datadogV1::model::WidgetLiveSpanUnit::UnparsedObject( + _unit, + ) => { + _unparsed = true; + } + _ => {} + } + } + } + "value" => { + value = Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + &_ => { + if let Ok(value) = serde_json::from_value(v.clone()) { + additional_properties.insert(k, value); + } + } + } + } + let type_ = type_.ok_or_else(|| M::Error::missing_field("type_"))?; + let unit = unit.ok_or_else(|| M::Error::missing_field("unit"))?; + let value = value.ok_or_else(|| M::Error::missing_field("value"))?; + + let content = DashboardLiveTimeframe { + type_, + unit, + value, + additional_properties, + _unparsed, + }; + + Ok(content) + } + } + + deserializer.deserialize_any(DashboardLiveTimeframeVisitor) + } +} diff --git a/src/datadogV1/model/model_dashboard_live_timeframe_type.rs b/src/datadogV1/model/model_dashboard_live_timeframe_type.rs new file mode 100644 index 0000000000..2e59d69a4b --- /dev/null +++ b/src/datadogV1/model/model_dashboard_live_timeframe_type.rs @@ -0,0 +1,48 @@ +// 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::{Deserialize, Deserializer, Serialize, Serializer}; + +#[non_exhaustive] +#[derive(Clone, Debug, Eq, PartialEq)] +pub enum DashboardLiveTimeframeType { + LIVE, + UnparsedObject(crate::datadog::UnparsedObject), +} + +impl ToString for DashboardLiveTimeframeType { + fn to_string(&self) -> String { + match self { + Self::LIVE => String::from("live"), + Self::UnparsedObject(v) => v.value.to_string(), + } + } +} + +impl Serialize for DashboardLiveTimeframeType { + fn serialize(&self, serializer: S) -> Result + where + S: Serializer, + { + match self { + Self::UnparsedObject(v) => v.serialize(serializer), + _ => serializer.serialize_str(self.to_string().as_str()), + } + } +} + +impl<'de> Deserialize<'de> for DashboardLiveTimeframeType { + fn deserialize(deserializer: D) -> Result + where + D: Deserializer<'de>, + { + let s: String = String::deserialize(deserializer)?; + Ok(match s.as_str() { + "live" => Self::LIVE, + _ => Self::UnparsedObject(crate::datadog::UnparsedObject { + value: serde_json::Value::String(s.into()), + }), + }) + } +} diff --git a/tests/scenarios/features/v1/dashboards.feature b/tests/scenarios/features/v1/dashboards.feature index 932dc22b0b..2fb06cd716 100644 --- a/tests/scenarios/features/v1/dashboards.feature +++ b/tests/scenarios/features/v1/dashboards.feature @@ -90,7 +90,7 @@ Feature: Dashboards @generated @skip @team:DataDog/dashboards-backend Scenario: Create a new dashboard returns "Bad Request" response Given new "CreateDashboard" request - And body with value {"description": null, "is_read_only": false, "layout_type": "ordered", "notify_list": [], "reflow_type": "auto", "restricted_roles": [], "tabs": [{"id": "", "name": "L", "widget_ids": [0]}], "tags": [], "template_variable_presets": [{"template_variables": [{"values": []}]}], "template_variables": [{"available_values": ["my-host", "host1", "host2"], "default": "my-host", "defaults": ["my-host-1", "my-host-2"], "name": "host1", "prefix": "host", "type": "group"}], "title": "", "widgets": [{"definition": {"requests": {"fill": {"q": "avg:system.cpu.user{*}"}}, "type": "hostmap"}}]} + And body with value {"default_timeframe": {"type": "live", "unit": "minute", "value": 4}, "description": null, "is_read_only": false, "layout_type": "ordered", "notify_list": [], "reflow_type": "auto", "restricted_roles": [], "tabs": [{"id": "", "name": "L", "widget_ids": [0]}], "tags": [], "template_variable_presets": [{"template_variables": [{"values": []}]}], "template_variables": [{"available_values": ["my-host", "host1", "host2"], "default": "my-host", "defaults": ["my-host-1", "my-host-2"], "name": "host1", "prefix": "host", "type": "group"}], "title": "", "widgets": [{"definition": {"requests": {"fill": {"q": "avg:system.cpu.user{*}"}}, "type": "hostmap"}}]} When the request is sent Then the response status is 400 Bad Request @@ -1463,7 +1463,7 @@ Feature: Dashboards Scenario: Update a dashboard returns "Bad Request" response Given new "UpdateDashboard" request And request contains "dashboard_id" parameter from "REPLACE.ME" - And body with value {"description": null, "is_read_only": false, "layout_type": "ordered", "notify_list": [], "reflow_type": "auto", "restricted_roles": [], "tabs": [{"id": "", "name": "L", "widget_ids": [0]}], "tags": [], "template_variable_presets": [{"template_variables": [{"values": []}]}], "template_variables": [{"available_values": ["my-host", "host1", "host2"], "default": "my-host", "defaults": ["my-host-1", "my-host-2"], "name": "host1", "prefix": "host", "type": "group"}], "title": "", "widgets": [{"definition": {"requests": {"fill": {"q": "avg:system.cpu.user{*}"}}, "type": "hostmap"}}]} + And body with value {"default_timeframe": {"type": "live", "unit": "minute", "value": 4}, "description": null, "is_read_only": false, "layout_type": "ordered", "notify_list": [], "reflow_type": "auto", "restricted_roles": [], "tabs": [{"id": "", "name": "L", "widget_ids": [0]}], "tags": [], "template_variable_presets": [{"template_variables": [{"values": []}]}], "template_variables": [{"available_values": ["my-host", "host1", "host2"], "default": "my-host", "defaults": ["my-host-1", "my-host-2"], "name": "host1", "prefix": "host", "type": "group"}], "title": "", "widgets": [{"definition": {"requests": {"fill": {"q": "avg:system.cpu.user{*}"}}, "type": "hostmap"}}]} When the request is sent Then the response status is 400 Bad Request @@ -1471,7 +1471,7 @@ Feature: Dashboards Scenario: Update a dashboard returns "Item Not Found" response Given new "UpdateDashboard" request And request contains "dashboard_id" parameter from "REPLACE.ME" - And body with value {"description": null, "is_read_only": false, "layout_type": "ordered", "notify_list": [], "reflow_type": "auto", "restricted_roles": [], "tabs": [{"id": "", "name": "L", "widget_ids": [0]}], "tags": [], "template_variable_presets": [{"template_variables": [{"values": []}]}], "template_variables": [{"available_values": ["my-host", "host1", "host2"], "default": "my-host", "defaults": ["my-host-1", "my-host-2"], "name": "host1", "prefix": "host", "type": "group"}], "title": "", "widgets": [{"definition": {"requests": {"fill": {"q": "avg:system.cpu.user{*}"}}, "type": "hostmap"}}]} + And body with value {"default_timeframe": {"type": "live", "unit": "minute", "value": 4}, "description": null, "is_read_only": false, "layout_type": "ordered", "notify_list": [], "reflow_type": "auto", "restricted_roles": [], "tabs": [{"id": "", "name": "L", "widget_ids": [0]}], "tags": [], "template_variable_presets": [{"template_variables": [{"values": []}]}], "template_variables": [{"available_values": ["my-host", "host1", "host2"], "default": "my-host", "defaults": ["my-host-1", "my-host-2"], "name": "host1", "prefix": "host", "type": "group"}], "title": "", "widgets": [{"definition": {"requests": {"fill": {"q": "avg:system.cpu.user{*}"}}, "type": "hostmap"}}]} When the request is sent Then the response status is 404 Item Not Found