Files
threshold/internal/cmd/commands/scopescmd/funcs.go
T

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

199 lines
5.4 KiB
Go
Raw Normal View History

2021-04-08 20:54:32 -04:00
// Copyright (c) HashiCorp, Inc.
2021-02-23 19:06:39 -05:00
// SPDX-License-Identifier: BUSL-1.1
2023-02-02 17:15:17 -08:00
2021-02-23 19:06:39 -05:00
package scopescmd
import (
"fmt"
"sort"
"time"
2021-05-04 19:57:35 -05:00
"github.com/hashicorp/boundary/api"
2021-02-23 19:06:39 -05:00
"github.com/hashicorp/boundary/api/scopes"
"github.com/hashicorp/boundary/internal/cmd/base"
)
2021-04-08 20:54:32 -04:00
const (
flagPrimaryAuthMethodIdName = "primary-auth-method-id"
flagSkipAdminRoleCreationName = "skip-admin-role-creation"
flagSkipDefaultRoleCreationName = "skip-default-role-creation"
)
2021-02-23 19:06:39 -05:00
func init() {
extraActionsFlagsMapFunc = extraActionsFlagsMapFuncImpl
extraFlagsFunc = extraFlagsFuncImpl
extraFlagsHandlingFunc = extraFlagsHandlingFuncImpl
}
func extraActionsFlagsMapFuncImpl() map[string][]string {
return map[string][]string{
2021-04-08 20:54:32 -04:00
"create": {flagSkipAdminRoleCreationName, flagSkipDefaultRoleCreationName},
"update": {flagPrimaryAuthMethodIdName},
2021-02-23 19:06:39 -05:00
}
}
type extraCmdVars struct {
flagSkipAdminRoleCreation bool
flagSkipDefaultRoleCreation bool
2021-04-08 20:54:32 -04:00
flagPrimaryAuthMethodId string
2021-02-23 19:06:39 -05:00
}
func extraFlagsFuncImpl(c *Command, set *base.FlagSets, f *base.FlagSet) {
for _, name := range flagsMap[c.Func] {
switch name {
2021-04-08 20:54:32 -04:00
case flagSkipAdminRoleCreationName:
2021-02-23 19:06:39 -05:00
f.BoolVar(&base.BoolVar{
2021-04-08 20:54:32 -04:00
Name: flagSkipAdminRoleCreationName,
2021-02-23 19:06:39 -05:00
Target: &c.flagSkipAdminRoleCreation,
Usage: "If set, a role granting the current user access to administer the newly-created scope will not automatically be created",
})
2021-04-08 20:54:32 -04:00
case flagSkipDefaultRoleCreationName:
2021-02-23 19:06:39 -05:00
f.BoolVar(&base.BoolVar{
2021-04-08 20:54:32 -04:00
Name: flagSkipDefaultRoleCreationName,
2021-02-23 19:06:39 -05:00
Target: &c.flagSkipDefaultRoleCreation,
Usage: "If set, a role granting the anonymous user access to log into auth methods and a few other actions within the newly-created scope will not automatically be created",
})
2021-04-08 20:54:32 -04:00
case flagPrimaryAuthMethodIdName:
f.StringVar(&base.StringVar{
Name: flagPrimaryAuthMethodIdName,
Target: &c.flagPrimaryAuthMethodId,
Usage: "If set, the primary auth method id for the scope. A primary auth method is allowed to create users on first login and is also used as a source for account full name and email for a scope's users",
})
2021-02-23 19:06:39 -05:00
}
}
}
2021-04-08 20:54:32 -04:00
func extraFlagsHandlingFuncImpl(c *Command, _ *base.FlagSets, opts *[]scopes.Option) bool {
2021-02-23 19:06:39 -05:00
if c.flagSkipAdminRoleCreation {
*opts = append(*opts, scopes.WithSkipAdminRoleCreation(c.flagSkipAdminRoleCreation))
}
if c.flagSkipDefaultRoleCreation {
*opts = append(*opts, scopes.WithSkipDefaultRoleCreation(c.flagSkipDefaultRoleCreation))
}
2021-04-08 20:54:32 -04:00
if c.flagPrimaryAuthMethodId != "" {
*opts = append(*opts, scopes.WithPrimaryAuthMethodId(c.flagPrimaryAuthMethodId))
}
2021-02-23 19:06:39 -05:00
return true
2021-02-23 19:06:39 -05:00
}
func (c *Command) printListTable(items []*scopes.Scope) string {
if len(items) == 0 {
return "No child scopes found"
}
var output []string
output = []string{
"",
"Scope information:",
}
for i, item := range items {
if i > 0 {
output = append(output, "")
}
if true {
output = append(output,
fmt.Sprintf(" ID: %s", item.Id),
)
}
if c.FlagRecursive {
output = append(output,
fmt.Sprintf(" Scope ID: %s", item.Scope.Id),
)
}
2021-05-04 19:57:35 -05:00
if item.Version > 0 {
2021-02-23 19:06:39 -05:00
output = append(output,
fmt.Sprintf(" Version: %d", item.Version),
)
}
if item.Name != "" {
output = append(output,
fmt.Sprintf(" Name: %s", item.Name),
)
}
if item.Description != "" {
output = append(output,
fmt.Sprintf(" Description: %s", item.Description),
)
}
2021-04-08 20:54:32 -04:00
if item.PrimaryAuthMethodId != "" {
output = append(output,
fmt.Sprintf(" PrimaryAuthMethodId: %s", item.PrimaryAuthMethodId),
)
}
2021-02-23 19:06:39 -05:00
if len(item.AuthorizedActions) > 0 {
output = append(output,
" Authorized Actions:",
base.WrapSlice(6, item.AuthorizedActions),
)
}
}
return base.WrapForHelpText(output)
}
func printItemTable(item *scopes.Scope, resp *api.Response) string {
2022-10-25 18:29:38 -05:00
nonAttributeMap := map[string]any{}
2021-05-04 19:57:35 -05:00
if item.Id != "" {
nonAttributeMap["ID"] = item.Id
2021-02-23 19:06:39 -05:00
}
2021-05-04 19:57:35 -05:00
if item.Version != 0 {
nonAttributeMap["Version"] = item.Version
}
if !item.CreatedTime.IsZero() {
nonAttributeMap["Created Time"] = item.CreatedTime.Local().Format(time.RFC1123)
2021-02-23 19:06:39 -05:00
}
2021-05-04 19:57:35 -05:00
if !item.UpdatedTime.IsZero() {
nonAttributeMap["Updated Time"] = item.UpdatedTime.Local().Format(time.RFC1123)
2021-02-23 19:06:39 -05:00
}
2021-05-04 19:57:35 -05:00
if item.Name != "" {
nonAttributeMap["Name"] = item.Name
}
if item.Description != "" {
nonAttributeMap["Description"] = item.Description
}
if item.PrimaryAuthMethodId != "" {
nonAttributeMap["Primary Auth Method ID"] = item.PrimaryAuthMethodId
2021-04-08 20:54:32 -04:00
}
2021-02-23 19:06:39 -05:00
maxLength := base.MaxAttributesLength(nonAttributeMap, nil, nil)
ret := []string{
"",
"Scope information:",
base.WrapMap(2, maxLength+2, nonAttributeMap),
}
2021-05-04 19:57:35 -05:00
if item.Scope != nil {
ret = append(ret,
"",
" Scope (parent):",
base.ScopeInfoForOutput(item.Scope, maxLength),
)
}
if len(item.AuthorizedActions) > 0 {
2021-02-23 19:06:39 -05:00
ret = append(ret,
"",
" Authorized Actions:",
2021-05-04 19:57:35 -05:00
base.WrapSlice(4, item.AuthorizedActions),
2021-02-23 19:06:39 -05:00
"",
)
}
2021-05-04 19:57:35 -05:00
if len(item.AuthorizedCollectionActions) > 0 {
keys := make([]string, 0, len(item.AuthorizedCollectionActions))
for k := range item.AuthorizedCollectionActions {
2021-02-23 19:06:39 -05:00
keys = append(keys, k)
}
sort.Strings(keys)
ret = append(ret, " Authorized Actions on Scope's Collections:")
for _, key := range keys {
ret = append(ret,
fmt.Sprintf(" %s:", key),
2021-05-04 19:57:35 -05:00
base.WrapSlice(6, item.AuthorizedCollectionActions[key]),
2021-02-23 19:06:39 -05:00
)
}
}
return base.WrapForHelpText(ret)
}