grafana.oss.getDashboards

import * as pulumi from "@pulumi/pulumi";
import * as grafana from "@pulumiverse/grafana";
import * as std from "@pulumi/std";

const test = new grafana.oss.Organization("test", {name: "testing dashboards data source"});
const dataSourceDashboards = new grafana.oss.Folder("data_source_dashboards", {
    orgId: test.id,
    title: "test folder data_source_dashboards",
});
const dataSourceDashboards1 = new grafana.oss.Dashboard("data_source_dashboards1", {
    orgId: test.id,
    folder: dataSourceDashboards.id,
    configJson: JSON.stringify({
        uid: "data-source-dashboards-1",
        title: "data_source_dashboards 1",
        tags: ["dev"],
    }),
});
const dataSourceDashboards2 = new grafana.oss.Dashboard("data_source_dashboards2", {
    orgId: test.id,
    configJson: JSON.stringify({
        uid: "data-source-dashboards-2",
        title: "data_source_dashboards 2",
        tags: ["prod"],
    }),
});
const tags = pulumi.all([test.id, dataSourceDashboards1.configJson]).apply(([id, configJson]) => grafana.oss.getDashboardsOutput({
    orgId: id,
    tags: std.index.jsondecode({
        input: configJson,
    }).result.tags,
}));
const folderUids = pulumi.all([test.id, dataSourceDashboards1.folder]).apply(([id, folder]) => grafana.oss.getDashboardsOutput({
    orgId: id,
    folderUids: [folder],
}));
const folderUidsTags = pulumi.all([test.id, dataSourceDashboards1.folder, dataSourceDashboards1.configJson]).apply(([id, folder, configJson]) => grafana.oss.getDashboardsOutput({
    orgId: id,
    folderUids: [folder],
    tags: std.index.jsondecode({
        input: configJson,
    }).result.tags,
}));
// use depends_on to wait for dashboard resource to be created before searching
const all = grafana.oss.getDashboardsOutput({
    orgId: test.id,
});
// get only one result
const limitOne = test.id.apply(id => grafana.oss.getDashboardsOutput({
    orgId: id,
    limit: 1,
}));
// The dashboards are not in the default org so this should return an empty list
const wrongOrg = grafana.oss.getDashboards({});

import pulumi
import json
import pulumi_grafana as grafana
import pulumi_std as std
import pulumiverse_grafana as grafana

test = grafana.oss.Organization("test", name="testing dashboards data source")
data_source_dashboards = grafana.oss.Folder("data_source_dashboards",
    org_id=test.id,
    title="test folder data_source_dashboards")
data_source_dashboards1 = grafana.oss.Dashboard("data_source_dashboards1",
    org_id=test.id,
    folder=data_source_dashboards.id,
    config_json=json.dumps({
        "uid": "data-source-dashboards-1",
        "title": "data_source_dashboards 1",
        "tags": ["dev"],
    }))
data_source_dashboards2 = grafana.oss.Dashboard("data_source_dashboards2",
    org_id=test.id,
    config_json=json.dumps({
        "uid": "data-source-dashboards-2",
        "title": "data_source_dashboards 2",
        "tags": ["prod"],
    }))
tags = pulumi.Output.all(
    id=test.id,
    config_json=data_source_dashboards1.config_json
).apply(lambda resolved_outputs: grafana.oss.get_dashboards_output(org_id=resolved_outputs['id'],
    tags=std.index.jsondecode(input=resolved_outputs['config_json'])["result"]["tags"]))

folder_uids = pulumi.Output.all(
    id=test.id,
    folder=data_source_dashboards1.folder
).apply(lambda resolved_outputs: grafana.oss.get_dashboards_output(org_id=resolved_outputs['id'],
    folder_uids=[resolved_outputs['folder']]))

folder_uids_tags = pulumi.Output.all(
    id=test.id,
    folder=data_source_dashboards1.folder,
    config_json=data_source_dashboards1.config_json
).apply(lambda resolved_outputs: grafana.oss.get_dashboards_output(org_id=resolved_outputs['id'],
    folder_uids=[resolved_outputs['folder']],
    tags=std.index.jsondecode(input=resolved_outputs['config_json'])["result"]["tags"]))

# use depends_on to wait for dashboard resource to be created before searching
all = grafana.oss.get_dashboards_output(org_id=test.id)
# get only one result
limit_one = test.id.apply(lambda id: grafana.oss.get_dashboards_output(org_id=id,
    limit=1))
# The dashboards are not in the default org so this should return an empty list
wrong_org = grafana.oss.get_dashboards()

package main

import (
	"encoding/json"

	"github.com/pulumi/pulumi-std/sdk/go/std"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
	"github.com/pulumiverse/pulumi-grafana/sdk/v2/go/grafana/oss"
)
func main() {
pulumi.Run(func(ctx *pulumi.Context) error {
test, err := oss.NewOrganization(ctx, "test", &oss.OrganizationArgs{
Name: pulumi.String("testing dashboards data source"),
})
if err != nil {
return err
}
dataSourceDashboards, err := oss.NewFolder(ctx, "data_source_dashboards", &oss.FolderArgs{
OrgId: test.ID(),
Title: pulumi.String("test folder data_source_dashboards"),
})
if err != nil {
return err
}
tmpJSON0, err := json.Marshal(map[string]interface{}{
"uid": "data-source-dashboards-1",
"title": "data_source_dashboards 1",
"tags": []string{
"dev",
},
})
if err != nil {
return err
}
json0 := string(tmpJSON0)
dataSourceDashboards1, err := oss.NewDashboard(ctx, "data_source_dashboards1", &oss.DashboardArgs{
OrgId: test.ID(),
Folder: dataSourceDashboards.ID(),
ConfigJson: pulumi.String(pulumi.String(json0)),
})
if err != nil {
return err
}
tmpJSON1, err := json.Marshal(map[string]interface{}{
"uid": "data-source-dashboards-2",
"title": "data_source_dashboards 2",
"tags": []string{
"prod",
},
})
if err != nil {
return err
}
json1 := string(tmpJSON1)
_, err = oss.NewDashboard(ctx, "data_source_dashboards2", &oss.DashboardArgs{
OrgId: test.ID(),
ConfigJson: pulumi.String(pulumi.String(json1)),
})
if err != nil {
return err
}
_ = pulumi.All(test.ID(),dataSourceDashboards1.ConfigJson).ApplyT(func(_args []interface{}) (oss.GetDashboardsResult, error) {
id := _args[0].(string)
configJson := _args[1].(string)
return oss.GetDashboardsResult(interface{}(oss.GetDashboards(ctx, &oss.GetDashboardsArgs{
OrgId: pulumi.StringRef(pulumi.StringRef(id)),
Tags: []string(std.Jsondecode(ctx, map[string]interface{}{
"input": configJson,
}, nil).Result.Tags),
}, nil))), nil
}).(oss.GetDashboardsResultOutput)
_ = pulumi.All(test.ID(),dataSourceDashboards1.Folder).ApplyT(func(_args []interface{}) (oss.GetDashboardsResult, error) {
id := _args[0].(string)
folder := _args[1].(*string)
return oss.GetDashboardsResult(interface{}(oss.GetDashboards(ctx, &oss.GetDashboardsArgs{
OrgId: pulumi.StringRef(pulumi.StringRef(id)),
FolderUids: interface{}{
folder,
},
}, nil))), nil
}).(oss.GetDashboardsResultOutput)
_ = pulumi.All(test.ID(),dataSourceDashboards1.Folder,dataSourceDashboards1.ConfigJson).ApplyT(func(_args []interface{}) (oss.GetDashboardsResult, error) {
id := _args[0].(string)
folder := _args[1].(*string)
configJson := _args[2].(string)
return oss.GetDashboardsResult(interface{}(oss.GetDashboards(ctx, &oss.GetDashboardsArgs{
OrgId: pulumi.StringRef(pulumi.StringRef(id)),
FolderUids: interface{}{
folder,
},
Tags: []string(std.Jsondecode(ctx, map[string]interface{}{
"input": configJson,
}, nil).Result.Tags),
}, nil))), nil
}).(oss.GetDashboardsResultOutput)
// use depends_on to wait for dashboard resource to be created before searching
_ = oss.GetDashboardsOutput(ctx, oss.GetDashboardsOutputArgs{
OrgId: test.ID(),
}, nil);
// get only one result
_ = test.ID().ApplyT(func(id string) (oss.GetDashboardsResult, error) {
return oss.GetDashboardsResult(interface{}(oss.GetDashboards(ctx, &oss.GetDashboardsArgs{
OrgId: pulumi.StringRef(pulumi.StringRef(id)),
Limit: pulumi.IntRef(pulumi.IntRef(int(1))),
}, nil))), nil
}).(oss.GetDashboardsResultOutput)
// The dashboards are not in the default org so this should return an empty list
_, err = oss.GetDashboards(ctx, &oss.GetDashboardsArgs{
}, nil);
if err != nil {
return err
}
return nil
})
}

using System.Collections.Generic;
using System.Linq;
using System.Text.Json;
using Pulumi;
using Grafana = Pulumiverse.Grafana;
using Std = Pulumi.Std;

return await Deployment.RunAsync(() => 
{
    var test = new Grafana.Oss.Organization("test", new()
    {
        Name = "testing dashboards data source",
    });

    var dataSourceDashboards = new Grafana.Oss.Folder("data_source_dashboards", new()
    {
        OrgId = test.Id,
        Title = "test folder data_source_dashboards",
    });

    var dataSourceDashboards1 = new Grafana.Oss.Dashboard("data_source_dashboards1", new()
    {
        OrgId = test.Id,
        Folder = dataSourceDashboards.Id,
        ConfigJson = JsonSerializer.Serialize(new Dictionary<string, object?>
        {
            ["uid"] = "data-source-dashboards-1",
            ["title"] = "data_source_dashboards 1",
            ["tags"] = new[]
            {
                "dev",
            },
        }),
    });

    var dataSourceDashboards2 = new Grafana.Oss.Dashboard("data_source_dashboards2", new()
    {
        OrgId = test.Id,
        ConfigJson = JsonSerializer.Serialize(new Dictionary<string, object?>
        {
            ["uid"] = "data-source-dashboards-2",
            ["title"] = "data_source_dashboards 2",
            ["tags"] = new[]
            {
                "prod",
            },
        }),
    });

    var tags = Grafana.Oss.GetDashboards.Invoke(new()
    {
        OrgId = test.Id,
        Tags = Std.Index.Jsondecode.Invoke(new()
        {
            Input = dataSourceDashboards1.ConfigJson,
        }).Result.Tags,
    });

    var folderUids = Grafana.Oss.GetDashboards.Invoke(new()
    {
        OrgId = test.Id,
        FolderUids = new[]
        {
            dataSourceDashboards1.Folder,
        },
    });

    var folderUidsTags = Grafana.Oss.GetDashboards.Invoke(new()
    {
        OrgId = test.Id,
        FolderUids = new[]
        {
            dataSourceDashboards1.Folder,
        },
        Tags = Std.Index.Jsondecode.Invoke(new()
        {
            Input = dataSourceDashboards1.ConfigJson,
        }).Result.Tags,
    });

    // use depends_on to wait for dashboard resource to be created before searching
    var all = Grafana.Oss.GetDashboards.Invoke(new()
    {
        OrgId = test.Id,
    });

    // get only one result
    var limitOne = Grafana.Oss.GetDashboards.Invoke(new()
    {
        OrgId = test.Id,
        Limit = 1,
    });

    // The dashboards are not in the default org so this should return an empty list
    var wrongOrg = Grafana.Oss.GetDashboards.Invoke();

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.grafana.oss.Organization;
import com.pulumi.grafana.oss.OrganizationArgs;
import com.pulumi.grafana.oss.Folder;
import com.pulumi.grafana.oss.FolderArgs;
import com.pulumi.grafana.oss.Dashboard;
import com.pulumi.grafana.oss.DashboardArgs;
import com.pulumi.std.StdFunctions;
import com.pulumi.grafana.oss.OssFunctions;
import com.pulumi.grafana.oss.inputs.GetDashboardsArgs;
import static com.pulumi.codegen.internal.Serialization.*;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }

    public static void stack(Context ctx) {
        var test = new Organization("test", OrganizationArgs.builder()
            .name("testing dashboards data source")
            .build());

        var dataSourceDashboards = new Folder("dataSourceDashboards", FolderArgs.builder()
            .orgId(test.id())
            .title("test folder data_source_dashboards")
            .build());

        var dataSourceDashboards1 = new Dashboard("dataSourceDashboards1", DashboardArgs.builder()
            .orgId(test.id())
            .folder(dataSourceDashboards.id())
            .configJson(serializeJson(
                jsonObject(
                    jsonProperty("uid", "data-source-dashboards-1"),
                    jsonProperty("title", "data_source_dashboards 1"),
                    jsonProperty("tags", jsonArray("dev"))
                )))
            .build());

        var dataSourceDashboards2 = new Dashboard("dataSourceDashboards2", DashboardArgs.builder()
            .orgId(test.id())
            .configJson(serializeJson(
                jsonObject(
                    jsonProperty("uid", "data-source-dashboards-2"),
                    jsonProperty("title", "data_source_dashboards 2"),
                    jsonProperty("tags", jsonArray("prod"))
                )))
            .build());

        final var tags = Output.tuple(test.id(), dataSourceDashboards1.configJson()).applyValue(values -> {
            var id = values.t1;
            var configJson = values.t2;
            return OssFunctions.getDashboards(GetDashboardsArgs.builder()
                .orgId(id)
                .tags(StdFunctions.jsondecode(Map.of("input", configJson)).result().tags())
                .build());
        });

        final var folderUids = Output.tuple(test.id(), dataSourceDashboards1.folder()).applyValue(values -> {
            var id = values.t1;
            var folder = values.t2;
            return OssFunctions.getDashboards(GetDashboardsArgs.builder()
                .orgId(id)
                .folderUids(folder)
                .build());
        });

        final var folderUidsTags = Output.tuple(test.id(), dataSourceDashboards1.folder(), dataSourceDashboards1.configJson()).applyValue(values -> {
            var id = values.t1;
            var folder = values.t2;
            var configJson = values.t3;
            return OssFunctions.getDashboards(GetDashboardsArgs.builder()
                .orgId(id)
                .folderUids(folder)
                .tags(StdFunctions.jsondecode(Map.of("input", configJson)).result().tags())
                .build());
        });

        // use depends_on to wait for dashboard resource to be created before searching
        final var all = OssFunctions.getDashboards(GetDashboardsArgs.builder()
            .orgId(test.id())
            .build());

        // get only one result
        final var limitOne = test.id().applyValue(_id -> OssFunctions.getDashboards(GetDashboardsArgs.builder()
            .orgId(_id)
            .limit(1)
            .build()));

        // The dashboards are not in the default org so this should return an empty list
        final var wrongOrg = OssFunctions.getDashboards(GetDashboardsArgs.builder()
            .build());

    }
}

resources:
  test:
    type: grafana:oss:Organization
    properties:
      name: testing dashboards data source
  dataSourceDashboards:
    type: grafana:oss:Folder
    name: data_source_dashboards
    properties:
      orgId: ${test.id}
      title: test folder data_source_dashboards
  dataSourceDashboards1:
    type: grafana:oss:Dashboard
    name: data_source_dashboards1
    properties:
      orgId: ${test.id}
      folder: ${dataSourceDashboards.id}
      configJson:
        fn::toJSON:
          uid: data-source-dashboards-1
          title: data_source_dashboards 1
          tags:
            - dev
  dataSourceDashboards2:
    type: grafana:oss:Dashboard
    name: data_source_dashboards2
    properties:
      orgId: ${test.id}
      configJson:
        fn::toJSON:
          uid: data-source-dashboards-2
          title: data_source_dashboards 2
          tags:
            - prod
variables:
  tags:
    fn::invoke:
      function: grafana:oss:getDashboards
      arguments:
        orgId: ${test.id}
        tags:
          fn::invoke:
            function: std:jsondecode
            arguments:
              input: ${dataSourceDashboards1.configJson}
            return: result.tags
  folderUids:
    fn::invoke:
      function: grafana:oss:getDashboards
      arguments:
        orgId: ${test.id}
        folderUids:
          - ${dataSourceDashboards1.folder}
  folderUidsTags:
    fn::invoke:
      function: grafana:oss:getDashboards
      arguments:
        orgId: ${test.id}
        folderUids:
          - ${dataSourceDashboards1.folder}
        tags:
          fn::invoke:
            function: std:jsondecode
            arguments:
              input: ${dataSourceDashboards1.configJson}
            return: result.tags
  # use depends_on to wait for dashboard resource to be created before searching
  all:
    fn::invoke:
      function: grafana:oss:getDashboards
      arguments:
        orgId: ${test.id}
  # get only one result
  limitOne:
    fn::invoke:
      function: grafana:oss:getDashboards
      arguments:
        orgId: ${test.id}
        limit: 1
  # The dashboards are not in the default org so this should return an empty list
  wrongOrg:
    fn::invoke:
      function: grafana:oss:getDashboards
      arguments: {}

function getDashboards(args: GetDashboardsArgs, opts?: InvokeOptions): Promise<GetDashboardsResult>
function getDashboardsOutput(args: GetDashboardsOutputArgs, opts?: InvokeOptions): Output<GetDashboardsResult>

def get_dashboards(folder_uids: Optional[Sequence[str]] = None,
                   limit: Optional[int] = None,
                   org_id: Optional[str] = None,
                   tags: Optional[Sequence[str]] = None,
                   opts: Optional[InvokeOptions] = None) -> GetDashboardsResult
def get_dashboards_output(folder_uids: pulumi.Input[Optional[Sequence[pulumi.Input[str]]]] = None,
                   limit: pulumi.Input[Optional[int]] = None,
                   org_id: pulumi.Input[Optional[str]] = None,
                   tags: pulumi.Input[Optional[Sequence[pulumi.Input[str]]]] = None,
                   opts: Optional[InvokeOptions] = None) -> Output[GetDashboardsResult]

func GetDashboards(ctx *Context, args *GetDashboardsArgs, opts ...InvokeOption) (*GetDashboardsResult, error)
func GetDashboardsOutput(ctx *Context, args *GetDashboardsOutputArgs, opts ...InvokeOption) GetDashboardsResultOutput

public static class GetDashboards 
{
    public static Task<GetDashboardsResult> InvokeAsync(GetDashboardsArgs args, InvokeOptions? opts = null)
    public static Output<GetDashboardsResult> Invoke(GetDashboardsInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<GetDashboardsResult> getDashboards(GetDashboardsArgs args, InvokeOptions options)
public static Output<GetDashboardsResult> getDashboards(GetDashboardsArgs args, InvokeOptions options)

fn::invoke:
  function: grafana:oss/getDashboards:getDashboards
  arguments:
    # arguments dictionary