github.com/phrase/openapi@v0.0.0-20240514140800-49e8a106740e/openapi-generator/templates/cli/api.handlebars

package cmd
{{#operations}}
import (
	"context"
	"encoding/json"
	"fmt"
	"os"
	"strings"

	"github.com/antihax/optional"
	helpers "github.com/phrase/phrase-cli/helpers"
	api "github.com/phrase/phrase-go/v3"
	"github.com/spf13/cobra"
	"github.com/spf13/viper"
)

func init() {
	{{#operation}}init{{{nickname}}}()
	{{/operation}}
	rootCmd.AddCommand({{{classname}}}Cmd)
}

var {{{classname}}}Cmd = &cobra.Command{
	Use:	 helpers.ToSnakeCase("{{{cut classname "Api"}}}"),
	Short:	 "{{{join (cut classname "Api") "API" " "}}}",
}
{{#operation}}
func init{{{nickname}}}() {
	params := viper.New()
	var use string
	// this weird approach is due to mustache template limitations
	use = strings.Join(strings.Split("{{operationIdOriginal}}", "/")[1:], "_")
	var {{{nickname}}} = &cobra.Command{
		Use:	 use,
		Short: "{{#summary}}{{{.}}}{{/summary}}{{^summary}}Method for {{operationId}}{{/summary}}",
		Long:  `{{#notes}}{{notes}}{{/notes}}`,
		Run: func(cmd *cobra.Command, args []string) {
			auth := Auth()

			cfg := api.NewConfiguration()
			cfg.SetUserAgent(Config.UserAgent)
			if Config.Credentials.Host != "" {
				cfg.BasePath = Config.Credentials.Host
			}

			client := api.NewAPIClient(cfg)
			{{#hasOptionalParams}}localVarOptionals := api.{{#structPrefix}}{{&classname}}{{/structPrefix}}{{{nickname}}}Opts{}

			if Config.Credentials.TFA && Config.Credentials.TFAToken != "" {
				localVarOptionals.XPhraseAppOTP = optional.NewString(Config.Credentials.TFAToken)
			}{{/hasOptionalParams}}


			{{#allParams~}}
				{{#required~}}
					{{#isPrimitiveType~}}
						{{#if (eq paramName "file")~}}
							{{paramName}}, err := os.Open(params.GetString(helpers.ToSnakeCase("{{paramName}}")))
							if err != nil {
							HandleError(err)
							}
						{{else~}}
							{{paramName}} := params.Get{{{capitalizeFirst dataType}}}(helpers.ToSnakeCase("{{{vendorExtensions.x-export-param-name}}}"))
						{{/if}}
					{{else~}}
						var {{paramName}} api.{{{dataType}}}
						if err := json.Unmarshal([]byte(params.GetString("data")), &{{paramName}}); err != nil {
							HandleError(err)
						}
						if Config.Debug {
							fmt.Printf("%+v\n", {{paramName}})
						}
					{{/isPrimitiveType~}}
				{{else~}}
					{{#if (or (eq paramName "file") (eq paramName "filename"))~}}
						if params.IsSet(helpers.ToSnakeCase("{{paramName}}")) {
							file, err := os.Open(params.GetString(helpers.ToSnakeCase("{{paramName}}")))
							localVarOptionals.{{{vendorExtensions.x-export-param-name}}} = optional.NewInterface(file)
							if err != nil {
								HandleError(err)
							}
						}
					{{else~}}
						{{#isPrimitiveType~}}
							if params.IsSet(helpers.ToSnakeCase("{{paramName}}")) {
								localVarOptionals.{{{vendorExtensions.x-export-param-name}}} = optional.New{{capitalizeFirst dataType}}(params.Get{{{capitalizeFirst dataType}}}(helpers.ToSnakeCase("{{{vendorExtensions.x-export-param-name}}}")))
							}
						{{/isPrimitiveType~}}
						{{#isModel~}}
							var {{paramName}} map[string]interface{}
							if err := json.Unmarshal([]byte(params.GetString("data")), &{{paramName}}); err != nil {
								HandleError(err)
							}
							if Config.Debug {
								fmt.Printf("%+v\n", {{paramName}})
							}
						{{/isModel~}}
						{{^isPrimitiveType}}{{^isModel}}
							if params.IsSet(helpers.ToSnakeCase("{{paramName}}")) {
								var {{paramName}} map[string]interface{}
								if err := json.Unmarshal([]byte(params.GetString(helpers.ToSnakeCase("{{{vendorExtensions.x-export-param-name}}}"))), &{{paramName}}); err != nil {
									HandleError(err)
								}
								localVarOptionals.{{{vendorExtensions.x-export-param-name}}} = optional.NewInterface({{paramName}})
							}
						{{/isModel}}{{/isPrimitiveType}}
					{{/if}}
				{{/required~}}
			{{/allParams~}}

			data, api_response, err := client.{{classname}}.{{{nickname}}}(auth{{#hasParams}}, {{/hasParams}}{{#allParams}}{{#required}}{{paramName}}{{#unless @last}}, {{/unless}}{{/required}}{{/allParams}}{{#hasOptionalParams}}&localVarOptionals{{/hasOptionalParams}})

			if err != nil {
				switch castedError := err.(type) {
					case api.GenericOpenAPIError:
						fmt.Printf("\n%s\n\n", string(castedError.Body()))
						HandleError(castedError)

					default:
						HandleError(castedError)
				}
			} else if api_response.StatusCode >= 200 && api_response.StatusCode < 300 {
				{{#if returnType}}{{#if (eq returnType "*os.File")}}content, _ := ioutil.ReadAll(data)
				fmt.Printf("%s", string(content))
				data.Close()
				os.Remove(data.Name()){{else}}jsonBuf, jsonErr := json.MarshalIndent(data, "", " ")
				if jsonErr != nil {
					fmt.Printf("%v\n", data)
					HandleError(err)
				}
				fmt.Printf("%s\n", string(jsonBuf)){{/if}}{{else}}os.Stdout.Write(data){{/if}}

				if Config.Debug {
					fmt.Printf("%+v\n", api_response) // &{Response:0xc00011ccf0 NextPage:2 FirstPage:1 LastPage:4 Rate:{Limit:1000 Remaining:998 Reset:2020-04-25 00:35:00 +0200 CEST}}
				}
			}
		},
	}

	{{{classname}}}Cmd.AddCommand({{{nickname}}})
	{{#allParams}}{{#isPrimitiveType}}AddFlag({{{nickname}}}, "{{{dataType}}}", helpers.ToSnakeCase("{{{vendorExtensions.x-export-param-name}}}"), "", "{{#description}}{{{.}}}{{/description}}", {{#required}}true{{/required}}{{^required}}false{{/required}}){{/isPrimitiveType}}{{^isPrimitiveType}}{{#isModel}}AddFlag({{{nickname}}}, "string", "data", "d", "payload in JSON format", {{#required}}true{{/required}}{{^required}}false{{/required}}){{/isModel}}{{^isModel}}AddFlag({{{nickname}}}, "string", helpers.ToSnakeCase("{{{vendorExtensions.x-export-param-name}}}"), "", "payload in JSON format", {{#required}}true{{/required}}{{^required}}false{{/required}}){{/isModel}}{{/isPrimitiveType}}
  {{/allParams}}
	params.BindPFlags({{{nickname}}}.Flags())
}{{/operation}}
{{/operations}}