github.com/thetreep/go-swagger@v0.0.0-20240223100711-35af64f14f01/generator/templates/cli/operation.gotmpl

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

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

package cli {{/* TODO: do not hardcode cli pkg */}}

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

import (
  "fmt"

  {{ imports .DefaultImports }}
  {{ imports .Imports }}

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

// make{{ cmdName . }} returns a command to handle operation {{ camelize .Name }}
func make{{ cmdName . }}() (*cobra.Command, error) {
	cmd := &cobra.Command{
		Use:   "{{ .Name }}",
		Short: `{{ escapeBackticks .Description}}`,
		RunE: runOperation{{pascalize .Package}}{{ pascalize .Name }},
	}

	if err := registerOperation{{pascalize .Package}}{{ pascalize .Name }}ParamFlags(cmd); err != nil{
		return nil, err
	}

	return cmd, nil
}

{{ $operationGroup := .Package }}
{{ $operation := .Name }}
{{ $operationPkgAlias := .PackageAlias }}
// runOperation{{pascalize $operationGroup }}{{ pascalize $operation }} uses cmd flags to call endpoint api
func runOperation{{pascalize $operationGroup }}{{ pascalize $operation }}(cmd *cobra.Command, args []string) error{
	appCli, err := makeClient(cmd, args)
	if err != nil {
		return err
	}
	// retrieve flag values from cmd and fill params
	params := {{ .PackageAlias }}.New{{ pascalize .Name}}Params()
{{- range .Params }}
	if err, _ = retrieveOperation{{pascalize $operationGroup }}{{ pascalize $operation }}{{ pascalize .Name }}Flag(params, "", cmd); err != nil{
		return err
	}
{{- end }} {{/*Params*/}}
	if dryRun { {{/* Note: dry run is not very useful for now, but useful when validation is added in future*/}}
		logDebugf("dry-run flag specified. Skip sending request.")
		return nil
	}
	// make request and then print result
{{- /*Package string is the operation name*/}}
	msgStr, err :=  parseOperation{{pascalize .Package}}{{ pascalize .Name }}Result(appCli.{{- pascalize .Package }}.{{ pascalize .Name }}(params {{- if .Authorized}}, nil{{ end }}{{ if .HasStreamingResponse }}, &bytes.Buffer{}{{ end }}))
	if err != nil {
		return err
	}

	if !debug{ {{/* In debug mode content should have been printed in transport layer, so do not print again*/}}
		fmt.Println(msgStr)
	}

	return nil
}

// registerOperation{{pascalize $operationGroup }}{{ pascalize $operation }}ParamFlags registers all flags needed to fill params
func registerOperation{{pascalize $operationGroup }}{{ pascalize $operation }}ParamFlags(cmd *cobra.Command) error {
{{- range .Params }}
	if err := registerOperation{{pascalize $operationGroup }}{{ pascalize $operation }}{{pascalize .Name }}ParamFlags("", cmd); err != nil{
		return err
	}
{{- end }}
	return nil
}
{{/*register functions for each fields in this operation*/}}
{{- range .Params }}

func registerOperation{{pascalize $operationGroup }}{{ pascalize $operation }}{{pascalize .Name }}ParamFlags(cmdPrefix string, cmd *cobra.Command) error{
	{{- if .IsPrimitive }}
		{{ template "primitiveregistrator" . }}
	{{- else if .IsArray }}
		{{ template "arrayregistrator" . }}
	{{- else if and .IsBodyParam .Schema (not .IsArray) (not .IsMap) (not .IsStream) }}
		{{ template "modelparamstringregistrator" . }}
		{{ template "modelparamregistrator" . }}
		{{/* Do not mark body flag as required, since the individial flag for body field will be added separately */}}
	{{- else }}
		// warning: go type {{ .GoType }} is not supported by go-swagger cli yet.
	{{- end }}
	return nil
}
{{- end }}

{{/*functions to retrieve each field of params*/}}
{{- range .Params }}

func retrieveOperation{{pascalize $operationGroup }}{{ pascalize $operation }}{{ pascalize .Name }}Flag(m *{{ $operationPkgAlias }}.{{ pascalize $operation }}Params, cmdPrefix string, cmd *cobra.Command) (error,bool){
	retAdded := false
	{{- $flagStr := .Name }}
	{{- $flagValueVar := printf "%vValue" (camelize .Name) }}
		{{- /*only set the param if user set the flag*/}}
	if cmd.Flags().Changed("{{ $flagStr }}") {
	{{- if .IsPrimitive }}
		{{ template "primitiveretriever" . }}
	{{- else if .IsArray }}
		{{ template "arrayretriever" . }}
	{{- else if .IsMap }}
		// warning: {{ .Name }} map type {{.GoType}} is not supported by go-swagger cli yet
	{{- else if and .IsBodyParam .Schema .IsComplexObject (not .IsStream) }}
		{{- /*schema payload can be passed in cmd as a string and here is unmarshalled to model struct and attached in params*/}}
		// Read {{ $flagStr }} string from cmd and unmarshal
		{{ $flagValueVar }}Str, err := cmd.Flags().GetString("{{ $flagStr }}")
		if err != nil {
			return err, false
		}
		{{/*Note anonymous body schema is not pointer*/}}
		{{ $flagValueVar }} := {{if containsPkgStr .GoType}}{{ .GoType }}{{else}}{{ .Pkg }}.{{.GoType}}{{ end }}{}
		if err := json.Unmarshal([]byte({{ $flagValueVar }}Str), &{{ $flagValueVar }}); err!= nil{
			return fmt.Errorf("cannot unmarshal {{ $flagStr }} string in {{.GoType}}: %v", err), false
		}
		m.{{ .ID }} = {{- if .IsNullable }}&{{- end }}{{ $flagValueVar }}
	{{- else }}
		// warning: {{.GoType}} is not supported by go-swagger cli yet
	{{- end }} {{/*end go type case*/}}
	}
	{{- if and .IsBodyParam .Schema .IsComplexObject (not .IsArray) (not .IsMap) (not .IsStream) }}
		{{- /* Add flags to capture fields in Body. If previously Body struct was constructed in unmarshalling body string,
			then reuse the struct, otherwise construct an empty value struct to fill. Here body field flags overwrites
			unmarshalled body string values. */}}
		{{- $flagModelVar := printf "%vModel" (camelize $flagValueVar) }}
	{{ $flagModelVar }} := m.{{ .ID }}
	if swag.IsZero({{ $flagModelVar }}){
		{{ $flagModelVar }} = {{- if .IsNullable }}&{{- end }}{{if containsPkgStr .GoType}}{{ .GoType }}{{else}}{{ .Pkg }}.{{.GoType}}{{ end }}{}
	}
		{{- /*Only attach the body struct in params if user passed some flag filling some body fields.*/}}
		{{- /* add "&" to $flagModelVar when it is not nullable because the retrieve method always expects a pointer */}}
	err, added := retrieveModel{{ pascalize (dropPackage .GoType) }}Flags(0, {{if not .IsNullable}}&{{end}}{{ $flagModelVar }}, "{{ camelize (dropPackage .GoType) }}", cmd)
	if err != nil{
		return err, false
	}
	if added {
		m.{{.ID}} = {{ $flagModelVar }}
	}

	if dryRun && debug { {{/* dry run we don't get trasnport debug strings, so print it here*/}}
		{{- $bodyDebugVar := printf "%vDebugBytes" (camelize $flagValueVar) }}
		{{ $bodyDebugVar }}, err := json.Marshal(m.{{.ID}})
		if err != nil{
			return err, false
		}
		logDebugf("{{.ID }} dry-run payload: %v", string({{ $bodyDebugVar }}))
	}

	retAdded = retAdded || added {{/*body debug string will be printed in transport layer*/}}
	{{- end }}

	return nil, retAdded
}
{{- end }} {{/*Params*/}}

// parseOperation{{pascalize .Package}}{{ pascalize .Name }}Result parses request result and return the string content
{{- /*TODO: handle multiple success response case*/}}
func parseOperation{{pascalize .Package}}{{ pascalize .Name }}Result({{- if .SuccessResponse }}{{ range $i, $v := .SuccessResponses }} resp{{$i}} *{{$v.Package}}.{{pascalize $v.Name}},{{- end }}{{- end }} respErr error) (string, error){
	if respErr != nil {
		{{- /*error is of type default model. If we can cast, then print the resp.*/}}
		{{ if .DefaultResponse }} {{with .DefaultResponse}}
			{{ if .Schema }}
		var iRespD interface{} = respErr
		respD, ok := iRespD.(*{{ .Package }}.{{ pascalize .Name }})
		if ok {
			if !swag.IsZero(respD) && !swag.IsZero(respD.Payload) {
				msgStr,err := json.Marshal(respD.Payload)
				if err != nil{
					return "", err
				}
				return string(msgStr), nil
			}
		}
			{{ else }}
			// Non schema case: warning {{.Name}} is not supported
			{{ end }}
		{{ end }} {{ end }}
		{{- range $i, $v := .Responses }}
			{{ if .Schema }}
		var iResp{{$i}} interface{} = respErr
		resp{{$i}}, ok := iResp{{$i}}.(*{{ .Package }}.{{ pascalize .Name }})
		if ok {
			if !swag.IsZero(resp{{$i}}) && !swag.IsZero(resp{{$i}}.Payload) {
				msgStr,err := json.Marshal(resp{{$i}}.Payload)
				if err != nil{
					return "", err
				}
				return string(msgStr), nil
			}
		}
			{{ else }}
			// Non schema case: warning {{.Name}} is not supported
			{{ end }}
		{{ end }}
		return "", respErr
	}
	{{- range $i, $v := .SuccessResponses }}
		{{ if .Schema }}
		{{- with .Schema}}
	if !swag.IsZero(resp{{$i}}) && !swag.IsZero(resp{{$i}}.Payload) {
			{{- if or .IsComplexObject .IsArray .IsMap }}
		msgStr,err := json.Marshal(resp{{$i}}.Payload)
		if err != nil{
			return "", err
		}
			{{- else }}
		msgStr := fmt.Sprintf("%v", resp{{$i}}.Payload)
			{{- end }}
		return string(msgStr), nil
	}
		{{- end }}
		{{ else }}
		// warning: non schema response {{.Name}} is not supported by go-swagger cli yet.
		{{ end }}
	{{ end }}
	return "", nil
}

{{/*for models defined in params, generate their register and retrieve flags functions*/}}
{{- range .ExtraSchemas }}
	{{ template "modelschemacli" . }}
{{- end}}