user.go

package create

import (
	"encoding/json"
	"io"
	"os"

	"github.com/ibm-verify/verifyctl/pkg/cmd/resource"
	"github.com/ibm-verify/verifyctl/pkg/config"
	"gopkg.in/yaml.v3"

	"github.com/ibm-verify/verify-sdk-go/pkg/config/directory"
	cmdutil "github.com/ibm-verify/verifyctl/pkg/util/cmd"
	"github.com/ibm-verify/verifyctl/pkg/util/templates"
	"github.com/spf13/cobra"

	contextx "github.com/ibm-verify/verify-sdk-go/pkg/core/context"
	errorsx "github.com/ibm-verify/verify-sdk-go/pkg/core/errors"
)

const (
	userUsage         = "user [options]"
	userMessagePrefix = "CreateUser"
	userEntitlements  = "Manage users"
	userResourceName  = "user"
)

var (
	userShortDesc = cmdutil.TranslateShortDesc(userMessagePrefix, "Additional options to create a user.")

	userLongDesc = templates.LongDesc(cmdutil.TranslateLongDesc(userMessagePrefix, `
		Additional options to create a user.

Resources managed on Verify have specific entitlements, so ensure that the application or API client used
with the 'auth' command is configured with the appropriate entitlements.

An empty resource file can be generated using:

	verifyctl create user --boilerplate

You can identify the entitlement required by running:

	verifyctl create user --entitlements`))

	userExamples = templates.Examples(cmdutil.TranslateExamples(userMessagePrefix, `
		# Create an empty user resource. This can be piped into a file.
		verifyctl create user --boilerplate

		# Create a user using a YAML file.
		verifyctl create -f "user.yaml"

		# Create a user using a JSON file.
		verifyctl create -f "user.json"`))
)

type userOptions struct {
	options

	config *config.CLIConfig
}

func newUserCommand(config *config.CLIConfig, streams io.ReadWriter) *cobra.Command {
	o := &userOptions{
		config: config,
	}

	cmd := &cobra.Command{
		Use:                   userUsage,
		Short:                 userShortDesc,
		Long:                  userLongDesc,
		Example:               userExamples,
		DisableFlagsInUseLine: true,
		Run: func(cmd *cobra.Command, args []string) {
			cmdutil.ExitOnError(cmd, o.Complete(cmd, args))
			cmdutil.ExitOnError(cmd, o.Validate(cmd, args))
			cmdutil.ExitOnError(cmd, o.Run(cmd, args))
		},
	}

	cmd.SetOut(streams)
	cmd.SetErr(streams)
	cmd.SetIn(streams)

	o.AddFlags(cmd)

	return cmd
}

func (o *userOptions) AddFlags(cmd *cobra.Command) {
	o.addCommonFlags(cmd, userResourceName)
	cmd.Flags().StringVarP(&o.file, "file", "f", "", "Path to the JSON file containing user data.")
}

func (o *userOptions) Complete(cmd *cobra.Command, args []string) error {
	return nil
}

func (o *userOptions) Validate(cmd *cobra.Command, args []string) error {
	if o.entitlements || o.boilerplate {
		return nil
	}

	if len(o.file) == 0 {
		return errorsx.G11NError("The 'file' option is required if no other options are used.")
	}
	return nil
}

func (o *userOptions) Run(cmd *cobra.Command, args []string) error {
	if o.entitlements {
		cmdutil.WriteString(cmd, entitlementsMessage+"  "+userEntitlements)
		return nil
	}

	if o.boilerplate {
		resourceObj := &resource.ResourceObject{
			Kind:       resource.ResourceTypePrefix + "User",
			APIVersion: "2.0",
			Data:       &directory.User{},
		}

		cmdutil.WriteAsYAML(cmd, resourceObj, cmd.OutOrStdout())
		return nil
	}

	_, err := o.config.SetAuthToContext(cmd.Context())
	if err != nil {
		return err
	}

	return o.createUser(cmd)
}

func (o *userOptions) createUser(cmd *cobra.Command) error {
	ctx := cmd.Context()
	vc := contextx.GetVerifyContext(ctx)

	// get the contents of the file
	b, err := os.ReadFile(o.file)
	if err != nil {
		vc.Logger.Errorf("Unable to read file; filename=%s, err=%v", o.file, err)
		return err
	}

	// create user with data
	return o.createUserWithData(cmd, b)
}

func (o *userOptions) createUserWithData(cmd *cobra.Command, data []byte) error {
	ctx := cmd.Context()
	vc := contextx.GetVerifyContext(ctx)

	// unmarshal to user
	user := &directory.User{}
	if err := yaml.Unmarshal(data, &user); err != nil {
		vc.Logger.Errorf("unable to unmarshal the user; err=%v", err)
		return err
	}

	client := directory.NewUserClient()
	resourceURI, err := client.CreateUser(ctx, user)
	if err != nil {
		return err
	}

	cmdutil.WriteString(cmd, "Resource created: "+resourceURI)
	return nil
}

func (o *userOptions) createUserFromDataMap(cmd *cobra.Command, data map[string]interface{}) error {
	ctx := cmd.Context()
	vc := contextx.GetVerifyContext(ctx)

	// unmarshal to user
	user := &directory.User{}
	b, err := json.Marshal(data)
	if err != nil {
		vc.Logger.Errorf("failed to marshal the data map; err=%v", err)
		return err
	}

	if err := json.Unmarshal(b, user); err != nil {
		vc.Logger.Errorf("unable to unmarshal to an user; err=%v", err)
		return err
	}

	client := directory.NewUserClient()
	resourceURI, err := client.CreateUser(ctx, user)
	if err != nil {
		vc.Logger.Errorf("unable to create the user; err=%v, user=%+v", err, user)
		return err
	}

	cmdutil.WriteString(cmd, "Resource created: "+resourceURI)
	return nil
}