databricks.getDashboards

import * as pulumi from "@pulumi/pulumi";
import * as databricks from "@pulumi/databricks";

export = async () => {
    const all = await databricks.getDashboards({});
    const dashboardsPermissions: databricks.Permissions[] = [];
    for (const range of all.dashboards.map(__item => __item.dashboardId).map((v, k) => ({key: k, value: v}))) {
        dashboardsPermissions.push(new databricks.Permissions(`dashboards_permissions-${range.key}`, {
            depends: [all],
            dashboardId: range.value,
            accessControls: [{
                groupName: "Example Group",
                permissionLevel: "CAN_MANAGE",
            }],
        }));
    }
}

import pulumi
import pulumi_databricks as databricks

all = databricks.get_dashboards()
dashboards_permissions = []
for range in [{"key": k, "value": v} for [k, v] in enumerate([__item.dashboard_id for __item in all.dashboards])]:
    dashboards_permissions.append(databricks.Permissions(f"dashboards_permissions-{range['key']}",
        depends=[all],
        dashboard_id=range["value"],
        access_controls=[{
            "group_name": "Example Group",
            "permission_level": "CAN_MANAGE",
        }]))

package main

import (
	"github.com/pulumi/pulumi-databricks/sdk/go/databricks"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		all, err := databricks.GetDashboards(ctx, &databricks.GetDashboardsArgs{}, nil)
		if err != nil {
			return err
		}
		var splat0 []*string
		for _, val0 := range all.Dashboards {
			splat0 = append(splat0, val0.DashboardId)
		}
		var dashboardsPermissions []*databricks.Permissions
		for key0, val0 := range splat0 {
			__res, err := databricks.NewPermissions(ctx, fmt.Sprintf("dashboards_permissions-%v", key0), &databricks.PermissionsArgs{
				Depends: []interface{}{
					all,
				},
				DashboardId: pulumi.String(val0),
				AccessControls: databricks.PermissionsAccessControlArray{
					&databricks.PermissionsAccessControlArgs{
						GroupName:       pulumi.String("Example Group"),
						PermissionLevel: pulumi.String("CAN_MANAGE"),
					},
				},
			})
			if err != nil {
				return err
			}
			dashboardsPermissions = append(dashboardsPermissions, __res)
		}
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using Pulumi;
using Databricks = Pulumi.Databricks;

return await Deployment.RunAsync(async() => 
{
    var all = await Databricks.GetDashboards.InvokeAsync();

    var dashboardsPermissions = new List<Databricks.Permissions>();
    foreach (var range in all.Dashboards.Select(__item => __item.DashboardId).ToList().Select((v, k) => new { Key = k, Value = v }))
    {
        dashboardsPermissions.Add(new Databricks.Permissions($"dashboards_permissions-{range.Key}", new()
        {
            Depends = new[]
            {
                all,
            },
            DashboardId = range.Value,
            AccessControls = new[]
            {
                new Databricks.Inputs.PermissionsAccessControlArgs
                {
                    GroupName = "Example Group",
                    PermissionLevel = "CAN_MANAGE",
                },
            },
        }));
    }
});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.databricks.DatabricksFunctions;
import com.pulumi.databricks.inputs.GetDashboardsArgs;
import com.pulumi.databricks.Permissions;
import com.pulumi.databricks.PermissionsArgs;
import com.pulumi.databricks.inputs.PermissionsAccessControlArgs;
import com.pulumi.codegen.internal.KeyedValue;
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) {
        final var all = DatabricksFunctions.getDashboards(GetDashboardsArgs.builder()
            .build());

        for (var range : KeyedValue.of(all.dashboards().stream().map(element -> element.dashboardId()).collect(toList()))) {
            new Permissions("dashboardsPermissions-" + range.key(), PermissionsArgs.builder()
                .depends(List.of(all))
                .dashboardId(range.value())
                .accessControls(PermissionsAccessControlArgs.builder()
                    .groupName("Example Group")
                    .permissionLevel("CAN_MANAGE")
                    .build())
                .build());
        }

    }
}

resources:
  dashboardsPermissions:
    type: databricks:Permissions
    name: dashboards_permissions
    properties:
      depends:
        - ${all}
      dashboardId: ${range.value}
      accessControls:
        - groupName: Example Group
          permissionLevel: CAN_MANAGE
    options: {}
variables:
  all:
    fn::invoke:
      function: databricks:getDashboards
      arguments: {}

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

def get_dashboards(dashboard_name_contains: Optional[str] = None,
                   provider_config: Optional[GetDashboardsProviderConfig] = None,
                   opts: Optional[InvokeOptions] = None) -> GetDashboardsResult
def get_dashboards_output(dashboard_name_contains: Optional[pulumi.Input[str]] = None,
                   provider_config: Optional[pulumi.Input[GetDashboardsProviderConfigArgs]] = 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: databricks:index/getDashboards:getDashboards
  arguments:
    # arguments dictionary