feat(account): add commands for listing accounts and permissions (#214)

Author: kangasta

.github/workflows/examples.yml

@@ -1,11 +1,17 @@
 name: Examples
+
 on:
   pull_request:
     paths:
       - "**.go"
       - "go.mod"
       - "go.sum"
       - "examples/**.md"
+
+concurrency:
+  group: ${{ github.repository }}-${{ github.workflow }}
+  cancel-in-progress: false
+
 jobs:
   test:
     name: Test

CHANGELOG.md

@@ -11,6 +11,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 - Support for storage encryption to storage `create`, `clone`, `show`, and `list` commands as well as server `create` and `show` commands.
 - _Managed object storages_ field to human readable output of `account show`.
+- Commands for listing accounts and permissions.
 
 ### Removed
 

internal/commands/account/list.go

@@ -0,0 +1,60 @@
+package account
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/UpCloudLtd/upcloud-cli/v3/internal/commands"
+	"github.com/UpCloudLtd/upcloud-cli/v3/internal/output"
+	"github.com/jedib0t/go-pretty/v6/text"
+)
+
+// ListCommand creates the 'account list' command
+func ListCommand() commands.Command {
+	return &listCommand{
+		BaseCommand: commands.New("list", "List sub-accounts", "upctl account list"),
+	}
+}
+
+type listCommand struct {
+	*commands.BaseCommand
+}
+
+// ExecuteWithoutArguments implements commands.NoArgumentCommand
+func (l *listCommand) ExecuteWithoutArguments(exec commands.Executor) (output.Output, error) {
+	svc := exec.Account()
+	accounts, err := svc.GetAccountList(exec.Context())
+	if err != nil {
+		return nil, err
+	}
+
+	rows := []output.TableRow{}
+	for _, a := range accounts {
+		rows = append(rows, output.TableRow{
+			a.Username,
+			a.Type,
+			a.Roles.Role,
+		})
+	}
+
+	return output.MarshaledWithHumanOutput{
+		Value: accounts,
+		Output: output.Table{
+			Columns: []output.TableColumn{
+				{Key: "username", Header: "Username"},
+				{Key: "type", Header: "Type"},
+				{Key: "roles", Header: "Roles", Format: formatRoles},
+			},
+			Rows: rows,
+		},
+	}, nil
+}
+
+func formatRoles(val interface{}) (text.Colors, string, error) {
+	roles, ok := val.([]string)
+	if !ok {
+		return nil, "", fmt.Errorf("cannot parse %T, expected []string", val)
+	}
+
+	return nil, strings.Join(roles, ", "), nil
+}

internal/commands/account/permissions/list.go

@@ -0,0 +1,89 @@
+package permissions
+
+import (
+	"fmt"
+
+	"github.com/UpCloudLtd/upcloud-cli/v3/internal/commands"
+	"github.com/UpCloudLtd/upcloud-cli/v3/internal/completion"
+	"github.com/UpCloudLtd/upcloud-cli/v3/internal/config"
+	"github.com/UpCloudLtd/upcloud-cli/v3/internal/format"
+	"github.com/UpCloudLtd/upcloud-cli/v3/internal/namedargs"
+	"github.com/UpCloudLtd/upcloud-cli/v3/internal/output"
+	"github.com/UpCloudLtd/upcloud-cli/v3/internal/ui"
+	"github.com/UpCloudLtd/upcloud-go-api/v6/upcloud"
+	"github.com/UpCloudLtd/upcloud-go-api/v6/upcloud/request"
+	"github.com/jedib0t/go-pretty/v6/text"
+	"github.com/spf13/pflag"
+)
+
+// ListCommand creates the 'permissions list' command
+func ListCommand() commands.Command {
+	return &listCommand{
+		BaseCommand: commands.New("list", "List permissions", "upctl account show"),
+	}
+}
+
+type listCommand struct {
+	*commands.BaseCommand
+	username string
+}
+
+// InitCommand implements Command.InitCommand
+func (l *listCommand) InitCommand() {
+	flagSet := &pflag.FlagSet{}
+	flagSet.StringVar(&l.username, "username", "", "Filter permissions by username.")
+
+	l.AddFlags(flagSet)
+}
+
+func (l *listCommand) InitCommandWithConfig(cfg *config.Config) {
+	_ = l.Cobra().RegisterFlagCompletionFunc("username", namedargs.CompletionFunc(completion.Username{}, cfg))
+}
+
+func (l *listCommand) ExecuteWithoutArguments(exec commands.Executor) (output.Output, error) {
+	svc := exec.All()
+	permissions, err := svc.GetPermissions(exec.Context(), &request.GetPermissionsRequest{})
+	if err != nil {
+		return nil, err
+	}
+
+	filtered := make([]upcloud.Permission, 0)
+	rows := []output.TableRow{}
+	for _, permission := range permissions {
+		if permission.User == l.username || l.username == "" {
+			filtered = append(filtered, permission)
+			rows = append(rows, output.TableRow{
+				permission.User,
+				permission.TargetType,
+				permission.TargetIdentifier,
+				permission.Options,
+			})
+		}
+	}
+	return output.MarshaledWithHumanOutput{
+		Value: filtered,
+		Output: output.Table{
+			Columns: []output.TableColumn{
+				{Key: "username", Header: "Username"},
+				{Key: "target_type", Header: "Target type"},
+				{Key: "target_identifier", Header: "Target identifier", Colour: ui.DefaultUUUIDColours},
+				{Key: "options", Header: "Options", Format: formatOptions},
+			},
+			Rows: rows,
+		},
+	}, nil
+}
+
+func formatOptions(val interface{}) (text.Colors, string, error) {
+	options, ok := val.(*upcloud.PermissionOptions)
+	if !ok {
+		return nil, "", fmt.Errorf("cannot parse %T, expected *upcloud.PermissionOptions", val)
+	}
+
+	if options == nil {
+		return nil, "", nil
+	}
+
+	colors, value, _ := format.Boolean(options.Storage)
+	return nil, fmt.Sprintf("Storage: %s", colors.Sprint(value)), nil
+}

internal/commands/account/permissions/permissions.go

@@ -0,0 +1,14 @@
+package permissions
+
+import (
+	"github.com/UpCloudLtd/upcloud-cli/v3/internal/commands"
+)
+
+// BasePermissionsCommand creates the base 'permissions' command
+func BasePermissionsCommand() commands.Command {
+	return &permissionsCommand{commands.New("permissions", "Manage permissions")}
+}
+
+type permissionsCommand struct {
+	*commands.BaseCommand
+}

internal/commands/all/all.go

@@ -3,6 +3,7 @@ package all
 import (
 	"github.com/UpCloudLtd/upcloud-cli/v3/internal/commands"
 	"github.com/UpCloudLtd/upcloud-cli/v3/internal/commands/account"
+	"github.com/UpCloudLtd/upcloud-cli/v3/internal/commands/account/permissions"
 	"github.com/UpCloudLtd/upcloud-cli/v3/internal/commands/database"
 	databaseindex "github.com/UpCloudLtd/upcloud-cli/v3/internal/commands/database/index"
 	databaseproperties "github.com/UpCloudLtd/upcloud-cli/v3/internal/commands/database/properties"
@@ -103,6 +104,11 @@ func BuildCommands(rootCmd *cobra.Command, conf *config.Config) {
 	// Account
 	accountCommand := commands.BuildCommand(account.BaseAccountCommand(), rootCmd, conf)
 	commands.BuildCommand(account.ShowCommand(), accountCommand.Cobra(), conf)
+	commands.BuildCommand(account.ListCommand(), accountCommand.Cobra(), conf)
+
+	// Account permissions
+	permissionsCommand := commands.BuildCommand(permissions.BasePermissionsCommand(), accountCommand.Cobra(), conf)
+	commands.BuildCommand(permissions.ListCommand(), permissionsCommand.Cobra(), conf)
 
 	// Zone
 	zoneCommand := commands.BuildCommand(zone.BaseZoneCommand(), rootCmd, conf)

internal/completion/username.go

@@ -0,0 +1,29 @@
+package completion
+
+import (
+	"context"
+
+	"github.com/UpCloudLtd/upcloud-cli/v3/internal/service"
+
+	"github.com/spf13/cobra"
+)
+
+// Username implements argument completion for zones by id.
+type Username struct{}
+
+// make sure Kubernetes implements the interface
+var _ Provider = Username{}
+
+// CompleteArgument implements completion.Provider
+func (s Username) CompleteArgument(ctx context.Context, svc service.AllServices, toComplete string) ([]string, cobra.ShellCompDirective) {
+	accounts, err := svc.GetAccountList(ctx)
+	if err != nil {
+		return None(toComplete)
+	}
+	var vals []string
+	for _, account := range accounts {
+		vals = append(vals, account.Username)
+	}
+
+	return MatchStringPrefix(vals, toComplete, true), cobra.ShellCompDirectiveNoFileComp
+}

internal/mock/mock.go

@@ -1184,3 +1184,27 @@ func (m *Service) WaitForManagedObjectStorageOperationalState(ctx context.Contex
 func (m *Service) WaitForManagedObjectStorageDeletion(ctx context.Context, r *request.WaitForManagedObjectStorageDeletionRequest) error {
 	return nil
 }
+
+func (m *Service) GetPermissions(ctx context.Context, r *request.GetPermissionsRequest) (upcloud.Permissions, error) {
+	args := m.Called(r)
+	if args[0] == nil {
+		return nil, args.Error(1)
+	}
+	return args[0].(upcloud.Permissions), args.Error(1)
+}
+
+func (m *Service) GrantPermission(ctx context.Context, r *request.GrantPermissionRequest) (*upcloud.Permission, error) {
+	args := m.Called(r)
+	if args[0] == nil {
+		return nil, args.Error(1)
+	}
+	return args[0].(*upcloud.Permission), args.Error(1)
+}
+
+func (m *Service) RevokePermission(ctx context.Context, r *request.RevokePermissionRequest) error {
+	args := m.Called(r)
+	if args[0] == nil {
+		return args.Error(0)
+	}
+	return nil
+}

internal/service/service.go

@@ -18,4 +18,5 @@ type AllServices interface {
 	service.Kubernetes
 	service.ServerGroup
 	service.ManagedObjectStorage
+	service.Permission
 }