feat(cli): extract handler for list cmd, add next start / stop

johnstcn · johnstcn · commit 5a61631ef55b · 2023-11-09T09:59:45.000Z
diff --git a/cli/list.go b/cli/list.go
@@ -1,12 +1,12 @@
 package cli
 
 import (
+	"context"
 	"fmt"
+	"io"
 	"strconv"
 	"time"
 
-	"github.com/google/uuid"
-
 	"github.com/coder/pretty"
 
 	"github.com/coder/coder/v2/cli/clibase"
@@ -31,57 +31,62 @@ type workspaceListRow struct {
 	LastBuilt     string `json:"-" table:"last built"`
 	Outdated      bool   `json:"-" table:"outdated"`
 	StartsAt      string `json:"-" table:"starts at"`
+	StartsNext    string `json:"-" table:"starts next"`
 	StopsAfter    string `json:"-" table:"stops after"`
+	StopsNext     string `json:"-" table:"stops next"`
 	DailyCost     string `json:"-" table:"daily cost"`
 }
 
-func workspaceListRowFromWorkspace(now time.Time, usersByID map[uuid.UUID]codersdk.User, workspace codersdk.Workspace) workspaceListRow {
+func workspaceListRowFromWorkspace(now time.Time, workspace codersdk.Workspace) workspaceListRow {
 	status := codersdk.WorkspaceDisplayStatus(workspace.LatestBuild.Job.Status, workspace.LatestBuild.Transition)
 
 	lastBuilt := now.UTC().Sub(workspace.LatestBuild.Job.CreatedAt).Truncate(time.Second)
 	autostartDisplay := "-"
+	nextStartDisplay := "-"
 	if !ptr.NilOrEmpty(workspace.AutostartSchedule) {
 		if sched, err := cron.Weekly(*workspace.AutostartSchedule); err == nil {
 			autostartDisplay = fmt.Sprintf("%s %s (%s)", sched.Time(), sched.DaysOfWeek(), sched.Location())
+			nextStartDisplay = relative(sched.Next(now).Sub(now))
 		}
 	}
 
 	autostopDisplay := "-"
+	nextStopDisplay := "-"
 	if !ptr.NilOrZero(workspace.TTLMillis) {
 		dur := time.Duration(*workspace.TTLMillis) * time.Millisecond
 		autostopDisplay = durationDisplay(dur)
 		if !workspace.LatestBuild.Deadline.IsZero() && workspace.LatestBuild.Deadline.Time.After(now) && status == "Running" {
 			remaining := time.Until(workspace.LatestBuild.Deadline.Time)
-			autostopDisplay = fmt.Sprintf("%s (%s)", autostopDisplay, relative(remaining))
+			nextStopDisplay = fmt.Sprintf("%s (%s)", autostopDisplay, relative(remaining))
 		}
 	}
 
 	healthy := ""
 	if status == "Starting" || status == "Started" {
 		healthy = strconv.FormatBool(workspace.Health.Healthy)
 	}
-	user := usersByID[workspace.OwnerID]
 	return workspaceListRow{
 		Workspace:     workspace,
-		WorkspaceName: user.Username + "/" + workspace.Name,
+		WorkspaceName: workspace.OwnerName + "/" + workspace.Name,
 		Template:      workspace.TemplateName,
 		Status:        status,
 		Healthy:       healthy,
 		LastBuilt:     durationDisplay(lastBuilt),
 		Outdated:      workspace.Outdated,
 		StartsAt:      autostartDisplay,
+		StartsNext:    nextStartDisplay,
 		StopsAfter:    autostopDisplay,
+		StopsNext:     nextStopDisplay,
 		DailyCost:     strconv.Itoa(int(workspace.LatestBuild.DailyCost)),
 	}
 }
 
 func (r *RootCmd) list() *clibase.Cmd {
 	var (
-		all               bool
-		defaultQuery      = "owner:me"
-		searchQuery       string
-		displayWorkspaces []workspaceListRow
-		formatter         = cliui.NewOutputFormatter(
+		all          bool
+		defaultQuery = "owner:me"
+		searchQuery  string
+		formatter    = cliui.NewOutputFormatter(
 			cliui.TableFormat(
 				[]workspaceListRow{},
 				[]string{
@@ -109,48 +114,17 @@ func (r *RootCmd) list() *clibase.Cmd {
 			r.InitClient(client),
 		),
 		Handler: func(inv *clibase.Invocation) error {
-			filter := codersdk.WorkspaceFilter{
-				FilterQuery: searchQuery,
-			}
-			if all && searchQuery == defaultQuery {
-				filter.FilterQuery = ""
-			}
-
-			res, err := client.Workspaces(inv.Context(), filter)
-			if err != nil {
-				return err
-			}
-			if len(res.Workspaces) == 0 {
-				pretty.Fprintf(inv.Stderr, cliui.DefaultStyles.Prompt, "No workspaces found! Create one:\n")
-				_, _ = fmt.Fprintln(inv.Stderr)
-				_, _ = fmt.Fprintln(inv.Stderr, "  "+pretty.Sprint(cliui.DefaultStyles.Code, "coder create <name>"))
-				_, _ = fmt.Fprintln(inv.Stderr)
-				return nil
-			}
-
-			userRes, err := client.Users(inv.Context(), codersdk.UsersRequest{})
-			if err != nil {
-				return err
-			}
-
-			usersByID := map[uuid.UUID]codersdk.User{}
-			for _, user := range userRes.Users {
-				usersByID[user.ID] = user
-			}
-
-			now := time.Now()
-			displayWorkspaces = make([]workspaceListRow, len(res.Workspaces))
-			for i, workspace := range res.Workspaces {
-				displayWorkspaces[i] = workspaceListRowFromWorkspace(now, usersByID, workspace)
-			}
-
-			out, err := formatter.Format(inv.Context(), displayWorkspaces)
-			if err != nil {
-				return err
-			}
-
-			_, err = fmt.Fprintln(inv.Stdout, out)
-			return err
+			return handleList(
+				inv.Context(),
+				handleListArgs{
+					formatter:   formatter,
+					client:      client,
+					searchQuery: searchQuery,
+					all:         all,
+					stdout:      inv.Stdout,
+					stderr:      inv.Stderr,
+				},
+			)
 		},
 	}
 	cmd.Options = clibase.OptionSet{
@@ -172,3 +146,46 @@ func (r *RootCmd) list() *clibase.Cmd {
 	formatter.AttachOptions(&cmd.Options)
 	return cmd
 }
+
+type handleListArgs struct {
+	formatter      *cliui.OutputFormatter
+	client         *codersdk.Client
+	searchQuery    string
+	all            bool
+	stdout, stderr io.Writer
+}
+
+func handleList(ctx context.Context, args handleListArgs) error {
+	filter := codersdk.WorkspaceFilter{
+		FilterQuery: args.searchQuery,
+	}
+	if args.all && args.searchQuery == "owner:me" {
+		filter.FilterQuery = ""
+	}
+
+	res, err := args.client.Workspaces(ctx, filter)
+	if err != nil {
+		return err
+	}
+	if len(res.Workspaces) == 0 {
+		pretty.Fprintf(args.stderr, cliui.DefaultStyles.Prompt, "No workspaces found! Create one:\n")
+		_, _ = fmt.Fprintln(args.stderr)
+		_, _ = fmt.Fprintln(args.stderr, "  "+pretty.Sprint(cliui.DefaultStyles.Code, "coder create <name>"))
+		_, _ = fmt.Fprintln(args.stderr)
+		return nil
+	}
+
+	now := time.Now()
+	displayWorkspaces := make([]workspaceListRow, len(res.Workspaces))
+	for i, workspace := range res.Workspaces {
+		displayWorkspaces[i] = workspaceListRowFromWorkspace(now, workspace)
+	}
+
+	out, err := args.formatter.Format(ctx, displayWorkspaces)
+	if err != nil {
+		return err
+	}
+
+	_, err = fmt.Fprintln(args.stdout, out)
+	return err
+}
