Merge Go frontend (apiserver + xcecli) into meson build

src/frontend/xcecli/cmd/queues/list.go

@@ -0,0 +1,199 @@
+package queues
+
+import (
+	"fmt"
+	"strings"
+	"xcecli/common/output"
+	"xcecli/common/request"
+	"xcecli/config"
+	logger "xcecli/config"
+	queue_filter "xcecli/filters"
+
+	"xcecli/models"
+
+	"github.com/spf13/cobra"
+	"go.uber.org/zap"
+)
+
+var (
+	user   string
+	queue  string
+	fields string
+)
+
+type QueuesQuerier struct {
+	configManager *config.ConfigManager
+	filter        *queue_filter.QueuesFilter
+	fields        string
+	jsonOutput    bool
+	noHeader      bool
+	verbose       bool
+	wideFormat    bool // wide format
+}
+
+func NewQueuesQuerier(configManager *config.ConfigManager) *QueuesQuerier {
+	return &QueuesQuerier{
+		configManager: configManager,
+		filter:        &queue_filter.QueuesFilter{},
+	}
+}
+
+// Parse parses command line arguments, simplified version that doesn't need to process flags already bound to filter
+func (qq *QueuesQuerier) ParseCmdArgs(cmd *cobra.Command, args []string) error {
+	// No additional processing needed, all parameters are bound in flags
+	if len(args) > 0 {
+		qq.filter.QueueName = strings.Join(args, ",")
+	}
+
+	// Define mutual exclusions for verbose flag
+	if qq.verbose {
+		conflicts := make([]string, 0)
+
+		if qq.wideFormat {
+			conflicts = append(conflicts, "--wided (-w)")
+		}
+
+		if qq.fields != "" {
+			conflicts = append(conflicts, "--output (-o)")
+		}
+
+		if len(conflicts) > 0 {
+			return fmt.Errorf("flag --verbose (-l) cannot be used with: %s\n\n%s",
+				strings.Join(conflicts, ", "), cmd.UsageString())
+		}
+	}
+	return nil
+}
+
+func NewListQueuesCmd(configManager *config.ConfigManager) *cobra.Command {
+	queuesQuerier := NewQueuesQuerier(configManager)
+
+	cmd := &cobra.Command{
+		Use:   "list",
+		Short: "Query queue info",
+		Long: `Query queue info, support filter by queue.
+example:
+  xce queues list                           # query all queues
+  xce queues list -l                        # query all queues with detail
+  xce queues list -w                        # list queues with wide format`,
+
+		RunE: func(cmd *cobra.Command, args []string) error {
+			if err := queuesQuerier.ParseCmdArgs(cmd, args); err != nil {
+				fmt.Println(strings.ToLower(err.Error()))
+				return nil
+			}
+			if err := queuesQuerier.RunQueuesList(); err != nil {
+				fmt.Println(strings.ToLower(err.Error()))
+				return nil
+			}
+			return nil
+		},
+	}
+
+	// Add command line parameters
+	flags := cmd.Flags()
+	flags.StringVarP(&user, "user", "u", "", "filter by user")
+	flags.StringVarP(&queuesQuerier.filter.QueueName, "queue", "q", "", "filter by queue name")
+	flags.StringVarP(&queuesQuerier.fields, "output", "o", "", "output fields for queues")
+	flags.BoolVarP(&queuesQuerier.wideFormat, "wided", "w", false, "output in wide format")
+	flags.BoolVarP(&queuesQuerier.verbose, "verbose", "l", false, "show queue detail")
+	flags.BoolVarP(&queuesQuerier.jsonOutput, "json", "", false, "output in JSON format")
+	flags.BoolVarP(&queuesQuerier.noHeader, "noheader", "n", false, "output no header")
+	return cmd
+}
+
+func (qq *QueuesQuerier) RunQueuesList() error {
+	// Get configuration
+
+	// Get server information
+	serverInfo, _ := qq.configManager.GetServerInfo()
+	// create API client
+	apiClient := request.NewAPIClient(serverInfo.URL)
+	apiClient.SetRootCAs(serverInfo.CACert)
+
+	// Create query parameters
+	params := make(map[string]string)
+
+	// Get filter string
+	filterStr, err := qq.filter.HandleQueueFilter()
+
+	if err != nil {
+		errMsg := request.ExtractErrorMessage(err)
+		return fmt.Errorf("failed to get filter: [%s]", errMsg)
+	} else if filterStr != "" {
+		params["filter"] = filterStr
+	}
+
+	// Field mapping
+	fieldsMap := models.QueueFieldsMap
+
+	if qq.verbose && qq.fields == "" {
+		for header := range fieldsMap {
+			qq.fields += header + ","
+		}
+		qq.fields = strings.TrimSuffix(qq.fields, ",")
+	}
+	// Process field selection
+	if qq.fields != "" {
+		qq.fields = request.CleanFields(qq.fields)
+		mappedFields, err := request.CheckAndMapFields(qq.fields, fieldsMap)
+		if err != nil {
+			return err
+		}
+		params["fields"] = strings.Join(mappedFields, ",")
+	}
+
+	// create page printer
+	pagePrinter := output.NewPagePrinter(output.DataTypeQueues, output.WithFields(qq.fields),
+		output.WithFormatJson(qq.jsonOutput), output.WithNoHeader(qq.noHeader),
+		output.WithVerbose(qq.verbose), output.WithWideFormat(qq.wideFormat))
+
+	// Record if the first page has been processed
+	isFirstPage := true
+
+	var (
+		resp      models.QueuesResponse
+		loopCount int
+		pageToken string
+	)
+
+	// Loop to get all pages of data
+	for {
+		if loopCount > 0 && pageToken == "" {
+			break
+		}
+
+		err = apiClient.GetRequestFromAPIServer(serverInfo.Token, pageToken, serverInfo.CACert, "/xce/v1/queues", &resp, params)
+		if err != nil {
+			return err
+		}
+
+		if len(resp.Data.Rows) == 0 {
+			if isFirstPage {
+				fmt.Println("no queue found")
+				return nil
+			}
+			//
+		}
+		// Process the first page
+		if isFirstPage {
+			// Start printing process
+			pagePrinter.StartPrinting()
+			// Prepare for printing, calculate column width and table header, etc.
+			pagePrinter.PrepareForPrinting(&resp)
+			isFirstPage = false
+		}
+		// Print the current page
+		pagePrinter.PrintPage(&resp)
+
+		// Update page token and loop counter
+		pageToken = resp.Data.Page_token
+		loopCount++
+	}
+
+	// Finish printing
+	pagePrinter.Finish()
+
+	logger.Debug("queues response completed", zap.Int("pages", loopCount))
+	return nil
+}