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  }