github.com/artisanhe/tools@v1.0.1-0.20210607022958-19a8fef2eb04/courier/client/gen/v2/to_client.go (about) 1 package v2 2 3 import ( 4 "fmt" 5 "io" 6 "strings" 7 8 "github.com/go-openapi/spec" 9 10 "github.com/artisanhe/tools/codegen" 11 "github.com/artisanhe/tools/courier/client/gen/common" 12 "github.com/artisanhe/tools/courier/httpx" 13 "github.com/artisanhe/tools/courier/swagger/gen" 14 ) 15 16 func ToClient(baseClient string, serviceName string, swagger *spec.Swagger) string { 17 clientSet := common.NewClientSet(baseClient, serviceName) 18 19 for path, pathItem := range swagger.Paths.Paths { 20 if pathItem.PathItemProps.Get != nil { 21 clientSet.AddOp(SwaggerOperationFrom(serviceName, "GET", path, pathItem.PathItemProps.Get, swagger.Responses)) 22 } 23 if pathItem.PathItemProps.Post != nil { 24 clientSet.AddOp(SwaggerOperationFrom(serviceName, "POST", path, pathItem.PathItemProps.Post, swagger.Responses)) 25 } 26 if pathItem.PathItemProps.Put != nil { 27 clientSet.AddOp(SwaggerOperationFrom(serviceName, "PUT", path, pathItem.PathItemProps.Put, swagger.Responses)) 28 } 29 if pathItem.PathItemProps.Delete != nil { 30 clientSet.AddOp(SwaggerOperationFrom(serviceName, "DELETE", path, pathItem.PathItemProps.Delete, swagger.Responses)) 31 } 32 if pathItem.PathItemProps.Head != nil { 33 clientSet.AddOp(SwaggerOperationFrom(serviceName, "HEAD", path, pathItem.PathItemProps.Head, swagger.Responses)) 34 } 35 if pathItem.PathItemProps.Patch != nil { 36 clientSet.AddOp(SwaggerOperationFrom(serviceName, "PATCH", path, pathItem.PathItemProps.Patch, swagger.Responses)) 37 } 38 if pathItem.PathItemProps.Options != nil { 39 clientSet.AddOp(SwaggerOperationFrom(serviceName, "OPTIONS", path, pathItem.PathItemProps.Options, swagger.Responses)) 40 } 41 } 42 43 return clientSet.String() 44 } 45 46 func SwaggerOperationFrom(serviceName string, method string, path string, operation *spec.Operation, responses map[string]spec.Response) *SwaggerOperation { 47 return &SwaggerOperation{ 48 serviceName: serviceName, 49 method: method, 50 path: path, 51 Operation: operation, 52 responses: responses, 53 } 54 } 55 56 type SwaggerOperation struct { 57 serviceName string 58 method string 59 path string 60 *spec.Operation 61 responses map[string]spec.Response 62 } 63 64 var _ interface { 65 common.Op 66 } = (*SwaggerOperation)(nil) 67 68 func (op *SwaggerOperation) Method() string { 69 return op.method 70 } 71 72 func (op *SwaggerOperation) ID() string { 73 return op.Operation.ID 74 } 75 76 func (op *SwaggerOperation) Path() string { 77 return common.PathFromSwaggerPath(op.path) 78 } 79 80 func (op *SwaggerOperation) HasRequest() bool { 81 return len(op.Operation.Parameters) > 0 82 } 83 84 func (op *SwaggerOperation) WriteReqType(w io.Writer, importer *codegen.Importer) { 85 io.WriteString(w, `struct { 86 `) 87 88 for _, parameter := range op.Parameters { 89 fieldName := codegen.ToUpperCamelCase(parameter.Name) 90 if parameter.Extensions[gen.XField] != nil { 91 fieldName = parameter.Extensions[gen.XField].(string) 92 } 93 94 field := common.NewField(fieldName) 95 field.AddTag("in", parameter.In) 96 97 tagName := parameter.Name 98 if parameter.Extensions[gen.XTagName] != nil { 99 tagName = fmt.Sprintf("%s", parameter.Extensions[gen.XTagName]) 100 } 101 flags := make([]string, 0) 102 if !parameter.Required && !strings.Contains(tagName, "omitempty") { 103 flags = append(flags, "omitempty") 104 } 105 field.AddTag("name", tagName, flags...) 106 field.Comment = parameter.Description 107 108 if parameter.Extensions[gen.XTagValidate] != nil { 109 field.AddTag("validate", fmt.Sprintf("%s", parameter.Extensions[gen.XTagValidate])) 110 } 111 112 if parameter.Default != nil { 113 defaultValue := fmt.Sprintf("%v", parameter.Default) 114 field.AddTag("default", defaultValue) 115 } 116 117 if parameter.Schema != nil { 118 field.Type = NewTypeGenerator(op.serviceName, importer).Type(parameter.Schema) 119 } else { 120 schema := spec.Schema{} 121 schema.Typed(parameter.Type, parameter.Format) 122 if parameter.Items != nil { 123 itemSchema := spec.Schema{} 124 itemSchema.Typed(parameter.Items.Type, parameter.Items.Format) 125 itemSchema.VendorExtensible = parameter.Items.VendorExtensible 126 schema.Items = &spec.SchemaOrArray{ 127 Schema: &itemSchema, 128 } 129 } 130 schema.Extensions = parameter.Extensions 131 field.Type = NewTypeGenerator(op.serviceName, importer).Type(&schema) 132 } 133 134 io.WriteString(w, field.String()) 135 } 136 137 io.WriteString(w, ` 138 } 139 `) 140 } 141 142 func (op *SwaggerOperation) WriteRespBodyType(w io.Writer, importer *codegen.Importer) { 143 respBodySchema := op.respBodySchema() 144 if respBodySchema == nil { 145 io.WriteString(w, `[]byte`) 146 return 147 } 148 io.WriteString(w, NewTypeGenerator(op.serviceName, importer).Type(respBodySchema)) 149 } 150 151 func (op *SwaggerOperation) respBodySchema() *spec.Schema { 152 if op.Responses == nil || op.Responses.StatusCodeResponses == nil { 153 return nil 154 } 155 156 var hasStringProduce = false 157 158 for _, produce := range op.Produces { 159 hasStringProduce = produce == httpx.MIMEHTML 160 } 161 162 var schema *spec.Schema 163 164 for code, r := range op.Responses.StatusCodeResponses { 165 if code >= 200 && code < 300 { 166 schema = &spec.Schema{} 167 168 if hasStringProduce { 169 schema.Typed("string", "") 170 } else { 171 schema.Typed("null", "") 172 } 173 174 if r.Ref.String() != "" && op.responses != nil { 175 if op.responses[common.RefName(r.Ref.String())].Schema != nil { 176 schema = op.responses[common.RefName(r.Ref.String())].Schema 177 } 178 } 179 180 if r.Schema != nil { 181 schema = r.Schema 182 } 183 } 184 } 185 186 return schema 187 }