pulumi-slack-kotlin/com.pulumi.slack.kotlin/Usergroup

Usergroup

class Usergroup : KotlinCustomResource

Manages a Slack User Group.

Required scopes

This resource requires the following scopes:

usergroups:write
usergroups:read The Slack API methods used by the resource are:
usergroups.create
usergroups.enable
usergroups.disable
usergroups.update
usergroups.list
usergroups.users.update If you get missing_scope errors while using this resource check the scopes against the documentation for the methods above.

Example Usage

import * as pulumi from "@pulumi/pulumi";
import * as slack from "@pulumi/slack";
const myGroup = new slack.Usergroup("my_group", {
    name: "TestGroup",
    handle: "test",
    description: "Test user group",
    users: ["USER00"],
    channels: ["CHANNEL00"],
});

import pulumi
import pulumi_slack as slack
my_group = slack.Usergroup("my_group",
    name="TestGroup",
    handle="test",
    description="Test user group",
    users=["USER00"],
    channels=["CHANNEL00"])

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Slack = Pulumi.Slack;
return await Deployment.RunAsync(() =>
{
    var myGroup = new Slack.Usergroup("my_group", new()
    {
        Name = "TestGroup",
        Handle = "test",
        Description = "Test user group",
        Users = new[]
        {
            "USER00",
        },
        Channels = new[]
        {
            "CHANNEL00",
        },
    });
});

package main
import (
	"github.com/pulumi/pulumi-slack/sdk/go/slack"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := slack.NewUsergroup(ctx, "my_group", &slack.UsergroupArgs{
			Name:        pulumi.String("TestGroup"),
			Handle:      pulumi.String("test"),
			Description: pulumi.String("Test user group"),
			Users: pulumi.StringArray{
				pulumi.String("USER00"),
			},
			Channels: pulumi.StringArray{
				pulumi.String("CHANNEL00"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.slack.Usergroup;
import com.pulumi.slack.UsergroupArgs;
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 myGroup = new Usergroup("myGroup", UsergroupArgs.builder()
            .name("TestGroup")
            .handle("test")
            .description("Test user group")
            .users("USER00")
            .channels("CHANNEL00")
            .build());
    }
}

resources:
  myGroup:
    type: slack:Usergroup
    name: my_group
    properties:
      name: TestGroup
      handle: test
      description: Test user group
      users:
        - USER00
      channels:
        - CHANNEL00

Note that if a channel is removed from the channels list users are not removed from the channel. In order to keep the users in the groups and in the channel in sync set permanent_users in the channel:

import * as pulumi from "@pulumi/pulumi";
import * as slack from "@pulumi/slack";
const myGroup = new slack.Usergroup("my_group", {
    name: "TestGroup",
    handle: "test",
    description: "Test user group",
    users: ["USER00"],
});
const test = new slack.Conversation("test", {
    name: "my-channel",
    topic: "The topic for my channel",
    permanentMembers: myGroup.users,
    isPrivate: true,
});

import pulumi
import pulumi_slack as slack
my_group = slack.Usergroup("my_group",
    name="TestGroup",
    handle="test",
    description="Test user group",
    users=["USER00"])
test = slack.Conversation("test",
    name="my-channel",
    topic="The topic for my channel",
    permanent_members=my_group.users,
    is_private=True)

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Slack = Pulumi.Slack;
return await Deployment.RunAsync(() =>
{
    var myGroup = new Slack.Usergroup("my_group", new()
    {
        Name = "TestGroup",
        Handle = "test",
        Description = "Test user group",
        Users = new[]
        {
            "USER00",
        },
    });
    var test = new Slack.Conversation("test", new()
    {
        Name = "my-channel",
        Topic = "The topic for my channel",
        PermanentMembers = myGroup.Users,
        IsPrivate = true,
    });
});

package main
import (
	"github.com/pulumi/pulumi-slack/sdk/go/slack"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		myGroup, err := slack.NewUsergroup(ctx, "my_group", &slack.UsergroupArgs{
			Name:        pulumi.String("TestGroup"),
			Handle:      pulumi.String("test"),
			Description: pulumi.String("Test user group"),
			Users: pulumi.StringArray{
				pulumi.String("USER00"),
			},
		})
		if err != nil {
			return err
		}
		_, err = slack.NewConversation(ctx, "test", &slack.ConversationArgs{
			Name:             pulumi.String("my-channel"),
			Topic:            pulumi.String("The topic for my channel"),
			PermanentMembers: myGroup.Users,
			IsPrivate:        pulumi.Bool(true),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.slack.Usergroup;
import com.pulumi.slack.UsergroupArgs;
import com.pulumi.slack.Conversation;
import com.pulumi.slack.ConversationArgs;
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 myGroup = new Usergroup("myGroup", UsergroupArgs.builder()
            .name("TestGroup")
            .handle("test")
            .description("Test user group")
            .users("USER00")
            .build());
        var test = new Conversation("test", ConversationArgs.builder()
            .name("my-channel")
            .topic("The topic for my channel")
            .permanentMembers(myGroup.users())
            .isPrivate(true)
            .build());
    }
}

resources:
  myGroup:
    type: slack:Usergroup
    name: my_group
    properties:
      name: TestGroup
      handle: test
      description: Test user group
      users:
        - USER00
  test:
    type: slack:Conversation
    properties:
      name: my-channel
      topic: The topic for my channel
      permanentMembers: ${myGroup.users}
      isPrivate: true

Import

slack_usergroup can be imported using the ID of the group, e.g.

$ pulumi import slack:index/usergroup:Usergroup my_group S022GE79E9G

Properties

channels

val channels: Output<List<String>>?

channel IDs for which the User Group uses as a default.

description

val description: Output<String>?

a short description of the User Group.

handle

val handle: Output<String>?

a mention handle. Must be unique among channels, users and User Groups.

val id: Output<String>

name

val name: Output<String>

a name for the User Group. Must be unique among User Groups.

pulumiChildResources

val pulumiChildResources: Set<KotlinResource>

pulumiResourceName

val pulumiResourceName: String

pulumiResourceType

val pulumiResourceType: String

urn

val urn: Output<String>

users

val users: Output<List<String>>?

user IDs that represent the entire list of users for the User Group.