127 lines
3.2 KiB
Go
127 lines
3.2 KiB
Go
package users
|
|
|
|
import (
|
|
"encoding/json"
|
|
"fmt"
|
|
"net/http"
|
|
"strings"
|
|
"xcecli/common/request"
|
|
"xcecli/config"
|
|
logger "xcecli/config"
|
|
"xcecli/models"
|
|
|
|
"github.com/spf13/cobra"
|
|
"go.uber.org/zap"
|
|
)
|
|
|
|
func NewUserSubmitter(configManager *config.ConfigManager) *UserSubmitter {
|
|
return &UserSubmitter{
|
|
configManager: configManager,
|
|
}
|
|
}
|
|
|
|
type UserSubmitter struct {
|
|
configManager *config.ConfigManager
|
|
userName string
|
|
roleName []string
|
|
}
|
|
|
|
func NewAssignUserRolesCmd(configManager *config.ConfigManager) *cobra.Command {
|
|
userSubmitter := NewUserSubmitter(configManager)
|
|
|
|
cmd := &cobra.Command{
|
|
Use: "assignrole",
|
|
Short: "Assign role to API Server",
|
|
Long: `Assign role to API Server.
|
|
Example:
|
|
xce user assignrole -u user_name -r role_name1,role_name2 # assign role to a user"`,
|
|
|
|
SilenceUsage: true,
|
|
Run: func(cmd *cobra.Command, args []string) {
|
|
if err := userSubmitter.ParseCmdArgs(cmd, args); err != nil {
|
|
fmt.Println(strings.ToLower(err.Error()))
|
|
return
|
|
}
|
|
if err := userSubmitter.RunUserAssignRole(); err != nil {
|
|
fmt.Println(strings.ToLower(err.Error()))
|
|
return
|
|
}
|
|
},
|
|
}
|
|
|
|
// add the flags
|
|
flags := cmd.Flags()
|
|
|
|
//modify the flags
|
|
flags.StringVarP(&userSubmitter.userName, "user_name", "u", "", "specify the user name")
|
|
flags.StringSliceVarP(&userSubmitter.roleName, "role_name", "r", []string{}, "specify the role name")
|
|
return cmd
|
|
//
|
|
}
|
|
|
|
func (rs *UserSubmitter) ParseCmdArgs(cmd *cobra.Command, args []string) error {
|
|
if rs.userName == "" {
|
|
return fmt.Errorf("please provide the user name")
|
|
}
|
|
if len(rs.userName) > 40 {
|
|
return fmt.Errorf("error: user name cannot be longer than 40 characters")
|
|
}
|
|
if len(rs.roleName) == 0 {
|
|
return fmt.Errorf("please provide the role name")
|
|
}
|
|
if len(args) > 0 {
|
|
return fmt.Errorf("too many arguments")
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (us *UserSubmitter) RunUserAssignRole() error {
|
|
// Get server info and validate authentication
|
|
serverInfo, _ := us.configManager.GetServerInfo()
|
|
// create the API client and submit the user
|
|
apiClient := request.NewAPIClient(serverInfo.URL)
|
|
apiClient.SetRootCAs(serverInfo.CACert)
|
|
|
|
// build the user request
|
|
userReq, err := us.BuildUserRequest()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
// encode request to JSON bytes
|
|
reqData, err := json.Marshal(userReq)
|
|
if err != nil {
|
|
errMsg := request.ExtractErrorMessage(err)
|
|
return fmt.Errorf("failed to encode request data: [%s]", errMsg)
|
|
}
|
|
url := fmt.Sprintf("/xce/v1/users/%s/roles", us.userName)
|
|
var resp models.UserAssignRoleResponse
|
|
err = apiClient.PostRequestToAPIServer(
|
|
serverInfo.Token,
|
|
serverInfo.CACert,
|
|
url,
|
|
reqData,
|
|
&resp,
|
|
)
|
|
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
if resp.Code != http.StatusCreated {
|
|
logger.Info("user assign role failed", zap.Any("resp", resp), zap.Error(err))
|
|
return fmt.Errorf("%s", resp.Data.Message)
|
|
}
|
|
logger.Debug("user assign role successfully", zap.String("message", resp.Data.Message))
|
|
logger.Info("user assign role successfully", zap.String("message", resp.Data.Message))
|
|
fmt.Printf("%s\n", resp.Data.Message)
|
|
return nil
|
|
}
|
|
|
|
func (us *UserSubmitter) BuildUserRequest() (*models.AddRoleForUserRequest, error) {
|
|
roleReq := &models.AddRoleForUserRequest{
|
|
UserName: us.userName,
|
|
RoleName: us.roleName,
|
|
}
|
|
return roleReq, nil
|
|
}
|