github.com/tickoalcantara12/micro/v3@v3.0.0-20221007104245-9d75b9bcbab9/client/cli/auth/accounts.go (about)

     1  package cli
     2  
     3  import (
     4  	"encoding/json"
     5  	"fmt"
     6  	"os"
     7  	"strings"
     8  	"text/tabwriter"
     9  
    10  	"github.com/tickoalcantara12/micro/v3/client/cli/namespace"
    11  	"github.com/tickoalcantara12/micro/v3/client/cli/util"
    12  	pb "github.com/tickoalcantara12/micro/v3/proto/auth"
    13  	"github.com/tickoalcantara12/micro/v3/service/auth"
    14  	"github.com/tickoalcantara12/micro/v3/service/client"
    15  	"github.com/tickoalcantara12/micro/v3/service/context"
    16  	"github.com/urfave/cli/v2"
    17  )
    18  
    19  func listAccounts(ctx *cli.Context) error {
    20  	cli := pb.NewAccountsService("auth", client.DefaultClient)
    21  
    22  	env, err := util.GetEnv(ctx)
    23  	if err != nil {
    24  		return err
    25  	}
    26  	ns, err := namespace.Get(env.Name)
    27  	if err != nil {
    28  		return fmt.Errorf("Error getting namespace: %v", err)
    29  	}
    30  
    31  	rsp, err := cli.List(context.DefaultContext, &pb.ListAccountsRequest{
    32  		Options: &pb.Options{Namespace: ns},
    33  	}, client.WithAuthToken())
    34  	if err != nil {
    35  		return fmt.Errorf("Error listing accounts: %v", err)
    36  	}
    37  
    38  	w := tabwriter.NewWriter(os.Stdout, 0, 8, 1, '\t', 0)
    39  	defer w.Flush()
    40  
    41  	fmt.Fprintln(w, strings.Join([]string{"ID", "Name", "Scopes", "Metadata"}, "\t\t"))
    42  	for _, r := range rsp.Accounts {
    43  		var metadata string
    44  		for k, v := range r.Metadata {
    45  			metadata = fmt.Sprintf("%v%v=%v ", metadata, k, v)
    46  		}
    47  		scopes := strings.Join(r.Scopes, ", ")
    48  
    49  		if len(metadata) == 0 {
    50  			metadata = "n/a"
    51  		}
    52  		if len(scopes) == 0 {
    53  			scopes = "n/a"
    54  		}
    55  
    56  		fmt.Fprintln(w, strings.Join([]string{r.Id, r.Name, scopes, metadata}, "\t\t"))
    57  	}
    58  
    59  	return nil
    60  }
    61  
    62  func createAccount(ctx *cli.Context) error {
    63  	if ctx.Args().Len() == 0 {
    64  		return fmt.Errorf("Missing argument: ID")
    65  	}
    66  
    67  	env, err := util.GetEnv(ctx)
    68  	if err != nil {
    69  		return err
    70  	}
    71  	ns, err := namespace.Get(env.Name)
    72  	if err != nil {
    73  		return fmt.Errorf("Error getting namespace: %v", err)
    74  	}
    75  	if len(ctx.String("namespace")) > 0 {
    76  		ns = ctx.String("namespace")
    77  	}
    78  
    79  	options := []auth.GenerateOption{auth.WithIssuer(ns)}
    80  	if len(ctx.StringSlice("scopes")) > 0 {
    81  		options = append(options, auth.WithScopes(ctx.StringSlice("scopes")...))
    82  	}
    83  	if len(ctx.String("secret")) > 0 {
    84  		options = append(options, auth.WithSecret(ctx.String("secret")))
    85  	}
    86  	acc, err := auth.Generate(ctx.Args().First(), options...)
    87  	if err != nil {
    88  		return fmt.Errorf("Error creating account: %v", err)
    89  	}
    90  
    91  	json, _ := json.Marshal(acc)
    92  	fmt.Printf("Account created: %v\n", string(json))
    93  	return nil
    94  }
    95  
    96  func deleteAccount(ctx *cli.Context) error {
    97  	if ctx.Args().Len() == 0 {
    98  		return fmt.Errorf("Missing argument: ID")
    99  	}
   100  	cli := pb.NewAccountsService("auth", client.DefaultClient)
   101  
   102  	env, err := util.GetEnv(ctx)
   103  	if err != nil {
   104  		return err
   105  	}
   106  	ns, err := namespace.Get(env.Name)
   107  	if err != nil {
   108  		return fmt.Errorf("Error getting namespace: %v", err)
   109  	}
   110  
   111  	_, err = cli.Delete(context.DefaultContext, &pb.DeleteAccountRequest{
   112  		Id:      ctx.Args().First(),
   113  		Options: &pb.Options{Namespace: ns},
   114  	}, client.WithAuthToken())
   115  	if err != nil {
   116  		return fmt.Errorf("Error deleting account: %v", err)
   117  	}
   118  
   119  	return nil
   120  }
   121  
   122  func updateAccount(ctx *cli.Context) error {
   123  	if ctx.Args().Len() == 0 {
   124  		return fmt.Errorf("Missing argument: ID")
   125  	}
   126  
   127  	env, err := util.GetEnv(ctx)
   128  	if err != nil {
   129  		return err
   130  	}
   131  	ns, err := namespace.Get(env.Name)
   132  	if err != nil {
   133  		return fmt.Errorf("Error getting namespace: %v", err)
   134  	}
   135  	if len(ctx.String("namespace")) > 0 {
   136  		ns = ctx.String("namespace")
   137  	}
   138  
   139  	cli := pb.NewAccountsService("auth", client.DefaultClient)
   140  
   141  	_, err = cli.ChangeSecret(context.DefaultContext, &pb.ChangeSecretRequest{
   142  		Id:        ctx.Args().First(),
   143  		OldSecret: ctx.String("old_secret"),
   144  		NewSecret: ctx.String("new_secret"),
   145  		Options:   &pb.Options{Namespace: ns},
   146  	}, client.WithAuthToken())
   147  
   148  	if err != nil {
   149  		return fmt.Errorf("Error updating accounts: %v", err)
   150  	}
   151  
   152  	fmt.Printf("Account updated\n")
   153  	return nil
   154  }