diff --git a/.generator/schemas/v1/openapi.yaml b/.generator/schemas/v1/openapi.yaml index 4fc8dbe37..93876ddf3 100644 --- a/.generator/schemas/v1/openapi.yaml +++ b/.generator/schemas/v1/openapi.yaml @@ -895,6 +895,172 @@ components: items: $ref: '#/components/schemas/AzureAccount' type: array + BarChartWidgetDefinition: + description: The bar chart visualization displays categorical data using vertical + bars, allowing you to compare values across different groups. + properties: + custom_links: + description: List of custom links. + items: + $ref: '#/components/schemas/WidgetCustomLink' + type: array + requests: + description: List of bar chart widget requests. + example: + - q: system.load.1 + items: + $ref: '#/components/schemas/BarChartWidgetRequest' + type: array + style: + $ref: '#/components/schemas/BarChartWidgetStyle' + time: + $ref: '#/components/schemas/WidgetTime' + title: + description: Title of your widget. + type: string + title_align: + $ref: '#/components/schemas/WidgetTextAlign' + title_size: + description: Size of the title. + type: string + type: + $ref: '#/components/schemas/BarChartWidgetDefinitionType' + required: + - type + - requests + type: object + BarChartWidgetDefinitionType: + default: bar_chart + description: Type of the bar chart widget. + enum: + - bar_chart + example: bar_chart + type: string + x-enum-varnames: + - BAR_CHART + BarChartWidgetDisplay: + description: Bar chart widget display options. + oneOf: + - $ref: '#/components/schemas/BarChartWidgetStacked' + - $ref: '#/components/schemas/BarChartWidgetFlat' + BarChartWidgetFlat: + description: Bar chart widget flat display. + properties: + type: + $ref: '#/components/schemas/BarChartWidgetFlatType' + required: + - type + type: object + BarChartWidgetFlatType: + default: flat + description: Bar chart widget flat display type. + enum: + - flat + example: flat + type: string + x-enum-varnames: + - FLAT + BarChartWidgetLegend: + description: Bar chart widget stacked legend behavior. + enum: + - automatic + - inline + - none + example: automatic + type: string + x-enum-varnames: + - AUTOMATIC + - INLINE + - NONE + BarChartWidgetRequest: + description: Updated bar chart widget. + properties: + apm_query: + $ref: '#/components/schemas/LogQueryDefinition' + audit_query: + $ref: '#/components/schemas/LogQueryDefinition' + conditional_formats: + description: List of conditional formats. + example: + - comparator: '>=' + palette: blue + value: 1.0 + items: + $ref: '#/components/schemas/WidgetConditionalFormat' + type: array + event_query: + $ref: '#/components/schemas/LogQueryDefinition' + formulas: + description: List of formulas that operate on queries. + items: + $ref: '#/components/schemas/WidgetFormula' + type: array + log_query: + $ref: '#/components/schemas/LogQueryDefinition' + network_query: + $ref: '#/components/schemas/LogQueryDefinition' + process_query: + $ref: '#/components/schemas/ProcessQueryDefinition' + profile_metrics_query: + $ref: '#/components/schemas/LogQueryDefinition' + q: + description: Widget query. + type: string + queries: + description: List of queries that can be returned directly or used in formulas. + items: + $ref: '#/components/schemas/FormulaAndFunctionQueryDefinition' + type: array + response_format: + $ref: '#/components/schemas/FormulaAndFunctionResponseFormat' + rum_query: + $ref: '#/components/schemas/LogQueryDefinition' + security_query: + $ref: '#/components/schemas/LogQueryDefinition' + sort: + $ref: '#/components/schemas/WidgetSortBy' + style: + $ref: '#/components/schemas/WidgetRequestStyle' + type: object + BarChartWidgetScaling: + description: Bar chart widget scaling definition. + enum: + - absolute + - relative + type: string + x-enum-varnames: + - ABSOLUTE + - RELATIVE + BarChartWidgetStacked: + description: Bar chart widget stacked display options. + properties: + legend: + $ref: '#/components/schemas/BarChartWidgetLegend' + type: + $ref: '#/components/schemas/BarChartWidgetStackedType' + required: + - type + type: object + BarChartWidgetStackedType: + default: stacked + description: Bar chart widget stacked display type. + enum: + - stacked + example: stacked + type: string + x-enum-varnames: + - STACKED + BarChartWidgetStyle: + description: Style customization for a bar chart widget. + properties: + display: + $ref: '#/components/schemas/BarChartWidgetDisplay' + palette: + description: Color palette to apply to the widget. + type: string + scaling: + $ref: '#/components/schemas/BarChartWidgetScaling' + type: object CancelDowntimesByScopeRequest: description: Cancel downtimes according to scope. properties: @@ -14300,6 +14466,7 @@ components: SplitGraphSourceWidgetDefinition: description: The original widget we are splitting on. oneOf: + - $ref: '#/components/schemas/BarChartWidgetDefinition' - $ref: '#/components/schemas/ChangeWidgetDefinition' - $ref: '#/components/schemas/GeomapWidgetDefinition' - $ref: '#/components/schemas/QueryValueWidgetDefinition' @@ -24731,6 +24898,7 @@ components: oneOf: - $ref: '#/components/schemas/AlertGraphWidgetDefinition' - $ref: '#/components/schemas/AlertValueWidgetDefinition' + - $ref: '#/components/schemas/BarChartWidgetDefinition' - $ref: '#/components/schemas/ChangeWidgetDefinition' - $ref: '#/components/schemas/CheckStatusWidgetDefinition' - $ref: '#/components/schemas/DistributionWidgetDefinition' diff --git a/examples/v1_dashboards_CreateDashboard_1712853070.rs b/examples/v1_dashboards_CreateDashboard_1712853070.rs new file mode 100644 index 000000000..e0fe14acd --- /dev/null +++ b/examples/v1_dashboards_CreateDashboard_1712853070.rs @@ -0,0 +1,116 @@ +// Create a new dashboard with bar_chart widget +use datadog_api_client::datadog; +use datadog_api_client::datadogV1::api_dashboards::DashboardsAPI; +use datadog_api_client::datadogV1::model::BarChartWidgetDefinition; +use datadog_api_client::datadogV1::model::BarChartWidgetDefinitionType; +use datadog_api_client::datadogV1::model::BarChartWidgetDisplay; +use datadog_api_client::datadogV1::model::BarChartWidgetLegend; +use datadog_api_client::datadogV1::model::BarChartWidgetRequest; +use datadog_api_client::datadogV1::model::BarChartWidgetScaling; +use datadog_api_client::datadogV1::model::BarChartWidgetStacked; +use datadog_api_client::datadogV1::model::BarChartWidgetStackedType; +use datadog_api_client::datadogV1::model::BarChartWidgetStyle; +use datadog_api_client::datadogV1::model::Dashboard; +use datadog_api_client::datadogV1::model::DashboardLayoutType; +use datadog_api_client::datadogV1::model::FormulaAndFunctionMetricAggregation; +use datadog_api_client::datadogV1::model::FormulaAndFunctionMetricDataSource; +use datadog_api_client::datadogV1::model::FormulaAndFunctionMetricQueryDefinition; +use datadog_api_client::datadogV1::model::FormulaAndFunctionQueryDefinition; +use datadog_api_client::datadogV1::model::FormulaAndFunctionResponseFormat; +use datadog_api_client::datadogV1::model::FormulaType; +use datadog_api_client::datadogV1::model::Widget; +use datadog_api_client::datadogV1::model::WidgetDefinition; +use datadog_api_client::datadogV1::model::WidgetFormula; +use datadog_api_client::datadogV1::model::WidgetFormulaSort; +use datadog_api_client::datadogV1::model::WidgetLayout; +use datadog_api_client::datadogV1::model::WidgetLegacyLiveSpan; +use datadog_api_client::datadogV1::model::WidgetSort; +use datadog_api_client::datadogV1::model::WidgetSortBy; +use datadog_api_client::datadogV1::model::WidgetSortOrderBy; +use datadog_api_client::datadogV1::model::WidgetTextAlign; +use datadog_api_client::datadogV1::model::WidgetTime; + +#[tokio::main] +async fn main() { + let body = + Dashboard::new( + DashboardLayoutType::FREE, + "Example-Dashboard".to_string(), + vec![ + Widget::new( + WidgetDefinition::BarChartWidgetDefinition( + Box::new( + BarChartWidgetDefinition::new( + vec![ + BarChartWidgetRequest::new() + .formulas(vec![WidgetFormula::new("query1".to_string())]) + .queries( + vec![ + FormulaAndFunctionQueryDefinition + ::FormulaAndFunctionMetricQueryDefinition( + Box::new( + FormulaAndFunctionMetricQueryDefinition::new( + FormulaAndFunctionMetricDataSource::METRICS, + "query1".to_string(), + "avg:system.cpu.user{*} by {service}".to_string(), + ).aggregator(FormulaAndFunctionMetricAggregation::AVG), + ), + ) + ], + ) + .response_format(FormulaAndFunctionResponseFormat::SCALAR) + .sort( + WidgetSortBy::new() + .count(10) + .order_by( + vec![ + WidgetSortOrderBy::WidgetFormulaSort( + Box::new( + WidgetFormulaSort::new( + 0, + WidgetSort::DESCENDING, + FormulaType::FORMULA, + ), + ), + ) + ], + ), + ) + ], + BarChartWidgetDefinitionType::BAR_CHART, + ) + .style( + BarChartWidgetStyle::new() + .display( + BarChartWidgetDisplay::BarChartWidgetStacked( + Box::new( + BarChartWidgetStacked::new( + BarChartWidgetStackedType::STACKED, + ).legend(BarChartWidgetLegend::INLINE), + ), + ), + ) + .palette("dog_classic".to_string()) + .scaling(BarChartWidgetScaling::RELATIVE), + ) + .time(WidgetTime::WidgetLegacyLiveSpan(Box::new(WidgetLegacyLiveSpan::new()))) + .title("".to_string()) + .title_align(WidgetTextAlign::LEFT) + .title_size("16".to_string()), + ), + ), + ).layout(WidgetLayout::new(15, 47, 0, 0)) + ], + ) + .description(Some("".to_string())) + .notify_list(Some(vec![])) + .template_variables(Some(vec![])); + let configuration = datadog::Configuration::new(); + let api = DashboardsAPI::with_config(configuration); + let resp = api.create_dashboard(body).await; + if let Ok(value) = resp { + println!("{:#?}", value); + } else { + println!("{:#?}", resp.unwrap_err()); + } +} diff --git a/examples/v1_dashboards_CreateDashboard_2345541687.rs b/examples/v1_dashboards_CreateDashboard_2345541687.rs new file mode 100644 index 000000000..136333d00 --- /dev/null +++ b/examples/v1_dashboards_CreateDashboard_2345541687.rs @@ -0,0 +1,114 @@ +// Create a new dashboard with a bar_chart widget with stacked type and no legend +// specified +use datadog_api_client::datadog; +use datadog_api_client::datadogV1::api_dashboards::DashboardsAPI; +use datadog_api_client::datadogV1::model::BarChartWidgetDefinition; +use datadog_api_client::datadogV1::model::BarChartWidgetDefinitionType; +use datadog_api_client::datadogV1::model::BarChartWidgetDisplay; +use datadog_api_client::datadogV1::model::BarChartWidgetRequest; +use datadog_api_client::datadogV1::model::BarChartWidgetScaling; +use datadog_api_client::datadogV1::model::BarChartWidgetStacked; +use datadog_api_client::datadogV1::model::BarChartWidgetStackedType; +use datadog_api_client::datadogV1::model::BarChartWidgetStyle; +use datadog_api_client::datadogV1::model::Dashboard; +use datadog_api_client::datadogV1::model::DashboardLayoutType; +use datadog_api_client::datadogV1::model::FormulaAndFunctionMetricAggregation; +use datadog_api_client::datadogV1::model::FormulaAndFunctionMetricDataSource; +use datadog_api_client::datadogV1::model::FormulaAndFunctionMetricQueryDefinition; +use datadog_api_client::datadogV1::model::FormulaAndFunctionQueryDefinition; +use datadog_api_client::datadogV1::model::FormulaAndFunctionResponseFormat; +use datadog_api_client::datadogV1::model::GroupType; +use datadog_api_client::datadogV1::model::Widget; +use datadog_api_client::datadogV1::model::WidgetDefinition; +use datadog_api_client::datadogV1::model::WidgetFormula; +use datadog_api_client::datadogV1::model::WidgetGroupSort; +use datadog_api_client::datadogV1::model::WidgetLayout; +use datadog_api_client::datadogV1::model::WidgetLegacyLiveSpan; +use datadog_api_client::datadogV1::model::WidgetSort; +use datadog_api_client::datadogV1::model::WidgetSortBy; +use datadog_api_client::datadogV1::model::WidgetSortOrderBy; +use datadog_api_client::datadogV1::model::WidgetTextAlign; +use datadog_api_client::datadogV1::model::WidgetTime; + +#[tokio::main] +async fn main() { + let body = + Dashboard::new( + DashboardLayoutType::FREE, + "Example-Dashboard".to_string(), + vec![ + Widget::new( + WidgetDefinition::BarChartWidgetDefinition( + Box::new( + BarChartWidgetDefinition::new( + vec![ + BarChartWidgetRequest::new() + .formulas(vec![WidgetFormula::new("query1".to_string())]) + .queries( + vec![ + FormulaAndFunctionQueryDefinition + ::FormulaAndFunctionMetricQueryDefinition( + Box::new( + FormulaAndFunctionMetricQueryDefinition::new( + FormulaAndFunctionMetricDataSource::METRICS, + "query1".to_string(), + "avg:system.cpu.user{*} by {service}".to_string(), + ).aggregator(FormulaAndFunctionMetricAggregation::AVG), + ), + ) + ], + ) + .response_format(FormulaAndFunctionResponseFormat::SCALAR) + .sort( + WidgetSortBy::new() + .count(10) + .order_by( + vec![ + WidgetSortOrderBy::WidgetGroupSort( + Box::new( + WidgetGroupSort::new( + "service".to_string(), + WidgetSort::ASCENDING, + GroupType::GROUP, + ), + ), + ) + ], + ), + ) + ], + BarChartWidgetDefinitionType::BAR_CHART, + ) + .style( + BarChartWidgetStyle::new() + .display( + BarChartWidgetDisplay::BarChartWidgetStacked( + Box::new( + BarChartWidgetStacked::new(BarChartWidgetStackedType::STACKED), + ), + ), + ) + .palette("dog_classic".to_string()) + .scaling(BarChartWidgetScaling::RELATIVE), + ) + .time(WidgetTime::WidgetLegacyLiveSpan(Box::new(WidgetLegacyLiveSpan::new()))) + .title("".to_string()) + .title_align(WidgetTextAlign::LEFT) + .title_size("16".to_string()), + ), + ), + ).layout(WidgetLayout::new(15, 47, 0, 0)) + ], + ) + .description(Some("".to_string())) + .notify_list(Some(vec![])) + .template_variables(Some(vec![])); + let configuration = datadog::Configuration::new(); + let api = DashboardsAPI::with_config(configuration); + let resp = api.create_dashboard(body).await; + if let Ok(value) = resp { + println!("{:#?}", value); + } else { + println!("{:#?}", resp.unwrap_err()); + } +} diff --git a/examples/v1_dashboards_CreateDashboard_2617251399.rs b/examples/v1_dashboards_CreateDashboard_2617251399.rs new file mode 100644 index 000000000..dd16a3802 --- /dev/null +++ b/examples/v1_dashboards_CreateDashboard_2617251399.rs @@ -0,0 +1,116 @@ +// Create a new dashboard with bar_chart widget sorted by group +use datadog_api_client::datadog; +use datadog_api_client::datadogV1::api_dashboards::DashboardsAPI; +use datadog_api_client::datadogV1::model::BarChartWidgetDefinition; +use datadog_api_client::datadogV1::model::BarChartWidgetDefinitionType; +use datadog_api_client::datadogV1::model::BarChartWidgetDisplay; +use datadog_api_client::datadogV1::model::BarChartWidgetLegend; +use datadog_api_client::datadogV1::model::BarChartWidgetRequest; +use datadog_api_client::datadogV1::model::BarChartWidgetScaling; +use datadog_api_client::datadogV1::model::BarChartWidgetStacked; +use datadog_api_client::datadogV1::model::BarChartWidgetStackedType; +use datadog_api_client::datadogV1::model::BarChartWidgetStyle; +use datadog_api_client::datadogV1::model::Dashboard; +use datadog_api_client::datadogV1::model::DashboardLayoutType; +use datadog_api_client::datadogV1::model::FormulaAndFunctionMetricAggregation; +use datadog_api_client::datadogV1::model::FormulaAndFunctionMetricDataSource; +use datadog_api_client::datadogV1::model::FormulaAndFunctionMetricQueryDefinition; +use datadog_api_client::datadogV1::model::FormulaAndFunctionQueryDefinition; +use datadog_api_client::datadogV1::model::FormulaAndFunctionResponseFormat; +use datadog_api_client::datadogV1::model::GroupType; +use datadog_api_client::datadogV1::model::Widget; +use datadog_api_client::datadogV1::model::WidgetDefinition; +use datadog_api_client::datadogV1::model::WidgetFormula; +use datadog_api_client::datadogV1::model::WidgetGroupSort; +use datadog_api_client::datadogV1::model::WidgetLayout; +use datadog_api_client::datadogV1::model::WidgetLegacyLiveSpan; +use datadog_api_client::datadogV1::model::WidgetSort; +use datadog_api_client::datadogV1::model::WidgetSortBy; +use datadog_api_client::datadogV1::model::WidgetSortOrderBy; +use datadog_api_client::datadogV1::model::WidgetTextAlign; +use datadog_api_client::datadogV1::model::WidgetTime; + +#[tokio::main] +async fn main() { + let body = + Dashboard::new( + DashboardLayoutType::FREE, + "Example-Dashboard".to_string(), + vec![ + Widget::new( + WidgetDefinition::BarChartWidgetDefinition( + Box::new( + BarChartWidgetDefinition::new( + vec![ + BarChartWidgetRequest::new() + .formulas(vec![WidgetFormula::new("query1".to_string())]) + .queries( + vec![ + FormulaAndFunctionQueryDefinition + ::FormulaAndFunctionMetricQueryDefinition( + Box::new( + FormulaAndFunctionMetricQueryDefinition::new( + FormulaAndFunctionMetricDataSource::METRICS, + "query1".to_string(), + "avg:system.cpu.user{*} by {service}".to_string(), + ).aggregator(FormulaAndFunctionMetricAggregation::AVG), + ), + ) + ], + ) + .response_format(FormulaAndFunctionResponseFormat::SCALAR) + .sort( + WidgetSortBy::new() + .count(10) + .order_by( + vec![ + WidgetSortOrderBy::WidgetGroupSort( + Box::new( + WidgetGroupSort::new( + "service".to_string(), + WidgetSort::ASCENDING, + GroupType::GROUP, + ), + ), + ) + ], + ), + ) + ], + BarChartWidgetDefinitionType::BAR_CHART, + ) + .style( + BarChartWidgetStyle::new() + .display( + BarChartWidgetDisplay::BarChartWidgetStacked( + Box::new( + BarChartWidgetStacked::new( + BarChartWidgetStackedType::STACKED, + ).legend(BarChartWidgetLegend::INLINE), + ), + ), + ) + .palette("dog_classic".to_string()) + .scaling(BarChartWidgetScaling::RELATIVE), + ) + .time(WidgetTime::WidgetLegacyLiveSpan(Box::new(WidgetLegacyLiveSpan::new()))) + .title("".to_string()) + .title_align(WidgetTextAlign::LEFT) + .title_size("16".to_string()), + ), + ), + ).layout(WidgetLayout::new(15, 47, 0, 0)) + ], + ) + .description(Some("".to_string())) + .notify_list(Some(vec![])) + .template_variables(Some(vec![])); + let configuration = datadog::Configuration::new(); + let api = DashboardsAPI::with_config(configuration); + let resp = api.create_dashboard(body).await; + if let Ok(value) = resp { + println!("{:#?}", value); + } else { + println!("{:#?}", resp.unwrap_err()); + } +} diff --git a/src/datadogV1/model/mod.rs b/src/datadogV1/model/mod.rs index 417066ecb..7275d2e6a 100644 --- a/src/datadogV1/model/mod.rs +++ b/src/datadogV1/model/mod.rs @@ -126,12 +126,12 @@ pub mod model_alert_value_widget_definition; pub use self::model_alert_value_widget_definition::AlertValueWidgetDefinition; pub mod model_alert_value_widget_definition_type; pub use self::model_alert_value_widget_definition_type::AlertValueWidgetDefinitionType; -pub mod model_change_widget_definition; -pub use self::model_change_widget_definition::ChangeWidgetDefinition; +pub mod model_bar_chart_widget_definition; +pub use self::model_bar_chart_widget_definition::BarChartWidgetDefinition; pub mod model_widget_custom_link; pub use self::model_widget_custom_link::WidgetCustomLink; -pub mod model_change_widget_request; -pub use self::model_change_widget_request::ChangeWidgetRequest; +pub mod model_bar_chart_widget_request; +pub use self::model_bar_chart_widget_request::BarChartWidgetRequest; pub mod model_log_query_definition; pub use self::model_log_query_definition::LogQueryDefinition; pub mod model_logs_query_compute; @@ -144,10 +144,12 @@ pub mod model_widget_sort; pub use self::model_widget_sort::WidgetSort; pub mod model_log_query_definition_search; pub use self::model_log_query_definition_search::LogQueryDefinitionSearch; -pub mod model_widget_change_type; -pub use self::model_widget_change_type::WidgetChangeType; -pub mod model_widget_compare_to; -pub use self::model_widget_compare_to::WidgetCompareTo; +pub mod model_widget_conditional_format; +pub use self::model_widget_conditional_format::WidgetConditionalFormat; +pub mod model_widget_comparator; +pub use self::model_widget_comparator::WidgetComparator; +pub mod model_widget_palette; +pub use self::model_widget_palette::WidgetPalette; pub mod model_widget_formula; pub use self::model_widget_formula::WidgetFormula; pub mod model_table_widget_cell_display_mode; @@ -158,12 +160,6 @@ pub mod model_widget_formula_cell_display_mode_options_trend_type; pub use self::model_widget_formula_cell_display_mode_options_trend_type::WidgetFormulaCellDisplayModeOptionsTrendType; pub mod model_widget_formula_cell_display_mode_options_y_scale; pub use self::model_widget_formula_cell_display_mode_options_y_scale::WidgetFormulaCellDisplayModeOptionsYScale; -pub mod model_widget_conditional_format; -pub use self::model_widget_conditional_format::WidgetConditionalFormat; -pub mod model_widget_comparator; -pub use self::model_widget_comparator::WidgetComparator; -pub mod model_widget_palette; -pub use self::model_widget_palette::WidgetPalette; pub mod model_widget_formula_limit; pub use self::model_widget_formula_limit::WidgetFormulaLimit; pub mod model_query_sort_order; @@ -184,8 +180,6 @@ pub mod model_number_format_unit_scale; pub use self::model_number_format_unit_scale::NumberFormatUnitScale; pub mod model_widget_formula_style; pub use self::model_widget_formula_style::WidgetFormulaStyle; -pub mod model_widget_order_by; -pub use self::model_widget_order_by::WidgetOrderBy; pub mod model_process_query_definition; pub use self::model_process_query_definition::ProcessQueryDefinition; pub mod model_formula_and_function_metric_query_definition; @@ -244,6 +238,52 @@ pub mod model_formula_and_function_query_definition; pub use self::model_formula_and_function_query_definition::FormulaAndFunctionQueryDefinition; pub mod model_formula_and_function_response_format; pub use self::model_formula_and_function_response_format::FormulaAndFunctionResponseFormat; +pub mod model_widget_sort_by; +pub use self::model_widget_sort_by::WidgetSortBy; +pub mod model_widget_formula_sort; +pub use self::model_widget_formula_sort::WidgetFormulaSort; +pub mod model_formula_type; +pub use self::model_formula_type::FormulaType; +pub mod model_widget_group_sort; +pub use self::model_widget_group_sort::WidgetGroupSort; +pub mod model_group_type; +pub use self::model_group_type::GroupType; +pub mod model_widget_sort_order_by; +pub use self::model_widget_sort_order_by::WidgetSortOrderBy; +pub mod model_widget_request_style; +pub use self::model_widget_request_style::WidgetRequestStyle; +pub mod model_widget_line_type; +pub use self::model_widget_line_type::WidgetLineType; +pub mod model_widget_line_width; +pub use self::model_widget_line_width::WidgetLineWidth; +pub mod model_bar_chart_widget_style; +pub use self::model_bar_chart_widget_style::BarChartWidgetStyle; +pub mod model_bar_chart_widget_stacked; +pub use self::model_bar_chart_widget_stacked::BarChartWidgetStacked; +pub mod model_bar_chart_widget_legend; +pub use self::model_bar_chart_widget_legend::BarChartWidgetLegend; +pub mod model_bar_chart_widget_stacked_type; +pub use self::model_bar_chart_widget_stacked_type::BarChartWidgetStackedType; +pub mod model_bar_chart_widget_flat; +pub use self::model_bar_chart_widget_flat::BarChartWidgetFlat; +pub mod model_bar_chart_widget_flat_type; +pub use self::model_bar_chart_widget_flat_type::BarChartWidgetFlatType; +pub mod model_bar_chart_widget_display; +pub use self::model_bar_chart_widget_display::BarChartWidgetDisplay; +pub mod model_bar_chart_widget_scaling; +pub use self::model_bar_chart_widget_scaling::BarChartWidgetScaling; +pub mod model_bar_chart_widget_definition_type; +pub use self::model_bar_chart_widget_definition_type::BarChartWidgetDefinitionType; +pub mod model_change_widget_definition; +pub use self::model_change_widget_definition::ChangeWidgetDefinition; +pub mod model_change_widget_request; +pub use self::model_change_widget_request::ChangeWidgetRequest; +pub mod model_widget_change_type; +pub use self::model_widget_change_type::WidgetChangeType; +pub mod model_widget_compare_to; +pub use self::model_widget_compare_to::WidgetCompareTo; +pub mod model_widget_order_by; +pub use self::model_widget_order_by::WidgetOrderBy; pub mod model_change_widget_definition_type; pub use self::model_change_widget_definition_type::ChangeWidgetDefinitionType; pub mod model_check_status_widget_definition; @@ -324,18 +364,6 @@ pub mod model_list_stream_group_by_items; pub use self::model_list_stream_group_by_items::ListStreamGroupByItems; pub mod model_widget_field_sort; pub use self::model_widget_field_sort::WidgetFieldSort; -pub mod model_widget_sort_by; -pub use self::model_widget_sort_by::WidgetSortBy; -pub mod model_widget_formula_sort; -pub use self::model_widget_formula_sort::WidgetFormulaSort; -pub mod model_formula_type; -pub use self::model_formula_type::FormulaType; -pub mod model_widget_group_sort; -pub use self::model_widget_group_sort::WidgetGroupSort; -pub mod model_group_type; -pub use self::model_group_type::GroupType; -pub mod model_widget_sort_order_by; -pub use self::model_widget_sort_order_by::WidgetSortOrderBy; pub mod model_geomap_widget_definition_style; pub use self::model_geomap_widget_definition_style::GeomapWidgetDefinitionStyle; pub mod model_geomap_widget_definition_type; @@ -548,12 +576,6 @@ pub mod model_widget_display_type; pub use self::model_widget_display_type::WidgetDisplayType; pub mod model_timeseries_widget_expression_alias; pub use self::model_timeseries_widget_expression_alias::TimeseriesWidgetExpressionAlias; -pub mod model_widget_request_style; -pub use self::model_widget_request_style::WidgetRequestStyle; -pub mod model_widget_line_type; -pub use self::model_widget_line_type::WidgetLineType; -pub mod model_widget_line_width; -pub use self::model_widget_line_width::WidgetLineWidth; pub mod model_timeseries_widget_definition_type; pub use self::model_timeseries_widget_definition_type::TimeseriesWidgetDefinitionType; pub mod model_toplist_widget_definition; diff --git a/src/datadogV1/model/model_bar_chart_widget_definition.rs b/src/datadogV1/model/model_bar_chart_widget_definition.rs new file mode 100644 index 000000000..2fc77f7f4 --- /dev/null +++ b/src/datadogV1/model/model_bar_chart_widget_definition.rs @@ -0,0 +1,236 @@ +// 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}; + +/// The bar chart visualization displays categorical data using vertical bars, allowing you to compare values across different groups. +#[non_exhaustive] +#[skip_serializing_none] +#[derive(Clone, Debug, PartialEq, Serialize)] +pub struct BarChartWidgetDefinition { + /// List of custom links. + #[serde(rename = "custom_links")] + pub custom_links: Option>, + /// List of bar chart widget requests. + #[serde(rename = "requests")] + pub requests: Vec, + /// Style customization for a bar chart widget. + #[serde(rename = "style")] + pub style: Option, + /// Time setting for the widget. + #[serde(rename = "time")] + pub time: Option, + /// Title of your widget. + #[serde(rename = "title")] + pub title: Option, + /// How to align the text on the widget. + #[serde(rename = "title_align")] + pub title_align: Option, + /// Size of the title. + #[serde(rename = "title_size")] + pub title_size: Option, + /// Type of the bar chart widget. + #[serde(rename = "type")] + pub type_: crate::datadogV1::model::BarChartWidgetDefinitionType, + #[serde(flatten)] + pub additional_properties: std::collections::BTreeMap, + #[serde(skip)] + #[serde(default)] + pub(crate) _unparsed: bool, +} + +impl BarChartWidgetDefinition { + pub fn new( + requests: Vec, + type_: crate::datadogV1::model::BarChartWidgetDefinitionType, + ) -> BarChartWidgetDefinition { + BarChartWidgetDefinition { + custom_links: None, + requests, + style: None, + time: None, + title: None, + title_align: None, + title_size: None, + type_, + additional_properties: std::collections::BTreeMap::new(), + _unparsed: false, + } + } + + pub fn custom_links(mut self, value: Vec) -> Self { + self.custom_links = Some(value); + self + } + + pub fn style(mut self, value: crate::datadogV1::model::BarChartWidgetStyle) -> Self { + self.style = Some(value); + self + } + + pub fn time(mut self, value: crate::datadogV1::model::WidgetTime) -> Self { + self.time = Some(value); + self + } + + pub fn title(mut self, value: String) -> Self { + self.title = Some(value); + self + } + + pub fn title_align(mut self, value: crate::datadogV1::model::WidgetTextAlign) -> Self { + self.title_align = Some(value); + self + } + + pub fn title_size(mut self, value: String) -> Self { + self.title_size = Some(value); + self + } + + pub fn additional_properties( + mut self, + value: std::collections::BTreeMap, + ) -> Self { + self.additional_properties = value; + self + } +} + +impl<'de> Deserialize<'de> for BarChartWidgetDefinition { + fn deserialize(deserializer: D) -> Result + where + D: Deserializer<'de>, + { + struct BarChartWidgetDefinitionVisitor; + impl<'a> Visitor<'a> for BarChartWidgetDefinitionVisitor { + type Value = BarChartWidgetDefinition; + + 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 custom_links: Option> = None; + let mut requests: Option> = + None; + let mut style: Option = None; + let mut time: Option = None; + let mut title: Option = None; + let mut title_align: Option = None; + let mut title_size: 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() { + "custom_links" => { + if v.is_null() { + continue; + } + custom_links = + Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + "requests" => { + requests = Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + "style" => { + if v.is_null() { + continue; + } + style = Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + "time" => { + if v.is_null() { + continue; + } + time = Some(serde_json::from_value(v).map_err(M::Error::custom)?); + if let Some(ref _time) = time { + match _time { + crate::datadogV1::model::WidgetTime::UnparsedObject(_time) => { + _unparsed = true; + } + _ => {} + } + } + } + "title" => { + if v.is_null() { + continue; + } + title = Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + "title_align" => { + if v.is_null() { + continue; + } + title_align = + Some(serde_json::from_value(v).map_err(M::Error::custom)?); + if let Some(ref _title_align) = title_align { + match _title_align { + crate::datadogV1::model::WidgetTextAlign::UnparsedObject( + _title_align, + ) => { + _unparsed = true; + } + _ => {} + } + } + } + "title_size" => { + if v.is_null() { + continue; + } + title_size = 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::BarChartWidgetDefinitionType::UnparsedObject(_type_) => { + _unparsed = true; + }, + _ => {} + } + } + } + &_ => { + if let Ok(value) = serde_json::from_value(v.clone()) { + additional_properties.insert(k, value); + } + } + } + } + let requests = requests.ok_or_else(|| M::Error::missing_field("requests"))?; + let type_ = type_.ok_or_else(|| M::Error::missing_field("type_"))?; + + let content = BarChartWidgetDefinition { + custom_links, + requests, + style, + time, + title, + title_align, + title_size, + type_, + additional_properties, + _unparsed, + }; + + Ok(content) + } + } + + deserializer.deserialize_any(BarChartWidgetDefinitionVisitor) + } +} diff --git a/src/datadogV1/model/model_bar_chart_widget_definition_type.rs b/src/datadogV1/model/model_bar_chart_widget_definition_type.rs new file mode 100644 index 000000000..4e8c1cf5a --- /dev/null +++ b/src/datadogV1/model/model_bar_chart_widget_definition_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 BarChartWidgetDefinitionType { + BAR_CHART, + UnparsedObject(crate::datadog::UnparsedObject), +} + +impl ToString for BarChartWidgetDefinitionType { + fn to_string(&self) -> String { + match self { + Self::BAR_CHART => String::from("bar_chart"), + Self::UnparsedObject(v) => v.value.to_string(), + } + } +} + +impl Serialize for BarChartWidgetDefinitionType { + 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 BarChartWidgetDefinitionType { + fn deserialize(deserializer: D) -> Result + where + D: Deserializer<'de>, + { + let s: String = String::deserialize(deserializer)?; + Ok(match s.as_str() { + "bar_chart" => Self::BAR_CHART, + _ => Self::UnparsedObject(crate::datadog::UnparsedObject { + value: serde_json::Value::String(s.into()), + }), + }) + } +} diff --git a/src/datadogV1/model/model_bar_chart_widget_display.rs b/src/datadogV1/model/model_bar_chart_widget_display.rs new file mode 100644 index 000000000..540991048 --- /dev/null +++ b/src/datadogV1/model/model_bar_chart_widget_display.rs @@ -0,0 +1,41 @@ +// 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}; + +/// Bar chart widget display options. +#[non_exhaustive] +#[derive(Clone, Debug, PartialEq, Serialize)] +#[serde(untagged)] +pub enum BarChartWidgetDisplay { + BarChartWidgetStacked(Box), + BarChartWidgetFlat(Box), + UnparsedObject(crate::datadog::UnparsedObject), +} + +impl<'de> Deserialize<'de> for BarChartWidgetDisplay { + 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(BarChartWidgetDisplay::BarChartWidgetStacked(_v)); + } + } + if let Ok(_v) = serde_json::from_value::>( + value.clone(), + ) { + if !_v._unparsed { + return Ok(BarChartWidgetDisplay::BarChartWidgetFlat(_v)); + } + } + + return Ok(BarChartWidgetDisplay::UnparsedObject( + crate::datadog::UnparsedObject { value }, + )); + } +} diff --git a/src/datadogV1/model/model_bar_chart_widget_flat.rs b/src/datadogV1/model/model_bar_chart_widget_flat.rs new file mode 100644 index 000000000..e612593d4 --- /dev/null +++ b/src/datadogV1/model/model_bar_chart_widget_flat.rs @@ -0,0 +1,100 @@ +// 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}; + +/// Bar chart widget flat display. +#[non_exhaustive] +#[skip_serializing_none] +#[derive(Clone, Debug, PartialEq, Serialize)] +pub struct BarChartWidgetFlat { + /// Bar chart widget flat display type. + #[serde(rename = "type")] + pub type_: crate::datadogV1::model::BarChartWidgetFlatType, + #[serde(flatten)] + pub additional_properties: std::collections::BTreeMap, + #[serde(skip)] + #[serde(default)] + pub(crate) _unparsed: bool, +} + +impl BarChartWidgetFlat { + pub fn new(type_: crate::datadogV1::model::BarChartWidgetFlatType) -> BarChartWidgetFlat { + BarChartWidgetFlat { + 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 BarChartWidgetFlat { + fn deserialize(deserializer: D) -> Result + where + D: Deserializer<'de>, + { + struct BarChartWidgetFlatVisitor; + impl<'a> Visitor<'a> for BarChartWidgetFlatVisitor { + type Value = BarChartWidgetFlat; + + 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 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::BarChartWidgetFlatType::UnparsedObject(_type_) => { + _unparsed = true; + }, + _ => {} + } + } + } + &_ => { + 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 content = BarChartWidgetFlat { + type_, + additional_properties, + _unparsed, + }; + + Ok(content) + } + } + + deserializer.deserialize_any(BarChartWidgetFlatVisitor) + } +} diff --git a/src/datadogV1/model/model_bar_chart_widget_flat_type.rs b/src/datadogV1/model/model_bar_chart_widget_flat_type.rs new file mode 100644 index 000000000..3c7e78d02 --- /dev/null +++ b/src/datadogV1/model/model_bar_chart_widget_flat_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 BarChartWidgetFlatType { + FLAT, + UnparsedObject(crate::datadog::UnparsedObject), +} + +impl ToString for BarChartWidgetFlatType { + fn to_string(&self) -> String { + match self { + Self::FLAT => String::from("flat"), + Self::UnparsedObject(v) => v.value.to_string(), + } + } +} + +impl Serialize for BarChartWidgetFlatType { + 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 BarChartWidgetFlatType { + fn deserialize(deserializer: D) -> Result + where + D: Deserializer<'de>, + { + let s: String = String::deserialize(deserializer)?; + Ok(match s.as_str() { + "flat" => Self::FLAT, + _ => Self::UnparsedObject(crate::datadog::UnparsedObject { + value: serde_json::Value::String(s.into()), + }), + }) + } +} diff --git a/src/datadogV1/model/model_bar_chart_widget_legend.rs b/src/datadogV1/model/model_bar_chart_widget_legend.rs new file mode 100644 index 000000000..64baf82d6 --- /dev/null +++ b/src/datadogV1/model/model_bar_chart_widget_legend.rs @@ -0,0 +1,54 @@ +// 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 BarChartWidgetLegend { + AUTOMATIC, + INLINE, + NONE, + UnparsedObject(crate::datadog::UnparsedObject), +} + +impl ToString for BarChartWidgetLegend { + fn to_string(&self) -> String { + match self { + Self::AUTOMATIC => String::from("automatic"), + Self::INLINE => String::from("inline"), + Self::NONE => String::from("none"), + Self::UnparsedObject(v) => v.value.to_string(), + } + } +} + +impl Serialize for BarChartWidgetLegend { + 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 BarChartWidgetLegend { + fn deserialize(deserializer: D) -> Result + where + D: Deserializer<'de>, + { + let s: String = String::deserialize(deserializer)?; + Ok(match s.as_str() { + "automatic" => Self::AUTOMATIC, + "inline" => Self::INLINE, + "none" => Self::NONE, + _ => Self::UnparsedObject(crate::datadog::UnparsedObject { + value: serde_json::Value::String(s.into()), + }), + }) + } +} diff --git a/src/datadogV1/model/model_bar_chart_widget_request.rs b/src/datadogV1/model/model_bar_chart_widget_request.rs new file mode 100644 index 000000000..10debd846 --- /dev/null +++ b/src/datadogV1/model/model_bar_chart_widget_request.rs @@ -0,0 +1,396 @@ +// 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}; + +/// Updated bar chart widget. +#[non_exhaustive] +#[skip_serializing_none] +#[derive(Clone, Debug, PartialEq, Serialize)] +pub struct BarChartWidgetRequest { + /// The log query. + #[serde(rename = "apm_query")] + pub apm_query: Option, + /// The log query. + #[serde(rename = "audit_query")] + pub audit_query: Option, + /// List of conditional formats. + #[serde(rename = "conditional_formats")] + pub conditional_formats: Option>, + /// The log query. + #[serde(rename = "event_query")] + pub event_query: Option, + /// List of formulas that operate on queries. + #[serde(rename = "formulas")] + pub formulas: Option>, + /// The log query. + #[serde(rename = "log_query")] + pub log_query: Option, + /// The log query. + #[serde(rename = "network_query")] + pub network_query: Option, + /// The process query to use in the widget. + #[serde(rename = "process_query")] + pub process_query: Option, + /// The log query. + #[serde(rename = "profile_metrics_query")] + pub profile_metrics_query: Option, + /// Widget query. + #[serde(rename = "q")] + pub q: Option, + /// List of queries that can be returned directly or used in formulas. + #[serde(rename = "queries")] + pub queries: Option>, + /// Timeseries, scalar, or event list response. Event list response formats are supported by Geomap widgets. + #[serde(rename = "response_format")] + pub response_format: Option, + /// The log query. + #[serde(rename = "rum_query")] + pub rum_query: Option, + /// The log query. + #[serde(rename = "security_query")] + pub security_query: Option, + /// The controls for sorting the widget. + #[serde(rename = "sort")] + pub sort: Option, + /// Define request widget style. + #[serde(rename = "style")] + pub style: Option, + #[serde(flatten)] + pub additional_properties: std::collections::BTreeMap, + #[serde(skip)] + #[serde(default)] + pub(crate) _unparsed: bool, +} + +impl BarChartWidgetRequest { + pub fn new() -> BarChartWidgetRequest { + BarChartWidgetRequest { + apm_query: None, + audit_query: None, + conditional_formats: None, + event_query: None, + formulas: None, + log_query: None, + network_query: None, + process_query: None, + profile_metrics_query: None, + q: None, + queries: None, + response_format: None, + rum_query: None, + security_query: None, + sort: None, + style: None, + additional_properties: std::collections::BTreeMap::new(), + _unparsed: false, + } + } + + pub fn apm_query(mut self, value: crate::datadogV1::model::LogQueryDefinition) -> Self { + self.apm_query = Some(value); + self + } + + pub fn audit_query(mut self, value: crate::datadogV1::model::LogQueryDefinition) -> Self { + self.audit_query = Some(value); + self + } + + pub fn conditional_formats( + mut self, + value: Vec, + ) -> Self { + self.conditional_formats = Some(value); + self + } + + pub fn event_query(mut self, value: crate::datadogV1::model::LogQueryDefinition) -> Self { + self.event_query = Some(value); + self + } + + pub fn formulas(mut self, value: Vec) -> Self { + self.formulas = Some(value); + self + } + + pub fn log_query(mut self, value: crate::datadogV1::model::LogQueryDefinition) -> Self { + self.log_query = Some(value); + self + } + + pub fn network_query(mut self, value: crate::datadogV1::model::LogQueryDefinition) -> Self { + self.network_query = Some(value); + self + } + + pub fn process_query(mut self, value: crate::datadogV1::model::ProcessQueryDefinition) -> Self { + self.process_query = Some(value); + self + } + + pub fn profile_metrics_query( + mut self, + value: crate::datadogV1::model::LogQueryDefinition, + ) -> Self { + self.profile_metrics_query = Some(value); + self + } + + pub fn q(mut self, value: String) -> Self { + self.q = Some(value); + self + } + + pub fn queries( + mut self, + value: Vec, + ) -> Self { + self.queries = Some(value); + self + } + + pub fn response_format( + mut self, + value: crate::datadogV1::model::FormulaAndFunctionResponseFormat, + ) -> Self { + self.response_format = Some(value); + self + } + + pub fn rum_query(mut self, value: crate::datadogV1::model::LogQueryDefinition) -> Self { + self.rum_query = Some(value); + self + } + + pub fn security_query(mut self, value: crate::datadogV1::model::LogQueryDefinition) -> Self { + self.security_query = Some(value); + self + } + + pub fn sort(mut self, value: crate::datadogV1::model::WidgetSortBy) -> Self { + self.sort = Some(value); + self + } + + pub fn style(mut self, value: crate::datadogV1::model::WidgetRequestStyle) -> Self { + self.style = Some(value); + self + } + + pub fn additional_properties( + mut self, + value: std::collections::BTreeMap, + ) -> Self { + self.additional_properties = value; + self + } +} + +impl Default for BarChartWidgetRequest { + fn default() -> Self { + Self::new() + } +} + +impl<'de> Deserialize<'de> for BarChartWidgetRequest { + fn deserialize(deserializer: D) -> Result + where + D: Deserializer<'de>, + { + struct BarChartWidgetRequestVisitor; + impl<'a> Visitor<'a> for BarChartWidgetRequestVisitor { + type Value = BarChartWidgetRequest; + + 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 apm_query: Option = None; + let mut audit_query: Option = None; + let mut conditional_formats: Option< + Vec, + > = None; + let mut event_query: Option = None; + let mut formulas: Option> = None; + let mut log_query: Option = None; + let mut network_query: Option = None; + let mut process_query: Option = + None; + let mut profile_metrics_query: Option = + None; + let mut q: Option = None; + let mut queries: Option< + Vec, + > = None; + let mut response_format: Option< + crate::datadogV1::model::FormulaAndFunctionResponseFormat, + > = None; + let mut rum_query: Option = None; + let mut security_query: Option = None; + let mut sort: Option = None; + let mut style: 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() { + "apm_query" => { + if v.is_null() { + continue; + } + apm_query = Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + "audit_query" => { + if v.is_null() { + continue; + } + audit_query = + Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + "conditional_formats" => { + if v.is_null() { + continue; + } + conditional_formats = + Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + "event_query" => { + if v.is_null() { + continue; + } + event_query = + Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + "formulas" => { + if v.is_null() { + continue; + } + formulas = Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + "log_query" => { + if v.is_null() { + continue; + } + log_query = Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + "network_query" => { + if v.is_null() { + continue; + } + network_query = + Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + "process_query" => { + if v.is_null() { + continue; + } + process_query = + Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + "profile_metrics_query" => { + if v.is_null() { + continue; + } + profile_metrics_query = + Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + "q" => { + if v.is_null() { + continue; + } + q = Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + "queries" => { + if v.is_null() { + continue; + } + queries = Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + "response_format" => { + if v.is_null() { + continue; + } + response_format = + Some(serde_json::from_value(v).map_err(M::Error::custom)?); + if let Some(ref _response_format) = response_format { + match _response_format { + crate::datadogV1::model::FormulaAndFunctionResponseFormat::UnparsedObject(_response_format) => { + _unparsed = true; + }, + _ => {} + } + } + } + "rum_query" => { + if v.is_null() { + continue; + } + rum_query = Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + "security_query" => { + if v.is_null() { + continue; + } + security_query = + Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + "sort" => { + if v.is_null() { + continue; + } + sort = Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + "style" => { + if v.is_null() { + continue; + } + style = 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 content = BarChartWidgetRequest { + apm_query, + audit_query, + conditional_formats, + event_query, + formulas, + log_query, + network_query, + process_query, + profile_metrics_query, + q, + queries, + response_format, + rum_query, + security_query, + sort, + style, + additional_properties, + _unparsed, + }; + + Ok(content) + } + } + + deserializer.deserialize_any(BarChartWidgetRequestVisitor) + } +} diff --git a/src/datadogV1/model/model_bar_chart_widget_scaling.rs b/src/datadogV1/model/model_bar_chart_widget_scaling.rs new file mode 100644 index 000000000..0e27a4921 --- /dev/null +++ b/src/datadogV1/model/model_bar_chart_widget_scaling.rs @@ -0,0 +1,51 @@ +// 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 BarChartWidgetScaling { + ABSOLUTE, + RELATIVE, + UnparsedObject(crate::datadog::UnparsedObject), +} + +impl ToString for BarChartWidgetScaling { + fn to_string(&self) -> String { + match self { + Self::ABSOLUTE => String::from("absolute"), + Self::RELATIVE => String::from("relative"), + Self::UnparsedObject(v) => v.value.to_string(), + } + } +} + +impl Serialize for BarChartWidgetScaling { + 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 BarChartWidgetScaling { + fn deserialize(deserializer: D) -> Result + where + D: Deserializer<'de>, + { + let s: String = String::deserialize(deserializer)?; + Ok(match s.as_str() { + "absolute" => Self::ABSOLUTE, + "relative" => Self::RELATIVE, + _ => Self::UnparsedObject(crate::datadog::UnparsedObject { + value: serde_json::Value::String(s.into()), + }), + }) + } +} diff --git a/src/datadogV1/model/model_bar_chart_widget_stacked.rs b/src/datadogV1/model/model_bar_chart_widget_stacked.rs new file mode 100644 index 000000000..e30168b9a --- /dev/null +++ b/src/datadogV1/model/model_bar_chart_widget_stacked.rs @@ -0,0 +1,125 @@ +// 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}; + +/// Bar chart widget stacked display options. +#[non_exhaustive] +#[skip_serializing_none] +#[derive(Clone, Debug, PartialEq, Serialize)] +pub struct BarChartWidgetStacked { + /// Bar chart widget stacked legend behavior. + #[serde(rename = "legend")] + pub legend: Option, + /// Bar chart widget stacked display type. + #[serde(rename = "type")] + pub type_: crate::datadogV1::model::BarChartWidgetStackedType, + #[serde(flatten)] + pub additional_properties: std::collections::BTreeMap, + #[serde(skip)] + #[serde(default)] + pub(crate) _unparsed: bool, +} + +impl BarChartWidgetStacked { + pub fn new(type_: crate::datadogV1::model::BarChartWidgetStackedType) -> BarChartWidgetStacked { + BarChartWidgetStacked { + legend: None, + type_, + additional_properties: std::collections::BTreeMap::new(), + _unparsed: false, + } + } + + pub fn legend(mut self, value: crate::datadogV1::model::BarChartWidgetLegend) -> Self { + self.legend = Some(value); + self + } + + pub fn additional_properties( + mut self, + value: std::collections::BTreeMap, + ) -> Self { + self.additional_properties = value; + self + } +} + +impl<'de> Deserialize<'de> for BarChartWidgetStacked { + fn deserialize(deserializer: D) -> Result + where + D: Deserializer<'de>, + { + struct BarChartWidgetStackedVisitor; + impl<'a> Visitor<'a> for BarChartWidgetStackedVisitor { + type Value = BarChartWidgetStacked; + + 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 legend: 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() { + "legend" => { + if v.is_null() { + continue; + } + legend = Some(serde_json::from_value(v).map_err(M::Error::custom)?); + if let Some(ref _legend) = legend { + match _legend { + crate::datadogV1::model::BarChartWidgetLegend::UnparsedObject(_legend) => { + _unparsed = true; + }, + _ => {} + } + } + } + "type" => { + type_ = Some(serde_json::from_value(v).map_err(M::Error::custom)?); + if let Some(ref _type_) = type_ { + match _type_ { + crate::datadogV1::model::BarChartWidgetStackedType::UnparsedObject(_type_) => { + _unparsed = true; + }, + _ => {} + } + } + } + &_ => { + 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 content = BarChartWidgetStacked { + legend, + type_, + additional_properties, + _unparsed, + }; + + Ok(content) + } + } + + deserializer.deserialize_any(BarChartWidgetStackedVisitor) + } +} diff --git a/src/datadogV1/model/model_bar_chart_widget_stacked_type.rs b/src/datadogV1/model/model_bar_chart_widget_stacked_type.rs new file mode 100644 index 000000000..0222975dc --- /dev/null +++ b/src/datadogV1/model/model_bar_chart_widget_stacked_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 BarChartWidgetStackedType { + STACKED, + UnparsedObject(crate::datadog::UnparsedObject), +} + +impl ToString for BarChartWidgetStackedType { + fn to_string(&self) -> String { + match self { + Self::STACKED => String::from("stacked"), + Self::UnparsedObject(v) => v.value.to_string(), + } + } +} + +impl Serialize for BarChartWidgetStackedType { + 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 BarChartWidgetStackedType { + fn deserialize(deserializer: D) -> Result + where + D: Deserializer<'de>, + { + let s: String = String::deserialize(deserializer)?; + Ok(match s.as_str() { + "stacked" => Self::STACKED, + _ => Self::UnparsedObject(crate::datadog::UnparsedObject { + value: serde_json::Value::String(s.into()), + }), + }) + } +} diff --git a/src/datadogV1/model/model_bar_chart_widget_style.rs b/src/datadogV1/model/model_bar_chart_widget_style.rs new file mode 100644 index 000000000..5891a09a2 --- /dev/null +++ b/src/datadogV1/model/model_bar_chart_widget_style.rs @@ -0,0 +1,155 @@ +// 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}; + +/// Style customization for a bar chart widget. +#[non_exhaustive] +#[skip_serializing_none] +#[derive(Clone, Debug, PartialEq, Serialize)] +pub struct BarChartWidgetStyle { + /// Bar chart widget display options. + #[serde(rename = "display")] + pub display: Option, + /// Color palette to apply to the widget. + #[serde(rename = "palette")] + pub palette: Option, + /// Bar chart widget scaling definition. + #[serde(rename = "scaling")] + pub scaling: Option, + #[serde(flatten)] + pub additional_properties: std::collections::BTreeMap, + #[serde(skip)] + #[serde(default)] + pub(crate) _unparsed: bool, +} + +impl BarChartWidgetStyle { + pub fn new() -> BarChartWidgetStyle { + BarChartWidgetStyle { + display: None, + palette: None, + scaling: None, + additional_properties: std::collections::BTreeMap::new(), + _unparsed: false, + } + } + + pub fn display(mut self, value: crate::datadogV1::model::BarChartWidgetDisplay) -> Self { + self.display = Some(value); + self + } + + pub fn palette(mut self, value: String) -> Self { + self.palette = Some(value); + self + } + + pub fn scaling(mut self, value: crate::datadogV1::model::BarChartWidgetScaling) -> Self { + self.scaling = Some(value); + self + } + + pub fn additional_properties( + mut self, + value: std::collections::BTreeMap, + ) -> Self { + self.additional_properties = value; + self + } +} + +impl Default for BarChartWidgetStyle { + fn default() -> Self { + Self::new() + } +} + +impl<'de> Deserialize<'de> for BarChartWidgetStyle { + fn deserialize(deserializer: D) -> Result + where + D: Deserializer<'de>, + { + struct BarChartWidgetStyleVisitor; + impl<'a> Visitor<'a> for BarChartWidgetStyleVisitor { + type Value = BarChartWidgetStyle; + + 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 display: Option = None; + let mut palette: Option = None; + let mut scaling: 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() { + "display" => { + if v.is_null() { + continue; + } + display = Some(serde_json::from_value(v).map_err(M::Error::custom)?); + if let Some(ref _display) = display { + match _display { + crate::datadogV1::model::BarChartWidgetDisplay::UnparsedObject(_display) => { + _unparsed = true; + }, + _ => {} + } + } + } + "palette" => { + if v.is_null() { + continue; + } + palette = Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + "scaling" => { + if v.is_null() { + continue; + } + scaling = Some(serde_json::from_value(v).map_err(M::Error::custom)?); + if let Some(ref _scaling) = scaling { + match _scaling { + crate::datadogV1::model::BarChartWidgetScaling::UnparsedObject(_scaling) => { + _unparsed = true; + }, + _ => {} + } + } + } + &_ => { + if let Ok(value) = serde_json::from_value(v.clone()) { + additional_properties.insert(k, value); + } + } + } + } + + let content = BarChartWidgetStyle { + display, + palette, + scaling, + additional_properties, + _unparsed, + }; + + Ok(content) + } + } + + deserializer.deserialize_any(BarChartWidgetStyleVisitor) + } +} diff --git a/src/datadogV1/model/model_split_graph_source_widget_definition.rs b/src/datadogV1/model/model_split_graph_source_widget_definition.rs index c71594634..5d47e3a81 100644 --- a/src/datadogV1/model/model_split_graph_source_widget_definition.rs +++ b/src/datadogV1/model/model_split_graph_source_widget_definition.rs @@ -8,6 +8,7 @@ use serde::{Deserialize, Deserializer, Serialize}; #[derive(Clone, Debug, PartialEq, Serialize)] #[serde(untagged)] pub enum SplitGraphSourceWidgetDefinition { + BarChartWidgetDefinition(Box), ChangeWidgetDefinition(Box), GeomapWidgetDefinition(Box), QueryValueWidgetDefinition(Box), @@ -26,6 +27,16 @@ impl<'de> Deserialize<'de> for SplitGraphSourceWidgetDefinition { D: Deserializer<'de>, { let value: serde_json::Value = Deserialize::deserialize(deserializer)?; + if let Ok(_v) = serde_json::from_value::< + Box, + >(value.clone()) + { + if !_v._unparsed { + return Ok(SplitGraphSourceWidgetDefinition::BarChartWidgetDefinition( + _v, + )); + } + } if let Ok(_v) = serde_json::from_value::>( value.clone(), ) { diff --git a/src/datadogV1/model/model_widget_definition.rs b/src/datadogV1/model/model_widget_definition.rs index 3e55d7e53..c5a228afe 100644 --- a/src/datadogV1/model/model_widget_definition.rs +++ b/src/datadogV1/model/model_widget_definition.rs @@ -10,6 +10,7 @@ use serde::{Deserialize, Deserializer, Serialize}; pub enum WidgetDefinition { AlertGraphWidgetDefinition(Box), AlertValueWidgetDefinition(Box), + BarChartWidgetDefinition(Box), ChangeWidgetDefinition(Box), CheckStatusWidgetDefinition(Box), DistributionWidgetDefinition(Box), @@ -67,6 +68,14 @@ impl<'de> Deserialize<'de> for WidgetDefinition { return Ok(WidgetDefinition::AlertValueWidgetDefinition(_v)); } } + if let Ok(_v) = serde_json::from_value::< + Box, + >(value.clone()) + { + if !_v._unparsed { + return Ok(WidgetDefinition::BarChartWidgetDefinition(_v)); + } + } if let Ok(_v) = serde_json::from_value::>( value.clone(), ) { diff --git a/tests/scenarios/cassettes/v1/dashboards/Create-a-new-dashboard-with-a-bar-chart-widget-with-stacked-type-and-no-legend-specified.frozen b/tests/scenarios/cassettes/v1/dashboards/Create-a-new-dashboard-with-a-bar-chart-widget-with-stacked-type-and-no-legend-specified.frozen new file mode 100644 index 000000000..4e9d15c6a --- /dev/null +++ b/tests/scenarios/cassettes/v1/dashboards/Create-a-new-dashboard-with-a-bar-chart-widget-with-stacked-type-and-no-legend-specified.frozen @@ -0,0 +1 @@ +2025-12-04T22:02:41.715Z \ No newline at end of file diff --git a/tests/scenarios/cassettes/v1/dashboards/Create-a-new-dashboard-with-a-bar-chart-widget-with-stacked-type-and-no-legend-specified.json b/tests/scenarios/cassettes/v1/dashboards/Create-a-new-dashboard-with-a-bar-chart-widget-with-stacked-type-and-no-legend-specified.json new file mode 100644 index 000000000..a0d41f86d --- /dev/null +++ b/tests/scenarios/cassettes/v1/dashboards/Create-a-new-dashboard-with-a-bar-chart-widget-with-stacked-type-and-no-legend-specified.json @@ -0,0 +1,67 @@ +{ + "http_interactions": [ + { + "request": { + "body": { + "string": "{\"description\":\"\",\"layout_type\":\"free\",\"notify_list\":[],\"template_variables\":[],\"title\":\"Test-Create_a_new_dashboard_with_a_bar_chart_widget_with_stacked_type_and_no_legend_specified-1764885761\",\"widgets\":[{\"definition\":{\"requests\":[{\"formulas\":[{\"formula\":\"query1\"}],\"queries\":[{\"aggregator\":\"avg\",\"data_source\":\"metrics\",\"name\":\"query1\",\"query\":\"avg:system.cpu.user{*} by {service}\"}],\"response_format\":\"scalar\",\"sort\":{\"count\":10,\"order_by\":[{\"name\":\"service\",\"order\":\"asc\",\"type\":\"group\"}]}}],\"style\":{\"display\":{\"type\":\"stacked\"},\"palette\":\"dog_classic\",\"scaling\":\"relative\"},\"time\":{},\"title\":\"\",\"title_align\":\"left\",\"title_size\":\"16\",\"type\":\"bar_chart\"},\"layout\":{\"height\":15,\"width\":47,\"x\":0,\"y\":0}}]}", + "encoding": null + }, + "headers": { + "Accept": [ + "application/json" + ], + "Content-Type": [ + "application/json" + ] + }, + "method": "post", + "uri": "https://api.datadoghq.com/api/v1/dashboard" + }, + "response": { + "body": { + "string": "{\"id\":\"a33-2hy-5uc\",\"title\":\"Test-Create_a_new_dashboard_with_a_bar_chart_widget_with_stacked_type_and_no_legend_specified-1764885761\",\"description\":\"\",\"author_handle\":\"jessica.sylvester@datadoghq.com\",\"author_name\":\"Jessica Sylvester\",\"layout_type\":\"free\",\"url\":\"/dashboard/a33-2hy-5uc/test-createanewdashboardwithabarchartwidgetwithstackedtypeandnolegendspecified-1\",\"template_variables\":[],\"widgets\":[{\"definition\":{\"requests\":[{\"formulas\":[{\"formula\":\"query1\"}],\"queries\":[{\"aggregator\":\"avg\",\"data_source\":\"metrics\",\"name\":\"query1\",\"query\":\"avg:system.cpu.user{*} by {service}\"}],\"response_format\":\"scalar\",\"sort\":{\"count\":10,\"order_by\":[{\"name\":\"service\",\"order\":\"asc\",\"type\":\"group\"}]}}],\"style\":{\"display\":{\"type\":\"stacked\"},\"palette\":\"dog_classic\",\"scaling\":\"relative\"},\"time\":{},\"title\":\"\",\"title_align\":\"left\",\"title_size\":\"16\",\"type\":\"bar_chart\"},\"layout\":{\"height\":15,\"width\":47,\"x\":0,\"y\":0},\"id\":7787234913675513}],\"notify_list\":[],\"created_at\":\"2025-12-04T22:02:41.934642+00:00\",\"modified_at\":\"2025-12-04T22:02:41.934642+00:00\",\"restricted_roles\":[]}", + "encoding": null + }, + "headers": { + "Content-Type": [ + "application/json" + ] + }, + "status": { + "code": 200, + "message": "OK" + } + }, + "recorded_at": "Thu, 04 Dec 2025 22:02:41 GMT" + }, + { + "request": { + "body": "", + "headers": { + "Accept": [ + "application/json" + ] + }, + "method": "delete", + "uri": "https://api.datadoghq.com/api/v1/dashboard/a33-2hy-5uc" + }, + "response": { + "body": { + "string": "{\"deleted_dashboard_id\":\"a33-2hy-5uc\"}", + "encoding": null + }, + "headers": { + "Content-Type": [ + "application/json" + ] + }, + "status": { + "code": 200, + "message": "OK" + } + }, + "recorded_at": "Thu, 04 Dec 2025 22:02:41 GMT" + } + ], + "recorded_with": "VCR 6.0.0" +} \ No newline at end of file diff --git a/tests/scenarios/cassettes/v1/dashboards/Create-a-new-dashboard-with-bar-chart-widget-sorted-by-group.frozen b/tests/scenarios/cassettes/v1/dashboards/Create-a-new-dashboard-with-bar-chart-widget-sorted-by-group.frozen new file mode 100644 index 000000000..035786094 --- /dev/null +++ b/tests/scenarios/cassettes/v1/dashboards/Create-a-new-dashboard-with-bar-chart-widget-sorted-by-group.frozen @@ -0,0 +1 @@ +2025-12-04T22:02:43.230Z \ No newline at end of file diff --git a/tests/scenarios/cassettes/v1/dashboards/Create-a-new-dashboard-with-bar-chart-widget-sorted-by-group.json b/tests/scenarios/cassettes/v1/dashboards/Create-a-new-dashboard-with-bar-chart-widget-sorted-by-group.json new file mode 100644 index 000000000..ea25de644 --- /dev/null +++ b/tests/scenarios/cassettes/v1/dashboards/Create-a-new-dashboard-with-bar-chart-widget-sorted-by-group.json @@ -0,0 +1,67 @@ +{ + "http_interactions": [ + { + "request": { + "body": { + "string": "{\"description\":\"\",\"layout_type\":\"free\",\"notify_list\":[],\"template_variables\":[],\"title\":\"Test-Create_a_new_dashboard_with_bar_chart_widget_sorted_by_group-1764885763\",\"widgets\":[{\"definition\":{\"requests\":[{\"formulas\":[{\"formula\":\"query1\"}],\"queries\":[{\"aggregator\":\"avg\",\"data_source\":\"metrics\",\"name\":\"query1\",\"query\":\"avg:system.cpu.user{*} by {service}\"}],\"response_format\":\"scalar\",\"sort\":{\"count\":10,\"order_by\":[{\"name\":\"service\",\"order\":\"asc\",\"type\":\"group\"}]}}],\"style\":{\"display\":{\"legend\":\"inline\",\"type\":\"stacked\"},\"palette\":\"dog_classic\",\"scaling\":\"relative\"},\"time\":{},\"title\":\"\",\"title_align\":\"left\",\"title_size\":\"16\",\"type\":\"bar_chart\"},\"layout\":{\"height\":15,\"width\":47,\"x\":0,\"y\":0}}]}", + "encoding": null + }, + "headers": { + "Accept": [ + "application/json" + ], + "Content-Type": [ + "application/json" + ] + }, + "method": "post", + "uri": "https://api.datadoghq.com/api/v1/dashboard" + }, + "response": { + "body": { + "string": "{\"id\":\"apq-83m-a8z\",\"title\":\"Test-Create_a_new_dashboard_with_bar_chart_widget_sorted_by_group-1764885763\",\"description\":\"\",\"author_handle\":\"jessica.sylvester@datadoghq.com\",\"author_name\":\"Jessica Sylvester\",\"layout_type\":\"free\",\"url\":\"/dashboard/apq-83m-a8z/test-createanewdashboardwithbarchartwidgetsortedbygroup-1764885763\",\"template_variables\":[],\"widgets\":[{\"definition\":{\"requests\":[{\"formulas\":[{\"formula\":\"query1\"}],\"queries\":[{\"aggregator\":\"avg\",\"data_source\":\"metrics\",\"name\":\"query1\",\"query\":\"avg:system.cpu.user{*} by {service}\"}],\"response_format\":\"scalar\",\"sort\":{\"count\":10,\"order_by\":[{\"name\":\"service\",\"order\":\"asc\",\"type\":\"group\"}]}}],\"style\":{\"display\":{\"legend\":\"inline\",\"type\":\"stacked\"},\"palette\":\"dog_classic\",\"scaling\":\"relative\"},\"time\":{},\"title\":\"\",\"title_align\":\"left\",\"title_size\":\"16\",\"type\":\"bar_chart\"},\"layout\":{\"height\":15,\"width\":47,\"x\":0,\"y\":0},\"id\":7535826278559265}],\"notify_list\":[],\"created_at\":\"2025-12-04T22:02:43.400317+00:00\",\"modified_at\":\"2025-12-04T22:02:43.400317+00:00\",\"restricted_roles\":[]}", + "encoding": null + }, + "headers": { + "Content-Type": [ + "application/json" + ] + }, + "status": { + "code": 200, + "message": "OK" + } + }, + "recorded_at": "Thu, 04 Dec 2025 22:02:43 GMT" + }, + { + "request": { + "body": "", + "headers": { + "Accept": [ + "application/json" + ] + }, + "method": "delete", + "uri": "https://api.datadoghq.com/api/v1/dashboard/apq-83m-a8z" + }, + "response": { + "body": { + "string": "{\"deleted_dashboard_id\":\"apq-83m-a8z\"}", + "encoding": null + }, + "headers": { + "Content-Type": [ + "application/json" + ] + }, + "status": { + "code": 200, + "message": "OK" + } + }, + "recorded_at": "Thu, 04 Dec 2025 22:02:43 GMT" + } + ], + "recorded_with": "VCR 6.0.0" +} \ No newline at end of file diff --git a/tests/scenarios/cassettes/v1/dashboards/Create-a-new-dashboard-with-bar-chart-widget.frozen b/tests/scenarios/cassettes/v1/dashboards/Create-a-new-dashboard-with-bar-chart-widget.frozen new file mode 100644 index 000000000..7026ef81d --- /dev/null +++ b/tests/scenarios/cassettes/v1/dashboards/Create-a-new-dashboard-with-bar-chart-widget.frozen @@ -0,0 +1 @@ +2025-12-04T22:02:42.516Z \ No newline at end of file diff --git a/tests/scenarios/cassettes/v1/dashboards/Create-a-new-dashboard-with-bar-chart-widget.json b/tests/scenarios/cassettes/v1/dashboards/Create-a-new-dashboard-with-bar-chart-widget.json new file mode 100644 index 000000000..b2df24e58 --- /dev/null +++ b/tests/scenarios/cassettes/v1/dashboards/Create-a-new-dashboard-with-bar-chart-widget.json @@ -0,0 +1,67 @@ +{ + "http_interactions": [ + { + "request": { + "body": { + "string": "{\"description\":\"\",\"layout_type\":\"free\",\"notify_list\":[],\"template_variables\":[],\"title\":\"Test-Create_a_new_dashboard_with_bar_chart_widget-1764885762\",\"widgets\":[{\"definition\":{\"requests\":[{\"formulas\":[{\"formula\":\"query1\"}],\"queries\":[{\"aggregator\":\"avg\",\"data_source\":\"metrics\",\"name\":\"query1\",\"query\":\"avg:system.cpu.user{*} by {service}\"}],\"response_format\":\"scalar\",\"sort\":{\"count\":10,\"order_by\":[{\"index\":0,\"order\":\"desc\",\"type\":\"formula\"}]}}],\"style\":{\"display\":{\"legend\":\"inline\",\"type\":\"stacked\"},\"palette\":\"dog_classic\",\"scaling\":\"relative\"},\"time\":{},\"title\":\"\",\"title_align\":\"left\",\"title_size\":\"16\",\"type\":\"bar_chart\"},\"layout\":{\"height\":15,\"width\":47,\"x\":0,\"y\":0}}]}", + "encoding": null + }, + "headers": { + "Accept": [ + "application/json" + ], + "Content-Type": [ + "application/json" + ] + }, + "method": "post", + "uri": "https://api.datadoghq.com/api/v1/dashboard" + }, + "response": { + "body": { + "string": "{\"id\":\"4yw-ryc-3a7\",\"title\":\"Test-Create_a_new_dashboard_with_bar_chart_widget-1764885762\",\"description\":\"\",\"author_handle\":\"jessica.sylvester@datadoghq.com\",\"author_name\":\"Jessica Sylvester\",\"layout_type\":\"free\",\"url\":\"/dashboard/4yw-ryc-3a7/test-createanewdashboardwithbarchartwidget-1764885762\",\"template_variables\":[],\"widgets\":[{\"definition\":{\"requests\":[{\"formulas\":[{\"formula\":\"query1\"}],\"queries\":[{\"aggregator\":\"avg\",\"data_source\":\"metrics\",\"name\":\"query1\",\"query\":\"avg:system.cpu.user{*} by {service}\"}],\"response_format\":\"scalar\",\"sort\":{\"count\":10,\"order_by\":[{\"index\":0,\"order\":\"desc\",\"type\":\"formula\"}]}}],\"style\":{\"display\":{\"legend\":\"inline\",\"type\":\"stacked\"},\"palette\":\"dog_classic\",\"scaling\":\"relative\"},\"time\":{},\"title\":\"\",\"title_align\":\"left\",\"title_size\":\"16\",\"type\":\"bar_chart\"},\"layout\":{\"height\":15,\"width\":47,\"x\":0,\"y\":0},\"id\":1213061409465696}],\"notify_list\":[],\"created_at\":\"2025-12-04T22:02:42.724028+00:00\",\"modified_at\":\"2025-12-04T22:02:42.724028+00:00\",\"restricted_roles\":[]}", + "encoding": null + }, + "headers": { + "Content-Type": [ + "application/json" + ] + }, + "status": { + "code": 200, + "message": "OK" + } + }, + "recorded_at": "Thu, 04 Dec 2025 22:02:42 GMT" + }, + { + "request": { + "body": "", + "headers": { + "Accept": [ + "application/json" + ] + }, + "method": "delete", + "uri": "https://api.datadoghq.com/api/v1/dashboard/4yw-ryc-3a7" + }, + "response": { + "body": { + "string": "{\"deleted_dashboard_id\":\"4yw-ryc-3a7\"}", + "encoding": null + }, + "headers": { + "Content-Type": [ + "application/json" + ] + }, + "status": { + "code": 200, + "message": "OK" + } + }, + "recorded_at": "Thu, 04 Dec 2025 22:02:42 GMT" + } + ], + "recorded_with": "VCR 6.0.0" +} \ No newline at end of file diff --git a/tests/scenarios/features/v1/dashboards.feature b/tests/scenarios/features/v1/dashboards.feature index 0d161522e..01de44939 100644 --- a/tests/scenarios/features/v1/dashboards.feature +++ b/tests/scenarios/features/v1/dashboards.feature @@ -90,6 +90,19 @@ Feature: Dashboards And the response "widgets[0].definition.requests[0].profile_metrics_query.compute.facet" is equal to "@prof_core_cpu_cores" And the response "widgets[0].definition.requests[0].profile_metrics_query.compute.aggregation" is equal to "sum" + @skip-terraform-config @skip-typescript @team:DataDog/dashboards-backend + Scenario: Create a new dashboard with a bar_chart widget with stacked type and no legend specified + Given new "CreateDashboard" request + And body with value {"title":"{{ unique }}","description":"","widgets":[{"layout":{"x":0,"y":0,"width":47,"height":15},"definition":{"title":"","title_size":"16","title_align":"left","time":{},"style":{"display": {"type": "stacked"},"scaling": "relative","palette": "dog_classic"},"type":"bar_chart","requests":[{"queries":[{"data_source":"metrics","name":"query1","query":"avg:system.cpu.user{*} by {service}","aggregator":"avg"}],"formulas":[{"formula":"query1"}],"sort":{"count":10,"order_by":[{"type":"group","name":"service","order":"asc"}]},"response_format":"scalar"}]}}],"template_variables":[],"layout_type":"free","notify_list":[]} + When the request is sent + Then the response status is 200 OK + And the response "widgets[0].definition.type" is equal to "bar_chart" + And the response "widgets[0].definition.requests[0].sort.order_by[0].order" is equal to "asc" + And the response "widgets[0].definition.requests[0].sort.order_by[0].type" is equal to "group" + And the response "widgets[0].definition.requests[0].sort.order_by[0].name" is equal to "service" + And the response "widgets[0].definition.style.display.type" is equal to "stacked" + And the response "widgets[0].definition.style.display" does not have field "legend" + @team:DataDog/dashboards-backend Scenario: Create a new dashboard with a change widget using formulas and functions slo query Given there is a valid "slo" in the system @@ -296,6 +309,28 @@ Feature: Dashboards And the response "widgets[0].definition.requests[0].columns[0].width" is equal to "auto" And the response "widgets[0].definition.requests[0].query.data_source" is equal to "apm_issue_stream" + @team:DataDog/dashboards-backend + Scenario: Create a new dashboard with bar_chart widget + Given new "CreateDashboard" request + And body from file "dashboards_json_payload/bar_chart_widget.json" + When the request is sent + Then the response status is 200 OK + And the response "widgets[0].definition.type" is equal to "bar_chart" + And the response "widgets[0].definition.requests[0].sort.order_by[0].order" is equal to "desc" + And the response "widgets[0].definition.requests[0].sort.order_by[0].type" is equal to "formula" + And the response "widgets[0].definition.requests[0].sort.order_by[0].index" is equal to 0 + + @team:DataDog/dashboards-backend + Scenario: Create a new dashboard with bar_chart widget sorted by group + Given new "CreateDashboard" request + And body with value {"title":"{{ unique }}","description":"","widgets":[{"layout":{"x":0,"y":0,"width":47,"height":15},"definition":{"title":"","title_size":"16","title_align":"left","time":{},"style":{"display": {"type": "stacked","legend": "inline"},"scaling": "relative","palette": "dog_classic"},"type":"bar_chart","requests":[{"queries":[{"data_source":"metrics","name":"query1","query":"avg:system.cpu.user{*} by {service}","aggregator":"avg"}],"formulas":[{"formula":"query1"}],"sort":{"count":10,"order_by":[{"type":"group","name":"service","order":"asc"}]},"response_format":"scalar"}]}}],"template_variables":[],"layout_type":"free","notify_list":[]} + When the request is sent + Then the response status is 200 OK + And the response "widgets[0].definition.type" is equal to "bar_chart" + And the response "widgets[0].definition.requests[0].sort.order_by[0].order" is equal to "asc" + And the response "widgets[0].definition.requests[0].sort.order_by[0].type" is equal to "group" + And the response "widgets[0].definition.requests[0].sort.order_by[0].name" is equal to "service" + @team:DataDog/dashboards-backend Scenario: Create a new dashboard with check_status widget Given new "CreateDashboard" request diff --git a/tests/scenarios/features/v1/dashboards_json_payload/bar_chart_widget.json b/tests/scenarios/features/v1/dashboards_json_payload/bar_chart_widget.json new file mode 100644 index 000000000..0fac4d091 --- /dev/null +++ b/tests/scenarios/features/v1/dashboards_json_payload/bar_chart_widget.json @@ -0,0 +1,66 @@ +{ + "title":"{{ unique }}", + "description":"", + "widgets":[ + { + "layout":{ + "x":0, + "y":0, + "width":47, + "height":15 + }, + "definition":{ + "title":"", + "title_size":"16", + "title_align":"left", + "time":{ + + }, + "style":{ + "display": { + "type": "stacked", + "legend": "inline" + }, + "scaling": "relative", + "palette": "dog_classic" + }, + "type":"bar_chart", + "requests":[ + { + "queries":[ + { + "data_source":"metrics", + "name":"query1", + "query":"avg:system.cpu.user{*} by {service}", + "aggregator":"avg" + } + ], + "formulas":[ + { + "formula":"query1" + } + ], + "sort": { + "count":10, + "order_by":[ + { + "type":"formula", + "index":0, + "order":"desc" + } + ] + }, + "response_format":"scalar" + } + ] + } + } + ], + "template_variables":[ + + ], + "layout_type":"free", + "notify_list":[ + + ] +}