Refactor get command

Signed-off-by: katara-Jayprakash <katarajayprakash@icloud.com>

Author: katara-Jayprakash

mgrctl/cmd/get/client.go

@@ -5,38 +5,71 @@
 package get
 
 import (
+	"os"
+
+	"github.com/rs/zerolog/log"
 	"github.com/spf13/cobra"
 	"github.com/uyuni-project/uyuni-tools/shared/api"
 	. "github.com/uyuni-project/uyuni-tools/shared/l10n"
 	"github.com/uyuni-project/uyuni-tools/shared/types"
+	"github.com/uyuni-project/uyuni-tools/shared/utils"
 )
 
-type getOptions struct {
+type getFlags struct {
 	api.ConnectionDetails `mapstructure:"api"`
-	OutputFormat          string `mapstructure:"output"` // e.g., "json", "yaml", "table"
+	OutputFormat          string `mapstructure:"output"`
+	Filter                string `mapstructure:"filter"`
+	Page                  int    `mapstructure:"-"`
+	PageSize              int    `mapstructure:"-"`
 }
 
-// NewCommand generates the 'mgrctl get' command root.
 func NewCommand(globalFlags *types.GlobalFlags) *cobra.Command {
-	var flags getOptions
+	var flags getFlags
+
+	cmd := &cobra.Command{
+		Use:   "get <resource-type> [flags]",
+		Short: L("Display one or many resources"),
+		Args:      cobra.MatchAll(cobra.ExactArgs(1), cobra.OnlyValidArgs),
+		ValidArgs: registeredTypes(),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			return utils.CommandHelper(globalFlags, cmd, args, &flags, nil, runGet)
+		},
+	}
+
+	cmd.Flags().StringVarP(&flags.OutputFormat, "output", "o", "table",
+		L("Output format: table|json|yaml|custom-columns=SPEC|custom-columns-file=PATH"))
+	cmd.Flags().StringVar(&flags.Filter, "filter", "",
+		L("Filter expression (e.g. extra_pkg_count=0)"))
+	cmd.Flags().IntVar(&flags.Page, "page", 0,
+		L("Page number for paginated results (0-indexed)"))
+	cmd.Flags().IntVar(&flags.PageSize, "page-size", 50,
+		L("Number of items per page"))
+
+	api.AddAPIFlags(cmd)
+	return cmd
+}
+
+func runGet(_ *types.GlobalFlags, flags *getFlags, _ *cobra.Command, args []string) error {
+	resourceType := args[0]
+	log.Debug().Msgf("Running get %s", resourceType)
 
-	getCmd := &cobra.Command{
-		Use:   "get [resource] [options]",
-		Short: L("Display one or many resources (systems, groups, etc.)"),
-		Long:  L("Prints tables, JSON, or YAML of Uyuni API resources. Modeled after kubectl get."),
+	fetcher, err := lookupFetcher(resourceType)
+	if err != nil {
+		return err
 	}
 
-	getCmd.PersistentFlags().StringVarP(
-		&flags.OutputFormat,
-		"output",
-		"o",
-		"table",
-		L("Output format. One of: table|json|yaml"),
-	)
+	client, err := api.Init(&flags.ConnectionDetails)
+	if err == nil && (client.Details.User != "" || client.Details.InSession) {
+		err = client.Login()
+	}
+	if err != nil {
+		return utils.Errorf(err, L("unable to login to the server"))
+	}
 
-	// passing the -o flag to the subcommands to be able to use it in the same way for all the resources
-	getCmd.AddCommand(newSystemCommand(globalFlags, &flags))
+	items, err := fetcher.List(client, flags.Filter, flags.Page, flags.PageSize)
+	if err != nil {
+		return err
+	}
 
-	api.AddAPIFlags(getCmd)
-	return getCmd
+	return printOutput(flags.OutputFormat, items, fetcher.Columns(), os.Stdout)
 }

mgrctl/cmd/get/descriptor.go

@@ -9,35 +9,62 @@ import (
 	"fmt"
 	"io"
 	"os"
-	"reflect"
 	"strings"
 	"text/tabwriter"
 
 	"gopkg.in/yaml.v2"
 )
 
-func printJSON[T any](items []T, out io.Writer) error {
-	bytes, err := json.MarshalIndent(items, "", "  ")
+func printOutput(format string, items []map[string]any, cols []ColumnDef, out io.Writer) error {
+	if strings.HasPrefix(format, "custom-columns=") {
+		spec := strings.TrimPrefix(format, "custom-columns=")
+		parsed := parseCustomColumns(spec)
+		if len(parsed) == 0 {
+			return fmt.Errorf("custom-columns format specified but no valid columns given")
+		}
+		return printTable(items, parsed, out)
+	}
+
+	if strings.HasPrefix(format, "custom-columns-file=") {
+		path := strings.TrimPrefix(format, "custom-columns-file=")
+		fileCols, err := parseCustomColumnsFile(path)
+		if err != nil {
+			return err
+		}
+		return printTable(items, fileCols, out)
+	}
+
+	switch format {
+	case "json":
+		return printJSON(items, out)
+	case "yaml":
+		return printYAML(items, out)
+	default:
+		return printTable(items, cols, out)
+	}
+}
+
+func printJSON(items []map[string]any, out io.Writer) error {
+	data, err := json.MarshalIndent(items, "", "  ")
 	if err != nil {
 		return err
 	}
-	_, err = fmt.Fprintln(out, string(bytes))
+	_, err = fmt.Fprintln(out, string(data))
 	return err
 }
 
-func printYAML[T any](items []T, out io.Writer) error {
-	bytes, err := yaml.Marshal(items)
+func printYAML(items []map[string]any, out io.Writer) error {
+	data, err := yaml.Marshal(items)
 	if err != nil {
 		return err
 	}
-	_, err = fmt.Fprint(out, string(bytes))
+	_, err = fmt.Fprint(out, string(data))
 	return err
 }
 
-func printTable[T any](items []T, cols []ColumnDef, out io.Writer) error {
+func printTable(items []map[string]any, cols []ColumnDef, out io.Writer) error {
 	w := tabwriter.NewWriter(out, 0, 0, 4, ' ', 0)
 
-	// Print headers
 	for i, col := range cols {
 		if i > 0 {
 			fmt.Fprint(w, "\t")
@@ -46,16 +73,13 @@ func printTable[T any](items []T, cols []ColumnDef, out io.Writer) error {
 	}
 	fmt.Fprintln(w)
 
-	// Print rows
 	for _, item := range items {
-		v := reflect.ValueOf(item)
 		for i, col := range cols {
 			if i > 0 {
 				fmt.Fprint(w, "\t")
 			}
-			field := v.FieldByName(col.Field)
-			if field.IsValid() {
-				fmt.Fprintf(w, "%v", field.Interface())
+			if val, ok := fieldValue(item, col.Field); ok {
+				fmt.Fprint(w, formatValue(val))
 			}
 		}
 		fmt.Fprintln(w)
@@ -64,99 +88,83 @@ func printTable[T any](items []T, cols []ColumnDef, out io.Writer) error {
 	return w.Flush()
 }
 
-func mapJsonPathToField[T any](path string) string {
-	path = strings.TrimPrefix(path, ".")
-
-	typ := reflect.TypeOf(new(T)).Elem()
-	if typ.Kind() == reflect.Ptr {
-		typ = typ.Elem()
+func formatValue(v any) string {
+	if f, ok := v.(float64); ok && f == float64(int64(f)) {
+		return fmt.Sprintf("%d", int64(f))
 	}
-
-	if typ.Kind() != reflect.Struct {
-		return path // fallback
-	}
-
-	for i := 0; i < typ.NumField(); i++ {
-		field := typ.Field(i)
-		jsonTag := field.Tag.Get("json")
-		if jsonTag != "" {
-			name := strings.Split(jsonTag, ",")[0]
-			if name == path {
-				return field.Name
-			}
-		}
-	}
-
-	return path // fallback if no tag matches
+	return fmt.Sprintf("%v", v)
 }
 
-func parseCustomColumns[T any](spec string) []ColumnDef {
+func parseCustomColumns(spec string) []ColumnDef {
 	var cols []ColumnDef
-	parts := strings.Split(spec, ",")
-	for _, part := range parts {
+	for _, part := range strings.Split(spec, ",") {
 		kv := strings.SplitN(part, ":", 2)
 		if len(kv) == 2 {
 			cols = append(cols, ColumnDef{
 				Header: strings.TrimSpace(kv[0]),
-				Field:  mapJsonPathToField[T](strings.TrimSpace(kv[1])),
+				Field:  normalizeFieldPath(kv[1]),
 			})
 		}
 	}
 	return cols
 }
 
-func printOutput[T any](format string, items []T, cols []ColumnDef, out io.Writer) error {
-	if strings.HasPrefix(format, "custom-columns=") {
-		spec := strings.TrimPrefix(format, "custom-columns=")
-		newCols := parseCustomColumns[T](spec)
-		if len(newCols) == 0 {
-			return fmt.Errorf("custom-columns format specified but no columns given")
-		}
-		return printTable(items, newCols, out)
+func parseCustomColumnsFile(path string) ([]ColumnDef, error) {
+	content, err := os.ReadFile(path)
+	if err != nil {
+		return nil, err
 	}
 
-	if strings.HasPrefix(format, "custom-columns-file=") {
-		filename := strings.TrimPrefix(format, "custom-columns-file=")
-		content, err := os.ReadFile(filename)
-		if err != nil {
-			return err
+	lines := strings.Split(string(content), "\n")
+	var headers, paths []string
+	for _, line := range lines {
+		line = strings.TrimSpace(line)
+		if line == "" {
+			continue
 		}
-
-		lines := strings.Split(string(content), "\n")
-		var headers, paths []string
-		for _, line := range lines {
-			line = strings.TrimSpace(line)
-			if line == "" {
-				continue
-			}
-			fields := strings.Fields(line)
-			if headers == nil {
-				headers = fields
-			} else if paths == nil {
-				paths = fields
-			}
+		if headers == nil {
+			headers = strings.Fields(line)
+		} else if paths == nil {
+			paths = strings.Fields(line)
 		}
+	}
 
-		if len(headers) != len(paths) || len(headers) == 0 {
-			return fmt.Errorf("invalid custom-columns file format")
-		}
+	if len(headers) != len(paths) || len(headers) == 0 {
+		return nil, fmt.Errorf("invalid custom-columns file format")
+	}
 
-		var specParts []string
-		for i := range headers {
-			specParts = append(specParts, headers[i]+":"+paths[i])
-		}
-		spec := strings.Join(specParts, ",")
-		
-		newCols := parseCustomColumns[T](spec)
-		return printTable(items, newCols, out)
+	var cols []ColumnDef
+	for i := range headers {
+		cols = append(cols, ColumnDef{
+			Header: headers[i],
+			Field:  normalizeFieldPath(paths[i]),
+		})
 	}
+	return cols, nil
+}
 
-	switch format {
-	case "json":
-		return printJSON(items, out)
-	case "yaml":
-		return printYAML(items, out)
-	default:
-		return printTable(items, cols, out)
+func normalizeFieldPath(path string) string {
+	return strings.TrimPrefix(strings.TrimSpace(path), ".")
+}
+
+func fieldValue(item map[string]any, path string) (any, bool) {
+	if path == "" {
+		return nil, false
+	}
+
+	var current any = item
+	for _, part := range strings.Split(normalizeFieldPath(path), ".") {
+		if part == "" {
+			return nil, false
+		}
+		m, ok := current.(map[string]any)
+		if !ok {
+			return nil, false
+		}
+		current, ok = m[part]
+		if !ok {
+			return nil, false
+		}
 	}
+	return current, true
 }