jager/gormt
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Restructure

Browse Source 
重构
This commit is contained in:
谢小军
2019-09-30 18:25:22 +08:00
parent 7a555e91f5
commit ee2e02092a
18 changed files with 249 additions and 247 deletions
Download Patch File Download Diff File Expand all files Collapse all files

241
data/view/gtools/common.go
View File

@@ -1,241 +0,0 @@
package gtools
import (
"fmt"
"regexp"
"strings"
"github.com/xxjwxc/gormt/data/config"
"github.com/xxjwxc/gormt/data/view/gtools/generate"
"github.com/xxjwxc/public/mybigcamel"
"github.com/xxjwxc/public/mysqldb"
)
//OnGetTables 获取表列及注释
func OnGetTables(orm *mysqldb.MySqlDB) map[string]string {
tbDesc := make(map[string]string)
//获取列名
var tables []string
rows, err := orm.Raw("show tables").Rows()
if err != nil {
fmt.Println(err)
return tbDesc
}
defer rows.Close()
for rows.Next() {
var table string
rows.Scan(&table)
tables = append(tables, table)
tbDesc[table] = ""
}
//获取表注释
rows, err = orm.Raw("SELECT TABLE_NAME,TABLE_COMMENT FROM information_schema.TABLES WHERE table_schema=?;",
config.GetMysqlDbInfo().Database).Rows()
if err != nil {
fmt.Println(err)
return tbDesc
}
for rows.Next() {
var table, desc string
rows.Scan(&table, &desc)
tbDesc[table] = desc
}
return tbDesc
}
//OnGetPackageInfo 获取包信息
func OnGetPackageInfo(orm *mysqldb.MySqlDB, tabls map[string]string) generate.GenPackage {
var pkg generate.GenPackage
for tab, desc := range tabls {
var sct generate.GenStruct
sct.SetStructName(OnGetCamelName(tab)) //大驼峰
sct.SetNotes(desc)
//构造元素
ems := OnGetTableElement(orm, tab)
//--------end
sct.AddElement(ems...)
//获取表注释
rows, err := orm.Raw("show create table " + tab).Rows()
defer rows.Close()
if err == nil {
if rows.Next() {
var table, CreateTable string
rows.Scan(&table, &CreateTable)
sct.SetCreatTableStr(CreateTable)
}
}
//----------end
pkg.AddStruct(sct)
}
return pkg
}
//OnGetTableElement 获取表列及注释
func OnGetTableElement(orm *mysqldb.MySqlDB, tab string) []generate.GenElement {
var el []generate.GenElement
keyNums := make(map[string]int)
//获取keys
var Keys []struct {
NonUnique int `gorm:"column:Non_unique"`
KeyName string `gorm:"column:Key_name"`
ColumnName string `gorm:"column:Column_name"`
}
orm.Raw("show keys from " + tab).Find(&Keys)
for _, v := range Keys {
keyNums[v.KeyName]++
}
//----------end
var list []struct {
Field string `gorm:"column:Field"`
Type string `gorm:"column:Type"`
Key string `gorm:"column:Key"`
Desc string `gorm:"column:Comment"`
Null string `gorm:"column:Null"`
}
//获取表注释
orm.Raw("show FULL COLUMNS from " + tab).Find(&list)
//过滤 gorm.Model
if OnHaveModel(&list) {
var tmp generate.GenElement
tmp.SetType("gorm.Model")
el = append(el, tmp)
}
//-----------------end
for _, v := range list {
var tmp generate.GenElement
tmp.SetName(OnGetCamelName(v.Field))
tmp.SetNotes(v.Desc)
tmp.SetType(OnGetTypeName(v.Type))
if strings.EqualFold(v.Key, "PRI") { //设置主键
tmp.AddTag(_tagGorm, "primary_key")
} else if strings.EqualFold(v.Key, "UNI") { //unique
tmp.AddTag(_tagGorm, "unique")
} else {
//index
for _, v1 := range Keys {
if strings.EqualFold(v1.ColumnName, v.Field) {
_val := ""
if v1.NonUnique == 1 { //index
_val += "index"
} else {
_val += "unique_index"
}
if keyNums[v1.KeyName] > 1 { //复合索引？
_val += ":" + v1.KeyName
}
tmp.AddTag(_tagGorm, _val)
}
}
}
//simple output
if !config.GetSimple() {
tmp.AddTag(_tagGorm, "column:"+v.Field)
tmp.AddTag(_tagGorm, "type:"+v.Type)
if strings.EqualFold(v.Null, "NO") {
tmp.AddTag(_tagGorm, "not null")
}
}
//json tag
if config.GetIsJSONTag() {
if strings.EqualFold(v.Field, "id") {
tmp.AddTag(_tagJSON, "-")
} else {
tmp.AddTag(_tagJSON, v.Field)
}
}
el = append(el, tmp)
}
return el
}
//OnHaveModel 过滤 gorm.Model
func OnHaveModel(list *[]struct {
Field string `gorm:"column:Field"`
Type string `gorm:"column:Type"`
Key string `gorm:"column:Key"`
Desc string `gorm:"column:Comment"`
Null string `gorm:"column:Null"`
}) bool {
var _temp []struct {
Field string `gorm:"column:Field"`
Type string `gorm:"column:Type"`
Key string `gorm:"column:Key"`
Desc string `gorm:"column:Comment"`
Null string `gorm:"column:Null"`
}
num := 0
for _, v := range *list {
if strings.EqualFold(v.Field, "id") ||
strings.EqualFold(v.Field, "created_at") ||
strings.EqualFold(v.Field, "updated_at") ||
strings.EqualFold(v.Field, "deleted_at") {
num++
} else {
_temp = append(_temp, v)
}
}
if num >= 4 {
*list = _temp
return true
}
return false
}
//OnGetTypeName 类型获取过滤
func OnGetTypeName(name string) string {
//先精确匹配
if v, ok := TypeDicMp[name]; ok {
return v
}
//模糊正则匹配
for k, v := range TypeMatchMp {
if ok, _ := regexp.MatchString(k, name); ok {
return v
}
}
panic(fmt.Sprintf("type (%v) not match in any way.", name))
}
//OnGetCamelName 大驼峰或者首字母大写
func OnGetCamelName(name string) string {
if config.GetSingularTable() { //如果全局禁用表名复数
return TitleCase(name)
}
return mybigcamel.Marshal(name)
}
//TitleCase 首字母大写
func TitleCase(name string) string {
vv := []rune(name)
if len(vv) > 0 {
if bool(vv[0] >= 'a' && vv[0] <= 'z') { //首字母大写
vv[0] -= 32
}
}
return string(vv)
}

32
data/view/gtools/def.go
View File

@@ -1,32 +0,0 @@
package gtools
const (
_tagGorm = "gorm"
_tagJSON = "json"
)
//TypeDicMp 精确匹配类型
var TypeDicMp = map[string]string{
"int": "int",
"bigint": "int64",
"varchar": "string",
"char": "string",
"date": "time.Time",
"datetime": "time.Time",
"bit(1)": "bool",
"tinyint(1)": "bool",
"tinyint(1) unsigned": "bool",
"tinyint(4)": "int8",
"json": "string",
"text": "string",
"timestamp": "time.Time",
}
//TypeMatchMp 模糊匹配类型
var TypeMatchMp = map[string]string{
`^(int)[(]\d+[)]`: "int",
`^(bigint)[(]\d+[)]`: "int64",
`^(char)[(]\d+[)]`: "string",
`^(varchar)[(]\d+[)]`: "string",
`^(decimal)[(]\d+,\d+[)]`: "float64",
}

193
data/view/gtools/generate/common.go
View File

@@ -1,193 +0,0 @@
package generate
import (
"fmt"
"sort"
"strings"
"github.com/xxjwxc/gormt/data/config"
"github.com/xxjwxc/public/tools"
)
//Add 打印
func (p *PrintAtom) Add(str ...interface{}) {
var tmp string
for _, v := range str {
tmp += tools.AsString(v) + _interval
}
p.lines = append(p.lines, tmp)
}
//Generate 打印
func (p *PrintAtom) Generate() []string {
return p.lines
}
//SetName 设置元素名字
func (e *GenElement) SetName(name string) {
e.Name = name
}
//SetType 设置元素类型
func (e *GenElement) SetType(tp string) {
e.Type = tp
}
//SetNotes 设置注释
func (e *GenElement) SetNotes(notes string) {
e.Notes = strings.Replace(notes, "\n", ",", -1)
}
//AddTag 添加一个tag标记
func (e *GenElement) AddTag(k string, v string) {
if e.Tags == nil {
e.Tags = make(map[string][]string)
}
e.Tags[k] = append(e.Tags[k], v)
}
//Generate 获取结果数据
func (e *GenElement) Generate() string {
tag := ""
if e.Tags != nil {
var ks []string
for k := range e.Tags {
ks = append(ks, k)
}
sort.Strings(ks)
var tags []string
for _, v := range ks {
tags = append(tags, fmt.Sprintf(`%v:"%v"`, v, strings.Join(e.Tags[v], ";")))
}
tag = fmt.Sprintf("`%v`", strings.Join(tags, " "))
}
var p PrintAtom
if len(e.Notes) > 0 {
p.Add(e.Name, e.Type, tag, "// "+e.Notes)
} else {
p.Add(e.Name, e.Type, tag)
}
return p.Generate()[0]
}
//////////////////////////////////////////////////////////////////////////////
// struct
//////////////////////////////////////////////////////////////////////////////
//SetCreatTableStr 设置创建语句，备份使用
func (s *GenStruct) SetCreatTableStr(sql string) {
s.SQLBuildStr = sql
}
//SetStructName 获取结果数据
func (s *GenStruct) SetStructName(name string) {
s.Name = name
}
//SetNotes 设置注释
func (s *GenStruct) SetNotes(notes string) {
a := strings.Split(notes, "\n")
var text []string
for _, v := range a {
if len(v) > 0 {
text = append(text, "// "+v)
}
}
s.Notes = strings.Join(text, "\r\n")
}
//AddElement 添加一个/或多个元素
func (s *GenStruct) AddElement(e ...GenElement) {
s.Em = append(s.Em, e...)
}
//Generate 获取结果数据
func (s *GenStruct) Generate() []string {
var p PrintAtom
if !config.GetSimple() {
p.Add("/******sql******")
p.Add(s.SQLBuildStr)
p.Add("******sql******/")
}
p.Add(s.Notes)
p.Add("type", s.Name, "struct {")
for _, v := range s.Em {
p.Add(v.Generate())
}
p.Add("}")
return p.Generate()
}
//////////////////////////////////////////////////////////////////////////////
// package
//////////////////////////////////////////////////////////////////////////////
//SetPackage 定义包名
func (p *GenPackage) SetPackage(pname string) {
p.Name = pname
}
//AddImport 通过类型添加import
func (p *GenPackage) AddImport(imp string) {
if p.Imports == nil {
p.Imports = make(map[string]string)
}
p.Imports[imp] = imp
}
//AddStruct 添加一个结构体
func (p *GenPackage) AddStruct(st GenStruct) {
p.Structs = append(p.Structs, st)
}
//Generate 获取结果数据
func (p *GenPackage) Generate() string {
p.genimport() //补充 import
var pa PrintAtom
pa.Add("package", p.Name)
//add import
if p.Imports != nil {
pa.Add("import (")
for _, v := range p.Imports {
pa.Add(v)
}
pa.Add(")")
}
//-----------end
//add struct
for _, v := range p.Structs {
for _, v1 := range v.Generate() {
pa.Add(v1)
}
}
//-----------end
//输出
strOut := ""
for _, v := range pa.Generate() {
strOut += v + "\n"
}
return strOut
}
//获取结果数据
func (p *GenPackage) genimport() {
for _, v := range p.Structs {
for _, v1 := range v.Em {
if v2, ok := EImportsHead[v1.Type]; ok {
if len(v2) > 0 {
p.AddImport(v2)
}
}
}
}
}

90
data/view/gtools/generate/def.go
View File

@@ -1,90 +0,0 @@
package generate
//IPackage 包类
type IPackage interface {
//定义包名
SetPackage(string)
//通过类型添加import
AddImport(string)
//添加一个结构体
AddStruct(IStruct)
//获取结果数据
Generate() string
}
//IStruct 结构体类
type IStruct interface {
//设置创建语句，备份使用
SetCreatTableStr(string)
//设置结构体名字
SetStructName(string)
//设置注释
SetNotes(string)
//添加一个元素
AddElement(...IElement)
//获取结果数据
Generate() []string
}
//IElement 元素类
type IElement interface {
//设置元素名字
SetName(string)
//设置元素类型
SetType(string)
//设置注释
SetNotes(string)
//添加一个tag标记
AddTag(k string, v string)
//获取结果数据
Generate() string
}
//////////////////////////////////////////////////////////////////////////////
//
//////////////////////////////////////////////////////////////////////////////
//GenElement 元素类
type GenElement struct {
Name string //元素名
Type string //类型标记
Notes string //注释
Tags map[string][]string //标记
}
//GenStruct 结构体
type GenStruct struct {
SQLBuildStr string //创建sql语句
Name string //名字
Notes string //注释
Em []GenElement //元素组合
}
//GenPackage 包体
type GenPackage struct {
Name string //名字
Imports map[string]string //元素组合
Structs []GenStruct //结构体组合
}
//间隔
var _interval = "\t"
//EImportsHead .
var EImportsHead = map[string]string{
"stirng": `"string"`,
"time.Time": `"time"`,
"gorm.Model": `"github.com/jinzhu/gorm"`,
}
//PrintAtom .
type PrintAtom struct {
lines []string
}

1
data/view/gtools/generate/generate.go
View File

@@ -1 +0,0 @@
package generate

11
data/view/gtools/gtools.go
View File

@@ -6,23 +6,20 @@ import (
"strings"
"github.com/xxjwxc/gormt/data/config"
"github.com/xxjwxc/gormt/data/view/model/genmysql"
"github.com/xxjwxc/public/mysqldb"
"github.com/xxjwxc/public/tools"
)
//Execute 开始执行
// Execute
func Execute() {
orm := mysqldb.OnInitDBOrm(config.GetMysqlConStr())
defer orm.OnDestoryDB()
// var tt oauth_db.UserInfoTbl
// tt.Nickname = "ticket_001"
// orm.Where("nickname = ?", "ticket_001").Find(&tt)
// fmt.Println(tt)
pkg := OnGetPackageInfo(orm, OnGetTables(orm))
pkg := genmysql.GenMysql()
pkg.SetPackage(getPkgName())
str := pkg.Generate()
@@ -39,7 +36,7 @@ func Execute() {
fmt.Println(string(cmd))
}
// 通过config outdir 配置获取报名
// Getting package names through config outdir configuration.通过config outdir 配置获取包名
func getPkgName() string {
dir := config.GetOutDir()
dir = strings.Replace(dir, "\\", "/", -1)