From 33b8e8aa5b1368a8db409326419ab3509ea668d6 Mon Sep 17 00:00:00 2001 From: wing328 Date: Mon, 16 Nov 2015 10:53:45 +0800 Subject: [PATCH 1/8] add golang --- .../resources/META-INF/services/io.swagger.codegen.CodegenConfig | 1 + 1 file changed, 1 insertion(+) diff --git a/modules/swagger-codegen/src/main/resources/META-INF/services/io.swagger.codegen.CodegenConfig b/modules/swagger-codegen/src/main/resources/META-INF/services/io.swagger.codegen.CodegenConfig index 5d8a4f0fc6b..87d61229936 100644 --- a/modules/swagger-codegen/src/main/resources/META-INF/services/io.swagger.codegen.CodegenConfig +++ b/modules/swagger-codegen/src/main/resources/META-INF/services/io.swagger.codegen.CodegenConfig @@ -4,6 +4,7 @@ io.swagger.codegen.languages.CSharpClientCodegen io.swagger.codegen.languages.DartClientCodegen io.swagger.codegen.languages.FlashClientCodegen io.swagger.codegen.languages.FlaskConnexionCodegen +io.swagger.codegen.languages.GoClientCodegen io.swagger.codegen.languages.JavaClientCodegen io.swagger.codegen.languages.JavascriptClientCodegen io.swagger.codegen.languages.JaxRSServerCodegen From a05076ed09d545cc555b682579bd47c7816f2706 Mon Sep 17 00:00:00 2001 From: wing328 Date: Mon, 21 Dec 2015 00:18:00 +0800 Subject: [PATCH 2/8] first commit of golang generator before fixing return --- .../io/swagger/codegen/DefaultCodegen.java | 2 + .../io/swagger/codegen/DefaultGenerator.java | 4 + .../codegen/languages/GoClientCodegen.java | 252 +++++++++++ .../src/main/resources/go/api.mustache | 98 +++++ .../src/main/resources/go/model.mustache | 15 + .../client/petstore/go/swagger/ApiClient.go | 33 ++ .../client/petstore/go/swagger/Category.go | 10 + samples/client/petstore/go/swagger/Order.go | 15 + samples/client/petstore/go/swagger/Pet.go | 14 + samples/client/petstore/go/swagger/PetApi.go | 407 ++++++++++++++++++ .../client/petstore/go/swagger/StoreApi.go | 198 +++++++++ samples/client/petstore/go/swagger/Tag.go | 10 + samples/client/petstore/go/swagger/User.go | 16 + samples/client/petstore/go/swagger/UserApi.go | 380 ++++++++++++++++ samples/client/petstore/go/test.go | 14 + 15 files changed, 1468 insertions(+) create mode 100644 modules/swagger-codegen/src/main/java/io/swagger/codegen/languages/GoClientCodegen.java create mode 100644 modules/swagger-codegen/src/main/resources/go/api.mustache create mode 100644 modules/swagger-codegen/src/main/resources/go/model.mustache create mode 100644 samples/client/petstore/go/swagger/ApiClient.go create mode 100644 samples/client/petstore/go/swagger/Category.go create mode 100644 samples/client/petstore/go/swagger/Order.go create mode 100644 samples/client/petstore/go/swagger/Pet.go create mode 100644 samples/client/petstore/go/swagger/PetApi.go create mode 100644 samples/client/petstore/go/swagger/StoreApi.go create mode 100644 samples/client/petstore/go/swagger/Tag.go create mode 100644 samples/client/petstore/go/swagger/User.go create mode 100644 samples/client/petstore/go/swagger/UserApi.go create mode 100644 samples/client/petstore/go/test.go diff --git a/modules/swagger-codegen/src/main/java/io/swagger/codegen/DefaultCodegen.java b/modules/swagger-codegen/src/main/java/io/swagger/codegen/DefaultCodegen.java index 11472fec4ff..ac91c60fa0f 100644 --- a/modules/swagger-codegen/src/main/java/io/swagger/codegen/DefaultCodegen.java +++ b/modules/swagger-codegen/src/main/java/io/swagger/codegen/DefaultCodegen.java @@ -1045,6 +1045,8 @@ public class DefaultCodegen { } property.baseType = getSwaggerType(p); + LOGGER.info("property.baseType=" + property.baseType); + LOGGER.info("property.datatype=" + property.datatype); if (p instanceof ArrayProperty) { property.isContainer = true; diff --git a/modules/swagger-codegen/src/main/java/io/swagger/codegen/DefaultGenerator.java b/modules/swagger-codegen/src/main/java/io/swagger/codegen/DefaultGenerator.java index 3623361387e..24c17615f2d 100644 --- a/modules/swagger-codegen/src/main/java/io/swagger/codegen/DefaultGenerator.java +++ b/modules/swagger-codegen/src/main/java/io/swagger/codegen/DefaultGenerator.java @@ -657,6 +657,7 @@ public class DefaultGenerator extends AbstractGenerator implements Generator { for (String nextImport : allImports) { Map im = new LinkedHashMap(); String mapping = config.importMapping().get(nextImport); + LOGGER.info("mapping = " + mapping); if (mapping == null) { mapping = config.toModelImport(nextImport); } @@ -703,6 +704,7 @@ public class DefaultGenerator extends AbstractGenerator implements Generator { List> imports = new ArrayList>(); for (String nextImport : allImports) { + LOGGER.info("nextImport=" + nextImport); Map im = new LinkedHashMap(); String mapping = config.importMapping().get(nextImport); if (mapping == null) { @@ -711,12 +713,14 @@ public class DefaultGenerator extends AbstractGenerator implements Generator { if (mapping != null && !config.defaultIncludes().contains(mapping)) { im.put("import", mapping); imports.add(im); + LOGGER.info("config.importMaping added " + mapping); } // add instantiation types mapping = config.instantiationTypes().get(nextImport); if (mapping != null && !config.defaultIncludes().contains(mapping)) { im.put("import", mapping); imports.add(im); + LOGGER.info("config.instantiationTypes added " + mapping); } } diff --git a/modules/swagger-codegen/src/main/java/io/swagger/codegen/languages/GoClientCodegen.java b/modules/swagger-codegen/src/main/java/io/swagger/codegen/languages/GoClientCodegen.java new file mode 100644 index 00000000000..04401b044e5 --- /dev/null +++ b/modules/swagger-codegen/src/main/java/io/swagger/codegen/languages/GoClientCodegen.java @@ -0,0 +1,252 @@ +package io.swagger.codegen.languages; + +import io.swagger.codegen.*; +import io.swagger.models.properties.ArrayProperty; +import io.swagger.models.properties.MapProperty; +import io.swagger.models.properties.Property; + +import java.io.File; +import java.util.*; + +import org.apache.commons.lang.StringUtils; + +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +public class GoClientCodegen extends DefaultCodegen implements CodegenConfig { + static Logger LOGGER = LoggerFactory.getLogger(GoClientCodegen.class); + + protected String invokerPackage = "swagger"; + protected String groupId = "io.swagger"; + protected String artifactId = "swagger-go-client"; + protected String artifactVersion = "1.0.0"; + + public CodegenType getTag() { + return CodegenType.CLIENT; + } + + public String getName() { + return "go"; + } + + public String getHelp() { + return "Generates a Go client library."; + } + + public GoClientCodegen() { + super(); + outputFolder = "generated-code/go"; + modelTemplateFiles.put("model.mustache", ".go"); + apiTemplateFiles.put("api.mustache", ".go"); + templateDir = "go"; + apiPackage = invokerPackage; + modelPackage = invokerPackage; + + reservedWords = new HashSet ( + Arrays.asList( + "break", "default", "func", "interface", "select", + "case", "defer", "go", "map", "struct", + "chan", "else", "goto", "package", "switch", + "const", "fallthrough", "if", "range", "type", + "continue", "for", "import", "return", "var") + ); + + additionalProperties.put("invokerPackage", invokerPackage); + /*additionalProperties.put("groupId", groupId); + additionalProperties.put("artifactId", artifactId); + additionalProperties.put("artifactVersion", artifactVersion);*/ + + defaultIncludes = new HashSet( + Arrays.asList( + "map", + "array") + ); + + languageSpecificPrimitives = new HashSet( + Arrays.asList( + "string", + "bool", + "uint", + "uint32", + "uint64", + "int", + "int32", + "int64", + "float32", + "float64", + "complex64", + "complex128", + "rune", + "byte") + ); + + instantiationTypes.clear(); + /*instantiationTypes.put("array", "GoArray"); + instantiationTypes.put("map", "GoMap");*/ + + typeMapping.clear(); + typeMapping.put("integer", "int32"); + typeMapping.put("long", "int64"); + typeMapping.put("float", "float32"); + typeMapping.put("double", "float64"); + typeMapping.put("boolean", "bool"); + typeMapping.put("string", "string"); + typeMapping.put("Date", "time.Time"); + typeMapping.put("DateTime", "time.Time"); + typeMapping.put("password", "string"); + typeMapping.put("file", "*os.File"); + //typeMapping.put("array", "array"); + //typeMapping.put("map", "map"); + + importMapping = new HashMap(); + importMapping.put("time.Time", "time"); + importMapping.put("*os.File", "os"); + + } + + @Override + public String escapeReservedWord(String name) { + return "_" + name; + } + + @Override + public String apiFileFolder() { + return outputFolder + File.separator + invokerPackage; + } + + public String modelFileFolder() { + return outputFolder + File.separator + invokerPackage; + } + + @Override + public String toVarName(String name) { + // replace - with _ e.g. created-at => created_at + name = name.replaceAll("-", "_"); + + // if it's all uppper case, do nothing + if (name.matches("^[A-Z_]*$")) + return name; + + // camelize (lower first character) the variable name + // pet_id => petId + name = camelize(name, true); + + // for reserved word or word starting with number, append _ + if(reservedWords.contains(name) || name.matches("^\\d.*")) + name = escapeReservedWord(name); + + return name; + } + + @Override + public String toParamName(String name) { + // should be the same as variable name + return toVarName(name); + } + + @Override + public String toModelName(String name) { + // model name cannot use reserved keyword, e.g. return + if(reservedWords.contains(name)) + throw new RuntimeException(name + " (reserved word) cannot be used as a model name"); + + // camelize the model name + // phone_number => PhoneNumber + return camelize(name); + } + + @Override + public String toModelFilename(String name) { + // should be the same as the model name + return toModelName(name); + } + + @Override + public String getTypeDeclaration(Property p) { + LOGGER.info("getTypeDeclaration=" + p.getName()); + if(p instanceof ArrayProperty) { + ArrayProperty ap = (ArrayProperty) p; + Property inner = ap.getItems(); + return "[]" + getTypeDeclaration(inner); + } + else if (p instanceof MapProperty) { + MapProperty mp = (MapProperty) p; + Property inner = mp.getAdditionalProperties(); + + return getSwaggerType(p) + "[string]" + getTypeDeclaration(inner); + } + LOGGER.info("super.getTypeDeclaration=" + super.getTypeDeclaration(p)); + return super.getTypeDeclaration(p); + } + + @Override + public String getSwaggerType(Property p) { + String swaggerType = super.getSwaggerType(p); + LOGGER.info("swaggerType=" + swaggerType); + String type = null; + if(typeMapping.containsKey(swaggerType)) { + type = typeMapping.get(swaggerType); + if(languageSpecificPrimitives.contains(type)) + return (type); + } + else + type = swaggerType; + return type; + } + + @Override + public String toOperationId(String operationId) { + // method name cannot use reserved keyword, e.g. return + if(reservedWords.contains(operationId)) + throw new RuntimeException(operationId + " (reserved word) cannot be used as method name"); + + return camelize(operationId, true); + } + + @Override + public Map postProcessOperations(Map objs) { + @SuppressWarnings("unchecked") + Map objectMap = (Map) objs.get("operations"); + @SuppressWarnings("unchecked") + List operations = (List) objectMap.get("operation"); + for (CodegenOperation operation : operations) { + // http method verb conversion (e.g. PUT => Put) + operation.httpMethod = camelize(operation.httpMethod.toLowerCase()); + } + + // remove model imports to avoid error + List> imports = (List>) objs.get("imports"); + if (imports == null) + return objs; + + Iterator> iterator = imports.iterator(); + while (iterator.hasNext()) { + String _import = iterator.next().get("import"); + if (_import.startsWith(apiPackage())) + iterator.remove(); + } + + return objs; + } + + @Override + public Map postProcessModels(Map objs) { + // remove model imports to avoid error + List> imports = (List>) objs.get("imports"); + final String prefix = modelPackage(); + Iterator> iterator = imports.iterator(); + while (iterator.hasNext()) { + String _import = iterator.next().get("import"); + if (_import.startsWith(prefix)) + iterator.remove(); + } + return objs; + } + + @Override + protected boolean needToImport(String type) { + return !defaultIncludes.contains(type) + && !languageSpecificPrimitives.contains(type); + } + +} diff --git a/modules/swagger-codegen/src/main/resources/go/api.mustache b/modules/swagger-codegen/src/main/resources/go/api.mustache new file mode 100644 index 00000000000..1e18bde85ca --- /dev/null +++ b/modules/swagger-codegen/src/main/resources/go/api.mustache @@ -0,0 +1,98 @@ +package {{invokerPackage}} + +{{#operations}} +import ( + "strings" + "fmt" +// "log" + "github.com/dghubble/sling" +{{#imports}} "{{import}}" +{{/imports}} +) + +type {{classname}} struct { + basePath string + apiClient ApiClient + sling *sling.Sling +} + +func New{{classname}}() *{{classname}}{ + return &{{classname}} { + basePath: "{{basePath}}", + } +} + +func New{{classname}}WithBasePath(basePath string) *{{classname}}{ + return &{{classname}} { + basePath: basePath, + } +} + +{{#operation}} +/** + * {{summary}} + * {{notes}} +{{#allParams}} * @param {{paramName}} {{description}} +{{/allParams}} * @return {{#returnType}}{{{returnType}}}{{/returnType}}{{^returnType}}void{{/returnType}} + */ +func (a {{classname}}) {{nickname}} ({{#allParams}}{{paramName}} {{{dataType}}}{{#hasMore}}, {{/hasMore}}{{/allParams}}) ({{#returnType}}{{{returnType}}}, {{/returnType}}error) { + {{#allParams}}{{#required}} + // verify the required parameter '{{paramName}}' is set + //if {{paramName}} == nil { + // return 0, fmt.Error("Missing the required parameter '{{paramName}}' when calling {{nickname}}") + //} + {{/required}}{{/allParams}} + + _sling := a.sling.{{httpMethod}}(a.basePath) + + // create path and map variables + path := "{{path}}" + {{#pathParams}}//path = regexp.MustCompile("{" + "{{paramName}}" + "}").ReplaceAllString(path, "$1") + //path = path.Replace("\\{" + "{{paramName}}" + "\\}", ApiClient.EscapeString({{{paramName}}})) + path = strings.Replace(path, "{" + "{{baseName}}" + "}", fmt.Sprintf("%b", {{paramName}}), -1) + {{/pathParams}} + + _sling = _sling.Path(path) + + {{#hasQueryParams}} + type QueryParams struct { + {{#queryParams}}{{paramName}} {{dataType}} `url:"{{baseName}},omitempty"` + {{/queryParams}} + } + + _sling = _sling.QueryStruct(&QueryParams{ {{#queryParams}}{{paramName}}: {{baseName}}{{#hasMore}},{{/hasMore}}{{/queryParams}} }) + {{/hasQueryParams}} + + {{#headerParams}}// header params "{{baseName}}" + _sling = _sling.Set("{{baseName}}", {{paramName}}) + {{/headerParams}} + + //contentTypes := []string { {{#consumes}}"{{mediaType}}"{{#hasMore}},{{/hasMore}}{{/consumes}} } + + {{#hasFormParams}} + type FormParams struct { + {{#formParams}}{{paramName}} {{dataType}} `url:"{{baseName}},omitempty"` + {{/formParams}} + } + _sling = _sling.BodyForm(&FormParams{ {{#formParams}}{{paramName}}: {{baseName}}{{#hasMore}},{{/hasMore}}{{/formParams}} }) + {{/hasFormParams}} + + {{#bodyParams}}// body params + _sling = _sling.BodyJSON({{paramName}}) + //b, _ := json.Marshal(body) + //bodyParams["{{baseName}}"] = string(b) + {{/bodyParams}} + + req, err := _sling.Request() + + /*response, err := a.apiClient.CallApi(a.basePath, path, "{{httpMethod}}", queryParams, headerParams, formParams, fileParams, bodyParams, contentTypes) + //if err != nil { + // log.Fatal(err) + //} */ + + //{{#returnType}}ApiClient.Deserialize(response, "{{returnContainer}}", "{{returnBaseType}}"){{/returnType}} + {{#returnType}}return req, err{{/returnType}} + {{^returnType}}return err{{/returnType}} +} +{{/operation}} +{{/operations}} diff --git a/modules/swagger-codegen/src/main/resources/go/model.mustache b/modules/swagger-codegen/src/main/resources/go/model.mustache new file mode 100644 index 00000000000..bbd7e772d0e --- /dev/null +++ b/modules/swagger-codegen/src/main/resources/go/model.mustache @@ -0,0 +1,15 @@ +package {{invokerPackage}} + +{{#models}} +import ( +{{#imports}} "{{import}}" +{{/imports}} +) + +{{#model}} +type {{classname}} struct { + {{#vars}}{{name}} {{{datatype}}} `json:"{{baseName}},omitempty"` + {{/vars}} +} +{{/model}} +{{/models}} diff --git a/samples/client/petstore/go/swagger/ApiClient.go b/samples/client/petstore/go/swagger/ApiClient.go new file mode 100644 index 00000000000..420a7df21ed --- /dev/null +++ b/samples/client/petstore/go/swagger/ApiClient.go @@ -0,0 +1,33 @@ +package swagger + +import ( +// "encoding/json" + "os" +// "fmt" + "log" +// "net/url" +// napping "github.com/jmcvetta/napping" +) + +type ApiClient struct { + basePath string + logger *log.Logger +} + +func NewApiClient() *ApiClient { + return &ApiClient { + basePath: "http://petstore.swagger.io/v2", + logger: log.New(os.Stderr, "", log.LstdFlags)} +} + +func NewApiClientWithBasePath(basePath string) *ApiClient { + return &ApiClient { + basePath: basePath, + logger: log.New(os.Stderr, "", log.LstdFlags)} +} + + +func (a *ApiClient) CallApi(basePath string, path string, httpMethod string, queryParams map[string]string, headerParams map[string]string, formParams map[string]string, fileParams map[string]string, bodyParams map[string]string, contentType []string) { + a.logger.Printf("Requesting %v\n%v\n%v\n%v\n%v\n%v\n%v\n%v\n%v\n", basePath, path, httpMethod, queryParams, headerParams, formParams, fileParams, bodyParams, contentType) + +} diff --git a/samples/client/petstore/go/swagger/Category.go b/samples/client/petstore/go/swagger/Category.go new file mode 100644 index 00000000000..7681d4c5e6f --- /dev/null +++ b/samples/client/petstore/go/swagger/Category.go @@ -0,0 +1,10 @@ +package swagger + +import ( +) + +type Category struct { + id int64 `json:"id,omitempty"` + name string `json:"name,omitempty"` + +} diff --git a/samples/client/petstore/go/swagger/Order.go b/samples/client/petstore/go/swagger/Order.go new file mode 100644 index 00000000000..187f3ed5795 --- /dev/null +++ b/samples/client/petstore/go/swagger/Order.go @@ -0,0 +1,15 @@ +package swagger + +import ( + "time" +) + +type Order struct { + id int64 `json:"id,omitempty"` + petId int64 `json:"petId,omitempty"` + quantity int32 `json:"quantity,omitempty"` + shipDate time.Time `json:"shipDate,omitempty"` + status string `json:"status,omitempty"` + complete bool `json:"complete,omitempty"` + +} diff --git a/samples/client/petstore/go/swagger/Pet.go b/samples/client/petstore/go/swagger/Pet.go new file mode 100644 index 00000000000..cbc962df530 --- /dev/null +++ b/samples/client/petstore/go/swagger/Pet.go @@ -0,0 +1,14 @@ +package swagger + +import ( +) + +type Pet struct { + id int64 `json:"id,omitempty"` + category Category `json:"category,omitempty"` + name string `json:"name,omitempty"` + photoUrls []string `json:"photoUrls,omitempty"` + tags []Tag `json:"tags,omitempty"` + status string `json:"status,omitempty"` + +} diff --git a/samples/client/petstore/go/swagger/PetApi.go b/samples/client/petstore/go/swagger/PetApi.go new file mode 100644 index 00000000000..5170797cc80 --- /dev/null +++ b/samples/client/petstore/go/swagger/PetApi.go @@ -0,0 +1,407 @@ +package swagger + +import ( + "strings" + "fmt" +// "log" + "github.com/dghubble/sling" + "os" +) + +type PetApi struct { + basePath string + apiClient ApiClient + sling *sling.Sling +} + +func NewPetApi() *PetApi{ + return &PetApi { + basePath: "http://petstore.swagger.io/v2", + } +} + +func NewPetApiWithBasePath(basePath string) *PetApi{ + return &PetApi { + basePath: basePath, + } +} + +/** + * Update an existing pet + * + * @param body Pet object that needs to be added to the store + * @return void + */ +func (a PetApi) updatePet (body Pet) (error) { + + + _sling := a.sling.Put(a.basePath) + + // create path and map variables + path := "/pet" + + + _sling = _sling.Path(path) + + + + + + //contentTypes := []string { "application/json","application/xml" } + + + + // body params + _sling = _sling.BodyJSON(body) + //b, _ := json.Marshal(body) + //bodyParams["body"] = string(b) + + + req, err := _sling.Request() + + /*response, err := a.apiClient.CallApi(a.basePath, path, "Put", queryParams, headerParams, formParams, fileParams, bodyParams, contentTypes) + //if err != nil { + // log.Fatal(err) + //} */ + + // + + return err +} +/** + * Add a new pet to the store + * + * @param body Pet object that needs to be added to the store + * @return void + */ +func (a PetApi) addPet (body Pet) (error) { + + + _sling := a.sling.Post(a.basePath) + + // create path and map variables + path := "/pet" + + + _sling = _sling.Path(path) + + + + + + //contentTypes := []string { "application/json","application/xml" } + + + + // body params + _sling = _sling.BodyJSON(body) + //b, _ := json.Marshal(body) + //bodyParams["body"] = string(b) + + + req, err := _sling.Request() + + /*response, err := a.apiClient.CallApi(a.basePath, path, "Post", queryParams, headerParams, formParams, fileParams, bodyParams, contentTypes) + //if err != nil { + // log.Fatal(err) + //} */ + + // + + return err +} +/** + * Finds Pets by status + * Multiple status values can be provided with comma seperated strings + * @param status Status values that need to be considered for filter + * @return []Pet + */ +func (a PetApi) findPetsByStatus (status []string) ([]Pet, error) { + + + _sling := a.sling.Get(a.basePath) + + // create path and map variables + path := "/pet/findByStatus" + + + _sling = _sling.Path(path) + + + type QueryParams struct { + status []string `url:"status,omitempty"` + + } + + _sling = _sling.QueryStruct(&QueryParams{ status: status }) + + + + + //contentTypes := []string { } + + + + + + req, err := _sling.Request() + + /*response, err := a.apiClient.CallApi(a.basePath, path, "Get", queryParams, headerParams, formParams, fileParams, bodyParams, contentTypes) + //if err != nil { + // log.Fatal(err) + //} */ + + //ApiClient.Deserialize(response, "array", "Pet") + return req, err + +} +/** + * Finds Pets by tags + * Muliple tags can be provided with comma seperated strings. Use tag1, tag2, tag3 for testing. + * @param tags Tags to filter by + * @return []Pet + */ +func (a PetApi) findPetsByTags (tags []string) ([]Pet, error) { + + + _sling := a.sling.Get(a.basePath) + + // create path and map variables + path := "/pet/findByTags" + + + _sling = _sling.Path(path) + + + type QueryParams struct { + tags []string `url:"tags,omitempty"` + + } + + _sling = _sling.QueryStruct(&QueryParams{ tags: tags }) + + + + + //contentTypes := []string { } + + + + + + req, err := _sling.Request() + + /*response, err := a.apiClient.CallApi(a.basePath, path, "Get", queryParams, headerParams, formParams, fileParams, bodyParams, contentTypes) + //if err != nil { + // log.Fatal(err) + //} */ + + //ApiClient.Deserialize(response, "array", "Pet") + return req, err + +} +/** + * Find pet by ID + * Returns a pet when ID < 10. ID > 10 or nonintegers will simulate API error conditions + * @param petId ID of pet that needs to be fetched + * @return Pet + */ +func (a PetApi) getPetById (petId int64) (Pet, error) { + + // verify the required parameter 'petId' is set + //if petId == nil { + // return 0, fmt.Error("Missing the required parameter 'petId' when calling getPetById") + //} + + + _sling := a.sling.Get(a.basePath) + + // create path and map variables + path := "/pet/{petId}" + //path = regexp.MustCompile("{" + "petId" + "}").ReplaceAllString(path, "$1") + //path = path.Replace("\\{" + "petId" + "\\}", ApiClient.EscapeString(petId)) + path = strings.Replace(path, "{" + "petId" + "}", fmt.Sprintf("%b", petId), -1) + + + _sling = _sling.Path(path) + + + + + + //contentTypes := []string { } + + + + + + req, err := _sling.Request() + + /*response, err := a.apiClient.CallApi(a.basePath, path, "Get", queryParams, headerParams, formParams, fileParams, bodyParams, contentTypes) + //if err != nil { + // log.Fatal(err) + //} */ + + //ApiClient.Deserialize(response, "", "Pet") + return req, err + +} +/** + * Updates a pet in the store with form data + * + * @param petId ID of pet that needs to be updated + * @param name Updated name of the pet + * @param status Updated status of the pet + * @return void + */ +func (a PetApi) updatePetWithForm (petId string, name string, status string) (error) { + + // verify the required parameter 'petId' is set + //if petId == nil { + // return 0, fmt.Error("Missing the required parameter 'petId' when calling updatePetWithForm") + //} + + + _sling := a.sling.Post(a.basePath) + + // create path and map variables + path := "/pet/{petId}" + //path = regexp.MustCompile("{" + "petId" + "}").ReplaceAllString(path, "$1") + //path = path.Replace("\\{" + "petId" + "\\}", ApiClient.EscapeString(petId)) + path = strings.Replace(path, "{" + "petId" + "}", fmt.Sprintf("%b", petId), -1) + + + _sling = _sling.Path(path) + + + + + + //contentTypes := []string { "application/x-www-form-urlencoded" } + + + type FormParams struct { + name string `url:"name,omitempty"` + status string `url:"status,omitempty"` + + } + _sling = _sling.BodyForm(&FormParams{ name: name,status: status }) + + + + + req, err := _sling.Request() + + /*response, err := a.apiClient.CallApi(a.basePath, path, "Post", queryParams, headerParams, formParams, fileParams, bodyParams, contentTypes) + //if err != nil { + // log.Fatal(err) + //} */ + + // + + return err +} +/** + * Deletes a pet + * + * @param petId Pet id to delete + * @param apiKey + * @return void + */ +func (a PetApi) deletePet (petId int64, apiKey string) (error) { + + // verify the required parameter 'petId' is set + //if petId == nil { + // return 0, fmt.Error("Missing the required parameter 'petId' when calling deletePet") + //} + + + _sling := a.sling.Delete(a.basePath) + + // create path and map variables + path := "/pet/{petId}" + //path = regexp.MustCompile("{" + "petId" + "}").ReplaceAllString(path, "$1") + //path = path.Replace("\\{" + "petId" + "\\}", ApiClient.EscapeString(petId)) + path = strings.Replace(path, "{" + "petId" + "}", fmt.Sprintf("%b", petId), -1) + + + _sling = _sling.Path(path) + + + + // header params "api_key" + _sling = _sling.Set("api_key", apiKey) + + + //contentTypes := []string { } + + + + + + req, err := _sling.Request() + + /*response, err := a.apiClient.CallApi(a.basePath, path, "Delete", queryParams, headerParams, formParams, fileParams, bodyParams, contentTypes) + //if err != nil { + // log.Fatal(err) + //} */ + + // + + return err +} +/** + * uploads an image + * + * @param petId ID of pet to update + * @param additionalMetadata Additional data to pass to server + * @param file file to upload + * @return void + */ +func (a PetApi) uploadFile (petId int64, additionalMetadata string, file *os.File) (error) { + + // verify the required parameter 'petId' is set + //if petId == nil { + // return 0, fmt.Error("Missing the required parameter 'petId' when calling uploadFile") + //} + + + _sling := a.sling.Post(a.basePath) + + // create path and map variables + path := "/pet/{petId}/uploadImage" + //path = regexp.MustCompile("{" + "petId" + "}").ReplaceAllString(path, "$1") + //path = path.Replace("\\{" + "petId" + "\\}", ApiClient.EscapeString(petId)) + path = strings.Replace(path, "{" + "petId" + "}", fmt.Sprintf("%b", petId), -1) + + + _sling = _sling.Path(path) + + + + + + //contentTypes := []string { "multipart/form-data" } + + + type FormParams struct { + additionalMetadata string `url:"additionalMetadata,omitempty"` + file *os.File `url:"file,omitempty"` + + } + _sling = _sling.BodyForm(&FormParams{ additionalMetadata: additionalMetadata,file: file }) + + + + + req, err := _sling.Request() + + /*response, err := a.apiClient.CallApi(a.basePath, path, "Post", queryParams, headerParams, formParams, fileParams, bodyParams, contentTypes) + //if err != nil { + // log.Fatal(err) + //} */ + + // + + return err +} diff --git a/samples/client/petstore/go/swagger/StoreApi.go b/samples/client/petstore/go/swagger/StoreApi.go new file mode 100644 index 00000000000..987c39a7216 --- /dev/null +++ b/samples/client/petstore/go/swagger/StoreApi.go @@ -0,0 +1,198 @@ +package swagger + +import ( + "strings" + "fmt" +// "log" + "github.com/dghubble/sling" +) + +type StoreApi struct { + basePath string + apiClient ApiClient + sling *sling.Sling +} + +func NewStoreApi() *StoreApi{ + return &StoreApi { + basePath: "http://petstore.swagger.io/v2", + } +} + +func NewStoreApiWithBasePath(basePath string) *StoreApi{ + return &StoreApi { + basePath: basePath, + } +} + +/** + * Returns pet inventories by status + * Returns a map of status codes to quantities + * @return map[string]int32 + */ +func (a StoreApi) getInventory () (map[string]int32, error) { + + + _sling := a.sling.Get(a.basePath) + + // create path and map variables + path := "/store/inventory" + + + _sling = _sling.Path(path) + + + + + + //contentTypes := []string { } + + + + + + req, err := _sling.Request() + + /*response, err := a.apiClient.CallApi(a.basePath, path, "Get", queryParams, headerParams, formParams, fileParams, bodyParams, contentTypes) + //if err != nil { + // log.Fatal(err) + //} */ + + //ApiClient.Deserialize(response, "map", "map") + return req, err + +} +/** + * Place an order for a pet + * + * @param body order placed for purchasing the pet + * @return Order + */ +func (a StoreApi) placeOrder (body Order) (Order, error) { + + + _sling := a.sling.Post(a.basePath) + + // create path and map variables + path := "/store/order" + + + _sling = _sling.Path(path) + + + + + + //contentTypes := []string { } + + + + // body params + _sling = _sling.BodyJSON(body) + //b, _ := json.Marshal(body) + //bodyParams["body"] = string(b) + + + req, err := _sling.Request() + + /*response, err := a.apiClient.CallApi(a.basePath, path, "Post", queryParams, headerParams, formParams, fileParams, bodyParams, contentTypes) + //if err != nil { + // log.Fatal(err) + //} */ + + //ApiClient.Deserialize(response, "", "Order") + return req, err + +} +/** + * Find purchase order by ID + * For valid response try integer IDs with value <= 5 or > 10. Other values will generated exceptions + * @param orderId ID of pet that needs to be fetched + * @return Order + */ +func (a StoreApi) getOrderById (orderId string) (Order, error) { + + // verify the required parameter 'orderId' is set + //if orderId == nil { + // return 0, fmt.Error("Missing the required parameter 'orderId' when calling getOrderById") + //} + + + _sling := a.sling.Get(a.basePath) + + // create path and map variables + path := "/store/order/{orderId}" + //path = regexp.MustCompile("{" + "orderId" + "}").ReplaceAllString(path, "$1") + //path = path.Replace("\\{" + "orderId" + "\\}", ApiClient.EscapeString(orderId)) + path = strings.Replace(path, "{" + "orderId" + "}", fmt.Sprintf("%b", orderId), -1) + + + _sling = _sling.Path(path) + + + + + + //contentTypes := []string { } + + + + + + req, err := _sling.Request() + + /*response, err := a.apiClient.CallApi(a.basePath, path, "Get", queryParams, headerParams, formParams, fileParams, bodyParams, contentTypes) + //if err != nil { + // log.Fatal(err) + //} */ + + //ApiClient.Deserialize(response, "", "Order") + return req, err + +} +/** + * Delete purchase order by ID + * For valid response try integer IDs with value < 1000. Anything above 1000 or nonintegers will generate API errors + * @param orderId ID of the order that needs to be deleted + * @return void + */ +func (a StoreApi) deleteOrder (orderId string) (error) { + + // verify the required parameter 'orderId' is set + //if orderId == nil { + // return 0, fmt.Error("Missing the required parameter 'orderId' when calling deleteOrder") + //} + + + _sling := a.sling.Delete(a.basePath) + + // create path and map variables + path := "/store/order/{orderId}" + //path = regexp.MustCompile("{" + "orderId" + "}").ReplaceAllString(path, "$1") + //path = path.Replace("\\{" + "orderId" + "\\}", ApiClient.EscapeString(orderId)) + path = strings.Replace(path, "{" + "orderId" + "}", fmt.Sprintf("%b", orderId), -1) + + + _sling = _sling.Path(path) + + + + + + //contentTypes := []string { } + + + + + + req, err := _sling.Request() + + /*response, err := a.apiClient.CallApi(a.basePath, path, "Delete", queryParams, headerParams, formParams, fileParams, bodyParams, contentTypes) + //if err != nil { + // log.Fatal(err) + //} */ + + // + + return err +} diff --git a/samples/client/petstore/go/swagger/Tag.go b/samples/client/petstore/go/swagger/Tag.go new file mode 100644 index 00000000000..7fd20f55ef4 --- /dev/null +++ b/samples/client/petstore/go/swagger/Tag.go @@ -0,0 +1,10 @@ +package swagger + +import ( +) + +type Tag struct { + id int64 `json:"id,omitempty"` + name string `json:"name,omitempty"` + +} diff --git a/samples/client/petstore/go/swagger/User.go b/samples/client/petstore/go/swagger/User.go new file mode 100644 index 00000000000..608ac360618 --- /dev/null +++ b/samples/client/petstore/go/swagger/User.go @@ -0,0 +1,16 @@ +package swagger + +import ( +) + +type User struct { + id int64 `json:"id,omitempty"` + username string `json:"username,omitempty"` + firstName string `json:"firstName,omitempty"` + lastName string `json:"lastName,omitempty"` + email string `json:"email,omitempty"` + password string `json:"password,omitempty"` + phone string `json:"phone,omitempty"` + userStatus int32 `json:"userStatus,omitempty"` + +} diff --git a/samples/client/petstore/go/swagger/UserApi.go b/samples/client/petstore/go/swagger/UserApi.go new file mode 100644 index 00000000000..4c2c73cb9dc --- /dev/null +++ b/samples/client/petstore/go/swagger/UserApi.go @@ -0,0 +1,380 @@ +package swagger + +import ( + "strings" + "fmt" +// "log" + "github.com/dghubble/sling" +) + +type UserApi struct { + basePath string + apiClient ApiClient + sling *sling.Sling +} + +func NewUserApi() *UserApi{ + return &UserApi { + basePath: "http://petstore.swagger.io/v2", + } +} + +func NewUserApiWithBasePath(basePath string) *UserApi{ + return &UserApi { + basePath: basePath, + } +} + +/** + * Create user + * This can only be done by the logged in user. + * @param body Created user object + * @return void + */ +func (a UserApi) createUser (body User) (error) { + + + _sling := a.sling.Post(a.basePath) + + // create path and map variables + path := "/user" + + + _sling = _sling.Path(path) + + + + + + //contentTypes := []string { } + + + + // body params + _sling = _sling.BodyJSON(body) + //b, _ := json.Marshal(body) + //bodyParams["body"] = string(b) + + + req, err := _sling.Request() + + /*response, err := a.apiClient.CallApi(a.basePath, path, "Post", queryParams, headerParams, formParams, fileParams, bodyParams, contentTypes) + //if err != nil { + // log.Fatal(err) + //} */ + + // + + return err +} +/** + * Creates list of users with given input array + * + * @param body List of user object + * @return void + */ +func (a UserApi) createUsersWithArrayInput (body []User) (error) { + + + _sling := a.sling.Post(a.basePath) + + // create path and map variables + path := "/user/createWithArray" + + + _sling = _sling.Path(path) + + + + + + //contentTypes := []string { } + + + + // body params + _sling = _sling.BodyJSON(body) + //b, _ := json.Marshal(body) + //bodyParams["body"] = string(b) + + + req, err := _sling.Request() + + /*response, err := a.apiClient.CallApi(a.basePath, path, "Post", queryParams, headerParams, formParams, fileParams, bodyParams, contentTypes) + //if err != nil { + // log.Fatal(err) + //} */ + + // + + return err +} +/** + * Creates list of users with given input array + * + * @param body List of user object + * @return void + */ +func (a UserApi) createUsersWithListInput (body []User) (error) { + + + _sling := a.sling.Post(a.basePath) + + // create path and map variables + path := "/user/createWithList" + + + _sling = _sling.Path(path) + + + + + + //contentTypes := []string { } + + + + // body params + _sling = _sling.BodyJSON(body) + //b, _ := json.Marshal(body) + //bodyParams["body"] = string(b) + + + req, err := _sling.Request() + + /*response, err := a.apiClient.CallApi(a.basePath, path, "Post", queryParams, headerParams, formParams, fileParams, bodyParams, contentTypes) + //if err != nil { + // log.Fatal(err) + //} */ + + // + + return err +} +/** + * Logs user into the system + * + * @param username The user name for login + * @param password The password for login in clear text + * @return string + */ +func (a UserApi) loginUser (username string, password string) (string, error) { + + + _sling := a.sling.Get(a.basePath) + + // create path and map variables + path := "/user/login" + + + _sling = _sling.Path(path) + + + type QueryParams struct { + username string `url:"username,omitempty"` + password string `url:"password,omitempty"` + + } + + _sling = _sling.QueryStruct(&QueryParams{ username: username,password: password }) + + + + + //contentTypes := []string { } + + + + + + req, err := _sling.Request() + + /*response, err := a.apiClient.CallApi(a.basePath, path, "Get", queryParams, headerParams, formParams, fileParams, bodyParams, contentTypes) + //if err != nil { + // log.Fatal(err) + //} */ + + //ApiClient.Deserialize(response, "", "string") + return req, err + +} +/** + * Logs out current logged in user session + * + * @return void + */ +func (a UserApi) logoutUser () (error) { + + + _sling := a.sling.Get(a.basePath) + + // create path and map variables + path := "/user/logout" + + + _sling = _sling.Path(path) + + + + + + //contentTypes := []string { } + + + + + + req, err := _sling.Request() + + /*response, err := a.apiClient.CallApi(a.basePath, path, "Get", queryParams, headerParams, formParams, fileParams, bodyParams, contentTypes) + //if err != nil { + // log.Fatal(err) + //} */ + + // + + return err +} +/** + * Get user by user name + * + * @param username The name that needs to be fetched. Use user1 for testing. + * @return User + */ +func (a UserApi) getUserByName (username string) (User, error) { + + // verify the required parameter 'username' is set + //if username == nil { + // return 0, fmt.Error("Missing the required parameter 'username' when calling getUserByName") + //} + + + _sling := a.sling.Get(a.basePath) + + // create path and map variables + path := "/user/{username}" + //path = regexp.MustCompile("{" + "username" + "}").ReplaceAllString(path, "$1") + //path = path.Replace("\\{" + "username" + "\\}", ApiClient.EscapeString(username)) + path = strings.Replace(path, "{" + "username" + "}", fmt.Sprintf("%b", username), -1) + + + _sling = _sling.Path(path) + + + + + + //contentTypes := []string { } + + + + + + req, err := _sling.Request() + + /*response, err := a.apiClient.CallApi(a.basePath, path, "Get", queryParams, headerParams, formParams, fileParams, bodyParams, contentTypes) + //if err != nil { + // log.Fatal(err) + //} */ + + //ApiClient.Deserialize(response, "", "User") + return req, err + +} +/** + * Updated user + * This can only be done by the logged in user. + * @param username name that need to be deleted + * @param body Updated user object + * @return void + */ +func (a UserApi) updateUser (username string, body User) (error) { + + // verify the required parameter 'username' is set + //if username == nil { + // return 0, fmt.Error("Missing the required parameter 'username' when calling updateUser") + //} + + + _sling := a.sling.Put(a.basePath) + + // create path and map variables + path := "/user/{username}" + //path = regexp.MustCompile("{" + "username" + "}").ReplaceAllString(path, "$1") + //path = path.Replace("\\{" + "username" + "\\}", ApiClient.EscapeString(username)) + path = strings.Replace(path, "{" + "username" + "}", fmt.Sprintf("%b", username), -1) + + + _sling = _sling.Path(path) + + + + + + //contentTypes := []string { } + + + + // body params + _sling = _sling.BodyJSON(body) + //b, _ := json.Marshal(body) + //bodyParams["body"] = string(b) + + + req, err := _sling.Request() + + /*response, err := a.apiClient.CallApi(a.basePath, path, "Put", queryParams, headerParams, formParams, fileParams, bodyParams, contentTypes) + //if err != nil { + // log.Fatal(err) + //} */ + + // + + return err +} +/** + * Delete user + * This can only be done by the logged in user. + * @param username The name that needs to be deleted + * @return void + */ +func (a UserApi) deleteUser (username string) (error) { + + // verify the required parameter 'username' is set + //if username == nil { + // return 0, fmt.Error("Missing the required parameter 'username' when calling deleteUser") + //} + + + _sling := a.sling.Delete(a.basePath) + + // create path and map variables + path := "/user/{username}" + //path = regexp.MustCompile("{" + "username" + "}").ReplaceAllString(path, "$1") + //path = path.Replace("\\{" + "username" + "\\}", ApiClient.EscapeString(username)) + path = strings.Replace(path, "{" + "username" + "}", fmt.Sprintf("%b", username), -1) + + + _sling = _sling.Path(path) + + + + + + //contentTypes := []string { } + + + + + + req, err := _sling.Request() + + /*response, err := a.apiClient.CallApi(a.basePath, path, "Delete", queryParams, headerParams, formParams, fileParams, bodyParams, contentTypes) + //if err != nil { + // log.Fatal(err) + //} */ + + // + + return err +} diff --git a/samples/client/petstore/go/test.go b/samples/client/petstore/go/test.go new file mode 100644 index 00000000000..b20f0347354 --- /dev/null +++ b/samples/client/petstore/go/test.go @@ -0,0 +1,14 @@ +package main + + +import ( + "fmt" + "log" + "./swagger" +) + +func main() { + + + fmt.Println("hello world") +} From 3ebefba6784f6cfd5b5d242e9fed7aac3191c0a6 Mon Sep 17 00:00:00 2001 From: wing328 Date: Mon, 21 Dec 2015 16:07:58 +0800 Subject: [PATCH 3/8] better return for golang method --- .../src/main/resources/go/api.mustache | 38 ++-- samples/client/petstore/go/swagger/PetApi.go | 186 +++++++++++------- .../client/petstore/go/swagger/StoreApi.go | 96 +++++---- samples/client/petstore/go/swagger/UserApi.go | 175 ++++++++++------ samples/client/petstore/go/test.go | 11 +- 5 files changed, 316 insertions(+), 190 deletions(-) diff --git a/modules/swagger-codegen/src/main/resources/go/api.mustache b/modules/swagger-codegen/src/main/resources/go/api.mustache index 1e18bde85ca..9e0679538fa 100644 --- a/modules/swagger-codegen/src/main/resources/go/api.mustache +++ b/modules/swagger-codegen/src/main/resources/go/api.mustache @@ -2,6 +2,7 @@ package {{invokerPackage}} {{#operations}} import ( +// "encoding/json" "strings" "fmt" // "log" @@ -35,13 +36,8 @@ func New{{classname}}WithBasePath(basePath string) *{{classname}}{ {{#allParams}} * @param {{paramName}} {{description}} {{/allParams}} * @return {{#returnType}}{{{returnType}}}{{/returnType}}{{^returnType}}void{{/returnType}} */ +//func (a {{classname}}) {{nickname}} ({{#allParams}}{{paramName}} {{{dataType}}}{{#hasMore}}, {{/hasMore}}{{/allParams}}) ({{#returnType}}{{{returnType}}}, {{/returnType}}error) { func (a {{classname}}) {{nickname}} ({{#allParams}}{{paramName}} {{{dataType}}}{{#hasMore}}, {{/hasMore}}{{/allParams}}) ({{#returnType}}{{{returnType}}}, {{/returnType}}error) { - {{#allParams}}{{#required}} - // verify the required parameter '{{paramName}}' is set - //if {{paramName}} == nil { - // return 0, fmt.Error("Missing the required parameter '{{paramName}}' when calling {{nickname}}") - //} - {{/required}}{{/allParams}} _sling := a.sling.{{httpMethod}}(a.basePath) @@ -54,8 +50,7 @@ func (a {{classname}}) {{nickname}} ({{#allParams}}{{paramName}} {{{dataType}}}{ _sling = _sling.Path(path) - {{#hasQueryParams}} - type QueryParams struct { + {{#hasQueryParams}}type QueryParams struct { {{#queryParams}}{{paramName}} {{dataType}} `url:"{{baseName}},omitempty"` {{/queryParams}} } @@ -69,8 +64,7 @@ func (a {{classname}}) {{nickname}} ({{#allParams}}{{paramName}} {{{dataType}}}{ //contentTypes := []string { {{#consumes}}"{{mediaType}}"{{#hasMore}},{{/hasMore}}{{/consumes}} } - {{#hasFormParams}} - type FormParams struct { + {{#hasFormParams}}type FormParams struct { {{#formParams}}{{paramName}} {{dataType}} `url:"{{baseName}},omitempty"` {{/formParams}} } @@ -83,16 +77,30 @@ func (a {{classname}}) {{nickname}} ({{#allParams}}{{paramName}} {{{dataType}}}{ //bodyParams["{{baseName}}"] = string(b) {{/bodyParams}} - req, err := _sling.Request() + {{#returnType}} + var response {{returnType}} + resp, err := _sling.ReceiveSuccess(response) + fmt.Println("{{operationId}} response: ", response, resp, err) + return response, err + {{/returnType}}{{^returnType}} + resp, err := _sling.Request() + fmt.Println("{{operationId}} response: void, ", resp, err) + return err + {{/returnType}} - /*response, err := a.apiClient.CallApi(a.basePath, path, "{{httpMethod}}", queryParams, headerParams, formParams, fileParams, bodyParams, contentTypes) + + + //response, err := a.apiClient.CallApi(a.basePath, path, "{{httpMethod}}", queryParams, headerParams, formParams, fileParams, bodyParams, contentTypes) //if err != nil { // log.Fatal(err) - //} */ + //} //{{#returnType}}ApiClient.Deserialize(response, "{{returnContainer}}", "{{returnBaseType}}"){{/returnType}} - {{#returnType}}return req, err{{/returnType}} - {{^returnType}}return err{{/returnType}} + + //{{#returnType}}var response {{returnType}} + //err = json.Unmarshal([]byte(req), &response) + //return response, err{{/returnType}} + //{{^returnType}}return err{{/returnType}} } {{/operation}} {{/operations}} diff --git a/samples/client/petstore/go/swagger/PetApi.go b/samples/client/petstore/go/swagger/PetApi.go index 5170797cc80..cf6f793805f 100644 --- a/samples/client/petstore/go/swagger/PetApi.go +++ b/samples/client/petstore/go/swagger/PetApi.go @@ -1,6 +1,7 @@ package swagger import ( +// "encoding/json" "strings" "fmt" // "log" @@ -32,8 +33,8 @@ func NewPetApiWithBasePath(basePath string) *PetApi{ * @param body Pet object that needs to be added to the store * @return void */ +//func (a PetApi) updatePet (body Pet) (error) { func (a PetApi) updatePet (body Pet) (error) { - _sling := a.sling.Put(a.basePath) @@ -57,16 +58,23 @@ func (a PetApi) updatePet (body Pet) (error) { //bodyParams["body"] = string(b) - req, err := _sling.Request() + + resp, err := _sling.Request() + fmt.Println("updatePet response: void, ", resp, err) + return err + - /*response, err := a.apiClient.CallApi(a.basePath, path, "Put", queryParams, headerParams, formParams, fileParams, bodyParams, contentTypes) + + + //response, err := a.apiClient.CallApi(a.basePath, path, "Put", queryParams, headerParams, formParams, fileParams, bodyParams, contentTypes) //if err != nil { // log.Fatal(err) - //} */ + //} // - - return err + + // + //return err } /** * Add a new pet to the store @@ -74,8 +82,8 @@ func (a PetApi) updatePet (body Pet) (error) { * @param body Pet object that needs to be added to the store * @return void */ +//func (a PetApi) addPet (body Pet) (error) { func (a PetApi) addPet (body Pet) (error) { - _sling := a.sling.Post(a.basePath) @@ -99,16 +107,23 @@ func (a PetApi) addPet (body Pet) (error) { //bodyParams["body"] = string(b) - req, err := _sling.Request() + + resp, err := _sling.Request() + fmt.Println("addPet response: void, ", resp, err) + return err + - /*response, err := a.apiClient.CallApi(a.basePath, path, "Post", queryParams, headerParams, formParams, fileParams, bodyParams, contentTypes) + + + //response, err := a.apiClient.CallApi(a.basePath, path, "Post", queryParams, headerParams, formParams, fileParams, bodyParams, contentTypes) //if err != nil { // log.Fatal(err) - //} */ + //} // - - return err + + // + //return err } /** * Finds Pets by status @@ -116,8 +131,8 @@ func (a PetApi) addPet (body Pet) (error) { * @param status Status values that need to be considered for filter * @return []Pet */ +//func (a PetApi) findPetsByStatus (status []string) ([]Pet, error) { func (a PetApi) findPetsByStatus (status []string) ([]Pet, error) { - _sling := a.sling.Get(a.basePath) @@ -127,7 +142,6 @@ func (a PetApi) findPetsByStatus (status []string) ([]Pet, error) { _sling = _sling.Path(path) - type QueryParams struct { status []string `url:"status,omitempty"` @@ -144,16 +158,26 @@ func (a PetApi) findPetsByStatus (status []string) ([]Pet, error) { - req, err := _sling.Request() + + var response []Pet + resp, err := _sling.ReceiveSuccess(response) + fmt.Println("findPetsByStatus response: ", response, resp, err) + return response, err + - /*response, err := a.apiClient.CallApi(a.basePath, path, "Get", queryParams, headerParams, formParams, fileParams, bodyParams, contentTypes) + + + //response, err := a.apiClient.CallApi(a.basePath, path, "Get", queryParams, headerParams, formParams, fileParams, bodyParams, contentTypes) //if err != nil { // log.Fatal(err) - //} */ + //} //ApiClient.Deserialize(response, "array", "Pet") - return req, err - + + //var response []Pet + //err = json.Unmarshal([]byte(req), &response) + //return response, err + // } /** * Finds Pets by tags @@ -161,8 +185,8 @@ func (a PetApi) findPetsByStatus (status []string) ([]Pet, error) { * @param tags Tags to filter by * @return []Pet */ +//func (a PetApi) findPetsByTags (tags []string) ([]Pet, error) { func (a PetApi) findPetsByTags (tags []string) ([]Pet, error) { - _sling := a.sling.Get(a.basePath) @@ -172,7 +196,6 @@ func (a PetApi) findPetsByTags (tags []string) ([]Pet, error) { _sling = _sling.Path(path) - type QueryParams struct { tags []string `url:"tags,omitempty"` @@ -189,16 +212,26 @@ func (a PetApi) findPetsByTags (tags []string) ([]Pet, error) { - req, err := _sling.Request() + + var response []Pet + resp, err := _sling.ReceiveSuccess(response) + fmt.Println("findPetsByTags response: ", response, resp, err) + return response, err + - /*response, err := a.apiClient.CallApi(a.basePath, path, "Get", queryParams, headerParams, formParams, fileParams, bodyParams, contentTypes) + + + //response, err := a.apiClient.CallApi(a.basePath, path, "Get", queryParams, headerParams, formParams, fileParams, bodyParams, contentTypes) //if err != nil { // log.Fatal(err) - //} */ + //} //ApiClient.Deserialize(response, "array", "Pet") - return req, err - + + //var response []Pet + //err = json.Unmarshal([]byte(req), &response) + //return response, err + // } /** * Find pet by ID @@ -206,13 +239,8 @@ func (a PetApi) findPetsByTags (tags []string) ([]Pet, error) { * @param petId ID of pet that needs to be fetched * @return Pet */ +//func (a PetApi) getPetById (petId int64) (Pet, error) { func (a PetApi) getPetById (petId int64) (Pet, error) { - - // verify the required parameter 'petId' is set - //if petId == nil { - // return 0, fmt.Error("Missing the required parameter 'petId' when calling getPetById") - //} - _sling := a.sling.Get(a.basePath) @@ -235,16 +263,26 @@ func (a PetApi) getPetById (petId int64) (Pet, error) { - req, err := _sling.Request() + + var response Pet + resp, err := _sling.ReceiveSuccess(response) + fmt.Println("getPetById response: ", response, resp, err) + return response, err + - /*response, err := a.apiClient.CallApi(a.basePath, path, "Get", queryParams, headerParams, formParams, fileParams, bodyParams, contentTypes) + + + //response, err := a.apiClient.CallApi(a.basePath, path, "Get", queryParams, headerParams, formParams, fileParams, bodyParams, contentTypes) //if err != nil { // log.Fatal(err) - //} */ + //} //ApiClient.Deserialize(response, "", "Pet") - return req, err - + + //var response Pet + //err = json.Unmarshal([]byte(req), &response) + //return response, err + // } /** * Updates a pet in the store with form data @@ -254,13 +292,8 @@ func (a PetApi) getPetById (petId int64) (Pet, error) { * @param status Updated status of the pet * @return void */ +//func (a PetApi) updatePetWithForm (petId string, name string, status string) (error) { func (a PetApi) updatePetWithForm (petId string, name string, status string) (error) { - - // verify the required parameter 'petId' is set - //if petId == nil { - // return 0, fmt.Error("Missing the required parameter 'petId' when calling updatePetWithForm") - //} - _sling := a.sling.Post(a.basePath) @@ -279,7 +312,6 @@ func (a PetApi) updatePetWithForm (petId string, name string, status string) (er //contentTypes := []string { "application/x-www-form-urlencoded" } - type FormParams struct { name string `url:"name,omitempty"` status string `url:"status,omitempty"` @@ -290,16 +322,23 @@ func (a PetApi) updatePetWithForm (petId string, name string, status string) (er - req, err := _sling.Request() + + resp, err := _sling.Request() + fmt.Println("updatePetWithForm response: void, ", resp, err) + return err + - /*response, err := a.apiClient.CallApi(a.basePath, path, "Post", queryParams, headerParams, formParams, fileParams, bodyParams, contentTypes) + + + //response, err := a.apiClient.CallApi(a.basePath, path, "Post", queryParams, headerParams, formParams, fileParams, bodyParams, contentTypes) //if err != nil { // log.Fatal(err) - //} */ + //} // - - return err + + // + //return err } /** * Deletes a pet @@ -308,13 +347,8 @@ func (a PetApi) updatePetWithForm (petId string, name string, status string) (er * @param apiKey * @return void */ +//func (a PetApi) deletePet (petId int64, apiKey string) (error) { func (a PetApi) deletePet (petId int64, apiKey string) (error) { - - // verify the required parameter 'petId' is set - //if petId == nil { - // return 0, fmt.Error("Missing the required parameter 'petId' when calling deletePet") - //} - _sling := a.sling.Delete(a.basePath) @@ -339,16 +373,23 @@ func (a PetApi) deletePet (petId int64, apiKey string) (error) { - req, err := _sling.Request() + + resp, err := _sling.Request() + fmt.Println("deletePet response: void, ", resp, err) + return err + - /*response, err := a.apiClient.CallApi(a.basePath, path, "Delete", queryParams, headerParams, formParams, fileParams, bodyParams, contentTypes) + + + //response, err := a.apiClient.CallApi(a.basePath, path, "Delete", queryParams, headerParams, formParams, fileParams, bodyParams, contentTypes) //if err != nil { // log.Fatal(err) - //} */ + //} // - - return err + + // + //return err } /** * uploads an image @@ -358,13 +399,8 @@ func (a PetApi) deletePet (petId int64, apiKey string) (error) { * @param file file to upload * @return void */ +//func (a PetApi) uploadFile (petId int64, additionalMetadata string, file *os.File) (error) { func (a PetApi) uploadFile (petId int64, additionalMetadata string, file *os.File) (error) { - - // verify the required parameter 'petId' is set - //if petId == nil { - // return 0, fmt.Error("Missing the required parameter 'petId' when calling uploadFile") - //} - _sling := a.sling.Post(a.basePath) @@ -383,7 +419,6 @@ func (a PetApi) uploadFile (petId int64, additionalMetadata string, file *os.Fil //contentTypes := []string { "multipart/form-data" } - type FormParams struct { additionalMetadata string `url:"additionalMetadata,omitempty"` file *os.File `url:"file,omitempty"` @@ -394,14 +429,21 @@ func (a PetApi) uploadFile (petId int64, additionalMetadata string, file *os.Fil - req, err := _sling.Request() + + resp, err := _sling.Request() + fmt.Println("uploadFile response: void, ", resp, err) + return err + - /*response, err := a.apiClient.CallApi(a.basePath, path, "Post", queryParams, headerParams, formParams, fileParams, bodyParams, contentTypes) + + + //response, err := a.apiClient.CallApi(a.basePath, path, "Post", queryParams, headerParams, formParams, fileParams, bodyParams, contentTypes) //if err != nil { // log.Fatal(err) - //} */ + //} // - - return err + + // + //return err } diff --git a/samples/client/petstore/go/swagger/StoreApi.go b/samples/client/petstore/go/swagger/StoreApi.go index 987c39a7216..17adb00933b 100644 --- a/samples/client/petstore/go/swagger/StoreApi.go +++ b/samples/client/petstore/go/swagger/StoreApi.go @@ -1,6 +1,7 @@ package swagger import ( +// "encoding/json" "strings" "fmt" // "log" @@ -30,8 +31,8 @@ func NewStoreApiWithBasePath(basePath string) *StoreApi{ * Returns a map of status codes to quantities * @return map[string]int32 */ +//func (a StoreApi) getInventory () (map[string]int32, error) { func (a StoreApi) getInventory () (map[string]int32, error) { - _sling := a.sling.Get(a.basePath) @@ -51,16 +52,26 @@ func (a StoreApi) getInventory () (map[string]int32, error) { - req, err := _sling.Request() + + var response map[string]int32 + resp, err := _sling.ReceiveSuccess(response) + fmt.Println("getInventory response: ", response, resp, err) + return response, err + - /*response, err := a.apiClient.CallApi(a.basePath, path, "Get", queryParams, headerParams, formParams, fileParams, bodyParams, contentTypes) + + + //response, err := a.apiClient.CallApi(a.basePath, path, "Get", queryParams, headerParams, formParams, fileParams, bodyParams, contentTypes) //if err != nil { // log.Fatal(err) - //} */ + //} //ApiClient.Deserialize(response, "map", "map") - return req, err - + + //var response map[string]int32 + //err = json.Unmarshal([]byte(req), &response) + //return response, err + // } /** * Place an order for a pet @@ -68,8 +79,8 @@ func (a StoreApi) getInventory () (map[string]int32, error) { * @param body order placed for purchasing the pet * @return Order */ +//func (a StoreApi) placeOrder (body Order) (Order, error) { func (a StoreApi) placeOrder (body Order) (Order, error) { - _sling := a.sling.Post(a.basePath) @@ -93,16 +104,26 @@ func (a StoreApi) placeOrder (body Order) (Order, error) { //bodyParams["body"] = string(b) - req, err := _sling.Request() + + var response Order + resp, err := _sling.ReceiveSuccess(response) + fmt.Println("placeOrder response: ", response, resp, err) + return response, err + - /*response, err := a.apiClient.CallApi(a.basePath, path, "Post", queryParams, headerParams, formParams, fileParams, bodyParams, contentTypes) + + + //response, err := a.apiClient.CallApi(a.basePath, path, "Post", queryParams, headerParams, formParams, fileParams, bodyParams, contentTypes) //if err != nil { // log.Fatal(err) - //} */ + //} //ApiClient.Deserialize(response, "", "Order") - return req, err - + + //var response Order + //err = json.Unmarshal([]byte(req), &response) + //return response, err + // } /** * Find purchase order by ID @@ -110,13 +131,8 @@ func (a StoreApi) placeOrder (body Order) (Order, error) { * @param orderId ID of pet that needs to be fetched * @return Order */ +//func (a StoreApi) getOrderById (orderId string) (Order, error) { func (a StoreApi) getOrderById (orderId string) (Order, error) { - - // verify the required parameter 'orderId' is set - //if orderId == nil { - // return 0, fmt.Error("Missing the required parameter 'orderId' when calling getOrderById") - //} - _sling := a.sling.Get(a.basePath) @@ -139,16 +155,26 @@ func (a StoreApi) getOrderById (orderId string) (Order, error) { - req, err := _sling.Request() + + var response Order + resp, err := _sling.ReceiveSuccess(response) + fmt.Println("getOrderById response: ", response, resp, err) + return response, err + - /*response, err := a.apiClient.CallApi(a.basePath, path, "Get", queryParams, headerParams, formParams, fileParams, bodyParams, contentTypes) + + + //response, err := a.apiClient.CallApi(a.basePath, path, "Get", queryParams, headerParams, formParams, fileParams, bodyParams, contentTypes) //if err != nil { // log.Fatal(err) - //} */ + //} //ApiClient.Deserialize(response, "", "Order") - return req, err - + + //var response Order + //err = json.Unmarshal([]byte(req), &response) + //return response, err + // } /** * Delete purchase order by ID @@ -156,13 +182,8 @@ func (a StoreApi) getOrderById (orderId string) (Order, error) { * @param orderId ID of the order that needs to be deleted * @return void */ +//func (a StoreApi) deleteOrder (orderId string) (error) { func (a StoreApi) deleteOrder (orderId string) (error) { - - // verify the required parameter 'orderId' is set - //if orderId == nil { - // return 0, fmt.Error("Missing the required parameter 'orderId' when calling deleteOrder") - //} - _sling := a.sling.Delete(a.basePath) @@ -185,14 +206,21 @@ func (a StoreApi) deleteOrder (orderId string) (error) { - req, err := _sling.Request() + + resp, err := _sling.Request() + fmt.Println("deleteOrder response: void, ", resp, err) + return err + - /*response, err := a.apiClient.CallApi(a.basePath, path, "Delete", queryParams, headerParams, formParams, fileParams, bodyParams, contentTypes) + + + //response, err := a.apiClient.CallApi(a.basePath, path, "Delete", queryParams, headerParams, formParams, fileParams, bodyParams, contentTypes) //if err != nil { // log.Fatal(err) - //} */ + //} // - - return err + + // + //return err } diff --git a/samples/client/petstore/go/swagger/UserApi.go b/samples/client/petstore/go/swagger/UserApi.go index 4c2c73cb9dc..0a1abeb7827 100644 --- a/samples/client/petstore/go/swagger/UserApi.go +++ b/samples/client/petstore/go/swagger/UserApi.go @@ -1,6 +1,7 @@ package swagger import ( +// "encoding/json" "strings" "fmt" // "log" @@ -31,8 +32,8 @@ func NewUserApiWithBasePath(basePath string) *UserApi{ * @param body Created user object * @return void */ +//func (a UserApi) createUser (body User) (error) { func (a UserApi) createUser (body User) (error) { - _sling := a.sling.Post(a.basePath) @@ -56,16 +57,23 @@ func (a UserApi) createUser (body User) (error) { //bodyParams["body"] = string(b) - req, err := _sling.Request() + + resp, err := _sling.Request() + fmt.Println("createUser response: void, ", resp, err) + return err + - /*response, err := a.apiClient.CallApi(a.basePath, path, "Post", queryParams, headerParams, formParams, fileParams, bodyParams, contentTypes) + + + //response, err := a.apiClient.CallApi(a.basePath, path, "Post", queryParams, headerParams, formParams, fileParams, bodyParams, contentTypes) //if err != nil { // log.Fatal(err) - //} */ + //} // - - return err + + // + //return err } /** * Creates list of users with given input array @@ -73,8 +81,8 @@ func (a UserApi) createUser (body User) (error) { * @param body List of user object * @return void */ +//func (a UserApi) createUsersWithArrayInput (body []User) (error) { func (a UserApi) createUsersWithArrayInput (body []User) (error) { - _sling := a.sling.Post(a.basePath) @@ -98,16 +106,23 @@ func (a UserApi) createUsersWithArrayInput (body []User) (error) { //bodyParams["body"] = string(b) - req, err := _sling.Request() + + resp, err := _sling.Request() + fmt.Println("createUsersWithArrayInput response: void, ", resp, err) + return err + - /*response, err := a.apiClient.CallApi(a.basePath, path, "Post", queryParams, headerParams, formParams, fileParams, bodyParams, contentTypes) + + + //response, err := a.apiClient.CallApi(a.basePath, path, "Post", queryParams, headerParams, formParams, fileParams, bodyParams, contentTypes) //if err != nil { // log.Fatal(err) - //} */ + //} // - - return err + + // + //return err } /** * Creates list of users with given input array @@ -115,8 +130,8 @@ func (a UserApi) createUsersWithArrayInput (body []User) (error) { * @param body List of user object * @return void */ +//func (a UserApi) createUsersWithListInput (body []User) (error) { func (a UserApi) createUsersWithListInput (body []User) (error) { - _sling := a.sling.Post(a.basePath) @@ -140,16 +155,23 @@ func (a UserApi) createUsersWithListInput (body []User) (error) { //bodyParams["body"] = string(b) - req, err := _sling.Request() + + resp, err := _sling.Request() + fmt.Println("createUsersWithListInput response: void, ", resp, err) + return err + - /*response, err := a.apiClient.CallApi(a.basePath, path, "Post", queryParams, headerParams, formParams, fileParams, bodyParams, contentTypes) + + + //response, err := a.apiClient.CallApi(a.basePath, path, "Post", queryParams, headerParams, formParams, fileParams, bodyParams, contentTypes) //if err != nil { // log.Fatal(err) - //} */ + //} // - - return err + + // + //return err } /** * Logs user into the system @@ -158,8 +180,8 @@ func (a UserApi) createUsersWithListInput (body []User) (error) { * @param password The password for login in clear text * @return string */ +//func (a UserApi) loginUser (username string, password string) (string, error) { func (a UserApi) loginUser (username string, password string) (string, error) { - _sling := a.sling.Get(a.basePath) @@ -169,7 +191,6 @@ func (a UserApi) loginUser (username string, password string) (string, error) { _sling = _sling.Path(path) - type QueryParams struct { username string `url:"username,omitempty"` password string `url:"password,omitempty"` @@ -187,24 +208,34 @@ func (a UserApi) loginUser (username string, password string) (string, error) { - req, err := _sling.Request() + + var response string + resp, err := _sling.ReceiveSuccess(response) + fmt.Println("loginUser response: ", response, resp, err) + return response, err + - /*response, err := a.apiClient.CallApi(a.basePath, path, "Get", queryParams, headerParams, formParams, fileParams, bodyParams, contentTypes) + + + //response, err := a.apiClient.CallApi(a.basePath, path, "Get", queryParams, headerParams, formParams, fileParams, bodyParams, contentTypes) //if err != nil { // log.Fatal(err) - //} */ + //} //ApiClient.Deserialize(response, "", "string") - return req, err - + + //var response string + //err = json.Unmarshal([]byte(req), &response) + //return response, err + // } /** * Logs out current logged in user session * * @return void */ +//func (a UserApi) logoutUser () (error) { func (a UserApi) logoutUser () (error) { - _sling := a.sling.Get(a.basePath) @@ -224,16 +255,23 @@ func (a UserApi) logoutUser () (error) { - req, err := _sling.Request() + + resp, err := _sling.Request() + fmt.Println("logoutUser response: void, ", resp, err) + return err + - /*response, err := a.apiClient.CallApi(a.basePath, path, "Get", queryParams, headerParams, formParams, fileParams, bodyParams, contentTypes) + + + //response, err := a.apiClient.CallApi(a.basePath, path, "Get", queryParams, headerParams, formParams, fileParams, bodyParams, contentTypes) //if err != nil { // log.Fatal(err) - //} */ + //} // - - return err + + // + //return err } /** * Get user by user name @@ -241,13 +279,8 @@ func (a UserApi) logoutUser () (error) { * @param username The name that needs to be fetched. Use user1 for testing. * @return User */ +//func (a UserApi) getUserByName (username string) (User, error) { func (a UserApi) getUserByName (username string) (User, error) { - - // verify the required parameter 'username' is set - //if username == nil { - // return 0, fmt.Error("Missing the required parameter 'username' when calling getUserByName") - //} - _sling := a.sling.Get(a.basePath) @@ -270,16 +303,26 @@ func (a UserApi) getUserByName (username string) (User, error) { - req, err := _sling.Request() + + var response User + resp, err := _sling.ReceiveSuccess(response) + fmt.Println("getUserByName response: ", response, resp, err) + return response, err + - /*response, err := a.apiClient.CallApi(a.basePath, path, "Get", queryParams, headerParams, formParams, fileParams, bodyParams, contentTypes) + + + //response, err := a.apiClient.CallApi(a.basePath, path, "Get", queryParams, headerParams, formParams, fileParams, bodyParams, contentTypes) //if err != nil { // log.Fatal(err) - //} */ + //} //ApiClient.Deserialize(response, "", "User") - return req, err - + + //var response User + //err = json.Unmarshal([]byte(req), &response) + //return response, err + // } /** * Updated user @@ -288,13 +331,8 @@ func (a UserApi) getUserByName (username string) (User, error) { * @param body Updated user object * @return void */ +//func (a UserApi) updateUser (username string, body User) (error) { func (a UserApi) updateUser (username string, body User) (error) { - - // verify the required parameter 'username' is set - //if username == nil { - // return 0, fmt.Error("Missing the required parameter 'username' when calling updateUser") - //} - _sling := a.sling.Put(a.basePath) @@ -321,16 +359,23 @@ func (a UserApi) updateUser (username string, body User) (error) { //bodyParams["body"] = string(b) - req, err := _sling.Request() + + resp, err := _sling.Request() + fmt.Println("updateUser response: void, ", resp, err) + return err + - /*response, err := a.apiClient.CallApi(a.basePath, path, "Put", queryParams, headerParams, formParams, fileParams, bodyParams, contentTypes) + + + //response, err := a.apiClient.CallApi(a.basePath, path, "Put", queryParams, headerParams, formParams, fileParams, bodyParams, contentTypes) //if err != nil { // log.Fatal(err) - //} */ + //} // - - return err + + // + //return err } /** * Delete user @@ -338,13 +383,8 @@ func (a UserApi) updateUser (username string, body User) (error) { * @param username The name that needs to be deleted * @return void */ +//func (a UserApi) deleteUser (username string) (error) { func (a UserApi) deleteUser (username string) (error) { - - // verify the required parameter 'username' is set - //if username == nil { - // return 0, fmt.Error("Missing the required parameter 'username' when calling deleteUser") - //} - _sling := a.sling.Delete(a.basePath) @@ -367,14 +407,21 @@ func (a UserApi) deleteUser (username string) (error) { - req, err := _sling.Request() + + resp, err := _sling.Request() + fmt.Println("deleteUser response: void, ", resp, err) + return err + - /*response, err := a.apiClient.CallApi(a.basePath, path, "Delete", queryParams, headerParams, formParams, fileParams, bodyParams, contentTypes) + + + //response, err := a.apiClient.CallApi(a.basePath, path, "Delete", queryParams, headerParams, formParams, fileParams, bodyParams, contentTypes) //if err != nil { // log.Fatal(err) - //} */ + //} // - - return err + + // + //return err } diff --git a/samples/client/petstore/go/test.go b/samples/client/petstore/go/test.go index b20f0347354..d1dbf4272a2 100644 --- a/samples/client/petstore/go/test.go +++ b/samples/client/petstore/go/test.go @@ -1,14 +1,15 @@ package main - import ( - "fmt" - "log" - "./swagger" + "fmt" + // "log" + swagger "./swagger" ) func main() { + fmt.Println("hello world") + s := swagger.NewPetApi() + &s.updatePetWithForm("2", "golang", "available") - fmt.Println("hello world") } From 4062deed92f203457766b5df5367bf48ee86788a Mon Sep 17 00:00:00 2001 From: wing328 Date: Mon, 21 Dec 2015 21:19:12 +0800 Subject: [PATCH 4/8] remove logger, fix deserialization of json response --- .../io/swagger/codegen/DefaultCodegen.java | 2 - .../io/swagger/codegen/DefaultGenerator.java | 4 - .../codegen/languages/GoClientCodegen.java | 16 +- .../src/main/resources/go/api.mustache | 73 ++-- .../client/petstore/go/swagger/Category.go | 4 +- samples/client/petstore/go/swagger/Order.go | 13 +- samples/client/petstore/go/swagger/Pet.go | 12 +- samples/client/petstore/go/swagger/PetApi.go | 400 ++++++------------ .../client/petstore/go/swagger/StoreApi.go | 189 +++------ samples/client/petstore/go/swagger/Tag.go | 4 +- samples/client/petstore/go/swagger/User.go | 16 +- samples/client/petstore/go/swagger/UserApi.go | 365 +++++----------- samples/client/petstore/go/test.go | 11 +- 13 files changed, 351 insertions(+), 758 deletions(-) diff --git a/modules/swagger-codegen/src/main/java/io/swagger/codegen/DefaultCodegen.java b/modules/swagger-codegen/src/main/java/io/swagger/codegen/DefaultCodegen.java index ac91c60fa0f..11472fec4ff 100644 --- a/modules/swagger-codegen/src/main/java/io/swagger/codegen/DefaultCodegen.java +++ b/modules/swagger-codegen/src/main/java/io/swagger/codegen/DefaultCodegen.java @@ -1045,8 +1045,6 @@ public class DefaultCodegen { } property.baseType = getSwaggerType(p); - LOGGER.info("property.baseType=" + property.baseType); - LOGGER.info("property.datatype=" + property.datatype); if (p instanceof ArrayProperty) { property.isContainer = true; diff --git a/modules/swagger-codegen/src/main/java/io/swagger/codegen/DefaultGenerator.java b/modules/swagger-codegen/src/main/java/io/swagger/codegen/DefaultGenerator.java index 24c17615f2d..3623361387e 100644 --- a/modules/swagger-codegen/src/main/java/io/swagger/codegen/DefaultGenerator.java +++ b/modules/swagger-codegen/src/main/java/io/swagger/codegen/DefaultGenerator.java @@ -657,7 +657,6 @@ public class DefaultGenerator extends AbstractGenerator implements Generator { for (String nextImport : allImports) { Map im = new LinkedHashMap(); String mapping = config.importMapping().get(nextImport); - LOGGER.info("mapping = " + mapping); if (mapping == null) { mapping = config.toModelImport(nextImport); } @@ -704,7 +703,6 @@ public class DefaultGenerator extends AbstractGenerator implements Generator { List> imports = new ArrayList>(); for (String nextImport : allImports) { - LOGGER.info("nextImport=" + nextImport); Map im = new LinkedHashMap(); String mapping = config.importMapping().get(nextImport); if (mapping == null) { @@ -713,14 +711,12 @@ public class DefaultGenerator extends AbstractGenerator implements Generator { if (mapping != null && !config.defaultIncludes().contains(mapping)) { im.put("import", mapping); imports.add(im); - LOGGER.info("config.importMaping added " + mapping); } // add instantiation types mapping = config.instantiationTypes().get(nextImport); if (mapping != null && !config.defaultIncludes().contains(mapping)) { im.put("import", mapping); imports.add(im); - LOGGER.info("config.instantiationTypes added " + mapping); } } diff --git a/modules/swagger-codegen/src/main/java/io/swagger/codegen/languages/GoClientCodegen.java b/modules/swagger-codegen/src/main/java/io/swagger/codegen/languages/GoClientCodegen.java index 04401b044e5..c9ec24de6b2 100644 --- a/modules/swagger-codegen/src/main/java/io/swagger/codegen/languages/GoClientCodegen.java +++ b/modules/swagger-codegen/src/main/java/io/swagger/codegen/languages/GoClientCodegen.java @@ -128,8 +128,8 @@ public class GoClientCodegen extends DefaultCodegen implements CodegenConfig { return name; // camelize (lower first character) the variable name - // pet_id => petId - name = camelize(name, true); + // pet_id => PetId + name = camelize(name); // for reserved word or word starting with number, append _ if(reservedWords.contains(name) || name.matches("^\\d.*")) @@ -163,7 +163,7 @@ public class GoClientCodegen extends DefaultCodegen implements CodegenConfig { @Override public String getTypeDeclaration(Property p) { - LOGGER.info("getTypeDeclaration=" + p.getName()); + String swaggerType = getSwaggerType(p); if(p instanceof ArrayProperty) { ArrayProperty ap = (ArrayProperty) p; Property inner = ap.getItems(); @@ -175,14 +175,6 @@ public class GoClientCodegen extends DefaultCodegen implements CodegenConfig { return getSwaggerType(p) + "[string]" + getTypeDeclaration(inner); } - LOGGER.info("super.getTypeDeclaration=" + super.getTypeDeclaration(p)); - return super.getTypeDeclaration(p); - } - - @Override - public String getSwaggerType(Property p) { - String swaggerType = super.getSwaggerType(p); - LOGGER.info("swaggerType=" + swaggerType); String type = null; if(typeMapping.containsKey(swaggerType)) { type = typeMapping.get(swaggerType); @@ -200,7 +192,7 @@ public class GoClientCodegen extends DefaultCodegen implements CodegenConfig { if(reservedWords.contains(operationId)) throw new RuntimeException(operationId + " (reserved word) cannot be used as method name"); - return camelize(operationId, true); + return camelize(operationId); } @Override diff --git a/modules/swagger-codegen/src/main/resources/go/api.mustache b/modules/swagger-codegen/src/main/resources/go/api.mustache index 9e0679538fa..16512786abc 100644 --- a/modules/swagger-codegen/src/main/resources/go/api.mustache +++ b/modules/swagger-codegen/src/main/resources/go/api.mustache @@ -14,7 +14,7 @@ import ( type {{classname}} struct { basePath string apiClient ApiClient - sling *sling.Sling + //sling *sling.Sling } func New{{classname}}() *{{classname}}{ @@ -39,68 +39,49 @@ func New{{classname}}WithBasePath(basePath string) *{{classname}}{ //func (a {{classname}}) {{nickname}} ({{#allParams}}{{paramName}} {{{dataType}}}{{#hasMore}}, {{/hasMore}}{{/allParams}}) ({{#returnType}}{{{returnType}}}, {{/returnType}}error) { func (a {{classname}}) {{nickname}} ({{#allParams}}{{paramName}} {{{dataType}}}{{#hasMore}}, {{/hasMore}}{{/allParams}}) ({{#returnType}}{{{returnType}}}, {{/returnType}}error) { - _sling := a.sling.{{httpMethod}}(a.basePath) + _sling := sling.New().{{httpMethod}}(a.basePath) // create path and map variables - path := "{{path}}" - {{#pathParams}}//path = regexp.MustCompile("{" + "{{paramName}}" + "}").ReplaceAllString(path, "$1") - //path = path.Replace("\\{" + "{{paramName}}" + "\\}", ApiClient.EscapeString({{{paramName}}})) - path = strings.Replace(path, "{" + "{{baseName}}" + "}", fmt.Sprintf("%b", {{paramName}}), -1) - {{/pathParams}} + path := "{{basePathWithoutHost}}{{path}}" +{{#pathParams}} path = strings.Replace(path, "{" + "{{baseName}}" + "}", fmt.Sprintf("%v", {{paramName}}), -1) +{{/pathParams}} _sling = _sling.Path(path) - {{#hasQueryParams}}type QueryParams struct { +{{#hasQueryParams}} type QueryParams struct { {{#queryParams}}{{paramName}} {{dataType}} `url:"{{baseName}},omitempty"` {{/queryParams}} +} + _sling = _sling.QueryStruct(&QueryParams{ {{#queryParams}}{{paramName}}: {{paramName}}{{#hasMore}},{{/hasMore}}{{/queryParams}} }) +{{/hasQueryParams}} + // accept header + accepts := []string { {{#produces}}"{{mediaType}}"{{#hasMore}}, {{/hasMore}}{{/produces}} } + for key := range accepts { + _sling = _sling.Set("Accept", accepts[key]) + break // only use the first Accept } - - _sling = _sling.QueryStruct(&QueryParams{ {{#queryParams}}{{paramName}}: {{baseName}}{{#hasMore}},{{/hasMore}}{{/queryParams}} }) - {{/hasQueryParams}} - - {{#headerParams}}// header params "{{baseName}}" +{{#hasHeaderParams}}{{#headerParams}} // header params "{{baseName}}" _sling = _sling.Set("{{baseName}}", {{paramName}}) - {{/headerParams}} - - //contentTypes := []string { {{#consumes}}"{{mediaType}}"{{#hasMore}},{{/hasMore}}{{/consumes}} } - - {{#hasFormParams}}type FormParams struct { - {{#formParams}}{{paramName}} {{dataType}} `url:"{{baseName}},omitempty"` - {{/formParams}} +{{/headerParams}}{{/hasHeaderParams}} +{{#hasFormParams}} type FormParams struct { +{{#formParams}} {{paramName}} {{dataType}} `url:"{{baseName}},omitempty"` +{{/formParams}} } - _sling = _sling.BodyForm(&FormParams{ {{#formParams}}{{paramName}}: {{baseName}}{{#hasMore}},{{/hasMore}}{{/formParams}} }) - {{/hasFormParams}} - - {{#bodyParams}}// body params + _sling = _sling.BodyForm(&FormParams{ {{#formParams}}{{paramName}}: {{paramName}}{{#hasMore}},{{/hasMore}}{{/formParams}} }) +{{/hasFormParams}} +{{#hasBodyParams}}{{#bodyParams}}// body params _sling = _sling.BodyJSON({{paramName}}) - //b, _ := json.Marshal(body) - //bodyParams["{{baseName}}"] = string(b) - {{/bodyParams}} +{{/bodyParams}}{{/hasBodyParams}} - {{#returnType}} - var response {{returnType}} +{{#returnType}} response := new({{returnType}}) resp, err := _sling.ReceiveSuccess(response) fmt.Println("{{operationId}} response: ", response, resp, err) - return response, err - {{/returnType}}{{^returnType}} + return *response, err +{{/returnType}}{{^returnType}} resp, err := _sling.Request() fmt.Println("{{operationId}} response: void, ", resp, err) return err - {{/returnType}} - - - - //response, err := a.apiClient.CallApi(a.basePath, path, "{{httpMethod}}", queryParams, headerParams, formParams, fileParams, bodyParams, contentTypes) - //if err != nil { - // log.Fatal(err) - //} - - //{{#returnType}}ApiClient.Deserialize(response, "{{returnContainer}}", "{{returnBaseType}}"){{/returnType}} - - //{{#returnType}}var response {{returnType}} - //err = json.Unmarshal([]byte(req), &response) - //return response, err{{/returnType}} - //{{^returnType}}return err{{/returnType}} +{{/returnType}} } {{/operation}} {{/operations}} diff --git a/samples/client/petstore/go/swagger/Category.go b/samples/client/petstore/go/swagger/Category.go index 7681d4c5e6f..0268f62488a 100644 --- a/samples/client/petstore/go/swagger/Category.go +++ b/samples/client/petstore/go/swagger/Category.go @@ -4,7 +4,7 @@ import ( ) type Category struct { - id int64 `json:"id,omitempty"` - name string `json:"name,omitempty"` + Id int64 `json:"id,omitempty"` + Name string `json:"name,omitempty"` } diff --git a/samples/client/petstore/go/swagger/Order.go b/samples/client/petstore/go/swagger/Order.go index 187f3ed5795..254b962de2f 100644 --- a/samples/client/petstore/go/swagger/Order.go +++ b/samples/client/petstore/go/swagger/Order.go @@ -1,15 +1,14 @@ package swagger import ( - "time" ) type Order struct { - id int64 `json:"id,omitempty"` - petId int64 `json:"petId,omitempty"` - quantity int32 `json:"quantity,omitempty"` - shipDate time.Time `json:"shipDate,omitempty"` - status string `json:"status,omitempty"` - complete bool `json:"complete,omitempty"` + Id int64 `json:"id,omitempty"` + PetId int64 `json:"petId,omitempty"` + Quantity int32 `json:"quantity,omitempty"` + ShipDate time.Time `json:"shipDate,omitempty"` + Status string `json:"status,omitempty"` + Complete bool `json:"complete,omitempty"` } diff --git a/samples/client/petstore/go/swagger/Pet.go b/samples/client/petstore/go/swagger/Pet.go index cbc962df530..7544eed6384 100644 --- a/samples/client/petstore/go/swagger/Pet.go +++ b/samples/client/petstore/go/swagger/Pet.go @@ -4,11 +4,11 @@ import ( ) type Pet struct { - id int64 `json:"id,omitempty"` - category Category `json:"category,omitempty"` - name string `json:"name,omitempty"` - photoUrls []string `json:"photoUrls,omitempty"` - tags []Tag `json:"tags,omitempty"` - status string `json:"status,omitempty"` + Id int64 `json:"id,omitempty"` + Category Category `json:"category,omitempty"` + Name string `json:"name,omitempty"` + PhotoUrls []string `json:"photoUrls,omitempty"` + Tags []Tag `json:"tags,omitempty"` + Status string `json:"status,omitempty"` } diff --git a/samples/client/petstore/go/swagger/PetApi.go b/samples/client/petstore/go/swagger/PetApi.go index cf6f793805f..a83f426471d 100644 --- a/samples/client/petstore/go/swagger/PetApi.go +++ b/samples/client/petstore/go/swagger/PetApi.go @@ -6,13 +6,12 @@ import ( "fmt" // "log" "github.com/dghubble/sling" - "os" ) type PetApi struct { basePath string apiClient ApiClient - sling *sling.Sling + //sling *sling.Sling } func NewPetApi() *PetApi{ @@ -30,420 +29,271 @@ func NewPetApiWithBasePath(basePath string) *PetApi{ /** * Update an existing pet * - * @param body Pet object that needs to be added to the store + * @param Body Pet object that needs to be added to the store * @return void */ -//func (a PetApi) updatePet (body Pet) (error) { -func (a PetApi) updatePet (body Pet) (error) { +//func (a PetApi) UpdatePet (Body Pet) (error) { +func (a PetApi) UpdatePet (Body Pet) (error) { - _sling := a.sling.Put(a.basePath) + _sling := sling.New().Put(a.basePath) // create path and map variables - path := "/pet" - + path := "/v2/pet" _sling = _sling.Path(path) - + // accept header + accepts := []string { "application/json", "application/xml" } + for key := range accepts { + _sling = _sling.Set("Accept", accepts[key]) + break // only use the first Accept + } - - //contentTypes := []string { "application/json","application/xml" } - - // body params - _sling = _sling.BodyJSON(body) - //b, _ := json.Marshal(body) - //bodyParams["body"] = string(b) - - - resp, err := _sling.Request() - fmt.Println("updatePet response: void, ", resp, err) + fmt.Println("UpdatePet response: void, ", resp, err) return err - - - - - //response, err := a.apiClient.CallApi(a.basePath, path, "Put", queryParams, headerParams, formParams, fileParams, bodyParams, contentTypes) - //if err != nil { - // log.Fatal(err) - //} - - // - - // - //return err } /** * Add a new pet to the store * - * @param body Pet object that needs to be added to the store + * @param Body Pet object that needs to be added to the store * @return void */ -//func (a PetApi) addPet (body Pet) (error) { -func (a PetApi) addPet (body Pet) (error) { +//func (a PetApi) AddPet (Body Pet) (error) { +func (a PetApi) AddPet (Body Pet) (error) { - _sling := a.sling.Post(a.basePath) + _sling := sling.New().Post(a.basePath) // create path and map variables - path := "/pet" - + path := "/v2/pet" _sling = _sling.Path(path) - + // accept header + accepts := []string { "application/json", "application/xml" } + for key := range accepts { + _sling = _sling.Set("Accept", accepts[key]) + break // only use the first Accept + } - - //contentTypes := []string { "application/json","application/xml" } - - // body params - _sling = _sling.BodyJSON(body) - //b, _ := json.Marshal(body) - //bodyParams["body"] = string(b) - - - resp, err := _sling.Request() - fmt.Println("addPet response: void, ", resp, err) + fmt.Println("AddPet response: void, ", resp, err) return err - - - - - //response, err := a.apiClient.CallApi(a.basePath, path, "Post", queryParams, headerParams, formParams, fileParams, bodyParams, contentTypes) - //if err != nil { - // log.Fatal(err) - //} - - // - - // - //return err } /** * Finds Pets by status * Multiple status values can be provided with comma seperated strings - * @param status Status values that need to be considered for filter + * @param Status Status values that need to be considered for filter * @return []Pet */ -//func (a PetApi) findPetsByStatus (status []string) ([]Pet, error) { -func (a PetApi) findPetsByStatus (status []string) ([]Pet, error) { +//func (a PetApi) FindPetsByStatus (Status []string) ([]Pet, error) { +func (a PetApi) FindPetsByStatus (Status []string) ([]Pet, error) { - _sling := a.sling.Get(a.basePath) + _sling := sling.New().Get(a.basePath) // create path and map variables - path := "/pet/findByStatus" - + path := "/v2/pet/findByStatus" _sling = _sling.Path(path) type QueryParams struct { - status []string `url:"status,omitempty"` + Status []string `url:"status,omitempty"` +} + _sling = _sling.QueryStruct(&QueryParams{ Status: Status }) + // accept header + accepts := []string { "application/json", "application/xml" } + for key := range accepts { + _sling = _sling.Set("Accept", accepts[key]) + break // only use the first Accept } - _sling = _sling.QueryStruct(&QueryParams{ status: status }) - - - //contentTypes := []string { } - - - - - - - var response []Pet + response := new([]Pet) resp, err := _sling.ReceiveSuccess(response) - fmt.Println("findPetsByStatus response: ", response, resp, err) - return response, err - - - - - //response, err := a.apiClient.CallApi(a.basePath, path, "Get", queryParams, headerParams, formParams, fileParams, bodyParams, contentTypes) - //if err != nil { - // log.Fatal(err) - //} - - //ApiClient.Deserialize(response, "array", "Pet") - - //var response []Pet - //err = json.Unmarshal([]byte(req), &response) - //return response, err - // + fmt.Println("FindPetsByStatus response: ", response, resp, err) + return *response, err } /** * Finds Pets by tags * Muliple tags can be provided with comma seperated strings. Use tag1, tag2, tag3 for testing. - * @param tags Tags to filter by + * @param Tags Tags to filter by * @return []Pet */ -//func (a PetApi) findPetsByTags (tags []string) ([]Pet, error) { -func (a PetApi) findPetsByTags (tags []string) ([]Pet, error) { +//func (a PetApi) FindPetsByTags (Tags []string) ([]Pet, error) { +func (a PetApi) FindPetsByTags (Tags []string) ([]Pet, error) { - _sling := a.sling.Get(a.basePath) + _sling := sling.New().Get(a.basePath) // create path and map variables - path := "/pet/findByTags" - + path := "/v2/pet/findByTags" _sling = _sling.Path(path) type QueryParams struct { - tags []string `url:"tags,omitempty"` + Tags []string `url:"tags,omitempty"` +} + _sling = _sling.QueryStruct(&QueryParams{ Tags: Tags }) + // accept header + accepts := []string { "application/json", "application/xml" } + for key := range accepts { + _sling = _sling.Set("Accept", accepts[key]) + break // only use the first Accept } - _sling = _sling.QueryStruct(&QueryParams{ tags: tags }) - - - //contentTypes := []string { } - - - - - - - var response []Pet + response := new([]Pet) resp, err := _sling.ReceiveSuccess(response) - fmt.Println("findPetsByTags response: ", response, resp, err) - return response, err - - - - - //response, err := a.apiClient.CallApi(a.basePath, path, "Get", queryParams, headerParams, formParams, fileParams, bodyParams, contentTypes) - //if err != nil { - // log.Fatal(err) - //} - - //ApiClient.Deserialize(response, "array", "Pet") - - //var response []Pet - //err = json.Unmarshal([]byte(req), &response) - //return response, err - // + fmt.Println("FindPetsByTags response: ", response, resp, err) + return *response, err } /** * Find pet by ID * Returns a pet when ID < 10. ID > 10 or nonintegers will simulate API error conditions - * @param petId ID of pet that needs to be fetched + * @param PetId ID of pet that needs to be fetched * @return Pet */ -//func (a PetApi) getPetById (petId int64) (Pet, error) { -func (a PetApi) getPetById (petId int64) (Pet, error) { +//func (a PetApi) GetPetById (PetId int64) (Pet, error) { +func (a PetApi) GetPetById (PetId int64) (Pet, error) { - _sling := a.sling.Get(a.basePath) + _sling := sling.New().Get(a.basePath) // create path and map variables - path := "/pet/{petId}" - //path = regexp.MustCompile("{" + "petId" + "}").ReplaceAllString(path, "$1") - //path = path.Replace("\\{" + "petId" + "\\}", ApiClient.EscapeString(petId)) - path = strings.Replace(path, "{" + "petId" + "}", fmt.Sprintf("%b", petId), -1) - + path := "/v2/pet/{petId}" + path = strings.Replace(path, "{" + "petId" + "}", fmt.Sprintf("%v", PetId), -1) _sling = _sling.Path(path) - + // accept header + accepts := []string { "application/json", "application/xml" } + for key := range accepts { + _sling = _sling.Set("Accept", accepts[key]) + break // only use the first Accept + } - - //contentTypes := []string { } - - - - - - var response Pet + response := new(Pet) resp, err := _sling.ReceiveSuccess(response) - fmt.Println("getPetById response: ", response, resp, err) - return response, err - - - - - //response, err := a.apiClient.CallApi(a.basePath, path, "Get", queryParams, headerParams, formParams, fileParams, bodyParams, contentTypes) - //if err != nil { - // log.Fatal(err) - //} - - //ApiClient.Deserialize(response, "", "Pet") - - //var response Pet - //err = json.Unmarshal([]byte(req), &response) - //return response, err - // + fmt.Println("GetPetById response: ", response, resp, err) + return *response, err } /** * Updates a pet in the store with form data * - * @param petId ID of pet that needs to be updated - * @param name Updated name of the pet - * @param status Updated status of the pet + * @param PetId ID of pet that needs to be updated + * @param Name Updated name of the pet + * @param Status Updated status of the pet * @return void */ -//func (a PetApi) updatePetWithForm (petId string, name string, status string) (error) { -func (a PetApi) updatePetWithForm (petId string, name string, status string) (error) { +//func (a PetApi) UpdatePetWithForm (PetId string, Name string, Status string) (error) { +func (a PetApi) UpdatePetWithForm (PetId string, Name string, Status string) (error) { - _sling := a.sling.Post(a.basePath) + _sling := sling.New().Post(a.basePath) // create path and map variables - path := "/pet/{petId}" - //path = regexp.MustCompile("{" + "petId" + "}").ReplaceAllString(path, "$1") - //path = path.Replace("\\{" + "petId" + "\\}", ApiClient.EscapeString(petId)) - path = strings.Replace(path, "{" + "petId" + "}", fmt.Sprintf("%b", petId), -1) - + path := "/v2/pet/{petId}" + path = strings.Replace(path, "{" + "petId" + "}", fmt.Sprintf("%v", PetId), -1) _sling = _sling.Path(path) - - - - - //contentTypes := []string { "application/x-www-form-urlencoded" } + // accept header + accepts := []string { "application/json", "application/xml" } + for key := range accepts { + _sling = _sling.Set("Accept", accepts[key]) + break // only use the first Accept + } type FormParams struct { - name string `url:"name,omitempty"` - status string `url:"status,omitempty"` - + Name string `url:"name,omitempty"` + Status string `url:"status,omitempty"` } - _sling = _sling.BodyForm(&FormParams{ name: name,status: status }) - + _sling = _sling.BodyForm(&FormParams{ Name: Name,Status: Status }) + - - resp, err := _sling.Request() - fmt.Println("updatePetWithForm response: void, ", resp, err) + fmt.Println("UpdatePetWithForm response: void, ", resp, err) return err - - - - - //response, err := a.apiClient.CallApi(a.basePath, path, "Post", queryParams, headerParams, formParams, fileParams, bodyParams, contentTypes) - //if err != nil { - // log.Fatal(err) - //} - - // - - // - //return err } /** * Deletes a pet * - * @param petId Pet id to delete - * @param apiKey + * @param PetId Pet id to delete + * @param ApiKey * @return void */ -//func (a PetApi) deletePet (petId int64, apiKey string) (error) { -func (a PetApi) deletePet (petId int64, apiKey string) (error) { +//func (a PetApi) DeletePet (PetId int64, ApiKey string) (error) { +func (a PetApi) DeletePet (PetId int64, ApiKey string) (error) { - _sling := a.sling.Delete(a.basePath) + _sling := sling.New().Delete(a.basePath) // create path and map variables - path := "/pet/{petId}" - //path = regexp.MustCompile("{" + "petId" + "}").ReplaceAllString(path, "$1") - //path = path.Replace("\\{" + "petId" + "\\}", ApiClient.EscapeString(petId)) - path = strings.Replace(path, "{" + "petId" + "}", fmt.Sprintf("%b", petId), -1) - + path := "/v2/pet/{petId}" + path = strings.Replace(path, "{" + "petId" + "}", fmt.Sprintf("%v", PetId), -1) _sling = _sling.Path(path) - - + // accept header + accepts := []string { "application/json", "application/xml" } + for key := range accepts { + _sling = _sling.Set("Accept", accepts[key]) + break // only use the first Accept + } // header params "api_key" - _sling = _sling.Set("api_key", apiKey) - + _sling = _sling.Set("api_key", ApiKey) - //contentTypes := []string { } - - - resp, err := _sling.Request() - fmt.Println("deletePet response: void, ", resp, err) + fmt.Println("DeletePet response: void, ", resp, err) return err - - - - - //response, err := a.apiClient.CallApi(a.basePath, path, "Delete", queryParams, headerParams, formParams, fileParams, bodyParams, contentTypes) - //if err != nil { - // log.Fatal(err) - //} - - // - - // - //return err } /** * uploads an image * - * @param petId ID of pet to update - * @param additionalMetadata Additional data to pass to server - * @param file file to upload + * @param PetId ID of pet to update + * @param AdditionalMetadata Additional data to pass to server + * @param File file to upload * @return void */ -//func (a PetApi) uploadFile (petId int64, additionalMetadata string, file *os.File) (error) { -func (a PetApi) uploadFile (petId int64, additionalMetadata string, file *os.File) (error) { +//func (a PetApi) UploadFile (PetId int64, AdditionalMetadata string, File *os.File) (error) { +func (a PetApi) UploadFile (PetId int64, AdditionalMetadata string, File *os.File) (error) { - _sling := a.sling.Post(a.basePath) + _sling := sling.New().Post(a.basePath) // create path and map variables - path := "/pet/{petId}/uploadImage" - //path = regexp.MustCompile("{" + "petId" + "}").ReplaceAllString(path, "$1") - //path = path.Replace("\\{" + "petId" + "\\}", ApiClient.EscapeString(petId)) - path = strings.Replace(path, "{" + "petId" + "}", fmt.Sprintf("%b", petId), -1) - + path := "/v2/pet/{petId}/uploadImage" + path = strings.Replace(path, "{" + "petId" + "}", fmt.Sprintf("%v", PetId), -1) _sling = _sling.Path(path) - - - - - //contentTypes := []string { "multipart/form-data" } + // accept header + accepts := []string { "application/json", "application/xml" } + for key := range accepts { + _sling = _sling.Set("Accept", accepts[key]) + break // only use the first Accept + } type FormParams struct { - additionalMetadata string `url:"additionalMetadata,omitempty"` - file *os.File `url:"file,omitempty"` - + AdditionalMetadata string `url:"additionalMetadata,omitempty"` + File *os.File `url:"file,omitempty"` } - _sling = _sling.BodyForm(&FormParams{ additionalMetadata: additionalMetadata,file: file }) - + _sling = _sling.BodyForm(&FormParams{ AdditionalMetadata: AdditionalMetadata,File: File }) + - - resp, err := _sling.Request() - fmt.Println("uploadFile response: void, ", resp, err) + fmt.Println("UploadFile response: void, ", resp, err) return err - - - - - //response, err := a.apiClient.CallApi(a.basePath, path, "Post", queryParams, headerParams, formParams, fileParams, bodyParams, contentTypes) - //if err != nil { - // log.Fatal(err) - //} - - // - - // - //return err } diff --git a/samples/client/petstore/go/swagger/StoreApi.go b/samples/client/petstore/go/swagger/StoreApi.go index 17adb00933b..1682b6ce16a 100644 --- a/samples/client/petstore/go/swagger/StoreApi.go +++ b/samples/client/petstore/go/swagger/StoreApi.go @@ -11,7 +11,7 @@ import ( type StoreApi struct { basePath string apiClient ApiClient - sling *sling.Sling + //sling *sling.Sling } func NewStoreApi() *StoreApi{ @@ -31,196 +31,119 @@ func NewStoreApiWithBasePath(basePath string) *StoreApi{ * Returns a map of status codes to quantities * @return map[string]int32 */ -//func (a StoreApi) getInventory () (map[string]int32, error) { -func (a StoreApi) getInventory () (map[string]int32, error) { +//func (a StoreApi) GetInventory () (map[string]int32, error) { +func (a StoreApi) GetInventory () (map[string]int32, error) { - _sling := a.sling.Get(a.basePath) + _sling := sling.New().Get(a.basePath) // create path and map variables - path := "/store/inventory" - + path := "/v2/store/inventory" _sling = _sling.Path(path) - + // accept header + accepts := []string { "application/json", "application/xml" } + for key := range accepts { + _sling = _sling.Set("Accept", accepts[key]) + break // only use the first Accept + } - - //contentTypes := []string { } - - - - - - var response map[string]int32 + response := new(map[string]int32) resp, err := _sling.ReceiveSuccess(response) - fmt.Println("getInventory response: ", response, resp, err) - return response, err - - - - - //response, err := a.apiClient.CallApi(a.basePath, path, "Get", queryParams, headerParams, formParams, fileParams, bodyParams, contentTypes) - //if err != nil { - // log.Fatal(err) - //} - - //ApiClient.Deserialize(response, "map", "map") - - //var response map[string]int32 - //err = json.Unmarshal([]byte(req), &response) - //return response, err - // + fmt.Println("GetInventory response: ", response, resp, err) + return *response, err } /** * Place an order for a pet * - * @param body order placed for purchasing the pet + * @param Body order placed for purchasing the pet * @return Order */ -//func (a StoreApi) placeOrder (body Order) (Order, error) { -func (a StoreApi) placeOrder (body Order) (Order, error) { +//func (a StoreApi) PlaceOrder (Body Order) (Order, error) { +func (a StoreApi) PlaceOrder (Body Order) (Order, error) { - _sling := a.sling.Post(a.basePath) + _sling := sling.New().Post(a.basePath) // create path and map variables - path := "/store/order" - + path := "/v2/store/order" _sling = _sling.Path(path) - + // accept header + accepts := []string { "application/json", "application/xml" } + for key := range accepts { + _sling = _sling.Set("Accept", accepts[key]) + break // only use the first Accept + } - - //contentTypes := []string { } - - - // body params - _sling = _sling.BodyJSON(body) - //b, _ := json.Marshal(body) - //bodyParams["body"] = string(b) - - - - var response Order + response := new(Order) resp, err := _sling.ReceiveSuccess(response) - fmt.Println("placeOrder response: ", response, resp, err) - return response, err - - - - - //response, err := a.apiClient.CallApi(a.basePath, path, "Post", queryParams, headerParams, formParams, fileParams, bodyParams, contentTypes) - //if err != nil { - // log.Fatal(err) - //} - - //ApiClient.Deserialize(response, "", "Order") - - //var response Order - //err = json.Unmarshal([]byte(req), &response) - //return response, err - // + fmt.Println("PlaceOrder response: ", response, resp, err) + return *response, err } /** * Find purchase order by ID * For valid response try integer IDs with value <= 5 or > 10. Other values will generated exceptions - * @param orderId ID of pet that needs to be fetched + * @param OrderId ID of pet that needs to be fetched * @return Order */ -//func (a StoreApi) getOrderById (orderId string) (Order, error) { -func (a StoreApi) getOrderById (orderId string) (Order, error) { +//func (a StoreApi) GetOrderById (OrderId string) (Order, error) { +func (a StoreApi) GetOrderById (OrderId string) (Order, error) { - _sling := a.sling.Get(a.basePath) + _sling := sling.New().Get(a.basePath) // create path and map variables - path := "/store/order/{orderId}" - //path = regexp.MustCompile("{" + "orderId" + "}").ReplaceAllString(path, "$1") - //path = path.Replace("\\{" + "orderId" + "\\}", ApiClient.EscapeString(orderId)) - path = strings.Replace(path, "{" + "orderId" + "}", fmt.Sprintf("%b", orderId), -1) - + path := "/v2/store/order/{orderId}" + path = strings.Replace(path, "{" + "orderId" + "}", fmt.Sprintf("%v", OrderId), -1) _sling = _sling.Path(path) - + // accept header + accepts := []string { "application/json", "application/xml" } + for key := range accepts { + _sling = _sling.Set("Accept", accepts[key]) + break // only use the first Accept + } - - //contentTypes := []string { } - - - - - - var response Order + response := new(Order) resp, err := _sling.ReceiveSuccess(response) - fmt.Println("getOrderById response: ", response, resp, err) - return response, err - - - - - //response, err := a.apiClient.CallApi(a.basePath, path, "Get", queryParams, headerParams, formParams, fileParams, bodyParams, contentTypes) - //if err != nil { - // log.Fatal(err) - //} - - //ApiClient.Deserialize(response, "", "Order") - - //var response Order - //err = json.Unmarshal([]byte(req), &response) - //return response, err - // + fmt.Println("GetOrderById response: ", response, resp, err) + return *response, err } /** * Delete purchase order by ID * For valid response try integer IDs with value < 1000. Anything above 1000 or nonintegers will generate API errors - * @param orderId ID of the order that needs to be deleted + * @param OrderId ID of the order that needs to be deleted * @return void */ -//func (a StoreApi) deleteOrder (orderId string) (error) { -func (a StoreApi) deleteOrder (orderId string) (error) { +//func (a StoreApi) DeleteOrder (OrderId string) (error) { +func (a StoreApi) DeleteOrder (OrderId string) (error) { - _sling := a.sling.Delete(a.basePath) + _sling := sling.New().Delete(a.basePath) // create path and map variables - path := "/store/order/{orderId}" - //path = regexp.MustCompile("{" + "orderId" + "}").ReplaceAllString(path, "$1") - //path = path.Replace("\\{" + "orderId" + "\\}", ApiClient.EscapeString(orderId)) - path = strings.Replace(path, "{" + "orderId" + "}", fmt.Sprintf("%b", orderId), -1) - + path := "/v2/store/order/{orderId}" + path = strings.Replace(path, "{" + "orderId" + "}", fmt.Sprintf("%v", OrderId), -1) _sling = _sling.Path(path) - + // accept header + accepts := []string { "application/json", "application/xml" } + for key := range accepts { + _sling = _sling.Set("Accept", accepts[key]) + break // only use the first Accept + } - - //contentTypes := []string { } - - - - resp, err := _sling.Request() - fmt.Println("deleteOrder response: void, ", resp, err) + fmt.Println("DeleteOrder response: void, ", resp, err) return err - - - - - //response, err := a.apiClient.CallApi(a.basePath, path, "Delete", queryParams, headerParams, formParams, fileParams, bodyParams, contentTypes) - //if err != nil { - // log.Fatal(err) - //} - - // - - // - //return err } diff --git a/samples/client/petstore/go/swagger/Tag.go b/samples/client/petstore/go/swagger/Tag.go index 7fd20f55ef4..6b505272a15 100644 --- a/samples/client/petstore/go/swagger/Tag.go +++ b/samples/client/petstore/go/swagger/Tag.go @@ -4,7 +4,7 @@ import ( ) type Tag struct { - id int64 `json:"id,omitempty"` - name string `json:"name,omitempty"` + Id int64 `json:"id,omitempty"` + Name string `json:"name,omitempty"` } diff --git a/samples/client/petstore/go/swagger/User.go b/samples/client/petstore/go/swagger/User.go index 608ac360618..e7f26d1d10c 100644 --- a/samples/client/petstore/go/swagger/User.go +++ b/samples/client/petstore/go/swagger/User.go @@ -4,13 +4,13 @@ import ( ) type User struct { - id int64 `json:"id,omitempty"` - username string `json:"username,omitempty"` - firstName string `json:"firstName,omitempty"` - lastName string `json:"lastName,omitempty"` - email string `json:"email,omitempty"` - password string `json:"password,omitempty"` - phone string `json:"phone,omitempty"` - userStatus int32 `json:"userStatus,omitempty"` + Id int64 `json:"id,omitempty"` + Username string `json:"username,omitempty"` + FirstName string `json:"firstName,omitempty"` + LastName string `json:"lastName,omitempty"` + Email string `json:"email,omitempty"` + Password string `json:"password,omitempty"` + Phone string `json:"phone,omitempty"` + UserStatus int32 `json:"userStatus,omitempty"` } diff --git a/samples/client/petstore/go/swagger/UserApi.go b/samples/client/petstore/go/swagger/UserApi.go index 0a1abeb7827..31c26c7b6e7 100644 --- a/samples/client/petstore/go/swagger/UserApi.go +++ b/samples/client/petstore/go/swagger/UserApi.go @@ -11,7 +11,7 @@ import ( type UserApi struct { basePath string apiClient ApiClient - sling *sling.Sling + //sling *sling.Sling } func NewUserApi() *UserApi{ @@ -29,399 +29,250 @@ func NewUserApiWithBasePath(basePath string) *UserApi{ /** * Create user * This can only be done by the logged in user. - * @param body Created user object + * @param Body Created user object * @return void */ -//func (a UserApi) createUser (body User) (error) { -func (a UserApi) createUser (body User) (error) { +//func (a UserApi) CreateUser (Body User) (error) { +func (a UserApi) CreateUser (Body User) (error) { - _sling := a.sling.Post(a.basePath) + _sling := sling.New().Post(a.basePath) // create path and map variables - path := "/user" - + path := "/v2/user" _sling = _sling.Path(path) - + // accept header + accepts := []string { "application/json", "application/xml" } + for key := range accepts { + _sling = _sling.Set("Accept", accepts[key]) + break // only use the first Accept + } - - //contentTypes := []string { } - - // body params - _sling = _sling.BodyJSON(body) - //b, _ := json.Marshal(body) - //bodyParams["body"] = string(b) - - - resp, err := _sling.Request() - fmt.Println("createUser response: void, ", resp, err) + fmt.Println("CreateUser response: void, ", resp, err) return err - - - - - //response, err := a.apiClient.CallApi(a.basePath, path, "Post", queryParams, headerParams, formParams, fileParams, bodyParams, contentTypes) - //if err != nil { - // log.Fatal(err) - //} - - // - - // - //return err } /** * Creates list of users with given input array * - * @param body List of user object + * @param Body List of user object * @return void */ -//func (a UserApi) createUsersWithArrayInput (body []User) (error) { -func (a UserApi) createUsersWithArrayInput (body []User) (error) { +//func (a UserApi) CreateUsersWithArrayInput (Body []User) (error) { +func (a UserApi) CreateUsersWithArrayInput (Body []User) (error) { - _sling := a.sling.Post(a.basePath) + _sling := sling.New().Post(a.basePath) // create path and map variables - path := "/user/createWithArray" - + path := "/v2/user/createWithArray" _sling = _sling.Path(path) - + // accept header + accepts := []string { "application/json", "application/xml" } + for key := range accepts { + _sling = _sling.Set("Accept", accepts[key]) + break // only use the first Accept + } - - //contentTypes := []string { } - - // body params - _sling = _sling.BodyJSON(body) - //b, _ := json.Marshal(body) - //bodyParams["body"] = string(b) - - - resp, err := _sling.Request() - fmt.Println("createUsersWithArrayInput response: void, ", resp, err) + fmt.Println("CreateUsersWithArrayInput response: void, ", resp, err) return err - - - - - //response, err := a.apiClient.CallApi(a.basePath, path, "Post", queryParams, headerParams, formParams, fileParams, bodyParams, contentTypes) - //if err != nil { - // log.Fatal(err) - //} - - // - - // - //return err } /** * Creates list of users with given input array * - * @param body List of user object + * @param Body List of user object * @return void */ -//func (a UserApi) createUsersWithListInput (body []User) (error) { -func (a UserApi) createUsersWithListInput (body []User) (error) { +//func (a UserApi) CreateUsersWithListInput (Body []User) (error) { +func (a UserApi) CreateUsersWithListInput (Body []User) (error) { - _sling := a.sling.Post(a.basePath) + _sling := sling.New().Post(a.basePath) // create path and map variables - path := "/user/createWithList" - + path := "/v2/user/createWithList" _sling = _sling.Path(path) - + // accept header + accepts := []string { "application/json", "application/xml" } + for key := range accepts { + _sling = _sling.Set("Accept", accepts[key]) + break // only use the first Accept + } - - //contentTypes := []string { } - - // body params - _sling = _sling.BodyJSON(body) - //b, _ := json.Marshal(body) - //bodyParams["body"] = string(b) - - - resp, err := _sling.Request() - fmt.Println("createUsersWithListInput response: void, ", resp, err) + fmt.Println("CreateUsersWithListInput response: void, ", resp, err) return err - - - - - //response, err := a.apiClient.CallApi(a.basePath, path, "Post", queryParams, headerParams, formParams, fileParams, bodyParams, contentTypes) - //if err != nil { - // log.Fatal(err) - //} - - // - - // - //return err } /** * Logs user into the system * - * @param username The user name for login - * @param password The password for login in clear text + * @param Username The user name for login + * @param Password The password for login in clear text * @return string */ -//func (a UserApi) loginUser (username string, password string) (string, error) { -func (a UserApi) loginUser (username string, password string) (string, error) { +//func (a UserApi) LoginUser (Username string, Password string) (string, error) { +func (a UserApi) LoginUser (Username string, Password string) (string, error) { - _sling := a.sling.Get(a.basePath) + _sling := sling.New().Get(a.basePath) // create path and map variables - path := "/user/login" - + path := "/v2/user/login" _sling = _sling.Path(path) type QueryParams struct { - username string `url:"username,omitempty"` - password string `url:"password,omitempty"` + Username string `url:"username,omitempty"` + Password string `url:"password,omitempty"` +} + _sling = _sling.QueryStruct(&QueryParams{ Username: Username,Password: Password }) + // accept header + accepts := []string { "application/json", "application/xml" } + for key := range accepts { + _sling = _sling.Set("Accept", accepts[key]) + break // only use the first Accept } - _sling = _sling.QueryStruct(&QueryParams{ username: username,password: password }) - - - //contentTypes := []string { } - - - - - - - var response string + response := new(string) resp, err := _sling.ReceiveSuccess(response) - fmt.Println("loginUser response: ", response, resp, err) - return response, err - - - - - //response, err := a.apiClient.CallApi(a.basePath, path, "Get", queryParams, headerParams, formParams, fileParams, bodyParams, contentTypes) - //if err != nil { - // log.Fatal(err) - //} - - //ApiClient.Deserialize(response, "", "string") - - //var response string - //err = json.Unmarshal([]byte(req), &response) - //return response, err - // + fmt.Println("LoginUser response: ", response, resp, err) + return *response, err } /** * Logs out current logged in user session * * @return void */ -//func (a UserApi) logoutUser () (error) { -func (a UserApi) logoutUser () (error) { +//func (a UserApi) LogoutUser () (error) { +func (a UserApi) LogoutUser () (error) { - _sling := a.sling.Get(a.basePath) + _sling := sling.New().Get(a.basePath) // create path and map variables - path := "/user/logout" - + path := "/v2/user/logout" _sling = _sling.Path(path) - + // accept header + accepts := []string { "application/json", "application/xml" } + for key := range accepts { + _sling = _sling.Set("Accept", accepts[key]) + break // only use the first Accept + } - - //contentTypes := []string { } - - - - resp, err := _sling.Request() - fmt.Println("logoutUser response: void, ", resp, err) + fmt.Println("LogoutUser response: void, ", resp, err) return err - - - - - //response, err := a.apiClient.CallApi(a.basePath, path, "Get", queryParams, headerParams, formParams, fileParams, bodyParams, contentTypes) - //if err != nil { - // log.Fatal(err) - //} - - // - - // - //return err } /** * Get user by user name * - * @param username The name that needs to be fetched. Use user1 for testing. + * @param Username The name that needs to be fetched. Use user1 for testing. * @return User */ -//func (a UserApi) getUserByName (username string) (User, error) { -func (a UserApi) getUserByName (username string) (User, error) { +//func (a UserApi) GetUserByName (Username string) (User, error) { +func (a UserApi) GetUserByName (Username string) (User, error) { - _sling := a.sling.Get(a.basePath) + _sling := sling.New().Get(a.basePath) // create path and map variables - path := "/user/{username}" - //path = regexp.MustCompile("{" + "username" + "}").ReplaceAllString(path, "$1") - //path = path.Replace("\\{" + "username" + "\\}", ApiClient.EscapeString(username)) - path = strings.Replace(path, "{" + "username" + "}", fmt.Sprintf("%b", username), -1) - + path := "/v2/user/{username}" + path = strings.Replace(path, "{" + "username" + "}", fmt.Sprintf("%v", Username), -1) _sling = _sling.Path(path) - + // accept header + accepts := []string { "application/json", "application/xml" } + for key := range accepts { + _sling = _sling.Set("Accept", accepts[key]) + break // only use the first Accept + } - - //contentTypes := []string { } - - - - - - var response User + response := new(User) resp, err := _sling.ReceiveSuccess(response) - fmt.Println("getUserByName response: ", response, resp, err) - return response, err - - - - - //response, err := a.apiClient.CallApi(a.basePath, path, "Get", queryParams, headerParams, formParams, fileParams, bodyParams, contentTypes) - //if err != nil { - // log.Fatal(err) - //} - - //ApiClient.Deserialize(response, "", "User") - - //var response User - //err = json.Unmarshal([]byte(req), &response) - //return response, err - // + fmt.Println("GetUserByName response: ", response, resp, err) + return *response, err } /** * Updated user * This can only be done by the logged in user. - * @param username name that need to be deleted - * @param body Updated user object + * @param Username name that need to be deleted + * @param Body Updated user object * @return void */ -//func (a UserApi) updateUser (username string, body User) (error) { -func (a UserApi) updateUser (username string, body User) (error) { +//func (a UserApi) UpdateUser (Username string, Body User) (error) { +func (a UserApi) UpdateUser (Username string, Body User) (error) { - _sling := a.sling.Put(a.basePath) + _sling := sling.New().Put(a.basePath) // create path and map variables - path := "/user/{username}" - //path = regexp.MustCompile("{" + "username" + "}").ReplaceAllString(path, "$1") - //path = path.Replace("\\{" + "username" + "\\}", ApiClient.EscapeString(username)) - path = strings.Replace(path, "{" + "username" + "}", fmt.Sprintf("%b", username), -1) - + path := "/v2/user/{username}" + path = strings.Replace(path, "{" + "username" + "}", fmt.Sprintf("%v", Username), -1) _sling = _sling.Path(path) - + // accept header + accepts := []string { "application/json", "application/xml" } + for key := range accepts { + _sling = _sling.Set("Accept", accepts[key]) + break // only use the first Accept + } - - //contentTypes := []string { } - - // body params - _sling = _sling.BodyJSON(body) - //b, _ := json.Marshal(body) - //bodyParams["body"] = string(b) - - - resp, err := _sling.Request() - fmt.Println("updateUser response: void, ", resp, err) + fmt.Println("UpdateUser response: void, ", resp, err) return err - - - - - //response, err := a.apiClient.CallApi(a.basePath, path, "Put", queryParams, headerParams, formParams, fileParams, bodyParams, contentTypes) - //if err != nil { - // log.Fatal(err) - //} - - // - - // - //return err } /** * Delete user * This can only be done by the logged in user. - * @param username The name that needs to be deleted + * @param Username The name that needs to be deleted * @return void */ -//func (a UserApi) deleteUser (username string) (error) { -func (a UserApi) deleteUser (username string) (error) { +//func (a UserApi) DeleteUser (Username string) (error) { +func (a UserApi) DeleteUser (Username string) (error) { - _sling := a.sling.Delete(a.basePath) + _sling := sling.New().Delete(a.basePath) // create path and map variables - path := "/user/{username}" - //path = regexp.MustCompile("{" + "username" + "}").ReplaceAllString(path, "$1") - //path = path.Replace("\\{" + "username" + "\\}", ApiClient.EscapeString(username)) - path = strings.Replace(path, "{" + "username" + "}", fmt.Sprintf("%b", username), -1) - + path := "/v2/user/{username}" + path = strings.Replace(path, "{" + "username" + "}", fmt.Sprintf("%v", Username), -1) _sling = _sling.Path(path) - + // accept header + accepts := []string { "application/json", "application/xml" } + for key := range accepts { + _sling = _sling.Set("Accept", accepts[key]) + break // only use the first Accept + } - - //contentTypes := []string { } - - - - resp, err := _sling.Request() - fmt.Println("deleteUser response: void, ", resp, err) + fmt.Println("DeleteUser response: void, ", resp, err) return err - - - - - //response, err := a.apiClient.CallApi(a.basePath, path, "Delete", queryParams, headerParams, formParams, fileParams, bodyParams, contentTypes) - //if err != nil { - // log.Fatal(err) - //} - - // - - // - //return err } diff --git a/samples/client/petstore/go/test.go b/samples/client/petstore/go/test.go index d1dbf4272a2..f28a510f3cc 100644 --- a/samples/client/petstore/go/test.go +++ b/samples/client/petstore/go/test.go @@ -1,15 +1,18 @@ package main import ( + sw "./swagger" "fmt" - // "log" - swagger "./swagger" ) func main() { fmt.Println("hello world") - s := swagger.NewPetApi() - &s.updatePetWithForm("2", "golang", "available") + s := sw.NewPetApi() + //s.UpdatePetWithForm("2", "golang", "available") + + // test Get + resp, err := s.GetPetById(3) + fmt.Println("GetPetById: ", resp, err) } From 0d377507b4bce9b89e0cfe85498c5e6a43bd00fa Mon Sep 17 00:00:00 2001 From: wing328 Date: Mon, 21 Dec 2015 22:32:54 +0800 Subject: [PATCH 5/8] fix post model and update test --- .../codegen/languages/GoClientCodegen.java | 7 +++- .../src/main/resources/go/api.mustache | 12 +++--- samples/client/petstore/go/swagger/Order.go | 1 + samples/client/petstore/go/swagger/PetApi.go | 37 +++++++++-------- .../client/petstore/go/swagger/StoreApi.go | 18 +++++---- samples/client/petstore/go/swagger/UserApi.go | 40 +++++++++++-------- samples/client/petstore/go/test.go | 16 ++++++-- 7 files changed, 81 insertions(+), 50 deletions(-) diff --git a/modules/swagger-codegen/src/main/java/io/swagger/codegen/languages/GoClientCodegen.java b/modules/swagger-codegen/src/main/java/io/swagger/codegen/languages/GoClientCodegen.java index c9ec24de6b2..81008d552cb 100644 --- a/modules/swagger-codegen/src/main/java/io/swagger/codegen/languages/GoClientCodegen.java +++ b/modules/swagger-codegen/src/main/java/io/swagger/codegen/languages/GoClientCodegen.java @@ -163,7 +163,6 @@ public class GoClientCodegen extends DefaultCodegen implements CodegenConfig { @Override public String getTypeDeclaration(Property p) { - String swaggerType = getSwaggerType(p); if(p instanceof ArrayProperty) { ArrayProperty ap = (ArrayProperty) p; Property inner = ap.getItems(); @@ -175,6 +174,12 @@ public class GoClientCodegen extends DefaultCodegen implements CodegenConfig { return getSwaggerType(p) + "[string]" + getTypeDeclaration(inner); } + return super.getTypeDeclaration(p); + } + + @Override + public String getSwaggerType(Property p) { + String swaggerType = super.getSwaggerType(p); String type = null; if(typeMapping.containsKey(swaggerType)) { type = typeMapping.get(swaggerType); diff --git a/modules/swagger-codegen/src/main/resources/go/api.mustache b/modules/swagger-codegen/src/main/resources/go/api.mustache index 16512786abc..d009ad10ef2 100644 --- a/modules/swagger-codegen/src/main/resources/go/api.mustache +++ b/modules/swagger-codegen/src/main/resources/go/api.mustache @@ -69,17 +69,17 @@ func (a {{classname}}) {{nickname}} ({{#allParams}}{{paramName}} {{{dataType}}}{ } _sling = _sling.BodyForm(&FormParams{ {{#formParams}}{{paramName}}: {{paramName}}{{#hasMore}},{{/hasMore}}{{/formParams}} }) {{/hasFormParams}} -{{#hasBodyParams}}{{#bodyParams}}// body params +{{#hasBodyParam}}{{#bodyParams}}// body params _sling = _sling.BodyJSON({{paramName}}) -{{/bodyParams}}{{/hasBodyParams}} +{{/bodyParams}}{{/hasBodyParam}} {{#returnType}} response := new({{returnType}}) - resp, err := _sling.ReceiveSuccess(response) - fmt.Println("{{operationId}} response: ", response, resp, err) + _, err := _sling.ReceiveSuccess(response) + //fmt.Println("{{operationId}} response: ", response, resp, err) return *response, err {{/returnType}}{{^returnType}} - resp, err := _sling.Request() - fmt.Println("{{operationId}} response: void, ", resp, err) + _, err := _sling.ReceiveSuccess(nil) + //fmt.Println("{{operationId}} response: void, ", resp, err) return err {{/returnType}} } diff --git a/samples/client/petstore/go/swagger/Order.go b/samples/client/petstore/go/swagger/Order.go index 254b962de2f..9db0f945110 100644 --- a/samples/client/petstore/go/swagger/Order.go +++ b/samples/client/petstore/go/swagger/Order.go @@ -1,6 +1,7 @@ package swagger import ( + "time" ) type Order struct { diff --git a/samples/client/petstore/go/swagger/PetApi.go b/samples/client/petstore/go/swagger/PetApi.go index a83f426471d..a4ed5033d57 100644 --- a/samples/client/petstore/go/swagger/PetApi.go +++ b/samples/client/petstore/go/swagger/PetApi.go @@ -6,6 +6,7 @@ import ( "fmt" // "log" "github.com/dghubble/sling" + "os" ) type PetApi struct { @@ -49,11 +50,13 @@ func (a PetApi) UpdatePet (Body Pet) (error) { break // only use the first Accept } +// body params + _sling = _sling.BodyJSON(Body) - resp, err := _sling.Request() - fmt.Println("UpdatePet response: void, ", resp, err) + _, err := _sling.ReceiveSuccess(nil) + //fmt.Println("UpdatePet response: void, ", resp, err) return err } /** @@ -79,11 +82,13 @@ func (a PetApi) AddPet (Body Pet) (error) { break // only use the first Accept } +// body params + _sling = _sling.BodyJSON(Body) - resp, err := _sling.Request() - fmt.Println("AddPet response: void, ", resp, err) + _, err := _sling.ReceiveSuccess(nil) + //fmt.Println("AddPet response: void, ", resp, err) return err } /** @@ -117,8 +122,8 @@ func (a PetApi) FindPetsByStatus (Status []string) ([]Pet, error) { response := new([]Pet) - resp, err := _sling.ReceiveSuccess(response) - fmt.Println("FindPetsByStatus response: ", response, resp, err) + _, err := _sling.ReceiveSuccess(response) + //fmt.Println("FindPetsByStatus response: ", response, resp, err) return *response, err } /** @@ -152,8 +157,8 @@ func (a PetApi) FindPetsByTags (Tags []string) ([]Pet, error) { response := new([]Pet) - resp, err := _sling.ReceiveSuccess(response) - fmt.Println("FindPetsByTags response: ", response, resp, err) + _, err := _sling.ReceiveSuccess(response) + //fmt.Println("FindPetsByTags response: ", response, resp, err) return *response, err } /** @@ -183,8 +188,8 @@ func (a PetApi) GetPetById (PetId int64) (Pet, error) { response := new(Pet) - resp, err := _sling.ReceiveSuccess(response) - fmt.Println("GetPetById response: ", response, resp, err) + _, err := _sling.ReceiveSuccess(response) + //fmt.Println("GetPetById response: ", response, resp, err) return *response, err } /** @@ -221,8 +226,8 @@ func (a PetApi) UpdatePetWithForm (PetId string, Name string, Status string) (er - resp, err := _sling.Request() - fmt.Println("UpdatePetWithForm response: void, ", resp, err) + _, err := _sling.ReceiveSuccess(nil) + //fmt.Println("UpdatePetWithForm response: void, ", resp, err) return err } /** @@ -255,8 +260,8 @@ func (a PetApi) DeletePet (PetId int64, ApiKey string) (error) { - resp, err := _sling.Request() - fmt.Println("DeletePet response: void, ", resp, err) + _, err := _sling.ReceiveSuccess(nil) + //fmt.Println("DeletePet response: void, ", resp, err) return err } /** @@ -293,7 +298,7 @@ func (a PetApi) UploadFile (PetId int64, AdditionalMetadata string, File *os.Fil - resp, err := _sling.Request() - fmt.Println("UploadFile response: void, ", resp, err) + _, err := _sling.ReceiveSuccess(nil) + //fmt.Println("UploadFile response: void, ", resp, err) return err } diff --git a/samples/client/petstore/go/swagger/StoreApi.go b/samples/client/petstore/go/swagger/StoreApi.go index 1682b6ce16a..4af27d02b7a 100644 --- a/samples/client/petstore/go/swagger/StoreApi.go +++ b/samples/client/petstore/go/swagger/StoreApi.go @@ -51,8 +51,8 @@ func (a StoreApi) GetInventory () (map[string]int32, error) { response := new(map[string]int32) - resp, err := _sling.ReceiveSuccess(response) - fmt.Println("GetInventory response: ", response, resp, err) + _, err := _sling.ReceiveSuccess(response) + //fmt.Println("GetInventory response: ", response, resp, err) return *response, err } /** @@ -78,11 +78,13 @@ func (a StoreApi) PlaceOrder (Body Order) (Order, error) { break // only use the first Accept } +// body params + _sling = _sling.BodyJSON(Body) response := new(Order) - resp, err := _sling.ReceiveSuccess(response) - fmt.Println("PlaceOrder response: ", response, resp, err) + _, err := _sling.ReceiveSuccess(response) + //fmt.Println("PlaceOrder response: ", response, resp, err) return *response, err } /** @@ -112,8 +114,8 @@ func (a StoreApi) GetOrderById (OrderId string) (Order, error) { response := new(Order) - resp, err := _sling.ReceiveSuccess(response) - fmt.Println("GetOrderById response: ", response, resp, err) + _, err := _sling.ReceiveSuccess(response) + //fmt.Println("GetOrderById response: ", response, resp, err) return *response, err } /** @@ -143,7 +145,7 @@ func (a StoreApi) DeleteOrder (OrderId string) (error) { - resp, err := _sling.Request() - fmt.Println("DeleteOrder response: void, ", resp, err) + _, err := _sling.ReceiveSuccess(nil) + //fmt.Println("DeleteOrder response: void, ", resp, err) return err } diff --git a/samples/client/petstore/go/swagger/UserApi.go b/samples/client/petstore/go/swagger/UserApi.go index 31c26c7b6e7..c5da3c81b6d 100644 --- a/samples/client/petstore/go/swagger/UserApi.go +++ b/samples/client/petstore/go/swagger/UserApi.go @@ -49,11 +49,13 @@ func (a UserApi) CreateUser (Body User) (error) { break // only use the first Accept } +// body params + _sling = _sling.BodyJSON(Body) - resp, err := _sling.Request() - fmt.Println("CreateUser response: void, ", resp, err) + _, err := _sling.ReceiveSuccess(nil) + //fmt.Println("CreateUser response: void, ", resp, err) return err } /** @@ -79,11 +81,13 @@ func (a UserApi) CreateUsersWithArrayInput (Body []User) (error) { break // only use the first Accept } +// body params + _sling = _sling.BodyJSON(Body) - resp, err := _sling.Request() - fmt.Println("CreateUsersWithArrayInput response: void, ", resp, err) + _, err := _sling.ReceiveSuccess(nil) + //fmt.Println("CreateUsersWithArrayInput response: void, ", resp, err) return err } /** @@ -109,11 +113,13 @@ func (a UserApi) CreateUsersWithListInput (Body []User) (error) { break // only use the first Accept } +// body params + _sling = _sling.BodyJSON(Body) - resp, err := _sling.Request() - fmt.Println("CreateUsersWithListInput response: void, ", resp, err) + _, err := _sling.ReceiveSuccess(nil) + //fmt.Println("CreateUsersWithListInput response: void, ", resp, err) return err } /** @@ -149,8 +155,8 @@ func (a UserApi) LoginUser (Username string, Password string) (string, error) { response := new(string) - resp, err := _sling.ReceiveSuccess(response) - fmt.Println("LoginUser response: ", response, resp, err) + _, err := _sling.ReceiveSuccess(response) + //fmt.Println("LoginUser response: ", response, resp, err) return *response, err } /** @@ -178,8 +184,8 @@ func (a UserApi) LogoutUser () (error) { - resp, err := _sling.Request() - fmt.Println("LogoutUser response: void, ", resp, err) + _, err := _sling.ReceiveSuccess(nil) + //fmt.Println("LogoutUser response: void, ", resp, err) return err } /** @@ -209,8 +215,8 @@ func (a UserApi) GetUserByName (Username string) (User, error) { response := new(User) - resp, err := _sling.ReceiveSuccess(response) - fmt.Println("GetUserByName response: ", response, resp, err) + _, err := _sling.ReceiveSuccess(response) + //fmt.Println("GetUserByName response: ", response, resp, err) return *response, err } /** @@ -238,11 +244,13 @@ func (a UserApi) UpdateUser (Username string, Body User) (error) { break // only use the first Accept } +// body params + _sling = _sling.BodyJSON(Body) - resp, err := _sling.Request() - fmt.Println("UpdateUser response: void, ", resp, err) + _, err := _sling.ReceiveSuccess(nil) + //fmt.Println("UpdateUser response: void, ", resp, err) return err } /** @@ -272,7 +280,7 @@ func (a UserApi) DeleteUser (Username string) (error) { - resp, err := _sling.Request() - fmt.Println("DeleteUser response: void, ", resp, err) + _, err := _sling.ReceiveSuccess(nil) + //fmt.Println("DeleteUser response: void, ", resp, err) return err } diff --git a/samples/client/petstore/go/test.go b/samples/client/petstore/go/test.go index f28a510f3cc..a2f72ca9ef3 100644 --- a/samples/client/petstore/go/test.go +++ b/samples/client/petstore/go/test.go @@ -2,16 +2,26 @@ package main import ( sw "./swagger" + "encoding/json" "fmt" ) func main() { - fmt.Println("hello world") s := sw.NewPetApi() - //s.UpdatePetWithForm("2", "golang", "available") - // test Get + // test POST(body) + newPet := (sw.Pet{Id: 12830, Name: "gopher", + PhotoUrls: []string{"http://1.com", "http://2.com"}, Status: "pending"}) + + jsonNewPet, _ := json.Marshal(newPet) + fmt.Println("newPet:", string(jsonNewPet)) + s.AddPet(newPet) + + // test POST(form) + s.UpdatePetWithForm("12830", "golang", "available") + + // test GET resp, err := s.GetPetById(3) fmt.Println("GetPetById: ", resp, err) From 6b2f15b2cf342377bba4679ef2f7a094a7c29231 Mon Sep 17 00:00:00 2001 From: wing328 Date: Tue, 22 Dec 2015 00:12:18 +0800 Subject: [PATCH 6/8] add packageName support to golang --- .../codegen/languages/GoClientCodegen.java | 61 ++++++++++++++----- .../src/main/resources/go/README.mustache | 12 ++++ .../src/main/resources/go/api.mustache | 6 +- .../src/main/resources/go/model.mustache | 2 +- .../client/petstore/go/swagger/ApiClient.go | 33 ---------- samples/client/petstore/go/swagger/PetApi.go | 33 ++++++++-- .../client/petstore/go/swagger/StoreApi.go | 4 -- samples/client/petstore/go/swagger/UserApi.go | 4 -- 8 files changed, 89 insertions(+), 66 deletions(-) create mode 100644 modules/swagger-codegen/src/main/resources/go/README.mustache delete mode 100644 samples/client/petstore/go/swagger/ApiClient.go diff --git a/modules/swagger-codegen/src/main/java/io/swagger/codegen/languages/GoClientCodegen.java b/modules/swagger-codegen/src/main/java/io/swagger/codegen/languages/GoClientCodegen.java index 81008d552cb..a7488983d40 100644 --- a/modules/swagger-codegen/src/main/java/io/swagger/codegen/languages/GoClientCodegen.java +++ b/modules/swagger-codegen/src/main/java/io/swagger/codegen/languages/GoClientCodegen.java @@ -16,10 +16,8 @@ import org.slf4j.LoggerFactory; public class GoClientCodegen extends DefaultCodegen implements CodegenConfig { static Logger LOGGER = LoggerFactory.getLogger(GoClientCodegen.class); - protected String invokerPackage = "swagger"; - protected String groupId = "io.swagger"; - protected String artifactId = "swagger-go-client"; - protected String artifactVersion = "1.0.0"; + protected String packageName = "swagger"; + protected String packageVersion = "1.0.0"; public CodegenType getTag() { return CodegenType.CLIENT; @@ -39,8 +37,6 @@ public class GoClientCodegen extends DefaultCodegen implements CodegenConfig { modelTemplateFiles.put("model.mustache", ".go"); apiTemplateFiles.put("api.mustache", ".go"); templateDir = "go"; - apiPackage = invokerPackage; - modelPackage = invokerPackage; reservedWords = new HashSet ( Arrays.asList( @@ -51,11 +47,6 @@ public class GoClientCodegen extends DefaultCodegen implements CodegenConfig { "continue", "for", "import", "return", "var") ); - additionalProperties.put("invokerPackage", invokerPackage); - /*additionalProperties.put("groupId", groupId); - additionalProperties.put("artifactId", artifactId); - additionalProperties.put("artifactVersion", artifactVersion);*/ - defaultIncludes = new HashSet( Arrays.asList( "map", @@ -94,16 +85,48 @@ public class GoClientCodegen extends DefaultCodegen implements CodegenConfig { typeMapping.put("Date", "time.Time"); typeMapping.put("DateTime", "time.Time"); typeMapping.put("password", "string"); + typeMapping.put("File", "*os.File"); typeMapping.put("file", "*os.File"); - //typeMapping.put("array", "array"); - //typeMapping.put("map", "map"); importMapping = new HashMap(); importMapping.put("time.Time", "time"); importMapping.put("*os.File", "os"); + cliOptions.clear(); + cliOptions.add(new CliOption(CodegenConstants.PACKAGE_NAME, "Go package name (convention: lowercase).") + .defaultValue("swagger")); + cliOptions.add(new CliOption(CodegenConstants.PACKAGE_VERSION, "Go package version.") + .defaultValue("1.0.0")); + } + @Override + public void processOpts() { + //super.processOpts(); + + if (additionalProperties.containsKey(CodegenConstants.PACKAGE_NAME)) { + setPackageName((String) additionalProperties.get(CodegenConstants.PACKAGE_NAME)); + } + else { + setPackageName("swagger"); + } + + if (additionalProperties.containsKey(CodegenConstants.PACKAGE_VERSION)) { + setPackageVersion((String) additionalProperties.get(CodegenConstants.PACKAGE_VERSION)); + } + else { + setPackageVersion("1.0.0"); + } + + additionalProperties.put(CodegenConstants.PACKAGE_NAME, packageName); + additionalProperties.put(CodegenConstants.PACKAGE_VERSION, packageVersion); + + modelPackage = packageName; + apiPackage = packageName; + + supportingFiles.add(new SupportingFile("README.mustache", "", "README.md")); + } + @Override public String escapeReservedWord(String name) { return "_" + name; @@ -111,11 +134,11 @@ public class GoClientCodegen extends DefaultCodegen implements CodegenConfig { @Override public String apiFileFolder() { - return outputFolder + File.separator + invokerPackage; + return outputFolder + File.separator + packageName; } public String modelFileFolder() { - return outputFolder + File.separator + invokerPackage; + return outputFolder + File.separator + packageName; } @Override @@ -246,4 +269,12 @@ public class GoClientCodegen extends DefaultCodegen implements CodegenConfig { && !languageSpecificPrimitives.contains(type); } + public void setPackageName(String packageName) { + this.packageName = packageName; + } + + public void setPackageVersion(String packageVersion) { + this.packageVersion = packageVersion; + } + } diff --git a/modules/swagger-codegen/src/main/resources/go/README.mustache b/modules/swagger-codegen/src/main/resources/go/README.mustache new file mode 100644 index 00000000000..586b35ed3f5 --- /dev/null +++ b/modules/swagger-codegen/src/main/resources/go/README.mustache @@ -0,0 +1,12 @@ +# Go API client for {{packageName}} + +## Overview +This API client was generated by the [swagger-codegen](https://github.com/swagger-api/swagger-codegen) project. By using the [swagger-spec](https://github.com/swagger-api/swagger-spec) from a remote server, you can easily generate an API client. + + +## Installation +Put the package under your project folder and add the following in import: +``` + "./{{packageName}}" +``` + diff --git a/modules/swagger-codegen/src/main/resources/go/api.mustache b/modules/swagger-codegen/src/main/resources/go/api.mustache index d009ad10ef2..ae7fb8412b0 100644 --- a/modules/swagger-codegen/src/main/resources/go/api.mustache +++ b/modules/swagger-codegen/src/main/resources/go/api.mustache @@ -1,11 +1,9 @@ -package {{invokerPackage}} +package {{packageName}} {{#operations}} import ( -// "encoding/json" "strings" "fmt" -// "log" "github.com/dghubble/sling" {{#imports}} "{{import}}" {{/imports}} @@ -13,8 +11,6 @@ import ( type {{classname}} struct { basePath string - apiClient ApiClient - //sling *sling.Sling } func New{{classname}}() *{{classname}}{ diff --git a/modules/swagger-codegen/src/main/resources/go/model.mustache b/modules/swagger-codegen/src/main/resources/go/model.mustache index bbd7e772d0e..83ba416883d 100644 --- a/modules/swagger-codegen/src/main/resources/go/model.mustache +++ b/modules/swagger-codegen/src/main/resources/go/model.mustache @@ -1,4 +1,4 @@ -package {{invokerPackage}} +package {{packageName}} {{#models}} import ( diff --git a/samples/client/petstore/go/swagger/ApiClient.go b/samples/client/petstore/go/swagger/ApiClient.go deleted file mode 100644 index 420a7df21ed..00000000000 --- a/samples/client/petstore/go/swagger/ApiClient.go +++ /dev/null @@ -1,33 +0,0 @@ -package swagger - -import ( -// "encoding/json" - "os" -// "fmt" - "log" -// "net/url" -// napping "github.com/jmcvetta/napping" -) - -type ApiClient struct { - basePath string - logger *log.Logger -} - -func NewApiClient() *ApiClient { - return &ApiClient { - basePath: "http://petstore.swagger.io/v2", - logger: log.New(os.Stderr, "", log.LstdFlags)} -} - -func NewApiClientWithBasePath(basePath string) *ApiClient { - return &ApiClient { - basePath: basePath, - logger: log.New(os.Stderr, "", log.LstdFlags)} -} - - -func (a *ApiClient) CallApi(basePath string, path string, httpMethod string, queryParams map[string]string, headerParams map[string]string, formParams map[string]string, fileParams map[string]string, bodyParams map[string]string, contentType []string) { - a.logger.Printf("Requesting %v\n%v\n%v\n%v\n%v\n%v\n%v\n%v\n%v\n", basePath, path, httpMethod, queryParams, headerParams, formParams, fileParams, bodyParams, contentType) - -} diff --git a/samples/client/petstore/go/swagger/PetApi.go b/samples/client/petstore/go/swagger/PetApi.go index a4ed5033d57..51b32061e0f 100644 --- a/samples/client/petstore/go/swagger/PetApi.go +++ b/samples/client/petstore/go/swagger/PetApi.go @@ -1,18 +1,14 @@ package swagger import ( -// "encoding/json" "strings" "fmt" -// "log" "github.com/dghubble/sling" "os" ) type PetApi struct { basePath string - apiClient ApiClient - //sling *sling.Sling } func NewPetApi() *PetApi{ @@ -264,6 +260,35 @@ func (a PetApi) DeletePet (PetId int64, ApiKey string) (error) { //fmt.Println("DeletePet response: void, ", resp, err) return err } +/** + * downloads an image + * + * @return *os.File + */ +//func (a PetApi) DownloadFile () (*os.File, error) { +func (a PetApi) DownloadFile () (*os.File, error) { + + _sling := sling.New().Get(a.basePath) + + // create path and map variables + path := "/v2/pet/{petId}/downloadImage" + + _sling = _sling.Path(path) + + // accept header + accepts := []string { "application/octet-stream" } + for key := range accepts { + _sling = _sling.Set("Accept", accepts[key]) + break // only use the first Accept + } + + + + response := new(*os.File) + _, err := _sling.ReceiveSuccess(response) + //fmt.Println("DownloadFile response: ", response, resp, err) + return *response, err +} /** * uploads an image * diff --git a/samples/client/petstore/go/swagger/StoreApi.go b/samples/client/petstore/go/swagger/StoreApi.go index 4af27d02b7a..c43d320077c 100644 --- a/samples/client/petstore/go/swagger/StoreApi.go +++ b/samples/client/petstore/go/swagger/StoreApi.go @@ -1,17 +1,13 @@ package swagger import ( -// "encoding/json" "strings" "fmt" -// "log" "github.com/dghubble/sling" ) type StoreApi struct { basePath string - apiClient ApiClient - //sling *sling.Sling } func NewStoreApi() *StoreApi{ diff --git a/samples/client/petstore/go/swagger/UserApi.go b/samples/client/petstore/go/swagger/UserApi.go index c5da3c81b6d..9907453bd39 100644 --- a/samples/client/petstore/go/swagger/UserApi.go +++ b/samples/client/petstore/go/swagger/UserApi.go @@ -1,17 +1,13 @@ package swagger import ( -// "encoding/json" "strings" "fmt" -// "log" "github.com/dghubble/sling" ) type UserApi struct { basePath string - apiClient ApiClient - //sling *sling.Sling } func NewUserApi() *UserApi{ From 25b60a194ba7f819ad7765406b32eb3c7da823ff Mon Sep 17 00:00:00 2001 From: wing328 Date: Fri, 22 Jan 2016 17:21:51 +0800 Subject: [PATCH 7/8] add sh script for go, add binary mapping for go, fix format --- bin/go-petstore.sh | 31 +++++++++++++++++++ bin/windows/go-petstore.bat | 10 ++++++ .../codegen/languages/GoClientCodegen.java | 5 ++- samples/client/petstore/go/README.md | 12 +++++++ 4 files changed, 57 insertions(+), 1 deletion(-) create mode 100755 bin/go-petstore.sh create mode 100755 bin/windows/go-petstore.bat create mode 100644 samples/client/petstore/go/README.md diff --git a/bin/go-petstore.sh b/bin/go-petstore.sh new file mode 100755 index 00000000000..239f31f0d71 --- /dev/null +++ b/bin/go-petstore.sh @@ -0,0 +1,31 @@ +#!/bin/sh + +SCRIPT="$0" + +while [ -h "$SCRIPT" ] ; do + ls=`ls -ld "$SCRIPT"` + link=`expr "$ls" : '.*-> \(.*\)$'` + if expr "$link" : '/.*' > /dev/null; then + SCRIPT="$link" + else + SCRIPT=`dirname "$SCRIPT"`/"$link" + fi +done + +if [ ! -d "${APP_DIR}" ]; then + APP_DIR=`dirname "$SCRIPT"`/.. + APP_DIR=`cd "${APP_DIR}"; pwd` +fi + +executable="./modules/swagger-codegen-cli/target/swagger-codegen-cli.jar" + +if [ ! -f "$executable" ] +then + mvn clean package +fi + +# if you've executed sbt assembly previously it will use that instead. +export JAVA_OPTS="${JAVA_OPTS} -XX:MaxPermSize=256M -Xmx1024M -DloggerPath=conf/log4j.properties" +ags="$@ generate -t modules/swagger-codegen/src/main/resources/go -i modules/swagger-codegen/src/test/resources/2_0/petstore.json -l go -o samples/client/petstore/go" + +java $JAVA_OPTS -jar $executable $ags diff --git a/bin/windows/go-petstore.bat b/bin/windows/go-petstore.bat new file mode 100755 index 00000000000..050bfd23cc8 --- /dev/null +++ b/bin/windows/go-petstore.bat @@ -0,0 +1,10 @@ +set executable=.\modules\swagger-codegen-cli\target\swagger-codegen-cli.jar + +If Not Exist %executable% ( + mvn clean package +) + +set JAVA_OPTS=%JAVA_OPTS% -XX:MaxPermSize=256M -Xmx1024M -DloggerPath=conf/log4j.properties +set ags=generate -t modules\swagger-codegen\src\main\resources\go -i modules\swagger-codegen\src\test\resources\2_0\petstore.json -l go -o samples\client\petstore\go + +java %JAVA_OPTS% -jar %executable% %ags% diff --git a/modules/swagger-codegen/src/main/java/io/swagger/codegen/languages/GoClientCodegen.java b/modules/swagger-codegen/src/main/java/io/swagger/codegen/languages/GoClientCodegen.java index a7488983d40..6e15f373864 100644 --- a/modules/swagger-codegen/src/main/java/io/swagger/codegen/languages/GoClientCodegen.java +++ b/modules/swagger-codegen/src/main/java/io/swagger/codegen/languages/GoClientCodegen.java @@ -71,7 +71,7 @@ public class GoClientCodegen extends DefaultCodegen implements CodegenConfig { "byte") ); - instantiationTypes.clear(); + instantiationTypes.clear(); /*instantiationTypes.put("array", "GoArray"); instantiationTypes.put("map", "GoMap");*/ @@ -87,6 +87,9 @@ public class GoClientCodegen extends DefaultCodegen implements CodegenConfig { typeMapping.put("password", "string"); typeMapping.put("File", "*os.File"); typeMapping.put("file", "*os.File"); + // map binary to string as a workaround + // the correct solution is to use []byte + typeMapping.put("binary", "string"); importMapping = new HashMap(); importMapping.put("time.Time", "time"); diff --git a/samples/client/petstore/go/README.md b/samples/client/petstore/go/README.md new file mode 100644 index 00000000000..7ce753fba9f --- /dev/null +++ b/samples/client/petstore/go/README.md @@ -0,0 +1,12 @@ +# Go API client for swagger + +## Overview +This API client was generated by the [swagger-codegen](https://github.com/swagger-api/swagger-codegen) project. By using the [swagger-spec](https://github.com/swagger-api/swagger-spec) from a remote server, you can easily generate an API client. + + +## Installation +Put the package under your project folder and add the following in import: +``` + "./swagger" +``` + From 20e531d6dd0a8ed71d1b8cab62ad869f56f700bc Mon Sep 17 00:00:00 2001 From: wing328 Date: Fri, 22 Jan 2016 17:27:30 +0800 Subject: [PATCH 8/8] update test case, add beta to go help --- .../main/java/io/swagger/codegen/languages/GoClientCodegen.java | 2 +- samples/client/petstore/go/test.go | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/modules/swagger-codegen/src/main/java/io/swagger/codegen/languages/GoClientCodegen.java b/modules/swagger-codegen/src/main/java/io/swagger/codegen/languages/GoClientCodegen.java index 6e15f373864..9e1c072cdb4 100644 --- a/modules/swagger-codegen/src/main/java/io/swagger/codegen/languages/GoClientCodegen.java +++ b/modules/swagger-codegen/src/main/java/io/swagger/codegen/languages/GoClientCodegen.java @@ -28,7 +28,7 @@ public class GoClientCodegen extends DefaultCodegen implements CodegenConfig { } public String getHelp() { - return "Generates a Go client library."; + return "Generates a Go client library (beta)."; } public GoClientCodegen() { diff --git a/samples/client/petstore/go/test.go b/samples/client/petstore/go/test.go index a2f72ca9ef3..d65e70575fc 100644 --- a/samples/client/petstore/go/test.go +++ b/samples/client/petstore/go/test.go @@ -22,7 +22,7 @@ func main() { s.UpdatePetWithForm("12830", "golang", "available") // test GET - resp, err := s.GetPetById(3) + resp, err := s.GetPetById(12830) fmt.Println("GetPetById: ", resp, err) }