492 lines
16 KiB
Go
492 lines
16 KiB
Go
// Copyright GoFrame gf Author(https://goframe.org). All Rights Reserved.
|
|
//
|
|
// This Source Code Form is subject to the terms of the MIT License.
|
|
// If a copy of the MIT was not distributed with this file,
|
|
// You can obtain one at https://github.com/gogf/gf.
|
|
|
|
package gendao
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"sort"
|
|
"strings"
|
|
|
|
"github.com/olekukonko/tablewriter"
|
|
"github.com/olekukonko/tablewriter/renderer"
|
|
"github.com/olekukonko/tablewriter/tw"
|
|
"golang.org/x/mod/modfile"
|
|
|
|
"git.magicany.cc/black1552/gin-base/database"
|
|
"github.com/gogf/gf/v2/container/garray"
|
|
"github.com/gogf/gf/v2/container/gset"
|
|
"github.com/gogf/gf/v2/frame/g"
|
|
"github.com/gogf/gf/v2/os/gfile"
|
|
"github.com/gogf/gf/v2/os/gproc"
|
|
"github.com/gogf/gf/v2/os/gtime"
|
|
"github.com/gogf/gf/v2/os/gview"
|
|
"github.com/gogf/gf/v2/text/gregex"
|
|
"github.com/gogf/gf/v2/text/gstr"
|
|
|
|
"git.magicany.cc/black1552/gin-base/cmd/gendao/internal/utility/mlog"
|
|
"git.magicany.cc/black1552/gin-base/cmd/gendao/internal/utility/utils"
|
|
)
|
|
|
|
type (
|
|
CGenDao struct{}
|
|
CGenDaoInput struct {
|
|
g.Meta `name:"dao" config:"{CGenDaoConfig}" usage:"{CGenDaoUsage}" brief:"{CGenDaoBrief}" eg:"{CGenDaoEg}" ad:"{CGenDaoAd}"`
|
|
Path string `name:"path" short:"p" brief:"{CGenDaoBriefPath}" d:"internal"`
|
|
Link string `name:"link" short:"l" brief:"{CGenDaoBriefLink}"`
|
|
Tables string `name:"tables" short:"t" brief:"{CGenDaoBriefTables}"`
|
|
TablesEx string `name:"tablesEx" short:"x" brief:"{CGenDaoBriefTablesEx}"`
|
|
ShardingPattern []string `name:"shardingPattern" short:"sp" brief:"{CGenDaoBriefShardingPattern}"`
|
|
Group string `name:"group" short:"g" brief:"{CGenDaoBriefGroup}" d:"default"`
|
|
Prefix string `name:"prefix" short:"f" brief:"{CGenDaoBriefPrefix}"`
|
|
RemovePrefix string `name:"removePrefix" short:"r" brief:"{CGenDaoBriefRemovePrefix}"`
|
|
RemoveFieldPrefix string `name:"removeFieldPrefix" short:"rf" brief:"{CGenDaoBriefRemoveFieldPrefix}"`
|
|
JsonCase string `name:"jsonCase" short:"j" brief:"{CGenDaoBriefJsonCase}" d:"CamelLower"`
|
|
ImportPrefix string `name:"importPrefix" short:"i" brief:"{CGenDaoBriefImportPrefix}"`
|
|
DaoPath string `name:"daoPath" short:"d" brief:"{CGenDaoBriefDaoPath}" d:"dao"`
|
|
TablePath string `name:"tablePath" short:"tp" brief:"{CGenDaoBriefTablePath}" d:"table"`
|
|
DoPath string `name:"doPath" short:"o" brief:"{CGenDaoBriefDoPath}" d:"model/do"`
|
|
EntityPath string `name:"entityPath" short:"e" brief:"{CGenDaoBriefEntityPath}" d:"model/entity"`
|
|
TplDaoTablePath string `name:"tplDaoTablePath" short:"t0" brief:"{CGenDaoBriefTplDaoTablePath}"`
|
|
TplDaoIndexPath string `name:"tplDaoIndexPath" short:"t1" brief:"{CGenDaoBriefTplDaoIndexPath}"`
|
|
TplDaoInternalPath string `name:"tplDaoInternalPath" short:"t2" brief:"{CGenDaoBriefTplDaoInternalPath}"`
|
|
TplDaoDoPath string `name:"tplDaoDoPath" short:"t3" brief:"{CGenDaoBriefTplDaoDoPathPath}"`
|
|
TplDaoEntityPath string `name:"tplDaoEntityPath" short:"t4" brief:"{CGenDaoBriefTplDaoEntityPath}"`
|
|
StdTime bool `name:"stdTime" short:"s" brief:"{CGenDaoBriefStdTime}" orphan:"true"`
|
|
WithTime bool `name:"withTime" short:"w" brief:"{CGenDaoBriefWithTime}" orphan:"true"`
|
|
GJsonSupport bool `name:"gJsonSupport" short:"n" brief:"{CGenDaoBriefGJsonSupport}" orphan:"true"`
|
|
OverwriteDao bool `name:"overwriteDao" short:"v" brief:"{CGenDaoBriefOverwriteDao}" orphan:"true"`
|
|
DescriptionTag bool `name:"descriptionTag" short:"c" brief:"{CGenDaoBriefDescriptionTag}" orphan:"true"`
|
|
NoJsonTag bool `name:"noJsonTag" short:"k" brief:"{CGenDaoBriefNoJsonTag}" orphan:"true"`
|
|
NoModelComment bool `name:"noModelComment" short:"m" brief:"{CGenDaoBriefNoModelComment}" orphan:"true"`
|
|
Clear bool `name:"clear" short:"a" brief:"{CGenDaoBriefClear}" orphan:"true"`
|
|
GenTable bool `name:"genTable" short:"gt" brief:"{CGenDaoBriefGenTable}" orphan:"true"`
|
|
|
|
TypeMapping map[DBFieldTypeName]CustomAttributeType `name:"typeMapping" short:"y" brief:"{CGenDaoBriefTypeMapping}" orphan:"true"`
|
|
FieldMapping map[DBTableFieldName]CustomAttributeType `name:"fieldMapping" short:"fm" brief:"{CGenDaoBriefFieldMapping}" orphan:"true"`
|
|
|
|
// internal usage purpose.
|
|
genItems *CGenDaoInternalGenItems
|
|
}
|
|
CGenDaoOutput struct{}
|
|
|
|
CGenDaoInternalInput struct {
|
|
CGenDaoInput
|
|
DB database.DB
|
|
TableNames []string
|
|
NewTableNames []string
|
|
ShardingTableSet *gset.StrSet
|
|
}
|
|
DBTableFieldName = string
|
|
DBFieldTypeName = string
|
|
CustomAttributeType struct {
|
|
Type string `brief:"custom attribute type name"`
|
|
Import string `brief:"custom import for this type"`
|
|
}
|
|
)
|
|
|
|
var (
|
|
createdAt = gtime.Now()
|
|
tplView = gview.New()
|
|
defaultTypeMapping = map[DBFieldTypeName]CustomAttributeType{
|
|
"decimal": {
|
|
Type: "float64",
|
|
},
|
|
"money": {
|
|
Type: "float64",
|
|
},
|
|
"numeric": {
|
|
Type: "float64",
|
|
},
|
|
"smallmoney": {
|
|
Type: "float64",
|
|
},
|
|
"uuid": {
|
|
Type: "uuid.UUID",
|
|
Import: "github.com/google/uuid",
|
|
},
|
|
}
|
|
|
|
// tablewriter Options
|
|
twRenderer = tablewriter.WithRenderer(renderer.NewBlueprint(tw.Rendition{
|
|
Borders: tw.Border{Top: tw.Off, Bottom: tw.Off, Left: tw.Off, Right: tw.Off},
|
|
Settings: tw.Settings{
|
|
Separators: tw.Separators{BetweenRows: tw.Off, BetweenColumns: tw.Off},
|
|
},
|
|
Symbols: tw.NewSymbols(tw.StyleASCII),
|
|
}))
|
|
twConfig = tablewriter.WithConfig(tablewriter.Config{
|
|
Row: tw.CellConfig{
|
|
Formatting: tw.CellFormatting{AutoWrap: tw.WrapNone},
|
|
},
|
|
})
|
|
)
|
|
|
|
func (c CGenDao) Dao(ctx context.Context, in CGenDaoInput) (out *CGenDaoOutput, err error) {
|
|
in.genItems = newCGenDaoInternalGenItems()
|
|
if in.Link != "" {
|
|
doGenDaoForArray(ctx, -1, in)
|
|
} else if g.Cfg().Available(ctx) {
|
|
v := g.Cfg().MustGet(ctx, CGenDaoConfig)
|
|
if v.IsSlice() {
|
|
for i := 0; i < len(v.Interfaces()); i++ {
|
|
doGenDaoForArray(ctx, i, in)
|
|
}
|
|
} else {
|
|
doGenDaoForArray(ctx, -1, in)
|
|
}
|
|
} else {
|
|
doGenDaoForArray(ctx, -1, in)
|
|
}
|
|
doClear(in.genItems)
|
|
mlog.Print("done!")
|
|
return
|
|
}
|
|
|
|
// doGenDaoForArray implements the "gen dao" command for configuration array.
|
|
func doGenDaoForArray(ctx context.Context, index int, in CGenDaoInput) {
|
|
var (
|
|
err error
|
|
db database.DB
|
|
)
|
|
if index >= 0 {
|
|
err = g.Cfg().MustGet(
|
|
ctx,
|
|
fmt.Sprintf(`%s.%d`, CGenDaoConfig, index),
|
|
).Scan(&in)
|
|
if err != nil {
|
|
mlog.Fatalf(`invalid configuration of "%s": %+v`, CGenDaoConfig, err)
|
|
}
|
|
}
|
|
if dirRealPath := gfile.RealPath(in.Path); dirRealPath == "" {
|
|
mlog.Fatalf(`path "%s" does not exist`, in.Path)
|
|
}
|
|
removePrefixArray := gstr.SplitAndTrim(in.RemovePrefix, ",")
|
|
|
|
// It uses user passed database configuration.
|
|
if in.Link != "" {
|
|
var tempGroup = gtime.TimestampNanoStr()
|
|
err = database.AddConfigNode(tempGroup, database.ConfigNode{
|
|
Link: in.Link,
|
|
})
|
|
if err != nil {
|
|
mlog.Fatalf(`database configuration failed: %+v`, err)
|
|
}
|
|
if db, err = database.Instance(tempGroup); err != nil {
|
|
mlog.Fatalf(`database initialization failed: %+v`, err)
|
|
}
|
|
} else {
|
|
db = database.Database(in.Group)
|
|
}
|
|
if db == nil {
|
|
mlog.Fatal(`database initialization failed, may be invalid database configuration`)
|
|
}
|
|
|
|
var tableNames []string
|
|
if in.Tables != "" {
|
|
inputTables := gstr.SplitAndTrim(in.Tables, ",")
|
|
// Check if any table pattern contains wildcard characters.
|
|
// https://github.com/gogf/gf/issues/4629
|
|
var hasPattern bool
|
|
for _, t := range inputTables {
|
|
if containsWildcard(t) {
|
|
hasPattern = true
|
|
break
|
|
}
|
|
}
|
|
if hasPattern {
|
|
// Fetch all tables first, then filter by patterns.
|
|
allTables, err := db.Tables(context.TODO())
|
|
if err != nil {
|
|
mlog.Fatalf("fetching tables failed: %+v", err)
|
|
}
|
|
tableNames = filterTablesByPatterns(allTables, inputTables)
|
|
} else {
|
|
// Use exact table names as before.
|
|
tableNames = inputTables
|
|
}
|
|
} else {
|
|
tableNames, err = db.Tables(context.TODO())
|
|
if err != nil {
|
|
mlog.Fatalf("fetching tables failed: %+v", err)
|
|
}
|
|
}
|
|
// Table excluding.
|
|
if in.TablesEx != "" {
|
|
array := garray.NewStrArrayFrom(tableNames)
|
|
for _, p := range gstr.SplitAndTrim(in.TablesEx, ",") {
|
|
if containsWildcard(p) {
|
|
// Use exact match with ^ and $ anchors for consistency with tables pattern.
|
|
regPattern := "^" + patternToRegex(p) + "$"
|
|
for _, v := range array.Clone().Slice() {
|
|
if gregex.IsMatchString(regPattern, v) {
|
|
array.RemoveValue(v)
|
|
}
|
|
}
|
|
} else {
|
|
array.RemoveValue(p)
|
|
}
|
|
}
|
|
tableNames = array.Slice()
|
|
}
|
|
|
|
// merge default typeMapping to input typeMapping.
|
|
if in.TypeMapping == nil {
|
|
in.TypeMapping = defaultTypeMapping
|
|
} else {
|
|
for key, typeMapping := range defaultTypeMapping {
|
|
if _, ok := in.TypeMapping[key]; !ok {
|
|
in.TypeMapping[key] = typeMapping
|
|
}
|
|
}
|
|
}
|
|
|
|
// Generating dao & model go files one by one according to given table name.
|
|
var (
|
|
newTableNames = make([]string, len(tableNames))
|
|
shardingNewTableSet = gset.NewStrSet()
|
|
)
|
|
// Sort sharding patterns by length descending, so that longer (more specific) patterns
|
|
// are matched first. This prevents shorter patterns like "a_?" from incorrectly matching
|
|
// tables that should match longer patterns like "a_b_?" or "a_c_?".
|
|
// https://github.com/gogf/gf/issues/4603
|
|
sortedShardingPatterns := make([]string, len(in.ShardingPattern))
|
|
copy(sortedShardingPatterns, in.ShardingPattern)
|
|
sort.Slice(sortedShardingPatterns, func(i, j int) bool {
|
|
return len(sortedShardingPatterns[i]) > len(sortedShardingPatterns[j])
|
|
})
|
|
for i, tableName := range tableNames {
|
|
newTableName := tableName
|
|
for _, v := range removePrefixArray {
|
|
newTableName = gstr.TrimLeftStr(newTableName, v, 1)
|
|
}
|
|
if len(sortedShardingPatterns) > 0 {
|
|
for _, pattern := range sortedShardingPatterns {
|
|
var (
|
|
match []string
|
|
regPattern = gstr.Replace(pattern, "?", `(.+)`)
|
|
)
|
|
match, err = gregex.MatchString(regPattern, newTableName)
|
|
if err != nil {
|
|
mlog.Fatalf(`invalid sharding pattern "%s": %+v`, pattern, err)
|
|
}
|
|
if len(match) < 2 {
|
|
continue
|
|
}
|
|
newTableName = gstr.Replace(pattern, "?", "")
|
|
newTableName = gstr.Trim(newTableName, `_.-`)
|
|
if shardingNewTableSet.Contains(newTableName) {
|
|
tableNames[i] = ""
|
|
break
|
|
}
|
|
// Add prefix to sharding table name, if not, the isSharding check would not match.
|
|
shardingNewTableSet.Add(in.Prefix + newTableName)
|
|
break
|
|
}
|
|
}
|
|
newTableName = in.Prefix + newTableName
|
|
if tableNames[i] != "" {
|
|
// If shardingNewTableSet contains newTableName (tableName is empty), it should not be added to tableNames, make it empty and filter later.
|
|
newTableNames[i] = newTableName
|
|
}
|
|
}
|
|
tableNames = garray.NewStrArrayFrom(tableNames).FilterEmpty().Slice()
|
|
newTableNames = garray.NewStrArrayFrom(newTableNames).FilterEmpty().Slice() // Filter empty table names. make sure that newTableNames and tableNames have the same length.
|
|
in.genItems.Scale()
|
|
|
|
// Dao: index and internal.
|
|
generateDao(ctx, CGenDaoInternalInput{
|
|
CGenDaoInput: in,
|
|
DB: db,
|
|
TableNames: tableNames,
|
|
NewTableNames: newTableNames,
|
|
ShardingTableSet: shardingNewTableSet,
|
|
})
|
|
// Table: table fields.
|
|
generateTable(ctx, CGenDaoInternalInput{
|
|
CGenDaoInput: in,
|
|
DB: db,
|
|
TableNames: tableNames,
|
|
NewTableNames: newTableNames,
|
|
ShardingTableSet: shardingNewTableSet,
|
|
})
|
|
// Do.
|
|
generateDo(ctx, CGenDaoInternalInput{
|
|
CGenDaoInput: in,
|
|
DB: db,
|
|
TableNames: tableNames,
|
|
NewTableNames: newTableNames,
|
|
})
|
|
// Entity.
|
|
generateEntity(ctx, CGenDaoInternalInput{
|
|
CGenDaoInput: in,
|
|
DB: db,
|
|
TableNames: tableNames,
|
|
NewTableNames: newTableNames,
|
|
})
|
|
|
|
in.genItems.SetClear(in.Clear)
|
|
}
|
|
|
|
func getImportPartContent(ctx context.Context, source string, isDo bool, appendImports []string) string {
|
|
var packageImportsArray = garray.NewStrArray()
|
|
if isDo {
|
|
packageImportsArray.Append(`"github.com/gogf/gf/v2/frame/g"`)
|
|
}
|
|
|
|
// Time package recognition.
|
|
if strings.Contains(source, "gtime.Time") {
|
|
packageImportsArray.Append(`"github.com/gogf/gf/v2/os/gtime"`)
|
|
} else if strings.Contains(source, "time.Time") {
|
|
packageImportsArray.Append(`"time"`)
|
|
}
|
|
|
|
// Json type.
|
|
if strings.Contains(source, "gjson.Json") {
|
|
packageImportsArray.Append(`"github.com/gogf/gf/v2/encoding/gjson"`)
|
|
}
|
|
|
|
// Check and update imports in go.mod
|
|
if len(appendImports) > 0 {
|
|
goModPath := utils.GetModPath()
|
|
if goModPath == "" {
|
|
mlog.Fatal("go.mod not found in current project")
|
|
}
|
|
mod, err := modfile.Parse(goModPath, gfile.GetBytes(goModPath), nil)
|
|
if err != nil {
|
|
mlog.Fatalf("parse go.mod failed: %+v", err)
|
|
}
|
|
for _, appendImport := range appendImports {
|
|
found := false
|
|
for _, require := range mod.Require {
|
|
if gstr.Contains(appendImport, require.Mod.Path) {
|
|
found = true
|
|
break
|
|
}
|
|
}
|
|
if !found {
|
|
if err = gproc.ShellRun(ctx, `go get `+appendImport); err != nil {
|
|
mlog.Fatalf(`%+v`, err)
|
|
}
|
|
}
|
|
packageImportsArray.Append(fmt.Sprintf(`"%s"`, appendImport))
|
|
}
|
|
}
|
|
|
|
// Generate and write content to golang file.
|
|
packageImportsStr := ""
|
|
if packageImportsArray.Len() > 0 {
|
|
packageImportsStr = fmt.Sprintf("import(\n%s\n)", packageImportsArray.Join("\n"))
|
|
}
|
|
return packageImportsStr
|
|
}
|
|
|
|
func assignDefaultVar(view *gview.View, in CGenDaoInternalInput) {
|
|
var (
|
|
tplCreatedAtDatetimeStr string
|
|
tplDatetimeStr = createdAt.String()
|
|
)
|
|
if in.WithTime {
|
|
tplCreatedAtDatetimeStr = fmt.Sprintf(`Created at %s`, tplDatetimeStr)
|
|
}
|
|
view.Assigns(g.Map{
|
|
tplVarDatetimeStr: tplDatetimeStr,
|
|
tplVarCreatedAtDatetimeStr: tplCreatedAtDatetimeStr,
|
|
})
|
|
}
|
|
|
|
func sortFieldKeyForDao(fieldMap map[string]*database.TableField) []string {
|
|
names := make(map[int]string)
|
|
for _, field := range fieldMap {
|
|
names[field.Index] = field.Name
|
|
}
|
|
var (
|
|
i = 0
|
|
j = 0
|
|
result = make([]string, len(names))
|
|
)
|
|
for {
|
|
if len(names) == 0 {
|
|
break
|
|
}
|
|
if val, ok := names[i]; ok {
|
|
result[j] = val
|
|
j++
|
|
delete(names, i)
|
|
}
|
|
i++
|
|
}
|
|
return result
|
|
}
|
|
|
|
func getTemplateFromPathOrDefault(filePath string, def string) string {
|
|
if filePath != "" {
|
|
if contents := gfile.GetContents(filePath); contents != "" {
|
|
return contents
|
|
}
|
|
}
|
|
return def
|
|
}
|
|
|
|
// containsWildcard checks if the pattern contains wildcard characters (* or ?).
|
|
func containsWildcard(pattern string) bool {
|
|
return gstr.Contains(pattern, "*") || gstr.Contains(pattern, "?")
|
|
}
|
|
|
|
// patternToRegex converts a wildcard pattern to a regex pattern.
|
|
// Wildcard characters: * matches any characters, ? matches single character.
|
|
func patternToRegex(pattern string) string {
|
|
pattern = gstr.ReplaceByMap(pattern, map[string]string{
|
|
"\r": "",
|
|
"\n": "",
|
|
})
|
|
pattern = gstr.ReplaceByMap(pattern, map[string]string{
|
|
"*": "\r",
|
|
"?": "\n",
|
|
})
|
|
pattern = gregex.Quote(pattern)
|
|
pattern = gstr.ReplaceByMap(pattern, map[string]string{
|
|
"\r": ".*",
|
|
"\n": ".",
|
|
})
|
|
return pattern
|
|
}
|
|
|
|
// filterTablesByPatterns filters tables by given patterns.
|
|
// Patterns support wildcard characters: * matches any characters, ? matches single character.
|
|
// https://github.com/gogf/gf/issues/4629
|
|
func filterTablesByPatterns(allTables []string, patterns []string) []string {
|
|
var result []string
|
|
matched := make(map[string]bool)
|
|
allTablesSet := make(map[string]bool)
|
|
for _, t := range allTables {
|
|
allTablesSet[t] = true
|
|
}
|
|
for _, p := range patterns {
|
|
if containsWildcard(p) {
|
|
regPattern := "^" + patternToRegex(p) + "$"
|
|
for _, table := range allTables {
|
|
if !matched[table] && gregex.IsMatchString(regPattern, table) {
|
|
result = append(result, table)
|
|
matched[table] = true
|
|
}
|
|
}
|
|
} else {
|
|
// Exact table name, use direct string comparison.
|
|
if !allTablesSet[p] {
|
|
mlog.Printf(`table "%s" does not exist, skipped`, p)
|
|
continue
|
|
}
|
|
if !matched[p] {
|
|
result = append(result, p)
|
|
matched[p] = true
|
|
}
|
|
}
|
|
}
|
|
return result
|
|
}
|