dynatrace.SettingsPermissions

import * as pulumi from "@pulumi/pulumi";
import * as dynatrace from "@pulumiverse/dynatrace";

const group = new dynatrace.IamGroup("group", {name: "#name#"});
const userIamUser = new dynatrace.IamUser("user", {
    email: "#name#@example.com",
    groups: [group.id],
});
// because the UID is not returned for the resource, we need data
const user = dynatrace.getIamUserOutput({
    email: userIamUser.id,
});
const connection = new dynatrace.GithubConnection("connection", {
    name: "#name#",
    type: "pat",
    token: "azAZ09",
});
const permission = new dynatrace.SettingsPermissions("permission", {
    settingsObjectId: connection.id,
    allUsers: "none",
    users: {
        users: [{
            uid: user.apply(user => user.uid),
            access: "write",
        }],
    },
    groups: {
        groups: [{
            id: group.id,
            access: "read",
        }],
    },
});

import pulumi
import pulumi_dynatrace as dynatrace
import pulumiverse_dynatrace as dynatrace

group = dynatrace.IamGroup("group", name="#name#")
user_iam_user = dynatrace.IamUser("user",
    email="#name#@example.com",
    groups=[group.id])
# because the UID is not returned for the resource, we need data
user = dynatrace.get_iam_user_output(email=user_iam_user.id)
connection = dynatrace.GithubConnection("connection",
    name="#name#",
    type="pat",
    token="azAZ09")
permission = dynatrace.SettingsPermissions("permission",
    settings_object_id=connection.id,
    all_users="none",
    users={
        "users": [{
            "uid": user.uid,
            "access": "write",
        }],
    },
    groups={
        "groups": [{
            "id": group.id,
            "access": "read",
        }],
    })

package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		group, err := dynatrace.NewIamGroup(ctx, "group", &dynatrace.IamGroupArgs{
			Name: pulumi.String("#name#"),
		})
		if err != nil {
			return err
		}
		userIamUser, err := dynatrace.NewIamUser(ctx, "user", &dynatrace.IamUserArgs{
			Email: pulumi.String("#name#@example.com"),
			Groups: pulumi.StringArray{
				group.ID(),
			},
		})
		if err != nil {
			return err
		}
		// because the UID is not returned for the resource, we need data
		user := dynatrace.GetIamUserOutput(ctx, dynatrace.GetIamUserOutputArgs{
			Email: userIamUser.ID(),
		}, nil)
		connection, err := dynatrace.NewGithubConnection(ctx, "connection", &dynatrace.GithubConnectionArgs{
			Name:  pulumi.String("#name#"),
			Type:  pulumi.String("pat"),
			Token: pulumi.String("azAZ09"),
		})
		if err != nil {
			return err
		}
		_, err = dynatrace.NewSettingsPermissions(ctx, "permission", &dynatrace.SettingsPermissionsArgs{
			SettingsObjectId: connection.ID(),
			AllUsers:         pulumi.String("none"),
			Users: &dynatrace.SettingsPermissionsUsersArgs{
				Users: dynatrace.SettingsPermissionsUsersUserArray{
					&dynatrace.SettingsPermissionsUsersUserArgs{
						Uid: user.ApplyT(func(user dynatrace.GetIamUserResult) (*string, error) {
							return &user.Uid, nil
						}).(pulumi.StringPtrOutput),
						Access: pulumi.String("write"),
					},
				},
			},
			Groups: &dynatrace.SettingsPermissionsGroupsArgs{
				Groups: dynatrace.SettingsPermissionsGroupsGroupArray{
					&dynatrace.SettingsPermissionsGroupsGroupArgs{
						Id:     group.ID(),
						Access: pulumi.String("read"),
					},
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Dynatrace = Pulumiverse.Dynatrace;

return await Deployment.RunAsync(() => 
{
    var @group = new Dynatrace.IamGroup("group", new()
    {
        Name = "#name#",
    });

    var userIamUser = new Dynatrace.IamUser("user", new()
    {
        Email = "#name#@example.com",
        Groups = new[]
        {
            @group.Id,
        },
    });

    // because the UID is not returned for the resource, we need data
    var user = Dynatrace.GetIamUser.Invoke(new()
    {
        Email = userIamUser.Id,
    });

    var connection = new Dynatrace.GithubConnection("connection", new()
    {
        Name = "#name#",
        Type = "pat",
        Token = "azAZ09",
    });

    var permission = new Dynatrace.SettingsPermissions("permission", new()
    {
        SettingsObjectId = connection.Id,
        AllUsers = "none",
        Users = new Dynatrace.Inputs.SettingsPermissionsUsersArgs
        {
            Users = new[]
            {
                new Dynatrace.Inputs.SettingsPermissionsUsersUserArgs
                {
                    Uid = user.Apply(getIamUserResult => getIamUserResult.Uid),
                    Access = "write",
                },
            },
        },
        Groups = new Dynatrace.Inputs.SettingsPermissionsGroupsArgs
        {
            Groups = new[]
            {
                new Dynatrace.Inputs.SettingsPermissionsGroupsGroupArgs
                {
                    Id = @group.Id,
                    Access = "read",
                },
            },
        },
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.dynatrace.IamGroup;
import com.pulumi.dynatrace.IamGroupArgs;
import com.pulumi.dynatrace.IamUser;
import com.pulumi.dynatrace.IamUserArgs;
import com.pulumi.dynatrace.DynatraceFunctions;
import com.pulumi.dynatrace.inputs.GetIamUserArgs;
import com.pulumi.dynatrace.GithubConnection;
import com.pulumi.dynatrace.GithubConnectionArgs;
import com.pulumi.dynatrace.SettingsPermissions;
import com.pulumi.dynatrace.SettingsPermissionsArgs;
import com.pulumi.dynatrace.inputs.SettingsPermissionsUsersArgs;
import com.pulumi.dynatrace.inputs.SettingsPermissionsGroupsArgs;
import java.util.ArrayList;
import java.util.Arrays;
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 group = new IamGroup("group", IamGroupArgs.builder()
            .name("#name#")
            .build());

        var userIamUser = new IamUser("userIamUser", IamUserArgs.builder()
            .email("#name#@example.com")
            .groups(group.id())
            .build());

        // because the UID is not returned for the resource, we need data
        final var user = DynatraceFunctions.getIamUser(GetIamUserArgs.builder()
            .email(userIamUser.id())
            .build());

        var connection = new GithubConnection("connection", GithubConnectionArgs.builder()
            .name("#name#")
            .type("pat")
            .token("azAZ09")
            .build());

        var permission = new SettingsPermissions("permission", SettingsPermissionsArgs.builder()
            .settingsObjectId(connection.id())
            .allUsers("none")
            .users(SettingsPermissionsUsersArgs.builder()
                .users(SettingsPermissionsUsersUserArgs.builder()
                    .uid(user.applyValue(_user -> _user.uid()))
                    .access("write")
                    .build())
                .build())
            .groups(SettingsPermissionsGroupsArgs.builder()
                .groups(SettingsPermissionsGroupsGroupArgs.builder()
                    .id(group.id())
                    .access("read")
                    .build())
                .build())
            .build());

    }
}

resources:
  group:
    type: dynatrace:IamGroup
    properties:
      name: '#name#'
  userIamUser:
    type: dynatrace:IamUser
    name: user
    properties:
      email: '#name#@example.com'
      groups:
        - ${group.id}
  connection:
    type: dynatrace:GithubConnection
    properties:
      name: '#name#'
      type: pat
      token: azAZ09
  permission:
    type: dynatrace:SettingsPermissions
    properties:
      settingsObjectId: ${connection.id}
      allUsers: none
      users:
        users:
          - uid: ${user.uid}
            access: write
      groups:
        groups:
          - id: ${group.id}
            access: read
variables:
  # because the UID is not returned for the resource, we need data
  user:
    fn::invoke:
      function: dynatrace:getIamUser
      arguments:
        email: ${userIamUser.id}

pulumi {
  required_providers {
    dynatrace = {
      source = "pulumi/dynatrace"
    }
  }
}

data "dynatrace_getiamuser" "user" {
  email = dynatrace_iamuser.user.id
}

resource "dynatrace_iamgroup" "group" {
  name = "#name#"
}
resource "dynatrace_iamuser" "user" {
  email  = "#name#@example.com"
  groups = [dynatrace_iamgroup.group.id]
}
resource "dynatrace_githubconnection" "connection" {
  name  = "#name#"
  type  = "pat"
  token = "azAZ09"
}
resource "dynatrace_settingspermissions" "permission" {
  settings_object_id = dynatrace_githubconnection.connection.id
  all_users          = "none"
  users = {
    users = [{
      "uid"    = data.dynatrace_getiamuser.user.uid
      "access" = "write"
    }]
  }
  groups = {
    groups = [{
      "id"     = dynatrace_iamgroup.group.id
      "access" = "read"
    }]
  }
}
// because the UID is not returned for the resource, we need data

var settingsPermissionsResource = new Dynatrace.SettingsPermissions("settingsPermissionsResource", new()
{
    SettingsObjectId = "string",
    AllUsers = "string",
    Groups = new Dynatrace.Inputs.SettingsPermissionsGroupsArgs
    {
        Groups = new[]
        {
            new Dynatrace.Inputs.SettingsPermissionsGroupsGroupArgs
            {
                Access = "string",
                Id = "string",
            },
        },
    },
    Users = new Dynatrace.Inputs.SettingsPermissionsUsersArgs
    {
        Users = new[]
        {
            new Dynatrace.Inputs.SettingsPermissionsUsersUserArgs
            {
                Access = "string",
                Uid = "string",
            },
        },
    },
});

example, err := dynatrace.NewSettingsPermissions(ctx, "settingsPermissionsResource", &dynatrace.SettingsPermissionsArgs{
	SettingsObjectId: pulumi.String("string"),
	AllUsers:         pulumi.String("string"),
	Groups: &dynatrace.SettingsPermissionsGroupsArgs{
		Groups: dynatrace.SettingsPermissionsGroupsGroupArray{
			&dynatrace.SettingsPermissionsGroupsGroupArgs{
				Access: pulumi.String("string"),
				Id:     pulumi.String("string"),
			},
		},
	},
	Users: &dynatrace.SettingsPermissionsUsersArgs{
		Users: dynatrace.SettingsPermissionsUsersUserArray{
			&dynatrace.SettingsPermissionsUsersUserArgs{
				Access: pulumi.String("string"),
				Uid:    pulumi.String("string"),
			},
		},
	},
})

resource "dynatrace_settingspermissions" "settingsPermissionsResource" {
  settings_object_id = "string"
  all_users          = "string"
  groups = {
    groups = [{
      "access" = "string"
      "id"     = "string"
    }]
  }
  users = {
    users = [{
      "access" = "string"
      "uid"    = "string"
    }]
  }
}

var settingsPermissionsResource = new SettingsPermissions("settingsPermissionsResource", SettingsPermissionsArgs.builder()
    .settingsObjectId("string")
    .allUsers("string")
    .groups(SettingsPermissionsGroupsArgs.builder()
        .groups(SettingsPermissionsGroupsGroupArgs.builder()
            .access("string")
            .id("string")
            .build())
        .build())
    .users(SettingsPermissionsUsersArgs.builder()
        .users(SettingsPermissionsUsersUserArgs.builder()
            .access("string")
            .uid("string")
            .build())
        .build())
    .build());

settings_permissions_resource = dynatrace.SettingsPermissions("settingsPermissionsResource",
    settings_object_id="string",
    all_users="string",
    groups={
        "groups": [{
            "access": "string",
            "id": "string",
        }],
    },
    users={
        "users": [{
            "access": "string",
            "uid": "string",
        }],
    })

const settingsPermissionsResource = new dynatrace.SettingsPermissions("settingsPermissionsResource", {
    settingsObjectId: "string",
    allUsers: "string",
    groups: {
        groups: [{
            access: "string",
            id: "string",
        }],
    },
    users: {
        users: [{
            access: "string",
            uid: "string",
        }],
    },
});

type: dynatrace:SettingsPermissions
properties:
    allUsers: string
    groups:
        groups:
            - access: string
              id: string
    settingsObjectId: string
    users:
        users:
            - access: string
              uid: string