managedUser.go

// Code generated by the Pulumi Terraform Bridge (tfgen) Tool DO NOT EDIT.
// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! ***

package artifactory

import (
	"context"
	"reflect"

	"errors"
	"github.com/pulumi/pulumi-artifactory/sdk/v4/go/artifactory/internal"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumix"
)

// ## Example Usage
//
// ```go
// package main
//
// import (
//
//	"github.com/pulumi/pulumi-artifactory/sdk/v4/go/artifactory"
//	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
//
// )
//
//	func main() {
//		pulumi.Run(func(ctx *pulumi.Context) error {
//			_, err := artifactory.NewManagedUser(ctx, "test-user", &artifactory.ManagedUserArgs{
//				Email: pulumi.String("test-user@artifactory-terraform.com"),
//				Groups: pulumi.StringArray{
//					pulumi.String("readers"),
//					pulumi.String("logged-in-users"),
//				},
//				Password: pulumi.String("my super secret password"),
//			})
//			if err != nil {
//				return err
//			}
//			return nil
//		})
//	}
//
// ```
//
// ## Import
//
// ```sh
//
//	$ pulumi import artifactory:index/managedUser:ManagedUser test-user myusername
//
// ```
type ManagedUser struct {
	pulumi.CustomResourceState

	// (Optional, Default: false) When enabled, this user is an administrator with all the ensuing privileges.
	Admin pulumi.BoolOutput `pulumi:"admin"`
	// (Optional, Default: true) When enabled, this user can only access the system through the REST API. This option cannot be set if the user has Admin privileges.
	DisableUiAccess pulumi.BoolOutput `pulumi:"disableUiAccess"`
	// Email for user.
	Email pulumi.StringOutput `pulumi:"email"`
	// List of groups this user is a part of. If no groups set, `readers` group will be added by default. If other groups are assigned, `readers` must be added to the list manually to avoid state drift.
	Groups pulumi.StringArrayOutput `pulumi:"groups"`
	// (Optional, Default: false) When enabled, disables the fallback mechanism for using an internal password when external authentication (such as LDAP) is enabled.
	InternalPasswordDisabled pulumi.BoolOutput `pulumi:"internalPasswordDisabled"`
	// Username for user. May contain lowercase letters, numbers and symbols: '.-_@'
	Name pulumi.StringOutput `pulumi:"name"`
	// (Optional, Sensitive) Password for the user. When omitted, a random password is generated using the following password policy: 12 characters with 1 digit, 1 symbol, with upper and lower case letters
	Password pulumi.StringPtrOutput `pulumi:"password"`
	// (Optional, Default: true) When enabled, this user can update their profile details (except for the password. Only an administrator can update the password). There may be cases in which you want to leave this unset to prevent users from updating their profile. For example, a departmental user with a single password shared between all department members.
	ProfileUpdatable pulumi.BoolOutput `pulumi:"profileUpdatable"`
}

// NewManagedUser registers a new resource with the given unique name, arguments, and options.
func NewManagedUser(ctx *pulumi.Context,
	name string, args *ManagedUserArgs, opts ...pulumi.ResourceOption) (*ManagedUser, error) {
	if args == nil {
		return nil, errors.New("missing one or more required arguments")
	}

	if args.Email == nil {
		return nil, errors.New("invalid value for required argument 'Email'")
	}
	if args.Password != nil {
		args.Password = pulumi.ToSecret(args.Password).(pulumi.StringPtrInput)
	}
	secrets := pulumi.AdditionalSecretOutputs([]string{
		"password",
	})
	opts = append(opts, secrets)
	opts = internal.PkgResourceDefaultOpts(opts)
	var resource ManagedUser
	err := ctx.RegisterResource("artifactory:index/managedUser:ManagedUser", name, args, &resource, opts...)
	if err != nil {
		return nil, err
	}
	return &resource, nil
}

// GetManagedUser gets an existing ManagedUser resource's state with the given name, ID, and optional
// state properties that are used to uniquely qualify the lookup (nil if not required).
func GetManagedUser(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *ManagedUserState, opts ...pulumi.ResourceOption) (*ManagedUser, error) {
	var resource ManagedUser
	err := ctx.ReadResource("artifactory:index/managedUser:ManagedUser", name, id, state, &resource, opts...)
	if err != nil {
		return nil, err
	}
	return &resource, nil
}

// Input properties used for looking up and filtering ManagedUser resources.
type managedUserState struct {
	// (Optional, Default: false) When enabled, this user is an administrator with all the ensuing privileges.
	Admin *bool `pulumi:"admin"`
	// (Optional, Default: true) When enabled, this user can only access the system through the REST API. This option cannot be set if the user has Admin privileges.
	DisableUiAccess *bool `pulumi:"disableUiAccess"`
	// Email for user.
	Email *string `pulumi:"email"`
	// List of groups this user is a part of. If no groups set, `readers` group will be added by default. If other groups are assigned, `readers` must be added to the list manually to avoid state drift.
	Groups []string `pulumi:"groups"`
	// (Optional, Default: false) When enabled, disables the fallback mechanism for using an internal password when external authentication (such as LDAP) is enabled.
	InternalPasswordDisabled *bool `pulumi:"internalPasswordDisabled"`
	// Username for user. May contain lowercase letters, numbers and symbols: '.-_@'
	Name *string `pulumi:"name"`
	// (Optional, Sensitive) Password for the user. When omitted, a random password is generated using the following password policy: 12 characters with 1 digit, 1 symbol, with upper and lower case letters
	Password *string `pulumi:"password"`
	// (Optional, Default: true) When enabled, this user can update their profile details (except for the password. Only an administrator can update the password). There may be cases in which you want to leave this unset to prevent users from updating their profile. For example, a departmental user with a single password shared between all department members.
	ProfileUpdatable *bool `pulumi:"profileUpdatable"`
}

type ManagedUserState struct {
	// (Optional, Default: false) When enabled, this user is an administrator with all the ensuing privileges.
	Admin pulumi.BoolPtrInput
	// (Optional, Default: true) When enabled, this user can only access the system through the REST API. This option cannot be set if the user has Admin privileges.
	DisableUiAccess pulumi.BoolPtrInput
	// Email for user.
	Email pulumi.StringPtrInput
	// List of groups this user is a part of. If no groups set, `readers` group will be added by default. If other groups are assigned, `readers` must be added to the list manually to avoid state drift.
	Groups pulumi.StringArrayInput
	// (Optional, Default: false) When enabled, disables the fallback mechanism for using an internal password when external authentication (such as LDAP) is enabled.
	InternalPasswordDisabled pulumi.BoolPtrInput
	// Username for user. May contain lowercase letters, numbers and symbols: '.-_@'
	Name pulumi.StringPtrInput
	// (Optional, Sensitive) Password for the user. When omitted, a random password is generated using the following password policy: 12 characters with 1 digit, 1 symbol, with upper and lower case letters
	Password pulumi.StringPtrInput
	// (Optional, Default: true) When enabled, this user can update their profile details (except for the password. Only an administrator can update the password). There may be cases in which you want to leave this unset to prevent users from updating their profile. For example, a departmental user with a single password shared between all department members.
	ProfileUpdatable pulumi.BoolPtrInput
}

func (ManagedUserState) ElementType() reflect.Type {
	return reflect.TypeOf((*managedUserState)(nil)).Elem()
}

type managedUserArgs struct {
	// (Optional, Default: false) When enabled, this user is an administrator with all the ensuing privileges.
	Admin *bool `pulumi:"admin"`
	// (Optional, Default: true) When enabled, this user can only access the system through the REST API. This option cannot be set if the user has Admin privileges.
	DisableUiAccess *bool `pulumi:"disableUiAccess"`
	// Email for user.
	Email string `pulumi:"email"`
	// List of groups this user is a part of. If no groups set, `readers` group will be added by default. If other groups are assigned, `readers` must be added to the list manually to avoid state drift.
	Groups []string `pulumi:"groups"`
	// (Optional, Default: false) When enabled, disables the fallback mechanism for using an internal password when external authentication (such as LDAP) is enabled.
	InternalPasswordDisabled *bool `pulumi:"internalPasswordDisabled"`
	// Username for user. May contain lowercase letters, numbers and symbols: '.-_@'
	Name *string `pulumi:"name"`
	// (Optional, Sensitive) Password for the user. When omitted, a random password is generated using the following password policy: 12 characters with 1 digit, 1 symbol, with upper and lower case letters
	Password *string `pulumi:"password"`
	// (Optional, Default: true) When enabled, this user can update their profile details (except for the password. Only an administrator can update the password). There may be cases in which you want to leave this unset to prevent users from updating their profile. For example, a departmental user with a single password shared between all department members.
	ProfileUpdatable *bool `pulumi:"profileUpdatable"`
}

// The set of arguments for constructing a ManagedUser resource.
type ManagedUserArgs struct {
	// (Optional, Default: false) When enabled, this user is an administrator with all the ensuing privileges.
	Admin pulumi.BoolPtrInput
	// (Optional, Default: true) When enabled, this user can only access the system through the REST API. This option cannot be set if the user has Admin privileges.
	DisableUiAccess pulumi.BoolPtrInput
	// Email for user.
	Email pulumi.StringInput
	// List of groups this user is a part of. If no groups set, `readers` group will be added by default. If other groups are assigned, `readers` must be added to the list manually to avoid state drift.
	Groups pulumi.StringArrayInput
	// (Optional, Default: false) When enabled, disables the fallback mechanism for using an internal password when external authentication (such as LDAP) is enabled.
	InternalPasswordDisabled pulumi.BoolPtrInput
	// Username for user. May contain lowercase letters, numbers and symbols: '.-_@'
	Name pulumi.StringPtrInput
	// (Optional, Sensitive) Password for the user. When omitted, a random password is generated using the following password policy: 12 characters with 1 digit, 1 symbol, with upper and lower case letters
	Password pulumi.StringPtrInput
	// (Optional, Default: true) When enabled, this user can update their profile details (except for the password. Only an administrator can update the password). There may be cases in which you want to leave this unset to prevent users from updating their profile. For example, a departmental user with a single password shared between all department members.
	ProfileUpdatable pulumi.BoolPtrInput
}

func (ManagedUserArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*managedUserArgs)(nil)).Elem()
}

type ManagedUserInput interface {
	pulumi.Input

	ToManagedUserOutput() ManagedUserOutput
	ToManagedUserOutputWithContext(ctx context.Context) ManagedUserOutput
}

func (*ManagedUser) ElementType() reflect.Type {
	return reflect.TypeOf((**ManagedUser)(nil)).Elem()
}

func (i *ManagedUser) ToManagedUserOutput() ManagedUserOutput {
	return i.ToManagedUserOutputWithContext(context.Background())
}

func (i *ManagedUser) ToManagedUserOutputWithContext(ctx context.Context) ManagedUserOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ManagedUserOutput)
}

func (i *ManagedUser) ToOutput(ctx context.Context) pulumix.Output[*ManagedUser] {
	return pulumix.Output[*ManagedUser]{
		OutputState: i.ToManagedUserOutputWithContext(ctx).OutputState,
	}
}

// ManagedUserArrayInput is an input type that accepts ManagedUserArray and ManagedUserArrayOutput values.
// You can construct a concrete instance of `ManagedUserArrayInput` via:
//
//	ManagedUserArray{ ManagedUserArgs{...} }
type ManagedUserArrayInput interface {
	pulumi.Input

	ToManagedUserArrayOutput() ManagedUserArrayOutput
	ToManagedUserArrayOutputWithContext(context.Context) ManagedUserArrayOutput
}

type ManagedUserArray []ManagedUserInput

func (ManagedUserArray) ElementType() reflect.Type {
	return reflect.TypeOf((*[]*ManagedUser)(nil)).Elem()
}

func (i ManagedUserArray) ToManagedUserArrayOutput() ManagedUserArrayOutput {
	return i.ToManagedUserArrayOutputWithContext(context.Background())
}

func (i ManagedUserArray) ToManagedUserArrayOutputWithContext(ctx context.Context) ManagedUserArrayOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ManagedUserArrayOutput)
}

func (i ManagedUserArray) ToOutput(ctx context.Context) pulumix.Output[[]*ManagedUser] {
	return pulumix.Output[[]*ManagedUser]{
		OutputState: i.ToManagedUserArrayOutputWithContext(ctx).OutputState,
	}
}

// ManagedUserMapInput is an input type that accepts ManagedUserMap and ManagedUserMapOutput values.
// You can construct a concrete instance of `ManagedUserMapInput` via:
//
//	ManagedUserMap{ "key": ManagedUserArgs{...} }
type ManagedUserMapInput interface {
	pulumi.Input

	ToManagedUserMapOutput() ManagedUserMapOutput
	ToManagedUserMapOutputWithContext(context.Context) ManagedUserMapOutput
}

type ManagedUserMap map[string]ManagedUserInput

func (ManagedUserMap) ElementType() reflect.Type {
	return reflect.TypeOf((*map[string]*ManagedUser)(nil)).Elem()
}

func (i ManagedUserMap) ToManagedUserMapOutput() ManagedUserMapOutput {
	return i.ToManagedUserMapOutputWithContext(context.Background())
}

func (i ManagedUserMap) ToManagedUserMapOutputWithContext(ctx context.Context) ManagedUserMapOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ManagedUserMapOutput)
}

func (i ManagedUserMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*ManagedUser] {
	return pulumix.Output[map[string]*ManagedUser]{
		OutputState: i.ToManagedUserMapOutputWithContext(ctx).OutputState,
	}
}

type ManagedUserOutput struct{ *pulumi.OutputState }

func (ManagedUserOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**ManagedUser)(nil)).Elem()
}

func (o ManagedUserOutput) ToManagedUserOutput() ManagedUserOutput {
	return o
}

func (o ManagedUserOutput) ToManagedUserOutputWithContext(ctx context.Context) ManagedUserOutput {
	return o
}

func (o ManagedUserOutput) ToOutput(ctx context.Context) pulumix.Output[*ManagedUser] {
	return pulumix.Output[*ManagedUser]{
		OutputState: o.OutputState,
	}
}

// (Optional, Default: false) When enabled, this user is an administrator with all the ensuing privileges.
func (o ManagedUserOutput) Admin() pulumi.BoolOutput {
	return o.ApplyT(func(v *ManagedUser) pulumi.BoolOutput { return v.Admin }).(pulumi.BoolOutput)
}

// (Optional, Default: true) When enabled, this user can only access the system through the REST API. This option cannot be set if the user has Admin privileges.
func (o ManagedUserOutput) DisableUiAccess() pulumi.BoolOutput {
	return o.ApplyT(func(v *ManagedUser) pulumi.BoolOutput { return v.DisableUiAccess }).(pulumi.BoolOutput)
}

// Email for user.
func (o ManagedUserOutput) Email() pulumi.StringOutput {
	return o.ApplyT(func(v *ManagedUser) pulumi.StringOutput { return v.Email }).(pulumi.StringOutput)
}

// List of groups this user is a part of. If no groups set, `readers` group will be added by default. If other groups are assigned, `readers` must be added to the list manually to avoid state drift.
func (o ManagedUserOutput) Groups() pulumi.StringArrayOutput {
	return o.ApplyT(func(v *ManagedUser) pulumi.StringArrayOutput { return v.Groups }).(pulumi.StringArrayOutput)
}

// (Optional, Default: false) When enabled, disables the fallback mechanism for using an internal password when external authentication (such as LDAP) is enabled.
func (o ManagedUserOutput) InternalPasswordDisabled() pulumi.BoolOutput {
	return o.ApplyT(func(v *ManagedUser) pulumi.BoolOutput { return v.InternalPasswordDisabled }).(pulumi.BoolOutput)
}

// Username for user. May contain lowercase letters, numbers and symbols: '.-_@'
func (o ManagedUserOutput) Name() pulumi.StringOutput {
	return o.ApplyT(func(v *ManagedUser) pulumi.StringOutput { return v.Name }).(pulumi.StringOutput)
}

// (Optional, Sensitive) Password for the user. When omitted, a random password is generated using the following password policy: 12 characters with 1 digit, 1 symbol, with upper and lower case letters
func (o ManagedUserOutput) Password() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *ManagedUser) pulumi.StringPtrOutput { return v.Password }).(pulumi.StringPtrOutput)
}

// (Optional, Default: true) When enabled, this user can update their profile details (except for the password. Only an administrator can update the password). There may be cases in which you want to leave this unset to prevent users from updating their profile. For example, a departmental user with a single password shared between all department members.
func (o ManagedUserOutput) ProfileUpdatable() pulumi.BoolOutput {
	return o.ApplyT(func(v *ManagedUser) pulumi.BoolOutput { return v.ProfileUpdatable }).(pulumi.BoolOutput)
}

type ManagedUserArrayOutput struct{ *pulumi.OutputState }

func (ManagedUserArrayOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*[]*ManagedUser)(nil)).Elem()
}

func (o ManagedUserArrayOutput) ToManagedUserArrayOutput() ManagedUserArrayOutput {
	return o
}

func (o ManagedUserArrayOutput) ToManagedUserArrayOutputWithContext(ctx context.Context) ManagedUserArrayOutput {
	return o
}

func (o ManagedUserArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*ManagedUser] {
	return pulumix.Output[[]*ManagedUser]{
		OutputState: o.OutputState,
	}
}

func (o ManagedUserArrayOutput) Index(i pulumi.IntInput) ManagedUserOutput {
	return pulumi.All(o, i).ApplyT(func(vs []interface{}) *ManagedUser {
		return vs[0].([]*ManagedUser)[vs[1].(int)]
	}).(ManagedUserOutput)
}

type ManagedUserMapOutput struct{ *pulumi.OutputState }

func (ManagedUserMapOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*map[string]*ManagedUser)(nil)).Elem()
}

func (o ManagedUserMapOutput) ToManagedUserMapOutput() ManagedUserMapOutput {
	return o
}

func (o ManagedUserMapOutput) ToManagedUserMapOutputWithContext(ctx context.Context) ManagedUserMapOutput {
	return o
}

func (o ManagedUserMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*ManagedUser] {
	return pulumix.Output[map[string]*ManagedUser]{
		OutputState: o.OutputState,
	}
}

func (o ManagedUserMapOutput) MapIndex(k pulumi.StringInput) ManagedUserOutput {
	return pulumi.All(o, k).ApplyT(func(vs []interface{}) *ManagedUser {
		return vs[0].(map[string]*ManagedUser)[vs[1].(string)]
	}).(ManagedUserOutput)
}

func init() {
	pulumi.RegisterInputType(reflect.TypeOf((*ManagedUserInput)(nil)).Elem(), &ManagedUser{})
	pulumi.RegisterInputType(reflect.TypeOf((*ManagedUserArrayInput)(nil)).Elem(), ManagedUserArray{})
	pulumi.RegisterInputType(reflect.TypeOf((*ManagedUserMapInput)(nil)).Elem(), ManagedUserMap{})
	pulumi.RegisterOutputType(ManagedUserOutput{})
	pulumi.RegisterOutputType(ManagedUserArrayOutput{})
	pulumi.RegisterOutputType(ManagedUserMapOutput{})
}