mirror of https://github.com/beego/bee.git
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
271 lines
7.1 KiB
271 lines
7.1 KiB
package main |
|
|
|
import ( |
|
"errors" |
|
"os" |
|
"path" |
|
"strings" |
|
) |
|
|
|
func generateModel(mname, fields, crupath string) { |
|
p, f := path.Split(mname) |
|
modelName := strings.Title(f) |
|
packageName := "models" |
|
if p != "" { |
|
i := strings.LastIndex(p[:len(p)-1], "/") |
|
packageName = p[i+1 : len(p)-1] |
|
} |
|
modelStruct, err := getStruct(modelName, fields) |
|
if err != nil { |
|
ColorLog("[ERRO] Could not genrate models struct: %s\n", err) |
|
os.Exit(2) |
|
} |
|
ColorLog("[INFO] Using '%s' as model name\n", modelName) |
|
ColorLog("[INFO] Using '%s' as package name\n", packageName) |
|
fp := path.Join(crupath, "models", p) |
|
if _, err := os.Stat(fp); os.IsNotExist(err) { |
|
// create controller directory |
|
if err := os.MkdirAll(fp, 0777); err != nil { |
|
ColorLog("[ERRO] Could not create models directory: %s\n", err) |
|
os.Exit(2) |
|
} |
|
} |
|
fpath := path.Join(fp, strings.ToLower(modelName)+".go") |
|
if f, err := os.OpenFile(fpath, os.O_CREATE|os.O_EXCL|os.O_RDWR, 0666); err == nil { |
|
defer f.Close() |
|
content := strings.Replace(modelTpl, "{{packageName}}", packageName, -1) |
|
content = strings.Replace(content, "{{modelName}}", modelName, -1) |
|
content = strings.Replace(content, "{{modelStruct}}", modelStruct, -1) |
|
f.WriteString(content) |
|
// gofmt generated source code |
|
formatAndFixImports(fpath) |
|
ColorLog("[INFO] model file generated: %s\n", fpath) |
|
} else { |
|
// error creating file |
|
ColorLog("[ERRO] Could not create model file: %s\n", err) |
|
os.Exit(2) |
|
} |
|
} |
|
|
|
func getStruct(structname, fields string) (string, error) { |
|
if fields == "" { |
|
return "", errors.New("fields can't empty") |
|
} |
|
structStr := "type " + structname + " struct{\n" |
|
fds := strings.Split(fields, ",") |
|
for i, v := range fds { |
|
kv := strings.SplitN(v, ":", 2) |
|
if len(kv) != 2 { |
|
return "", errors.New("the filds format is wrong. should key:type,key:type " + v) |
|
} |
|
typ, tag := getType(kv[1]) |
|
if typ == "" { |
|
return "", errors.New("the filds format is wrong. should key:type,key:type " + v) |
|
} |
|
if i == 0 && strings.ToLower(kv[0]) != "id" { |
|
structStr = structStr + "Id int64 `orm:\"auto\"`\n" |
|
} |
|
structStr = structStr + camelString(kv[0]) + " " + typ + " " + tag + "\n" |
|
} |
|
structStr += "}\n" |
|
return structStr, nil |
|
} |
|
|
|
func camelString(s string) string { |
|
data := make([]byte, 0, len(s)) |
|
j := false |
|
k := false |
|
num := len(s) - 1 |
|
for i := 0; i <= num; i++ { |
|
d := s[i] |
|
if k == false && d >= 'A' && d <= 'Z' { |
|
k = true |
|
} |
|
if d >= 'a' && d <= 'z' && (j || k == false) { |
|
d = d - 32 |
|
j = false |
|
k = true |
|
} |
|
if k && d == '_' && num > i && s[i+1] >= 'a' && s[i+1] <= 'z' { |
|
j = true |
|
continue |
|
} |
|
data = append(data, d) |
|
} |
|
return string(data[:len(data)]) |
|
} |
|
|
|
// fields support type |
|
// http://beego.me/docs/mvc/model/models.md#mysql |
|
func getType(ktype string) (kt, tag string) { |
|
kv := strings.SplitN(ktype, ":", 2) |
|
switch kv[0] { |
|
case "string": |
|
if len(kv) == 2 { |
|
return "string", "`orm:\"size(" + kv[1] + ")\"`" |
|
} else { |
|
return "string", "`orm:\"size(128)\"`" |
|
} |
|
case "text": |
|
return "string", "`orm:\"type(longtext)\"`" |
|
case "auto": |
|
return "int64", "`orm:\"auto\"`" |
|
case "pk": |
|
return "int64", "`orm:\"pk\"`" |
|
case "datetime": |
|
return "time.Time", "`orm:\"type(datetime)\"`" |
|
case "int", "int8", "int16", "int32", "int64": |
|
fallthrough |
|
case "uint", "uint8", "uint16", "uint32", "uint64": |
|
fallthrough |
|
case "bool": |
|
fallthrough |
|
case "float32", "float64": |
|
return kv[0], "" |
|
case "float": |
|
return "float64", "" |
|
} |
|
return "", "" |
|
} |
|
|
|
var modelTpl = `package {{packageName}} |
|
|
|
import ( |
|
"errors" |
|
"fmt" |
|
"reflect" |
|
"strings" |
|
"time" |
|
|
|
"github.com/astaxie/beego/orm" |
|
) |
|
|
|
{{modelStruct}} |
|
|
|
func init() { |
|
orm.RegisterModel(new({{modelName}})) |
|
} |
|
|
|
// Add{{modelName}} insert a new {{modelName}} into database and returns |
|
// last inserted Id on success. |
|
func Add{{modelName}}(m *{{modelName}}) (id int64, err error) { |
|
o := orm.NewOrm() |
|
id, err = o.Insert(m) |
|
return |
|
} |
|
|
|
// Get{{modelName}}ById retrieves {{modelName}} by Id. Returns error if |
|
// Id doesn't exist |
|
func Get{{modelName}}ById(id int) (v *{{modelName}}, err error) { |
|
o := orm.NewOrm() |
|
v = &{{modelName}}{Id: id} |
|
if err = o.Read(v); err == nil { |
|
return v, nil |
|
} |
|
return nil, err |
|
} |
|
|
|
// GetAll{{modelName}} retrieves all {{modelName}} matches certain condition. Returns empty list if |
|
// no records exist |
|
func GetAll{{modelName}}(query map[string]string, fields []string, sortby []string, order []string, |
|
offset int64, limit int64) (ml []interface{}, err error) { |
|
o := orm.NewOrm() |
|
qs := o.QueryTable(new({{modelName}})) |
|
// query k=v |
|
for k, v := range query { |
|
// rewrite dot-notation to Object__Attribute |
|
k = strings.Replace(k, ".", "__", -1) |
|
qs = qs.Filter(k, v) |
|
} |
|
// order by: |
|
var sortFields []string |
|
if len(sortby) != 0 { |
|
if len(sortby) == len(order) { |
|
// 1) for each sort field, there is an associated order |
|
for i, v := range sortby { |
|
orderby := "" |
|
if order[i] == "desc" { |
|
orderby = "-" + v |
|
} else if order[i] == "asc" { |
|
orderby = v |
|
} else { |
|
return nil, errors.New("Error: Invalid order. Must be either [asc|desc]") |
|
} |
|
sortFields = append(sortFields, orderby) |
|
} |
|
qs = qs.OrderBy(sortFields...) |
|
} else if len(sortby) != len(order) && len(order) == 1 { |
|
// 2) there is exactly one order, all the sorted fields will be sorted by this order |
|
for _, v := range sortby { |
|
orderby := "" |
|
if order[0] == "desc" { |
|
orderby = "-" + v |
|
} else if order[0] == "asc" { |
|
orderby = v |
|
} else { |
|
return nil, errors.New("Error: Invalid order. Must be either [asc|desc]") |
|
} |
|
sortFields = append(sortFields, orderby) |
|
} |
|
} else if len(sortby) != len(order) && len(order) != 1 { |
|
return nil, errors.New("Error: 'sortby', 'order' sizes mismatch or 'order' size is not 1") |
|
} |
|
} else { |
|
if len(order) != 0 { |
|
return nil, errors.New("Error: unused 'order' fields") |
|
} |
|
} |
|
|
|
var l []{{modelName}} |
|
qs = qs.OrderBy(sortFields...) |
|
if _, err := qs.Limit(limit, offset).All(&l, fields...); err == nil { |
|
if len(fields) == 0 { |
|
for _, v := range l { |
|
ml = append(ml, v) |
|
} |
|
} else { |
|
// trim unused fields |
|
for _, v := range l { |
|
m := make(map[string]interface{}) |
|
val := reflect.ValueOf(v) |
|
for _, fname := range fields { |
|
m[fname] = val.FieldByName(fname).Interface() |
|
} |
|
ml = append(ml, m) |
|
} |
|
} |
|
return ml, nil |
|
} |
|
return nil, err |
|
} |
|
|
|
// Update{{modelName}} updates {{modelName}} by Id and returns error if |
|
// the record to be updated doesn't exist |
|
func Update{{modelName}}ById(m *{{modelName}}) (err error) { |
|
o := orm.NewOrm() |
|
v := {{modelName}}{Id: m.Id} |
|
// ascertain id exists in the database |
|
if err = o.Read(&v); err == nil { |
|
var num int64 |
|
if num, err = o.Update(m); err == nil { |
|
fmt.Println("Number of records updated in database:", num) |
|
} |
|
} |
|
return |
|
} |
|
|
|
// Delete{{modelName}} deletes {{modelName}} by Id and returns error if |
|
// the record to be deleted doesn't exist |
|
func Delete{{modelName}}(id int) (err error) { |
|
o := orm.NewOrm() |
|
v := {{modelName}}{Id: id} |
|
// ascertain id exists in the database |
|
if err = o.Read(&v); err == nil { |
|
var num int64 |
|
if num, err = o.Delete(&{{modelName}}{Id: id}); err == nil { |
|
fmt.Println("Number of records deleted in database:", num) |
|
} |
|
} |
|
return |
|
} |
|
`
|
|
|