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") +}