github.com/fastly/cli@v1.7.2-0.20240304164155-9d0f1d77c3bf/pkg/commands/vcl/custom/list.go (about)

     1  package custom
     2  
     3  import (
     4  	"fmt"
     5  	"io"
     6  
     7  	"github.com/fastly/go-fastly/v9/fastly"
     8  
     9  	"github.com/fastly/cli/pkg/argparser"
    10  	fsterr "github.com/fastly/cli/pkg/errors"
    11  	"github.com/fastly/cli/pkg/global"
    12  	"github.com/fastly/cli/pkg/text"
    13  )
    14  
    15  // NewListCommand returns a usable command registered under the parent.
    16  func NewListCommand(parent argparser.Registerer, g *global.Data) *ListCommand {
    17  	c := ListCommand{
    18  		Base: argparser.Base{
    19  			Globals: g,
    20  		},
    21  	}
    22  	c.CmdClause = parent.Command("list", "List the uploaded VCLs for a particular service and version")
    23  
    24  	// Required.
    25  	c.RegisterFlag(argparser.StringFlagOpts{
    26  		Name:        argparser.FlagVersionName,
    27  		Description: argparser.FlagVersionDesc,
    28  		Dst:         &c.serviceVersion.Value,
    29  		Required:    true,
    30  	})
    31  
    32  	// Optional.
    33  	c.RegisterFlagBool(c.JSONFlag()) // --json
    34  	c.RegisterFlag(argparser.StringFlagOpts{
    35  		Name:        argparser.FlagServiceIDName,
    36  		Description: argparser.FlagServiceIDDesc,
    37  		Dst:         &g.Manifest.Flag.ServiceID,
    38  		Short:       's',
    39  	})
    40  	c.RegisterFlag(argparser.StringFlagOpts{
    41  		Action:      c.serviceName.Set,
    42  		Name:        argparser.FlagServiceName,
    43  		Description: argparser.FlagServiceDesc,
    44  		Dst:         &c.serviceName.Value,
    45  	})
    46  
    47  	return &c
    48  }
    49  
    50  // ListCommand calls the Fastly API to list appropriate resources.
    51  type ListCommand struct {
    52  	argparser.Base
    53  	argparser.JSONOutput
    54  
    55  	serviceName    argparser.OptionalServiceNameID
    56  	serviceVersion argparser.OptionalServiceVersion
    57  }
    58  
    59  // Exec invokes the application logic for the command.
    60  func (c *ListCommand) Exec(_ io.Reader, out io.Writer) error {
    61  	if c.Globals.Verbose() && c.JSONOutput.Enabled {
    62  		return fsterr.ErrInvalidVerboseJSONCombo
    63  	}
    64  
    65  	serviceID, serviceVersion, err := argparser.ServiceDetails(argparser.ServiceDetailsOpts{
    66  		AllowActiveLocked:  true,
    67  		APIClient:          c.Globals.APIClient,
    68  		Manifest:           *c.Globals.Manifest,
    69  		Out:                out,
    70  		ServiceNameFlag:    c.serviceName,
    71  		ServiceVersionFlag: c.serviceVersion,
    72  		VerboseMode:        c.Globals.Flags.Verbose,
    73  	})
    74  	if err != nil {
    75  		c.Globals.ErrLog.AddWithContext(err, map[string]any{
    76  			"Service ID":      serviceID,
    77  			"Service Version": fsterr.ServiceVersion(serviceVersion),
    78  		})
    79  		return err
    80  	}
    81  
    82  	input := c.constructInput(serviceID, fastly.ToValue(serviceVersion.Number))
    83  
    84  	o, err := c.Globals.APIClient.ListVCLs(input)
    85  	if err != nil {
    86  		c.Globals.ErrLog.AddWithContext(err, map[string]any{
    87  			"Service ID":      serviceID,
    88  			"Service Version": fastly.ToValue(serviceVersion.Number),
    89  		})
    90  		return err
    91  	}
    92  
    93  	if ok, err := c.WriteJSON(out, o); ok {
    94  		return err
    95  	}
    96  
    97  	if c.Globals.Verbose() {
    98  		c.printVerbose(out, fastly.ToValue(serviceVersion.Number), o)
    99  	} else {
   100  		err = c.printSummary(out, o)
   101  		if err != nil {
   102  			return err
   103  		}
   104  	}
   105  	return nil
   106  }
   107  
   108  // constructInput transforms values parsed from CLI flags into an object to be used by the API client library.
   109  func (c *ListCommand) constructInput(serviceID string, serviceVersion int) *fastly.ListVCLsInput {
   110  	var input fastly.ListVCLsInput
   111  
   112  	input.ServiceID = serviceID
   113  	input.ServiceVersion = serviceVersion
   114  
   115  	return &input
   116  }
   117  
   118  // printVerbose displays the information returned from the API in a verbose
   119  // format.
   120  func (c *ListCommand) printVerbose(out io.Writer, serviceVersion int, vs []*fastly.VCL) {
   121  	fmt.Fprintf(out, "Service Version: %d\n", serviceVersion)
   122  
   123  	for _, v := range vs {
   124  		fmt.Fprintf(out, "\nName: %s\n", fastly.ToValue(v.Name))
   125  		fmt.Fprintf(out, "Main: %t\n", fastly.ToValue(v.Main))
   126  		fmt.Fprintf(out, "Content: \n%s\n\n", fastly.ToValue(v.Content))
   127  		if v.CreatedAt != nil {
   128  			fmt.Fprintf(out, "Created at: %s\n", v.CreatedAt)
   129  		}
   130  		if v.UpdatedAt != nil {
   131  			fmt.Fprintf(out, "Updated at: %s\n", v.UpdatedAt)
   132  		}
   133  		if v.DeletedAt != nil {
   134  			fmt.Fprintf(out, "Deleted at: %s\n", v.DeletedAt)
   135  		}
   136  	}
   137  }
   138  
   139  // printSummary displays the information returned from the API in a summarised
   140  // format.
   141  func (c *ListCommand) printSummary(out io.Writer, vs []*fastly.VCL) error {
   142  	t := text.NewTable(out)
   143  	t.AddHeader("SERVICE ID", "VERSION", "NAME", "MAIN")
   144  	for _, v := range vs {
   145  		t.AddLine(
   146  			fastly.ToValue(v.ServiceID),
   147  			fastly.ToValue(v.ServiceVersion),
   148  			fastly.ToValue(v.Name),
   149  			fastly.ToValue(v.Main),
   150  		)
   151  	}
   152  	t.Print()
   153  	return nil
   154  }