feat: add --prices flag to server plans command (#633)

Co-authored-by: Toni Kangas <kangasta@users.noreply.github.com>

Author: mgajda

CHANGELOG.md

@@ -10,6 +10,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ### Added
 
 - Log API requests and responses when using global `--debug` option.
+- Include plan prices in `server plans` output if `--prices` flag is used.
 
 ### Fixed
 

go.mod

@@ -6,7 +6,7 @@ require (
 	dario.cat/mergo v1.0.2
 	github.com/UpCloudLtd/progress v1.1.0
 	github.com/UpCloudLtd/upcloud-go-api/credentials v0.1.1
-	github.com/UpCloudLtd/upcloud-go-api/v8 v8.33.0
+	github.com/UpCloudLtd/upcloud-go-api/v8 v8.34.0
 	github.com/adrg/xdg v0.5.3
 	github.com/asaskevich/govalidator v0.0.0-20230301143203-a9d515a09cc2
 	github.com/jedib0t/go-pretty/v6 v6.7.8

go.sum

@@ -28,8 +28,8 @@ github.com/UpCloudLtd/progress v1.1.0 h1:RT2DNMlvJy1R8WZr2dKdDgR+xD1+3+UdZauIfWr
 github.com/UpCloudLtd/progress v1.1.0/go.mod h1:iGxOnb9HvHW0yrLGUjHr0lxHhn7TehgWwh7a8NqK6iQ=
 github.com/UpCloudLtd/upcloud-go-api/credentials v0.1.1 h1:eTfQsv58ufALOk9BZ7WbS/i7pMUD11RnYYpRPsz0LdI=
 github.com/UpCloudLtd/upcloud-go-api/credentials v0.1.1/go.mod h1:7OtVs2UqtfvjkC1HfE+Oud0MnbMv7qUWnbEgxnTAqts=
-github.com/UpCloudLtd/upcloud-go-api/v8 v8.33.0 h1:18MDgUePzdapCSKwLWVL+WRawyT25yMxmV9TQ32KQJQ=
-github.com/UpCloudLtd/upcloud-go-api/v8 v8.33.0/go.mod h1:NBh1d/ip1bhdAIhuPWbyPme7tbLzDTV7dhutUmU1vg8=
+github.com/UpCloudLtd/upcloud-go-api/v8 v8.34.0 h1:MCrAV9HwUFOzFJ0OEKIlgXefaZVXo23PuAC/ctZwfFo=
+github.com/UpCloudLtd/upcloud-go-api/v8 v8.34.0/go.mod h1:NBh1d/ip1bhdAIhuPWbyPme7tbLzDTV7dhutUmU1vg8=
 github.com/adrg/xdg v0.5.3 h1:xRnxJXne7+oWDatRhR1JLnvuccuIeCoBu2rtuLqQB78=
 github.com/adrg/xdg v0.5.3/go.mod h1:nlTsY+NNiCBGCK2tpm09vRqfVzrc2fLmXGpBLF0zlTQ=
 github.com/armon/go-socks5 v0.0.0-20160902184237-e75332964ef5 h1:0CwZNZbxp69SHPdPJAN/hZIm0C4OItdklCFmMRWYpio=

internal/commands/server/plan_list.go

@@ -1,12 +1,23 @@
 package server
 
 import (
+	"fmt"
+	"math"
 	"sort"
 	"strings"
+	"time"
 
+	"github.com/UpCloudLtd/progress/messages"
 	"github.com/UpCloudLtd/upcloud-cli/v3/internal/commands"
 	"github.com/UpCloudLtd/upcloud-cli/v3/internal/output"
 	"github.com/UpCloudLtd/upcloud-go-api/v8/upcloud"
+	"github.com/jedib0t/go-pretty/v6/text"
+	"github.com/spf13/pflag"
+)
+
+const (
+	durationHour  = "hour"
+	durationMonth = "month"
 )
 
 // PlanListCommand creates the "server plans" command
@@ -18,6 +29,17 @@ func PlanListCommand() commands.Command {
 
 type planListCommand struct {
 	*commands.BaseCommand
+	pricesZone     string
+	pricesDuration string
+}
+
+// InitCommand initializes the command flags
+func (s *planListCommand) InitCommand() {
+	flagSet := &pflag.FlagSet{}
+	flagSet.StringVar(&s.pricesZone, "prices", "", "Show prices for the specified zone (e.g., de-fra1)")
+	flagSet.StringVar(&s.pricesDuration, "prices-duration", durationMonth, "Duration for prices calculation (e.g., 'hour', 'month', '1h', '24h')")
+
+	s.BaseCommand.Cobra().Flags().AddFlagSet(flagSet)
 }
 
 // ExecuteWithoutArguments implements commands.NoArgumentCommand
@@ -40,6 +62,47 @@ func (s *planListCommand) ExecuteWithoutArguments(exec commands.Executor) (outpu
 		return plans[i].StorageSize < plans[j].StorageSize
 	})
 
+	// Check if prices should be shown
+	showPrices := s.pricesZone != ""
+
+	// Validate that prices-duration is only used with --prices
+	if !showPrices && s.pricesDuration != "month" {
+		// User specified prices-duration without specifying a prices zone
+		return nil, fmt.Errorf("--prices-duration requires --prices zone to be specified")
+	}
+
+	// Fetch pricing information and parse duration if requested
+	var prices map[string]upcloud.Price
+	var duration time.Duration
+	if showPrices {
+		pricesByZone, err := exec.All().GetPricesByZone(exec.Context())
+		switch {
+		case err != nil:
+			exec.PushProgressUpdate(messages.Update{
+				Message: "Getting prices information failed. Plans are displayed without price details",
+				Status:  messages.MessageStatusWarning,
+				Details: "Error: " + err.Error(),
+			})
+			// Continue without pricing - just show plans
+			showPrices = false
+		case pricesByZone != nil:
+			// Find the requested zone
+			var ok bool
+			prices, ok = (*pricesByZone)[s.pricesZone]
+			if !ok {
+				return nil, fmt.Errorf("pricing zone %s not found", s.pricesZone)
+			}
+		default:
+			// priceZones is nil, disable pricing
+			showPrices = false
+		}
+
+		duration, err = getDuration(s.pricesDuration)
+		if err != nil {
+			return nil, err
+		}
+	}
+
 	rows := make(map[string][]output.TableRow)
 	for _, p := range plans {
 		key := planType(p)
@@ -57,18 +120,24 @@ func (s *planListCommand) ExecuteWithoutArguments(exec commands.Executor) (outpu
 			row = append(row, p.GPUModel, p.GPUAmount)
 		}
 
+		// Add cost if requested
+		if showPrices && prices != nil {
+			cost := getPlanCost(p, prices, duration)
+			row = append(row, cost)
+		}
+
 		rows[key] = append(rows[key], row)
 	}
 
 	return output.MarshaledWithHumanOutput{
 		Value: plans,
 		Output: output.Combined{
-			planSection("general_purpose", "General purpose", rows["general_purpose"]),
-			planSection("gpu", "GPU", rows["gpu"]),
-			planSection("cloud_native", "Cloud native", rows["cloud_native"]),
-			planSection("high_cpu", "High CPU", rows["high_cpu"]),
-			planSection("high_memory", "High memory", rows["high_memory"]),
-			planSection("developer", "Developer", rows["developer"]),
+			planSection("general_purpose", "General purpose", rows["general_purpose"], showPrices, s.pricesDuration),
+			planSection("gpu", "GPU", rows["gpu"], showPrices, s.pricesDuration),
+			planSection("cloud_native", "Cloud native", rows["cloud_native"], showPrices, s.pricesDuration),
+			planSection("high_cpu", "High CPU", rows["high_cpu"], showPrices, s.pricesDuration),
+			planSection("high_memory", "High memory", rows["high_memory"], showPrices, s.pricesDuration),
+			planSection("developer", "Developer", rows["developer"], showPrices, s.pricesDuration),
 		},
 	}, nil
 }
@@ -92,7 +161,7 @@ func planType(p upcloud.Plan) string {
 	return "general_purpose"
 }
 
-func planSection(key, title string, rows []output.TableRow) output.CombinedSection {
+func planSection(key, title string, rows []output.TableRow, showPricing bool, pricingDuration string) output.CombinedSection {
 	columns := []output.TableColumn{
 		{Key: "name", Header: "Name"},
 		{Key: "cores", Header: "Cores"},
@@ -109,6 +178,19 @@ func planSection(key, title string, rows []output.TableRow) output.CombinedSecti
 		)
 	}
 
+	if showPricing {
+		decimals := 3
+		if pricingDuration == durationMonth {
+			decimals = 2
+		}
+
+		columns = append(columns, output.TableColumn{
+			Key:    "cost",
+			Header: formatPricingHeader(pricingDuration),
+			Format: getFormatPrice(decimals),
+		})
+	}
+
 	return output.CombinedSection{
 		Key:   key,
 		Title: title,
@@ -118,3 +200,77 @@ func planSection(key, title string, rows []output.TableRow) output.CombinedSecti
 		},
 	}
 }
+
+func getDuration(pricesDuration string) (time.Duration, error) {
+	// Use 28 days per month for prices calculations (UpCloud bills max 28 days per month)
+	month := 28 * 24 * time.Hour
+
+	// Handle special keywords first
+	switch strings.ToLower(pricesDuration) {
+	case durationHour:
+		return 1 * time.Hour, nil
+	case durationMonth:
+		// Use 28 days per month for pricing calculations (UpCloud bills max 28 days per month)
+		return month, nil
+	default:
+		// Parse as standard duration
+		var err error
+		duration, err := time.ParseDuration(pricesDuration)
+		if err != nil {
+			return time.Duration(0), fmt.Errorf("failed to parse prices-duration from duration string: %w", err)
+		}
+		return duration, nil
+	}
+}
+
+// getPlanCost calculates the cost for a given plan
+func getPlanCost(plan upcloud.Plan, pricing map[string]upcloud.Price, duration time.Duration) float64 {
+	if pricing == nil {
+		return math.NaN()
+	}
+
+	fieldName := "server_plan_" + plan.Name
+
+	price, ok := pricing[fieldName]
+	if !ok {
+		return math.NaN()
+	}
+
+	hourlyPrice := price.Price / 100
+
+	// Calculate cost for the requested duration
+	// UpCloud bills per (starting) hour, so round up to next full hour
+	return hourlyPrice * math.Ceil(duration.Hours())
+}
+
+// formatPricingHeader creates a human-readable header for the cost column
+func formatPricingHeader(pricingDuration string) string {
+	switch strings.ToLower(pricingDuration) {
+	case durationHour:
+		return "Price (per hour)"
+	case durationMonth:
+		return "Price (per month)"
+	case "1h":
+		return "Price (per hour)"
+	case "24h":
+		return "Price (per day)"
+	default:
+		// For other durations, just display the duration string
+		return fmt.Sprintf("Price (per %s)", pricingDuration)
+	}
+}
+
+func getFormatPrice(decimals int) func(any) (text.Colors, string, error) {
+	format := fmt.Sprintf("%%.%df", decimals)
+	return func(val any) (text.Colors, string, error) {
+		price, ok := val.(float64)
+		if !ok {
+			return nil, "", fmt.Errorf("cannot parse price from %T, expected string", val)
+		}
+		if math.IsNaN(price) {
+			return text.Colors{text.FgHiBlack}, "unknown", nil
+		}
+
+		return nil, fmt.Sprintf(format, price), nil
+	}
+}

internal/commands/server/plan_list_test.go

@@ -0,0 +1,90 @@
+package server
+
+import (
+	"testing"
+
+	"github.com/UpCloudLtd/upcloud-go-api/v8/upcloud"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestDurationHeader(t *testing.T) {
+	testCases := []struct {
+		input          string
+		expectedHeader string
+	}{
+		{
+			input:          "hour",
+			expectedHeader: "Price (per hour)",
+		},
+		{
+			input:          "month",
+			expectedHeader: "Price (per month)",
+		},
+		{
+			input:          "1h",
+			expectedHeader: "Price (per hour)",
+		},
+		{
+			input:          "4h30m",
+			expectedHeader: "Price (per 4h30m)",
+		},
+		{
+			input:          "24h",
+			expectedHeader: "Price (per day)",
+		},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.input, func(t *testing.T) {
+			header := formatPricingHeader(tc.input)
+			assert.Equal(t, tc.expectedHeader, header)
+		})
+	}
+}
+
+func TestGetPlanCost(t *testing.T) {
+	prices := map[string]upcloud.Price{
+		"server_plan_1xCPU-1GB": {
+			Amount: 1,
+			Price:  1.0416,
+		},
+	}
+
+	testcases := []struct {
+		plan     upcloud.Plan
+		duration string
+		expected float64
+	}{
+		{
+			plan:     upcloud.Plan{Name: "1xCPU-1GB"},
+			duration: "1h",
+			expected: 0.010416,
+		},
+		{
+			plan:     upcloud.Plan{Name: "1xCPU-1GB"},
+			duration: "2h30m",
+			expected: 0.031248,
+		},
+		{
+			plan:     upcloud.Plan{Name: "1xCPU-1GB"},
+			duration: "hour",
+			expected: 0.010416,
+		},
+		{
+			plan:     upcloud.Plan{Name: "1xCPU-1GB"},
+			duration: "month",
+			expected: 7,
+		},
+	}
+
+	for _, tc := range testcases {
+		name := tc.plan.Name + "-" + tc.duration
+		t.Run(name, func(t *testing.T) {
+			duration, err := getDuration(tc.duration)
+			assert.NoError(t, err)
+
+			cost := getPlanCost(tc.plan, prices, duration)
+			assert.InDelta(t, tc.expected, cost, 0.001)
+		})
+	}
+}

internal/mock/mock.go

@@ -88,7 +88,12 @@ func (m *Service) GetZones(context.Context) (*upcloud.Zones, error) {
 }
 
 // GetPriceZones implements service.Zones.GetPriceZones
-func (m *Service) GetPriceZones(context.Context) (*upcloud.PriceZones, error) {
+func (m *Service) GetPriceZones(context.Context) (*upcloud.PriceZones, error) { //nolint: staticcheck // Required to implement interface
+	return nil, nil
+}
+
+// GetPricingByZone implements service.Zones.GetPricingByZone
+func (m *Service) GetPricesByZone(context.Context) (*upcloud.PricesByZone, error) {
 	return nil, nil
 }