grafana.enterprise.DataSourceConfigLbacRules

import pulumi
import json
import pulumiverse_grafana as grafana

team = grafana.oss.Team("team", name="Team Name")
test = grafana.oss.DataSource("test",
    type="loki",
    name="loki-from-terraform",
    url="https://mylokiurl.net",
    basic_auth_enabled=True,
    basic_auth_username="username",
    json_data_encoded=json.dumps({
        "authType": "default",
        "basicAuthPassword": "password",
    }))
test_rule = grafana.enterprise.DataSourceConfigLbacRules("test_rule",
    datasource_uid=test.uid,
    rules=pulumi.Output.json_dumps(team.team_uid.apply(lambda team_uid: {
        team_uid: [
            "{ cluster = \"dev-us-central-0\", namespace = \"hosted-grafana\" }",
            "{ foo = \"qux\" }",
        ],
    })),
    opts = pulumi.ResourceOptions(depends_on=[
            team,
            test,
        ]))

package main

import (
	"encoding/json"

	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
	"github.com/pulumiverse/pulumi-grafana/sdk/go/grafana/enterprise"
	"github.com/pulumiverse/pulumi-grafana/sdk/go/grafana/oss"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		team, err := oss.NewTeam(ctx, "team", &oss.TeamArgs{
			Name: pulumi.String("Team Name"),
		})
		if err != nil {
			return err
		}
		tmpJSON0, err := json.Marshal(map[string]interface{}{
			"authType":          "default",
			"basicAuthPassword": "password",
		})
		if err != nil {
			return err
		}
		json0 := string(tmpJSON0)
		test, err := oss.NewDataSource(ctx, "test", &oss.DataSourceArgs{
			Type:              pulumi.String("loki"),
			Name:              pulumi.String("loki-from-terraform"),
			Url:               pulumi.String("https://mylokiurl.net"),
			BasicAuthEnabled:  pulumi.Bool(true),
			BasicAuthUsername: pulumi.String("username"),
			JsonDataEncoded:   pulumi.String(json0),
		})
		if err != nil {
			return err
		}
		_, err = enterprise.NewDataSourceConfigLbacRules(ctx, "test_rule", &enterprise.DataSourceConfigLbacRulesArgs{
			DatasourceUid: test.Uid,
			Rules: team.TeamUid.ApplyT(func(teamUid string) (pulumi.String, error) {
				var _zero pulumi.String
				tmpJSON1, err := json.Marshal(map[string][]string{
					teamUid: []string{
						"{ cluster = \"dev-us-central-0\", namespace = \"hosted-grafana\" }",
						"{ foo = \"qux\" }",
					},
				})
				if err != nil {
					return _zero, err
				}
				json1 := string(tmpJSON1)
				return pulumi.String(json1), nil
			}).(pulumi.StringOutput),
		}, pulumi.DependsOn([]pulumi.Resource{
			team,
			test,
		}))
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var team = new Grafana.Oss.Team("team", new()
    {
        Name = "Team Name",
    });

    var test = new Grafana.Oss.DataSource("test", new()
    {
        Type = "loki",
        Name = "loki-from-terraform",
        Url = "https://mylokiurl.net",
        BasicAuthEnabled = true,
        BasicAuthUsername = "username",
        JsonDataEncoded = JsonSerializer.Serialize(new Dictionary<string, object?>
        {
            ["authType"] = "default",
            ["basicAuthPassword"] = "password",
        }),
    });

    var testRule = new Grafana.Enterprise.DataSourceConfigLbacRules("test_rule", new()
    {
        DatasourceUid = test.Uid,
        Rules = Output.JsonSerialize(Output.Create(team.TeamUid.Apply(teamUid => 
        {
            { teamUid, new[]
            {
                "{ cluster = \"dev-us-central-0\", namespace = \"hosted-grafana\" }",
                "{ foo = \"qux\" }",
            } },
        }))),
    }, new CustomResourceOptions
    {
        DependsOn =
        {
            team,
            test,
        },
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.grafana.oss.Team;
import com.pulumi.grafana.oss.TeamArgs;
import com.pulumi.grafana.oss.DataSource;
import com.pulumi.grafana.oss.DataSourceArgs;
import com.pulumi.grafana.enterprise.DataSourceConfigLbacRules;
import com.pulumi.grafana.enterprise.DataSourceConfigLbacRulesArgs;
import static com.pulumi.codegen.internal.Serialization.*;
import com.pulumi.resources.CustomResourceOptions;
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 team = new Team("team", TeamArgs.builder()
            .name("Team Name")
            .build());

        var test = new DataSource("test", DataSourceArgs.builder()
            .type("loki")
            .name("loki-from-terraform")
            .url("https://mylokiurl.net")
            .basicAuthEnabled(true)
            .basicAuthUsername("username")
            .jsonDataEncoded(serializeJson(
                jsonObject(
                    jsonProperty("authType", "default"),
                    jsonProperty("basicAuthPassword", "password")
                )))
            .build());

        var testRule = new DataSourceConfigLbacRules("testRule", DataSourceConfigLbacRulesArgs.builder()
            .datasourceUid(test.uid())
            .rules(team.teamUid().applyValue(teamUid -> serializeJson(
                jsonObject(
                    jsonProperty(teamUid, jsonArray(
                        "{ cluster = \"dev-us-central-0\", namespace = \"hosted-grafana\" }", 
                        "{ foo = \"qux\" }"
                    ))
                ))))
            .build(), CustomResourceOptions.builder()
                .dependsOn(                
                    team,
                    test)
                .build());

    }
}

resources:
  team:
    type: grafana:oss:Team
    properties:
      name: Team Name
  test:
    type: grafana:oss:DataSource
    properties:
      type: loki
      name: loki-from-terraform
      url: https://mylokiurl.net
      basicAuthEnabled: true
      basicAuthUsername: username
      jsonDataEncoded:
        fn::toJSON:
          authType: default
          basicAuthPassword: password
  testRule:
    type: grafana:enterprise:DataSourceConfigLbacRules
    name: test_rule
    properties:
      datasourceUid: ${test.uid}
      rules:
        fn::toJSON:
          ${team.teamUid}:
            - '{ cluster = "dev-us-central-0", namespace = "hosted-grafana" }'
            - '{ foo = "qux" }'
    options:
      dependsOn:
        - ${team}
        - ${test}

var dataSourceConfigLbacRulesResource = new Grafana.Enterprise.DataSourceConfigLbacRules("dataSourceConfigLbacRulesResource", new()
{
    DatasourceUid = "string",
    Rules = "string",
});

example, err := enterprise.NewDataSourceConfigLbacRules(ctx, "dataSourceConfigLbacRulesResource", &enterprise.DataSourceConfigLbacRulesArgs{
	DatasourceUid: pulumi.String("string"),
	Rules:         pulumi.String("string"),
})

var dataSourceConfigLbacRulesResource = new DataSourceConfigLbacRules("dataSourceConfigLbacRulesResource", DataSourceConfigLbacRulesArgs.builder()
    .datasourceUid("string")
    .rules("string")
    .build());

data_source_config_lbac_rules_resource = grafana.enterprise.DataSourceConfigLbacRules("dataSourceConfigLbacRulesResource",
    datasource_uid="string",
    rules="string")

type: grafana:enterprise:DataSourceConfigLbacRules
properties:
    datasourceUid: string
    rules: string