opms_backend/opms_parent/swaggerui/swagger.go

package main

import (
	"flag"
	"fmt"
	"go/ast"
	"go/parser"
	"go/token"
	"go/types"
	"io"
	"log"
	"os"
	"reflect"
	"strconv"
	"strings"

	"golang.org/x/tools/go/ast/astutil"
	"golang.org/x/tools/go/packages"
	"gopkg.in/yaml.v3"
)

var swagger = map[string]interface{}{
	"openapi": "3.0.0",
	"info": map[string]string{
		"title":       "CRM",
		"description": "CRM",
		"version":     "0.0.1",
	},
	"paths": map[string]interface{}{},
	"security": []map[string]interface{}{
		{
			"bearerAuth": []interface{}{},
		},
	},
	"components": map[string]interface{}{
		"securitySchemes": map[string]interface{}{
			"basicAuth": map[string]interface{}{
				"type":   "http",
				"scheme": "basic",
			},
			"bearerAuth": map[string]interface{}{
				"type":   "http",
				"scheme": "bearer",
			},
		},
		"schemas": map[string]interface{}{},
		"examples": map[string]interface{}{
			"success": map[string]interface{}{
				"summary": "请求成功",
				"value": map[string]interface{}{
					"code": 200,
					"msg":  "success",
				},
			},
		},
	},
}

type pathModel struct {
	OperationId string
	Summary     string
	Tags        []string
	Request     string
}

func newPath(m pathModel) interface{} {
	schemaref := fmt.Sprintf("#/components/schemas/%s", m.Request)
	examplesref := fmt.Sprintf("#/components/examples/%s", m.Request)
	return map[string]interface{}{
		"post": map[string]interface{}{
			"tags":        m.Tags,
			"operationId": m.OperationId,
			"summary":     m.Summary,
			"requestBody": map[string]interface{}{
				"required": true,
				"content": map[string]interface{}{
					"application/json": map[string]interface{}{
						"schema": map[string]interface{}{
							"oneOf": []map[string]interface{}{
								{
									"$ref": schemaref,
								},
							},
						},
						"examples": map[string]interface{}{
							m.Request: map[string]interface{}{
								"$ref": examplesref,
							},
						},
					},
				},
				"responses": map[string]interface{}{
					"200": map[string]interface{}{
						"description": "请求成功",
						"content": map[string]interface{}{
							"application/json": map[string]interface{}{
								"examples": map[string]interface{}{
									"success": map[string]interface{}{
										"$ref": "#/components/examples/success",
									},
								},
							},
						},
					},
				},
			},
		},
	}
}

func testGoParser() error {
	sourceFile, err := os.Open("/home/lai/code/working/opms_backend/opms_parent/app/handler/contract/ctr_contract.go")
	if err != nil {
		return err
	}
	sourceContent, err := io.ReadAll(sourceFile)
	if err != nil {
		return err
	}

	// Create the AST by parsing src.
	fset := token.NewFileSet() // positions are relative to fset
	f, err := parser.ParseFile(fset, "", sourceContent, parser.ParseComments)
	if err != nil {
		panic(err)
	}

	// Print the imports from the file's AST.
	for _, s := range f.Imports {
		debugLog(s.Path.Value)
		fmt.Printf("%#v\n", s.Path)
	}
	debugLog("-----------------------")
	if Debug {
		ast.Print(fset, f)
	}
	debugLog("-----------------------")
	for _, c := range f.Comments {
		for _, l := range c.List {
			fmt.Printf("%#v%#v\n", l.Text, l.Slash)
		}
	}
	return nil
}

type SwaggerModel struct {
	Type        string                   `yaml:"type"`
	Description string                   `yaml:"description"`
	Properties  map[string]*SwaggerModel `yaml:"properties,omitempty"`
	Items       *SwaggerModel            `yaml:"items,omitempty"`
	Ref         string                   `yaml:"ref,omitempty"`
}

func RangeSwaggerModel(node *SwaggerModel) []*SwaggerModel {
	if node == nil {
		return nil
	}
	allnode := []*SwaggerModel{}
	nodes := []*SwaggerModel{node}
	for len(nodes) != 0 {
		newnode := []*SwaggerModel{}
		for _, n := range nodes {
			allnode = append(allnode, n)
			if n.Items != nil {
				newnode = append(newnode, n.Items)
			}
			for _, p := range n.Properties {
				newnode = append(newnode, p)
			}
		}
		nodes = newnode
	}
	return allnode
}

const pkgLoadMode = packages.NeedName | packages.NeedFiles | packages.NeedImports | packages.NeedDeps | packages.NeedTypes | packages.NeedSyntax | packages.NeedTypesInfo

var AllPackages = map[string]*packages.Package{}
var Models = map[*ast.Ident]*entityDecl{}
var AllStructModel = map[string]*SwaggerModel{}
var AllSwaggerModel = map[string]*SwaggerModel{}
var SpecifiedSwaggerModel = []map[string]string{}
var Routes = map[string]pathModel{}

type entityDecl struct {
	Type *types.Named
	File *ast.File
	Pkg  *packages.Package
}

var outfile string

func init() {
	flag.StringVar(&outfile, "o", "swagger.yml", "output file")
}

func main() {
	// testGoParser()
	// return
	flag.Parse()
	toload := []string{"dashoo.cn/micro/app/model/contract", "dashoo.cn/micro/app/handler/contract"}
	cfg := &packages.Config{Mode: pkgLoadMode}
	pkgs, err := packages.Load(cfg, toload...)
	if err != nil {
		fmt.Fprintf(os.Stderr, "load: %v\n", err)
		os.Exit(1)
	}
	if packages.PrintErrors(pkgs) > 0 {
		os.Exit(1)
	}

	for _, pkg := range pkgs {
		AllPackages[pkg.PkgPath] = pkg
		for _, file := range pkg.Syntax {
			for _, dt := range file.Decls {
				switch fd := dt.(type) {
				case *ast.GenDecl:
					for _, sp := range fd.Specs {
						switch ts := sp.(type) {
						case *ast.TypeSpec:
							def, ok := pkg.TypesInfo.Defs[ts.Name]
							if !ok {
								debugLog("couldn't find type info for %s", ts.Name)
								continue
							}
							nt, isNamed := def.Type().(*types.Named)
							if !isNamed {
								debugLog("%s is not a named type but a %T", ts.Name, def.Type())
								continue
							}
							key := ts.Name
							Models[key] = &entityDecl{
								Type: nt,
								File: file,
								Pkg:  pkg,
							}
						}
					}
				}
			}

		}
	}
	// Print the names of the source files
	// for each package listed on the command line.
	for _, pkg := range pkgs {
		debugLog("-----------%s", pkg.Name)
		for _, f := range pkg.Syntax {
			detectModels(pkg, f)
		}
	}

	for n := range AllStructModel {
		m := AllStructModel[n]
		if m == nil {
			continue
		}
		// fmt.Println(m.Ref, AllStructModel[m.Ref])
		for _, subm := range RangeSwaggerModel(m) {
			if subm.Ref != "" && AllStructModel[subm.Ref] != nil {
				subm.Items = AllStructModel[subm.Ref].Items
				subm.Properties = AllStructModel[subm.Ref].Properties
			}
		}

		// b, err := yaml.Marshal(m)
		// if err != nil {
		// 	panic(err)
		// }
		// fmt.Println(n)
		// fmt.Println(string(b))
	}
	genconfig(outfile)
}

func genconfig(filename string) {
	f, err := os.Create(filename)
	if err != nil {
		panic(err)
	}
	defer f.Close()

	for n := range AllStructModel {
		m := AllStructModel[n]
		if m == nil {
			continue
		}
		namelist := strings.Split(n, ".")
		name := namelist[len(namelist)-1]

		swagger["components"].(map[string]interface{})["schemas"].(map[string]interface{})[name] = m
		swagger["components"].(map[string]interface{})["examples"].(map[string]interface{})[name] = map[string]interface{}{
			"value": map[string]interface{}{
				"placeholder": "",
			},
		}
	}

	for p, m := range Routes {
		swagger["paths"].(map[string]interface{})[p] = newPath(m)
	}

	encoder := yaml.NewEncoder(f)
	encoder.SetIndent(2)
	err = encoder.Encode(swagger)
	if err != nil {
		panic(err)
	}
}

func getFuncRecv(fd *ast.FuncDecl) string {
	defer func() {
		if r := recover(); r != nil {
			debugLog("%s", r)
		}
	}()

	return fd.Recv.List[0].Type.(*ast.StarExpr).X.(*ast.Ident).Name
}

func getFuncParams(fd *ast.FuncDecl) string {
	defer func() {
		if r := recover(); r != nil {
			debugLog("%s", r)
		}
	}()

	return fd.Type.Params.List[1].Type.(*ast.StarExpr).X.(*ast.SelectorExpr).Sel.Name
}

func detectPath(fd *ast.FuncDecl) {
	recv := getFuncRecv(fd)
	fname := fd.Name.String()
	req := getFuncParams(fd)
	debugLog("//////////%v %s %s %s %s", fd, fname, recv, req, fd.Doc.Text())
	commentText := fd.Doc.Text()
	for _, c := range strings.Split(commentText, "\n") {
		if !strings.HasPrefix(c, "swagger:route") {
			continue
		}
		names := strings.Split(c, " ")
		tags := []string{}
		summary := ""
		if len(names) == 3 {
			tags = strings.Split(names[1], ",")
			summary = names[2]
		}
		path := fmt.Sprintf("/%s.%s", recv, fname)
		operationId := recv + fname
		Routes[path] = pathModel{
			OperationId: operationId,
			Summary:     summary,
			Tags:        tags,
			Request:     req,
		}
		break
	}
}

func detectModels(pkg *packages.Package, file *ast.File) {
	for _, dt := range file.Decls {
		switch fd := dt.(type) {
		case *ast.BadDecl:
			continue
		case *ast.FuncDecl:
			detectPath(fd)
		case *ast.GenDecl:
			processDecl(pkg, file, fd)
		}
	}
}

func processDecl(pkg *packages.Package, file *ast.File, gd *ast.GenDecl) error {
	for _, sp := range gd.Specs {
		switch ts := sp.(type) {
		case *ast.ValueSpec:
			return nil
		case *ast.ImportSpec:
			return nil
		case *ast.TypeSpec:
			def, ok := pkg.TypesInfo.Defs[ts.Name]
			if !ok {
				debugLog("couldn't find type info for %s", ts.Name)
				continue
			}
			nt, isNamed := def.Type().(*types.Named)
			if !isNamed {
				debugLog("%s is not a named type but a %T", ts.Name, def.Type())
				continue
			}

			comments := ts.Doc // type ( /* doc */ Foo struct{} )
			if comments == nil {
				comments = gd.Doc // /* doc */  type ( Foo struct{} )
			}

			// decl := &entityDecl{
			// 	Comments: comments,
			// 	Type:     nt,
			// 	Ident:    ts.Name,
			// 	Spec:     ts,
			// 	File:     file,
			// 	Pkg:      pkg,
			// }
			// key := ts.Name
			// if n&modelNode != 0 && decl.HasModelAnnotation() {
			// 	a.Models[key] = decl
			// }
			// if n&parametersNode != 0 && decl.HasParameterAnnotation() {
			// 	a.Parameters = append(a.Parameters, decl)
			// }
			// if n&responseNode != 0 && decl.HasResponseAnnotation() {
			// 	a.Responses = append(a.Responses, decl)
			// }

			switch tpe := nt.Obj().Type().(type) {
			case *types.Struct:
				st := tpe
				for i := 0; i < st.NumFields(); i++ {
					fld := st.Field(i)
					if !fld.Anonymous() {
						debugLog("skipping field %q for allOf scan because not anonymous\n", fld.Name())
						continue
					}
					tg := st.Tag(i)
					debugLog(fld.Name(), tg)
				}
			case *types.Slice:
				debugLog("Slice")
			case *types.Basic:
				debugLog("Basic")
			case *types.Interface:
				debugLog("Interface")
			case *types.Array:
				debugLog("Array")
			case *types.Map:
				debugLog("Map")
			case *types.Named:
				debugLog("Named")
				o := tpe.Obj()
				if o != nil {
					debugLog("got the named type object: %s.%s | isAlias: %t | exported: %t //////////// %s", o.Pkg().Path(), o.Name(), o.IsAlias(), o.Exported(), comments.Text())
					if o.Pkg().Name() == "time" && o.Name() == "Time" {
						// schema.Typed("string", "date-time")
						return nil
					}

					for {
						ti := pkg.TypesInfo.Types[ts.Type]
						if ti.IsBuiltin() {
							break
						}
						if ti.IsType() {
							err, ret := buildFromType(ti.Type, file, comments.Text())
							if err != nil {
								return err
							}
							AllStructModel[fmt.Sprintf("%s.%s", o.Pkg().Path(), o.Name())] = ret
							break
						}
					}
				}
			}

		}
	}
	return nil
}

func buildFromType(tpe types.Type, declFile *ast.File, desc string) (error, *SwaggerModel) {
	switch titpe := tpe.(type) {
	case *types.Basic:
		return nil, &SwaggerModel{
			Type:        swaggerSchemaForType(titpe.String()),
			Description: desc,
		}
	case *types.Pointer:
		return buildFromType(titpe.Elem(), declFile, desc)
	case *types.Struct:
		return buildFromStruct(declFile, titpe, desc)
	case *types.Slice:
		err, ret := buildFromType(titpe.Elem(), declFile, desc)
		if err != nil {
			return err, nil
		}
		return nil, &SwaggerModel{
			Type:        "array",
			Items:       ret,
			Description: desc,
		}
	case *types.Named:
		tio := titpe.Obj()
		debugLog("%s", tio)
		if tio.Pkg() == nil && tio.Name() == "error" {
			return nil, &SwaggerModel{
				Type:        swaggerSchemaForType(tio.Name()),
				Description: desc,
			}
		}
		if tpe.String() == "github.com/gogf/gf/os/gtime.Time" {
			return nil, &SwaggerModel{
				Type:        "string",
				Description: desc + "DATETIME",
			}
		}

		debugLog("named refined type %s.%s", tio.Pkg().Path(), tio.Name())
		pkg, found := PkgForType(tpe)
		if !found {
			// this must be a builtin
			debugLog("skipping because package is nil: %s", tpe.String())
			return nil, nil
		}
		if pkg.Name == "time" && tio.Name() == "Time" {
			return nil, &SwaggerModel{
				Type:        "string",
				Description: desc,
			}
		}

		switch utitpe := tpe.Underlying().(type) {
		case *types.Struct:
			if decl, ok := FindModel(tio.Pkg().Path(), tio.Name()); ok {
				if decl.Type.Obj().Pkg().Path() == "time" && decl.Type.Obj().Name() == "Time" {
					return nil, &SwaggerModel{
						Type:        "string",
						Description: desc,
					}
				}

				debugLog("!!!!!!!%s", decl.Type.String())
				return nil, &SwaggerModel{
					Type: "object",
					Ref:  decl.Type.String(),
				}
			}
		case *types.Slice:
			debugLog("!!!!!!!slice %s", utitpe.Elem())

			// decl, ok := FindModel(tio.Pkg().Path(), tio.Name())
			// return buildFromType(utitpe.Elem(), tgt.Items())

		}

	default:
		panic(fmt.Sprintf("WARNING: can't determine refined type %s (%T)", titpe.String(), titpe))
	}

	return nil, nil
}

func buildFromStruct(declFile *ast.File, st *types.Struct, desc string) (error, *SwaggerModel) {
	// for i := 0; i < st.NumFields(); i++ {
	// 	fld := st.Field(i)
	// 	if !fld.Anonymous() {
	// 		debugLog("skipping field %q for allOf scan because not anonymous", fld.Name())
	// 		continue
	// 	}
	// 	tg := st.Tag(i)

	// 	debugLog("maybe allof field(%t) %s: %s (%T) [%q](anon: %t, embedded: %t)", fld.IsField(), fld.Name(), fld.Type().String(), fld.Type(), tg, fld.Anonymous(), fld.Embedded())
	// 	var afld *ast.Field
	// 	ans, _ := astutil.PathEnclosingInterval(declFile, fld.Pos(), fld.Pos())
	// 	// debugLog("got %d nodes (exact: %t)", len(ans), isExact)
	// 	for _, an := range ans {
	// 		at, valid := an.(*ast.Field)
	// 		if !valid {
	// 			continue
	// 		}

	// 		debugLog("maybe allof field %s: %s(%T) [%q]", fld.Name(), fld.Type().String(), fld.Type(), tg)
	// 		afld = at
	// 		break
	// 	}

	// 	if afld == nil {
	// 		debugLog("can't find source associated with %s for %s", fld.String(), st.String())
	// 		continue
	// 	}

	// 	_, ignore, _, err := parseJSONTag(afld)
	// 	if err != nil {
	// 		return err
	// 	}
	// 	if ignore {
	// 		continue
	// 	}
	// }

	properties := map[string]*SwaggerModel{}
	for i := 0; i < st.NumFields(); i++ {
		fld := st.Field(i)
		tg := st.Tag(i)

		if fld.Embedded() {
			if fld.Name() == "PageReq" {
				properties["beginTime"] = &SwaggerModel{Type: "string", Description: "开始时间"}
				properties["endTime"] = &SwaggerModel{Type: "string", Description: "结束时间"}
				properties["pageNum"] = &SwaggerModel{Type: "int", Description: "当前页码"}
				properties["pageSize"] = &SwaggerModel{Type: "int", Description: "每页数"}
				properties["orderBy"] = &SwaggerModel{Type: "string", Description: "排序方式"}
			}
			debugLog("Embedded %s, %s", fld.Name(), fld.Pkg())
			continue
		}

		if !fld.Exported() {
			debugLog("skipping field %s because it's not exported", fld.Name())
			continue
		}

		var afld *ast.Field
		ans, _ := astutil.PathEnclosingInterval(declFile, fld.Pos(), fld.Pos())
		// debugLog("got %d nodes (exact: %t)", len(ans), isExact)
		for _, an := range ans {
			at, valid := an.(*ast.Field)
			if !valid {
				continue
			}

			debugLog("field %s: %s(%T) [%q] ==> %s", fld.Name(), fld.Type().String(), fld.Type(), tg, at.Doc.Text())
			afld = at
			break
		}

		if afld == nil {
			debugLog("can't find source associated with %s", fld.String())
			continue
		}

		name, _, isString, err := parseJSONTag(afld)
		if err != nil {
			return err, nil
		}
		commentText := ""
		if afld.Comment != nil {
			commentText = afld.Comment.Text()
		}
		err, ret := buildFromType(fld.Type(), declFile, commentText)
		if err != nil {
			return err, nil
		}
		debugLog("****** %s %v %s", fld.Type(), ret, commentText)
		if isString {
			return nil, &SwaggerModel{
				Type:        "string",
				Description: desc,
			}
		}
		properties[name] = ret
	}
	return nil, &SwaggerModel{
		Type:        "object",
		Properties:  properties,
		Description: desc,
	}
}

func swaggerSchemaForType(typeName string) string {
	switch typeName {
	case "bool":
		return "boolean"
	case "byte":
		return "integer"
	case "float32":
		return "number"
	case "float64":
		return "number"
	case "int":
		return "integer"
	case "int16":
		return "integer"
	case "int32":
		return "integer"
	case "int64":
		return "integer"
	case "int8":
		return "integer"
	case "rune":
		return "integer"
	case "string":
		return "string"
	case "uint":
		return "integer"
	case "uint16":
		return "integer"
	case "uint32":
		return "integer"
	case "uint64":
		return "integer"
	case "uint8":
		return "integer"
	}
	return ""
}

func FindModel(pkgPath, name string) (*entityDecl, bool) {
	for _, cand := range Models {
		ct := cand.Type.Obj()
		if ct.Name() == name && ct.Pkg().Path() == pkgPath {
			return cand, true
		}
	}
	return nil, false
}

func PkgForType(t types.Type) (*packages.Package, bool) {
	switch tpe := t.(type) {
	// case *types.Basic:
	// case *types.Struct:
	// case *types.Pointer:
	// case *types.Interface:
	// case *types.Array:
	// case *types.Slice:
	// case *types.Map:
	case *types.Named:
		v, ok := AllPackages[tpe.Obj().Pkg().Path()]
		return v, ok
	default:
		log.Printf("unknown type to find the package for [%T]: %s", t, t.String())
		return nil, false
	}
}

func parseJSONTag(field *ast.Field) (name string, ignore bool, isString bool, err error) {
	if len(field.Names) > 0 {
		name = field.Names[0].Name
	}
	if field.Tag == nil || len(strings.TrimSpace(field.Tag.Value)) == 0 {
		return name, false, false, nil
	}

	tv, err := strconv.Unquote(field.Tag.Value)
	if err != nil {
		return name, false, false, err
	}

	if strings.TrimSpace(tv) != "" {
		st := reflect.StructTag(tv)
		jsonParts := tagOptions(strings.Split(st.Get("json"), ","))

		if jsonParts.Contain("string") {
			// Need to check if the field type is a scalar. Otherwise, the
			// ",string" directive doesn't apply.
			isString = isFieldStringable(field.Type)
		}

		switch jsonParts.Name() {
		case "-":
			return name, true, isString, nil
		case "":
			return name, false, isString, nil
		default:
			return jsonParts.Name(), false, isString, nil
		}
	}
	return name, false, false, nil
}

func isFieldStringable(tpe ast.Expr) bool {
	if ident, ok := tpe.(*ast.Ident); ok {
		switch ident.Name {
		case "int", "int8", "int16", "int32", "int64",
			"uint", "uint8", "uint16", "uint32", "uint64",
			"float64", "string", "bool":
			return true
		}
	} else if starExpr, ok := tpe.(*ast.StarExpr); ok {
		return isFieldStringable(starExpr.X)
	} else {
		return false
	}
	return false
}

type tagOptions []string

func (t tagOptions) Contain(option string) bool {
	for i := 1; i < len(t); i++ {
		if t[i] == option {
			return true
		}
	}
	return false
}

func (t tagOptions) Name() string {
	return t[0]
}

var Debug = false

func debugLog(format string, args ...interface{}) {
	if Debug {
		log.Printf(format, args...)
	}
}