github.com/johnnyeven/libtools@v0.0.0-20191126065708-61829c1adf46/courier/client/gen/common/client_set.go (about)

     1  package common
     2  
     3  import (
     4  	"bytes"
     5  	"fmt"
     6  	"io"
     7  	"sort"
     8  
     9  	"github.com/johnnyeven/libtools/codegen"
    10  )
    11  
    12  func NewClientSet(baseClient, name string) *ClientSet {
    13  	return &ClientSet{
    14  		BaseClient: baseClient,
    15  		Name:       codegen.ToLowerLinkCase(name),
    16  		PkgName:    codegen.ToLowerSnakeCase("Client-" + name),
    17  		ClientName: codegen.ToUpperCamelCase("Client-" + name),
    18  		Ops:        map[string]Op{},
    19  		Importer:   &codegen.Importer{},
    20  	}
    21  }
    22  
    23  type ClientSet struct {
    24  	BaseClient string
    25  	Name       string
    26  	PkgName    string
    27  	ClientName string
    28  	Ops        map[string]Op
    29  	Importer   *codegen.Importer
    30  }
    31  
    32  func (c *ClientSet) AddOp(op Op) {
    33  	if op != nil {
    34  		c.Ops[op.ID()] = op
    35  	}
    36  }
    37  
    38  func (c *ClientSet) WriteAll(w io.Writer) {
    39  	c.WriteTypeInterface(w)
    40  	c.WriteTypeClient(w)
    41  	c.WriteOperations(w)
    42  }
    43  func (c *ClientSet) WriteTypeInterface(w io.Writer) {
    44  	keys := make([]string, 0)
    45  	for key := range c.Ops {
    46  		if key == "Swagger" {
    47  			continue
    48  		}
    49  		keys = append(keys, key)
    50  	}
    51  	sort.Strings(keys)
    52  
    53  	io.WriteString(w, `type `+c.ClientName+`Interface interface {
    54  `)
    55  
    56  	for _, key := range keys {
    57  		op := c.Ops[key]
    58  
    59  		reqVar := ""
    60  		reqType := ""
    61  		reqTypeInParams := ""
    62  
    63  		if op.HasRequest() {
    64  			reqVar = "req"
    65  			reqType = RequestOf(op.ID())
    66  			reqTypeInParams = reqType + ", "
    67  		}
    68  
    69  		interfaceMethod := op.ID() + `(` + reqVar + ` ` + reqTypeInParams + `metas... ` + c.Importer.Use("github.com/johnnyeven/libtools/courier.Metadata") + `) (resp *` + ResponseOf(op.ID()) + `, err error)
    70  `
    71  
    72  		io.WriteString(w, interfaceMethod)
    73  	}
    74  
    75  	io.WriteString(w, `}
    76  `)
    77  }
    78  
    79  func (c *ClientSet) WriteOperations(w io.Writer) {
    80  	keys := make([]string, 0)
    81  	for key := range c.Ops {
    82  		keys = append(keys, key)
    83  	}
    84  	sort.Strings(keys)
    85  
    86  	for _, key := range keys {
    87  		op := c.Ops[key]
    88  
    89  		reqVar := ""
    90  		reqType := ""
    91  		reqTypeInParams := ""
    92  		reqVarInUse := "nil"
    93  
    94  		if op.HasRequest() {
    95  			reqVar = "req"
    96  			reqVarInUse = reqVar
    97  			reqType = RequestOf(op.ID())
    98  			reqTypeInParams = reqType + ", "
    99  
   100  			io.WriteString(w, `
   101  type `+reqType+" ")
   102  			op.WriteReqType(w, c.Importer)
   103  		}
   104  
   105  		interfaceMethod := op.ID() + `(` + reqVar + ` ` + reqTypeInParams + `metas... ` + c.Importer.Use("github.com/johnnyeven/libtools/courier.Metadata") + `) (resp *` + ResponseOf(op.ID()) + `, err error)`
   106  
   107  		io.WriteString(w, `
   108  func (c `+c.ClientName+`) `+interfaceMethod+` {
   109  	resp = &`+ResponseOf(op.ID())+`{}
   110  	resp.Meta = `+c.Importer.Use("github.com/johnnyeven/libtools/courier.Metadata")+`{}
   111  
   112  	err = c.Request(c.Name + ".`+op.ID()+`", "`+op.Method()+`", "`+op.Path()+`", `+reqVarInUse+`, metas...).
   113  		Do().
   114  		BindMeta(resp.Meta).
   115  		Into(&resp.Body)
   116  
   117  	return
   118  }
   119  `)
   120  
   121  		io.WriteString(w, `
   122  type `+ResponseOf(op.ID())+`  struct {
   123  	Meta `+c.Importer.Use("github.com/johnnyeven/libtools/courier.Metadata")+`
   124  	Body `)
   125  		op.WriteRespBodyType(w, c.Importer)
   126  		io.WriteString(w, `
   127  }
   128  `)
   129  
   130  	}
   131  }
   132  
   133  func (c *ClientSet) WriteTypeClient(w io.Writer) {
   134  	io.WriteString(w, `
   135  type `+c.ClientName+` struct {
   136  	`+c.Importer.Use(c.BaseClient)+`
   137  }
   138  
   139  func (`+c.ClientName+`) MarshalDefaults(v interface{}) {
   140  	if cl, ok := v.(* `+c.ClientName+`); ok {
   141  		cl.Name = "`+c.Name+`"
   142  		cl.Client.MarshalDefaults(&cl.Client)
   143  	}
   144  }
   145  
   146  func (c  `+c.ClientName+`) Init() {
   147  	c.CheckService()
   148  }
   149  
   150  func (c  `+c.ClientName+`) CheckService() {
   151  	err := c.Request(c.Name+".Check", "HEAD", "/", nil).
   152  		Do().
   153  		Into(nil)
   154  	statusErr := `+c.Importer.Use("github.com/johnnyeven/libtools/courier/status_error.FromError")+`(err)
   155  	if statusErr.Code == int64(`+c.Importer.Use("github.com/johnnyeven/libtools/courier/status_error.RequestTimeout")+`) {
   156  		panic(fmt.Errorf("service %s have some error %s", c.Name, statusErr))
   157  	}
   158  }
   159  `)
   160  }
   161  
   162  func (c *ClientSet) String() string {
   163  	buf := &bytes.Buffer{}
   164  
   165  	c.WriteAll(buf)
   166  
   167  	return fmt.Sprintf(`
   168  	package %s
   169  
   170  	%s
   171  
   172  	%s
   173  	`,
   174  		c.PkgName,
   175  		c.Importer.String(),
   176  		buf.String(),
   177  	)
   178  }