github.com/jamescostian/go-swagger@v0.30.4-0.20221130163922-68364d6b567b/generator/templates/cli/cli.gotmpl

// Code generated by go-swagger; DO NOT EDIT.


{{ if .Copyright -}}// {{ comment .Copyright -}}{{ end }}


package {{ .GenOpts.CliPackage }}

// This file was generated by the swagger tool.
// Editing this file might prove futile when you re-run the swagger generate command

import (
    {{ imports .DefaultImports }}
    {{ imports .Imports }}

    "github.com/spf13/cobra"
	"github.com/spf13/viper"
	"github.com/go-openapi/runtime"
	"github.com/go-openapi/swag"
	httptransport "github.com/go-openapi/runtime/client"
	homedir "github.com/mitchellh/go-homedir"
)

// debug flag indicating that cli should output debug logs
var debug bool
// config file location
var configFile string
// dry run flag
var dryRun bool

// name of the executable
var exeName string = filepath.Base(os.Args[0])

// logDebugf writes debug log to stdout
func logDebugf(format string, v ...interface{}) {
	if !debug{
		return
	}
	log.Printf(format, v...)
}

{{/*TODO: make this a swagger cli option*/}}
// depth of recursion to construct model flags
var maxDepth int = 5

// makeClient constructs a client object
func makeClient(cmd *cobra.Command, args []string) (*client.{{ pascalize .Name }}, error) {
	hostname := viper.GetString("hostname")
	viper.SetDefault("base_path", client.DefaultBasePath)
	basePath := viper.GetString("base_path")
	scheme := viper.GetString("scheme")

	r := httptransport.New(hostname, basePath, []string{scheme})
	r.SetDebug(debug)

	{{- /* user might define custom mediatype xxx/json and there is no registered ones to handle. */}}
	// set custom producer and consumer to use the default ones
	{{ range .Consumes }}
		{{ range .AllSerializers }}
			{{- if stringContains .MediaType "json" }}
		r.Consumers["{{ .MediaType }}"] = runtime.JSONConsumer()
			{{- else }}
		// warning: consumes {{ .MediaType }} is not supported by go-swagger cli yet
			{{- end }}
		{{- end }}
	{{ end }}
	{{ range .Produces }}
		{{- range .AllSerializers }}
			{{- if stringContains .MediaType "json" }}
		r.Producers["{{ .MediaType }}"] = runtime.JSONProducer()
			{{- else }}
		// warning: produces {{ .MediaType }} is not supported by go-swagger cli yet
			{{- end }}
		{{- end }}
	{{ end }}

	{{- if .SecurityDefinitions }}
	auth, err := makeAuthInfoWriter(cmd)
	if err != nil {
		return nil, err
	}
	r.DefaultAuthentication = auth
	{{ end }}
	appCli := client.New(r, strfmt.Default)
	logDebugf("Server url: %v://%v", scheme, hostname)
	return appCli, nil
}

// MakeRootCmd returns the root cmd
func MakeRootCmd() (*cobra.Command, error) {
	cobra.OnInitialize(initViperConfigs)
	
	// Use executable name as the command name
	rootCmd := &cobra.Command{
		Use: exeName,
	}
	{{/*note: viper binded flag value must be retrieved from viper rather than cmd*/}}
	// register basic flags
	rootCmd.PersistentFlags().String("hostname", client.DefaultHost, "hostname of the service")
	viper.BindPFlag("hostname", rootCmd.PersistentFlags().Lookup("hostname"))
	rootCmd.PersistentFlags().String("scheme", client.DefaultSchemes[0], fmt.Sprintf("Choose from: %v", client.DefaultSchemes))
	viper.BindPFlag("scheme", rootCmd.PersistentFlags().Lookup("scheme"))
	rootCmd.PersistentFlags().String("base-path", client.DefaultBasePath, fmt.Sprintf("For example: %v", client.DefaultBasePath))
	viper.BindPFlag("base_path", rootCmd.PersistentFlags().Lookup("base-path"))

	// configure debug flag
	rootCmd.PersistentFlags().BoolVar(&debug, "debug", false, "output debug logs")
	// configure config location
	rootCmd.PersistentFlags().StringVar(&configFile, "config", "", "config file path")
	// configure dry run flag
	rootCmd.PersistentFlags().BoolVar(&dryRun, "dry-run", false, "do not send the request to server")

	// register security flags
	{{- if .SecurityDefinitions }}
	if err := registerAuthInoWriterFlags(rootCmd); err != nil{
		return nil, err
	}
	{{- end }}
	// add all operation groups
{{- range .OperationGroups -}}
	{{- $operationGroupCmdVarName := printf "operationGroup%vCmd" (pascalize .Name) }}
	{{ $operationGroupCmdVarName }}, err := makeOperationGroup{{ pascalize .Name }}Cmd()
	if err != nil {
		return nil, err
	}
	rootCmd.AddCommand({{ $operationGroupCmdVarName }})
{{ end }}

	// add cobra completion
	rootCmd.AddCommand(makeGenCompletionCmd())

	return rootCmd, nil
}

// initViperConfigs initialize viper config using config file in '$HOME/.config/<cli name>/config.<json|yaml...>'
// currently hostname, scheme and auth tokens can be specified in this config file.
func initViperConfigs() {
	if configFile != "" {
		// use user specified config file location
		viper.SetConfigFile(configFile)
	}else{
		// look for default config
		// Find home directory.
		home, err := homedir.Dir()
		cobra.CheckErr(err)

		// Search config in home directory with name ".cobra" (without extension).
		viper.AddConfigPath(path.Join(home, ".config", exeName))
		viper.SetConfigName("config")
	}

	if err := viper.ReadInConfig(); err != nil {
		logDebugf("Error: loading config file: %v", err)
		return
	}
	logDebugf("Using config file: %v", viper.ConfigFileUsed())
}

{{- if .SecurityDefinitions }}
{{- /*youyuan: rework this since spec may define multiple auth schemes. 
	cli needs to detect which one user passed rather than add all of them.*/}}
// registerAuthInoWriterFlags registers all flags needed to perform authentication
func registerAuthInoWriterFlags(cmd *cobra.Command) error {
{{- range .SecurityDefinitions }}
		/*{{.Name}} {{.Description}}*/
		{{- if .IsBasicAuth }}
	cmd.PersistentFlags().String("username", "", "username for basic auth")
	viper.BindPFlag("username", cmd.PersistentFlags().Lookup("username"))
	cmd.PersistentFlags().String("password", "", "password for basic auth")
	viper.BindPFlag("password", cmd.PersistentFlags().Lookup("password"))
		{{- end }}
    	{{- if .IsAPIKeyAuth }}
	cmd.PersistentFlags().String("{{.Name}}", "", `{{.Description}}`)
	viper.BindPFlag("{{.Name}}", cmd.PersistentFlags().Lookup("{{.Name}}"))
    	{{- end }}
		{{- if .IsOAuth2 }}
	// oauth2: let user provide the token in a flag, rather than implement the logic to fetch the token.
	cmd.PersistentFlags().String("oauth2-token", "", `{{.Description}}`)
	viper.BindPFlag("oauth2-token", cmd.PersistentFlags().Lookup("oauth2-token"))
    	{{- end }}
{{- end }}
	return nil
}

// makeAuthInfoWriter retrieves cmd flags and construct an auth info writer
func makeAuthInfoWriter(cmd *cobra.Command) (runtime.ClientAuthInfoWriter, error) {
	auths := []runtime.ClientAuthInfoWriter{}
{{- range .SecurityDefinitions }}
	/*{{.Name}} {{.Description}}*/
	{{- if .IsBasicAuth }}
	if viper.IsSet("username") {
		usr := viper.GetString("username")
		if !viper.IsSet("password"){
			return nil, fmt.Errorf("Basic Auth password for user [%v] is not provided.", usr)
		}
		pwd := viper.GetString("password")
		auths = append(auths, httptransport.BasicAuth(usr,pwd))
    }
	{{- end }}
    {{- if .IsAPIKeyAuth }}
	if viper.IsSet("{{.Name}}") {
		{{ pascalize .Name }}Key := viper.GetString("{{.Name}}")
		auths = append(auths, httptransport.APIKeyAuth("{{.Name}}", "{{.In}}", {{ pascalize .Name }}Key))
    }
	{{- end }}
	{{- if .IsOAuth2 }}
	if viper.IsSet("oauth2-token") {
		// oauth2 workflow for generated CLI is not ideal. 
		// If you have suggestions on how to support it, raise an issue here: https://github.com/go-swagger/go-swagger/issues
		// This will be added to header: "Authorization: Bearer {oauth2-token value}"
		token := viper.GetString("oauth2-token")
		auths = append(auths, httptransport.BearerToken(token))
    }
    {{- end }}
{{- end }}
	if len(auths) == 0 {
		logDebugf("Warning: No auth params detected.")
		return nil, nil
	}
	// compose all auths together
	return httptransport.Compose(auths...), nil
}
{{- end }}

{{ range .OperationGroups -}}
func makeOperationGroup{{ pascalize .Name }}Cmd() (*cobra.Command, error) {
	{{- $operationGroupCmdVarName := printf "operationGroup%vCmd" (pascalize .Name) }}
	{{ $operationGroupCmdVarName }} := &cobra.Command{
		Use:   "{{ .Name }}",
		Long:  `{{ .Description }}`,
	}
{{ range .Operations }}
	{{- $operationCmdVarName := printf "operation%vCmd" (pascalize .Name) }}
	{{ $operationCmdVarName }}, err := makeOperation{{pascalize .Package}}{{ pascalize .Name }}Cmd()
	if err != nil {
		return nil, err
	}
	{{ $operationGroupCmdVarName }}.AddCommand({{ $operationCmdVarName }})
{{ end }}
	return {{ $operationGroupCmdVarName }}, nil
}
{{ end }} {{/*operation group*/}}