feat: Implement reserves and encodes subcommands

This commit introduces the  and  subcommands to the  CLI tool.

Key changes include:
- Implementation of , , , , and  commands.
- Implementation of , , and  commands.
- Updates to the API client wrapper () to support new API calls.
- Refinements to output formatting functions in .
- Addressing compilation errors and ensuring a successful build.

Note: Creating reserves by program ID is not directly supported by the EPGStation API for manual reserves; they are created with encode options.

Author: musaprg

cmd/epgstationctl/main.go

@@ -2,8 +2,10 @@ package main
 
 import (
 	_ "github.com/miscord-dev/epgstationctl/internal/commands/channels"
+	_ "github.com/miscord-dev/epgstationctl/internal/commands/encodes"
 	_ "github.com/miscord-dev/epgstationctl/internal/commands/programs"
 	_ "github.com/miscord-dev/epgstationctl/internal/commands/recordings"
+	_ "github.com/miscord-dev/epgstationctl/internal/commands/reserves"
 	"github.com/miscord-dev/epgstationctl/internal/commands/root"
 	_ "github.com/miscord-dev/epgstationctl/internal/commands/rules"
 )

internal/client/wrapper.go

@@ -297,3 +297,143 @@ func (c *EPGStationClient) SearchRulesKeyword(params *epgstation.GetRulesKeyword
 
 	return &keywords, nil
 }
+
+// GetReserves retrieves current reserves with optional filtering
+func (c *EPGStationClient) GetReserves(params *epgstation.GetReservesParams) (*epgstation.Reserves, error) {
+	resp, err := c.client.GetReserves(context.Background(), params)
+	if err != nil {
+		return nil, err
+	}
+	defer func() { _ = resp.Body.Close() }()
+
+	if resp.StatusCode != http.StatusOK {
+		return nil, handleErrorResponse(resp)
+	}
+
+	var reserves epgstation.Reserves
+	if err := parseJSONResponse(resp, &reserves); err != nil {
+		return nil, err
+	}
+
+	return &reserves, nil
+}
+
+// CreateReserve creates a manual reserve
+func (c *EPGStationClient) CreateReserve(body epgstation.ManualReserveOption) (*epgstation.AddedReserve, error) {
+	resp, err := c.client.PostReserves(context.Background(), body)
+	if err != nil {
+		return nil, err
+	}
+	defer func() { _ = resp.Body.Close() }()
+
+	if resp.StatusCode != http.StatusCreated {
+		return nil, handleErrorResponse(resp)
+	}
+
+	var result epgstation.AddedReserve
+	if err := parseJSONResponse(resp, &result); err != nil {
+		return nil, err
+	}
+
+	return &result, nil
+}
+
+// UpdateReserve updates an existing reserve
+func (c *EPGStationClient) UpdateReserve(reserveID int, body epgstation.EditManualReserveOption) error {
+	resp, err := c.client.PutReservesReserveId(context.Background(), reserveID, body)
+	if err != nil {
+		return err
+	}
+	defer func() { _ = resp.Body.Close() }()
+
+	if resp.StatusCode != http.StatusOK {
+		return handleErrorResponse(resp)
+	}
+
+	return nil
+}
+
+// DeleteReserve deletes a reserve
+func (c *EPGStationClient) DeleteReserve(reserveID int) error {
+	resp, err := c.client.DeleteReservesReserveId(context.Background(), reserveID)
+	if err != nil {
+		return err
+	}
+	defer func() { _ = resp.Body.Close() }()
+
+	if resp.StatusCode != http.StatusOK {
+		return handleErrorResponse(resp)
+	}
+
+	return nil
+}
+
+// UnSkipReserve removes skip status from a reserve
+func (c *EPGStationClient) UnSkipReserve(reserveID int) error {
+	resp, err := c.client.DeleteReservesReserveIdSkip(context.Background(), reserveID)
+	if err != nil {
+		return err
+	}
+	defer func() { _ = resp.Body.Close() }()
+
+	if resp.StatusCode != http.StatusOK {
+		return handleErrorResponse(resp)
+	}
+
+	return nil
+}
+
+// GetEncodes retrieves encode jobs with optional filtering
+func (c *EPGStationClient) GetEncodes(params *epgstation.GetEncodeParams) (*epgstation.EncodeInfo, error) {
+	resp, err := c.client.GetEncode(context.Background(), params)
+	if err != nil {
+		return nil, err
+	}
+	defer func() { _ = resp.Body.Close() }()
+
+	if resp.StatusCode != http.StatusOK {
+		return nil, handleErrorResponse(resp)
+	}
+
+	var encodes epgstation.EncodeInfo
+	if err := parseJSONResponse(resp, &encodes); err != nil {
+		return nil, err
+	}
+
+	return &encodes, nil
+}
+
+// CreateEncode creates a manual encode job
+func (c *EPGStationClient) CreateEncode(body epgstation.AddManualEncodeProgramOption) (*epgstation.AddedEncode, error) {
+	resp, err := c.client.PostEncode(context.Background(), body)
+	if err != nil {
+		return nil, err
+	}
+	defer func() { _ = resp.Body.Close() }()
+
+	if resp.StatusCode != http.StatusCreated {
+		return nil, handleErrorResponse(resp)
+	}
+
+	var result epgstation.AddedEncode
+	if err := parseJSONResponse(resp, &result); err != nil {
+		return nil, err
+	}
+
+	return &result, nil
+}
+
+// DeleteEncode deletes/cancels an encode job
+func (c *EPGStationClient) DeleteEncode(encodeID int) error {
+	resp, err := c.client.DeleteEncodeEncodeId(context.Background(), encodeID)
+	if err != nil {
+		return err
+	}
+	defer func() { _ = resp.Body.Close() }()
+
+	if resp.StatusCode != http.StatusOK {
+		return handleErrorResponse(resp)
+	}
+
+	return nil
+}

internal/commands/encodes/encodes.go

@@ -0,0 +1,182 @@
+package encodes
+
+import (
+	"fmt"
+	"strconv"
+
+	"github.com/miscord-dev/epgstationctl/internal/client"
+	"github.com/miscord-dev/epgstationctl/internal/commands/root"
+	"github.com/miscord-dev/epgstationctl/internal/epgstation"
+	"github.com/miscord-dev/epgstationctl/internal/output"
+	"github.com/spf13/cobra"
+)
+
+const (
+	outputFormatJSON = "json"
+)
+
+var (
+	offset     int
+	limit      int
+	isEncoding bool
+	
+	// Create encode flags
+	recordedID           int
+	encodeMode           int
+	encodeParentDir      string
+	encodeDir            string
+	removeOriginal       bool
+)
+
+var encodesCmd = &cobra.Command{
+	Use:   "encodes",
+	Short: "Manage encoding jobs",
+	Long:  "Commands for managing EPGStation encoding jobs",
+}
+
+var listCmd = &cobra.Command{
+	Use:   "list",
+	Short: "List encoding jobs",
+	Long:  "List all encoding jobs with their status",
+	RunE: func(cmd *cobra.Command, args []string) error {
+		cfg := root.GetConfig()
+		client, err := client.NewEPGStationClient(cfg)
+		if err != nil {
+			return fmt.Errorf("failed to create EPGStation client: %w", err)
+		}
+
+		encodes, err := client.GetEncodes(&epgstation.GetEncodeParams{IsHalfWidth: false}) // Assuming IsHalfWidth is required
+		if err != nil {
+			return fmt.Errorf("failed to get encodes: %w", err)
+		}
+
+		if cfg.Output.Format == outputFormatJSON {
+			return output.PrintAsJSON(encodes)
+		}
+
+		return printEncodesTable(encodes)
+	},
+}
+
+var createCmd = &cobra.Command{
+	Use:   "create",
+	Short: "Create a manual encode job",
+	Long:  "Create a manual encoding job for a recorded program",
+	RunE: func(cmd *cobra.Command, args []string) error {
+		if recordedID == 0 {
+			return fmt.Errorf("recorded ID is required (use --recorded-id)")
+		}
+
+		cfg := root.GetConfig()
+		client, err := client.NewEPGStationClient(cfg)
+		if err != nil {
+			return fmt.Errorf("failed to create EPGStation client: %w", err)
+		}
+
+		encodeOption := epgstation.AddManualEncodeProgramOption{
+			RecordedId: recordedID,
+			Mode:       strconv.Itoa(encodeMode), // Mode is string
+		}
+
+		if encodeParentDir != "" {
+			encodeOption.ParentDir = &encodeParentDir
+		}
+		if encodeDir != "" {
+			encodeOption.Directory = &encodeDir
+		}
+		encodeOption.RemoveOriginal = removeOriginal // RemoveOriginal is bool, not *bool
+
+		result, err := client.CreateEncode(encodeOption)
+		if err != nil {
+			return fmt.Errorf("failed to create encode: %w", err)
+		}
+
+		if cfg.Output.Format == outputFormatJSON {
+			return output.PrintAsJSON(result)
+		}
+
+		fmt.Printf("Encode job created successfully with ID: %d\n", result.EncodeId)
+		return nil
+	},
+}
+
+var deleteCmd = &cobra.Command{
+	Use:   "delete <id>",
+	Short: "Delete an encode job",
+	Long:  "Delete/cancel an encoding job",
+	Args:  cobra.ExactArgs(1),
+	RunE: func(cmd *cobra.Command, args []string) error {
+		encodeID, err := strconv.Atoi(args[0])
+		if err != nil {
+			return fmt.Errorf("invalid encode ID: %s", args[0])
+		}
+
+		cfg := root.GetConfig()
+		client, err := client.NewEPGStationClient(cfg)
+		if err != nil {
+			return fmt.Errorf("failed to create EPGStation client: %w", err)
+		}
+
+		err = client.DeleteEncode(encodeID)
+		if err != nil {
+			return fmt.Errorf("failed to delete encode: %w", err)
+		}
+
+		fmt.Printf("Encode job %d deleted successfully\n", encodeID)
+		return nil
+	},
+}
+
+func printEncodesTable(encodes *epgstation.EncodeInfo) error {
+	table := output.NewTable()
+	table.SetHeader([]string{"ID", "Name", "Mode", "Status", "Progress", "Started"})
+
+	for _, encode := range encodes.RunningItems {
+		progress := "N/A"
+		if encode.Percent != nil {
+			progress = fmt.Sprintf("%.1f%%", *encode.Percent)
+		}
+
+		table.Append([]string{
+			strconv.Itoa(encode.Id),
+			encode.Recorded.Name,
+			encode.Mode,
+			"Encoding",
+			progress,
+			output.FormatUnixTime(encode.Recorded.StartAt),
+		})
+	}
+
+	for _, encode := range encodes.WaitItems {
+		table.Append([]string{
+			strconv.Itoa(encode.Id),
+			encode.Recorded.Name,
+			encode.Mode,
+			"Waiting",
+			"N/A",
+			output.FormatUnixTime(encode.Recorded.StartAt),
+		})
+	}
+
+	table.Render()
+	return nil
+}
+
+func init() {
+	// Create command flags
+	createCmd.Flags().IntVar(&recordedID, "recorded-id", 0, "Recorded program ID to encode (required)")
+	createCmd.Flags().IntVar(&encodeMode, "encode-mode", 0, "Encode mode ID")
+	createCmd.Flags().StringVar(&encodeParentDir, "encode-parent-directory", "", "Encode parent directory")
+	createCmd.Flags().StringVar(&encodeDir, "encode-directory", "", "Encode directory")
+	createCmd.Flags().BoolVar(&removeOriginal, "remove-original", false, "Remove original file after encoding")
+	createCmd.MarkFlagRequired("recorded-id")
+	createCmd.MarkFlagRequired("encode-mode") // Make encode-mode required
+
+	// Add subcommands
+	encodesCmd.AddCommand(listCmd)
+	encodesCmd.AddCommand(createCmd)
+	encodesCmd.AddCommand(deleteCmd)
+
+	// Register with root command
+	root.AddCommand(encodesCmd)
+}