## Get Evaluation Dashboard

`client.EvaluationDashboards.Get(ctx, dashboardID, query) (*EvaluationDashboard, error)`

**get** `/v5/evaluation-dashboards/{dashboard_id}`

Fetch a single dashboard by ID within the caller's account.

By default only the dashboard's own fields are returned. Pass `views=widgets`
and/or `views=widget_results` to eagerly load the dashboard's widgets and their
last-computed results as nested relationships; without those views the `widgets`
and `widget_results` fields are omitted from the response entirely. Set
`include_archived=true` to retrieve a soft-deleted dashboard. Returns a not-found
error if no matching dashboard exists in the account.

### Parameters

- `dashboardID string`

- `query EvaluationDashboardGetParams`

  - `IncludeArchived param.Field[bool]`

  - `Views param.Field[[]string]`

    Optional relationships to include: 'widgets', 'widget_results'

    - `const EvaluationDashboardGetParamsViewWidgets EvaluationDashboardGetParamsView = "widgets"`

    - `const EvaluationDashboardGetParamsViewWidgetResults EvaluationDashboardGetParamsView = "widget_results"`

### Returns

- `type EvaluationDashboard struct{…}`

  - `ID string`

    Unique identifier of the dashboard

  - `AccountID string`

    Account that owns this dashboard

  - `CreatedAt Time`

    When the dashboard was created

  - `CreatedBy Identity`

    The identity that created the entity.

    - `ID string`

    - `Type IdentityType`

      - `const IdentityTypeUser IdentityType = "user"`

      - `const IdentityTypeServiceAccount IdentityType = "service_account"`

    - `Object IdentityObject`

      - `const IdentityObjectIdentity IdentityObject = "identity"`

  - `Name string`

    Dashboard name

  - `Tags []string`

    The tags associated with the entity

  - `UpdatedAt Time`

    When the dashboard was last updated

  - `ArchivedAt Time`

    When the dashboard was archived (soft-deleted)

  - `Description string`

    Dashboard description

  - `ErrorMessage string`

    Error message if computation failed

  - `EvaluationGroupID string`

    Evaluation group ID

  - `EvaluationID string`

    Evaluation ID

  - `Object EvaluationDashboardObject`

    - `const EvaluationDashboardObjectEvaluationDashboard EvaluationDashboardObject = "evaluation_dashboard"`

  - `WidgetOrder []string`

    Ordered array of widget IDs

  - `WidgetResults []EvaluationDashboardWidgetResult`

    Widget results for this dashboard. Populated with 'widget_results' view.

    - `ID string`

      Unique identifier of the widget result

    - `AccountID string`

      Account that owns this widget result

    - `ComputationStatus EvaluationDashboardWidgetResultComputationStatus`

      Status of the computation

      - `const EvaluationDashboardWidgetResultComputationStatusPending EvaluationDashboardWidgetResultComputationStatus = "pending"`

      - `const EvaluationDashboardWidgetResultComputationStatusCompleted EvaluationDashboardWidgetResultComputationStatus = "completed"`

      - `const EvaluationDashboardWidgetResultComputationStatusFailed EvaluationDashboardWidgetResultComputationStatus = "failed"`

    - `CreatedAt Time`

      When the widget result was created

    - `WidgetID string`

      Unique identifier of the widget

    - `ComputationJobID string`

      Temporal workflow ID or job ID for async computation tracking

    - `ComputedAt Time`

      Timestamp when computation completed successfully

    - `ComputedResult map[string, any]`

      Cached computation results

    - `ErrorMessage string`

      Error message if computation failed

    - `EvaluationGroupID string`

      FK to evaluation_groups. Null if result is for a single evaluation.

    - `EvaluationID string`

      FK to evaluations. Null if result is for an evaluation group.

    - `Object EvaluationDashboardWidgetResultObject`

      - `const EvaluationDashboardWidgetResultObjectEvaluationDashboardWidgetResult EvaluationDashboardWidgetResultObject = "evaluation_dashboard_widget_result"`

    - `Widget EvaluationDashboardWidget`

      Widget that this result is for

      - `ID string`

        Unique identifier of the widget

      - `AccountID string`

        Account that owns this widget

      - `CreatedAt Time`

        When the widget was created

      - `Title string`

        Widget title

      - `Type EvaluationWidgetTypeEnum`

        Widget type

        - `const EvaluationWidgetTypeEnumBar EvaluationWidgetTypeEnum = "bar"`

        - `const EvaluationWidgetTypeEnumHistogram EvaluationWidgetTypeEnum = "histogram"`

        - `const EvaluationWidgetTypeEnumDonut EvaluationWidgetTypeEnum = "donut"`

        - `const EvaluationWidgetTypeEnumScatter EvaluationWidgetTypeEnum = "scatter"`

        - `const EvaluationWidgetTypeEnumMetric EvaluationWidgetTypeEnum = "metric"`

        - `const EvaluationWidgetTypeEnumTable EvaluationWidgetTypeEnum = "table"`

        - `const EvaluationWidgetTypeEnumMarkdown EvaluationWidgetTypeEnum = "markdown"`

        - `const EvaluationWidgetTypeEnumHeading EvaluationWidgetTypeEnum = "heading"`

        - `const EvaluationWidgetTypeEnumTimeseries EvaluationWidgetTypeEnum = "timeseries"`

      - `ArchivedAt Time`

        When the widget was archived (soft-deleted)

      - `Config map[string, any]`

        Chart-specific display configuration

      - `Object EvaluationDashboardWidgetObject`

        - `const EvaluationDashboardWidgetObjectEvaluationDashboardWidget EvaluationDashboardWidgetObject = "evaluation_dashboard_widget"`

      - `Query EvaluationDashboardWidgetQueryUnion`

        Structured query AST for metric computation (SeriesQuery or MetricQuery)

        - `type SeriesQuery struct{…}`

          Query that returns a series of records (used for table/bar/histogram/donut/scatter widgets).

          Used for widget types: table, bar, histogram, donut, scatter.
          Returns: {"type": "series", "data": [...]}

          Example SQL equivalent:
          SELECT category, AVG(score) as avg_score, COUNT(*) as count
          FROM evaluation_items
          WHERE score > 0.5 AND category = 'test'
          GROUP BY category
          ORDER BY avg_score DESC
          LIMIT 100

          - `Select []SelectItem`

            - `Expression SelectItemExpressionUnion`

              Reference to a column from evaluation_items.data

              Example:
              {"type": "COLUMN", "column": "category"}

              - `type SelectItemExpressionColumn struct{…}`

                Reference to a column from evaluation_items.data

                Example:
                {"type": "COLUMN", "column": "category"}

                - `Column string`

                  Column name from evaluation_items.data

                - `Source string`

                  Column source: 'data' or 'task_result_cache'

                - `Type string`

                  - `const SelectItemExpressionColumnTypeColumn SelectItemExpressionColumnType = "COLUMN"`

              - `type SelectItemExpressionAggregation struct{…}`

                Aggregation function to apply

                Examples:
                {"type": "AGGREGATION", "function": "AVG", "column": "score"}
                {"type": "AGGREGATION", "function": "COUNT", "column": "*"}
                {"type": "AGGREGATION", "function": "PERCENTILE", "column": "score", "params": {"percentile": 95}}

                - `Column string`

                  Column to aggregate, or '*' for COUNT(*)

                - `Function string`

                  Supported aggregation functions

                  - `const SelectItemExpressionAggregationFunctionCount SelectItemExpressionAggregationFunction = "COUNT"`

                  - `const SelectItemExpressionAggregationFunctionSum SelectItemExpressionAggregationFunction = "SUM"`

                  - `const SelectItemExpressionAggregationFunctionAvg SelectItemExpressionAggregationFunction = "AVG"`

                  - `const SelectItemExpressionAggregationFunctionMin SelectItemExpressionAggregationFunction = "MIN"`

                  - `const SelectItemExpressionAggregationFunctionMax SelectItemExpressionAggregationFunction = "MAX"`

                  - `const SelectItemExpressionAggregationFunctionStddev SelectItemExpressionAggregationFunction = "STDDEV"`

                  - `const SelectItemExpressionAggregationFunctionVariance SelectItemExpressionAggregationFunction = "VARIANCE"`

                  - `const SelectItemExpressionAggregationFunctionPercentile SelectItemExpressionAggregationFunction = "PERCENTILE"`

                  - `const SelectItemExpressionAggregationFunctionCountDistinct SelectItemExpressionAggregationFunction = "COUNT_DISTINCT"`

                  - `const SelectItemExpressionAggregationFunctionPercentage SelectItemExpressionAggregationFunction = "PERCENTAGE"`

                - `EvaluationIDs []string`

                  Optional subset of evaluation IDs for per-aggregation filtering in evaluation group dashboards.

                - `Params map[string, any]`

                  Function parameters (e.g., {'percentile': 95} for PERCENTILE, {'percentage_filters': Filter} for PERCENTAGE)

                - `Source string`

                  Column source: 'data' or 'task_result_cache'

                - `Type string`

                  - `const SelectItemExpressionAggregationTypeAggregation SelectItemExpressionAggregationType = "AGGREGATION"`

            - `Alias string`

              Optional alias for the selected item

          - `EvaluationIDs []string`

            Optional subset of evaluation IDs to compute on. Only applicable for evaluation group dashboards. If omitted, computes on all evaluations in the group.

          - `Filter Filter`

            Filter conditions (WHERE clause)

            - `Conditions []FilterCondition`

              - `Column string`

                Column name to filter on

              - `Operator string`

                Comparison operator

                - `const FilterConditionOperatorEquals FilterConditionOperator = "="`

                - `const FilterConditionOperatorNotEquals FilterConditionOperator = "!="`

                - `const FilterConditionOperatorGreater FilterConditionOperator = ">"`

                - `const FilterConditionOperatorLess FilterConditionOperator = "<"`

                - `const FilterConditionOperatorGreaterOrEquals FilterConditionOperator = ">="`

                - `const FilterConditionOperatorLessOrEquals FilterConditionOperator = "<="`

                - `const FilterConditionOperatorIn FilterConditionOperator = "IN"`

                - `const FilterConditionOperatorNotIn FilterConditionOperator = "NOT IN"`

                - `const FilterConditionOperatorLike FilterConditionOperator = "LIKE"`

                - `const FilterConditionOperatorNotLike FilterConditionOperator = "NOT LIKE"`

                - `const FilterConditionOperatorIsNull FilterConditionOperator = "IS NULL"`

                - `const FilterConditionOperatorIsNotNull FilterConditionOperator = "IS NOT NULL"`

              - `Source string`

                Column source: 'data' or 'task_result_cache'

              - `Value FilterConditionValueUnion`

                Value to compare against. Not required for IS NULL / IS NOT NULL operators.

                - `string`

                - `float64`

                - `bool`

                - `type FilterConditionValueArray []any`

            - `LogicalOperators []string`

              Logical operators connecting conditions. Length must be len(conditions) - 1

              - `const FilterLogicalOperatorAnd FilterLogicalOperator = "AND"`

              - `const FilterLogicalOperatorOr FilterLogicalOperator = "OR"`

          - `GroupBy []string`

            Columns to group by

          - `LatestOnly bool`

            When True, the widget computes against rows from only the most recent active evaluation in the group (by EvaluationORM.created_at). Only applicable for evaluation group dashboards. Composes with evaluation_ids (latest within the subset). Cannot be combined with per-aggregation evaluation_ids; the use case enforces these rules.

          - `Limit int64`

            Max rows to return

          - `OrderBy []SeriesQueryOrderBy`

            Sort order

            - `Column string`

              Column name to sort by

            - `Direction string`

              Sort direction

              - `const SeriesQueryOrderByDirectionAsc SeriesQueryOrderByDirection = "ASC"`

              - `const SeriesQueryOrderByDirectionDesc SeriesQueryOrderByDirection = "DESC"`

            - `Source string`

              Column source: 'data' or 'task_result_cache'

        - `type MetricQuery struct{…}`

          Query that returns a single metric value (used for metric widgets).

          Used for widget type: metric.
          Enforces exactly 1 aggregation in select.
          Returns: {"type": "metric", "data": ...}

          Example SQL equivalent:
          SELECT AVG(score) as average_score
          FROM evaluation_items

          - `Select []SelectItem`

            - `Expression SelectItemExpressionUnion`

              Reference to a column from evaluation_items.data

              Example:
              {"type": "COLUMN", "column": "category"}

            - `Alias string`

              Optional alias for the selected item

          - `EvaluationIDs []string`

            Optional subset of evaluation IDs to compute on. Only applicable for evaluation group dashboards. If omitted, computes on all evaluations in the group.

          - `Filter Filter`

            Filter conditions (WHERE clause)

          - `LatestOnly bool`

            When True, the widget computes against rows from only the most recent active evaluation in the group (by EvaluationORM.created_at). Only applicable for evaluation group dashboards. Composes with evaluation_ids (latest within the subset). Cannot be combined with per-aggregation evaluation_ids; the use case enforces these rules.

  - `Widgets []EvaluationDashboardWidget`

    Widgets associated with this dashboard. Populated with 'widgets' view.

    - `ID string`

      Unique identifier of the widget

    - `AccountID string`

      Account that owns this widget

    - `CreatedAt Time`

      When the widget was created

    - `Title string`

      Widget title

    - `Type EvaluationWidgetTypeEnum`

      Widget type

    - `ArchivedAt Time`

      When the widget was archived (soft-deleted)

    - `Config map[string, any]`

      Chart-specific display configuration

    - `Object EvaluationDashboardWidgetObject`

    - `Query EvaluationDashboardWidgetQueryUnion`

      Structured query AST for metric computation (SeriesQuery or MetricQuery)

### Example

```go
package main

import (
  "context"
  "fmt"

  "github.com/scaleapi/sgp-dev-go"
  "github.com/scaleapi/sgp-dev-go/option"
)

func main() {
  client := sgpdev.NewClient(
    option.WithAPIKey("My API Key"),
    option.WithAccountID("My Account ID"),
  )
  evaluationDashboard, err := client.EvaluationDashboards.Get(
    context.TODO(),
    "dashboard_id",
    sgpdev.EvaluationDashboardGetParams{

    },
  )
  if err != nil {
    panic(err.Error())
  }
  fmt.Printf("%+v\n", evaluationDashboard.ID)
}
```

#### Response

```json
{
  "id": "id",
  "account_id": "account_id",
  "created_at": "2019-12-27T18:11:19.117Z",
  "created_by": {
    "id": "id",
    "type": "user",
    "object": "identity"
  },
  "name": "name",
  "tags": [
    "string"
  ],
  "updated_at": "2019-12-27T18:11:19.117Z",
  "archived_at": "2019-12-27T18:11:19.117Z",
  "description": "description",
  "error_message": "error_message",
  "evaluation_group_id": "evaluation_group_id",
  "evaluation_id": "evaluation_id",
  "object": "evaluation_dashboard",
  "widget_order": [
    "string"
  ],
  "widget_results": [
    {
      "id": "id",
      "account_id": "account_id",
      "computation_status": "pending",
      "created_at": "2019-12-27T18:11:19.117Z",
      "widget_id": "widget_id",
      "computation_job_id": "computation_job_id",
      "computed_at": "2019-12-27T18:11:19.117Z",
      "computed_result": {
        "foo": "bar"
      },
      "error_message": "error_message",
      "evaluation_group_id": "evaluation_group_id",
      "evaluation_id": "evaluation_id",
      "object": "evaluation_dashboard_widget_result",
      "widget": {
        "id": "id",
        "account_id": "account_id",
        "created_at": "2019-12-27T18:11:19.117Z",
        "title": "title",
        "type": "bar",
        "archived_at": "2019-12-27T18:11:19.117Z",
        "config": {
          "foo": "bar"
        },
        "object": "evaluation_dashboard_widget",
        "query": {
          "select": [
            {
              "expression": {
                "column": "column",
                "source": "source",
                "type": "COLUMN"
              },
              "alias": "alias"
            }
          ],
          "evaluation_ids": [
            "string"
          ],
          "filter": {
            "conditions": [
              {
                "column": "column",
                "operator": "=",
                "source": "source",
                "value": "string"
              }
            ],
            "logicalOperators": [
              "AND"
            ]
          },
          "groupBy": [
            "string"
          ],
          "latest_only": true,
          "limit": 1,
          "orderBy": [
            {
              "column": "column",
              "direction": "ASC",
              "source": "source"
            }
          ]
        }
      }
    }
  ],
  "widgets": [
    {
      "id": "id",
      "account_id": "account_id",
      "created_at": "2019-12-27T18:11:19.117Z",
      "title": "title",
      "type": "bar",
      "archived_at": "2019-12-27T18:11:19.117Z",
      "config": {
        "foo": "bar"
      },
      "object": "evaluation_dashboard_widget",
      "query": {
        "select": [
          {
            "expression": {
              "column": "column",
              "source": "source",
              "type": "COLUMN"
            },
            "alias": "alias"
          }
        ],
        "evaluation_ids": [
          "string"
        ],
        "filter": {
          "conditions": [
            {
              "column": "column",
              "operator": "=",
              "source": "source",
              "value": "string"
            }
          ],
          "logicalOperators": [
            "AND"
          ]
        },
        "groupBy": [
          "string"
        ],
        "latest_only": true,
        "limit": 1,
        "orderBy": [
          {
            "column": "column",
            "direction": "ASC",
            "source": "source"
          }
        ]
      }
    }
  ]
}
```
