2023-07-26 16:19:28 +03:00
|
|
|
package templ
|
2023-06-23 14:54:47 +03:00
|
|
|
|
|
|
|
import (
|
|
|
|
"bufio"
|
|
|
|
"bytes"
|
|
|
|
"embed"
|
2023-08-02 16:04:17 +03:00
|
|
|
"errors"
|
2023-06-26 15:35:24 +03:00
|
|
|
"fmt"
|
2023-06-23 14:54:47 +03:00
|
|
|
"log"
|
|
|
|
"os"
|
2023-08-02 16:04:17 +03:00
|
|
|
"path/filepath"
|
2023-07-18 14:33:58 +03:00
|
|
|
"regexp"
|
2023-06-23 14:54:47 +03:00
|
|
|
"strings"
|
|
|
|
"text/template"
|
2023-06-26 15:35:24 +03:00
|
|
|
|
|
|
|
"git.ymnuktech.ru/ymnuk/yt-gen-app/structs"
|
2023-06-23 14:54:47 +03:00
|
|
|
)
|
|
|
|
|
|
|
|
//go:embed tmpl/*
|
2023-07-26 16:19:28 +03:00
|
|
|
var Content embed.FS
|
2023-06-23 14:54:47 +03:00
|
|
|
|
|
|
|
var funcMap = template.FuncMap{
|
2023-07-26 16:19:28 +03:00
|
|
|
"fieldName": FieldName,
|
|
|
|
"fieldNamePrepare": FieldNamePrepare,
|
|
|
|
"fieldNameLowerPrepare": FieldNameLowerPrepare,
|
|
|
|
"fieldType": FieldType,
|
|
|
|
"hasFieldType": HasFieldType,
|
|
|
|
"fieldDescript": FieldDescript,
|
|
|
|
"configParamName": ConfigParamName,
|
|
|
|
"configParamType": ConfigParamType,
|
|
|
|
"configParamTag": ConfigParamTag,
|
2023-08-02 16:04:17 +03:00
|
|
|
"packageName": PackageName,
|
|
|
|
|
|
|
|
"methodNameGetId": MethodNameGetId,
|
|
|
|
|
|
|
|
"methodSummary": MethodSummary,
|
|
|
|
"methodComment": MethodComment,
|
|
|
|
"getModelName": GetModelName,
|
|
|
|
"displayMethodNamePost": DisplayMethodNamePost,
|
|
|
|
"methodNamePost": MethodNamePost,
|
|
|
|
"displayMethodNameGet": DisplayMethodNameGet,
|
|
|
|
"methodNameGet": MethodNameGet,
|
2023-08-09 14:45:36 +03:00
|
|
|
|
|
|
|
"isMethod": IsMethod,
|
|
|
|
"roles": Roles,
|
|
|
|
}
|
|
|
|
|
|
|
|
func IsMethod(arr map[string][]string, method string) bool {
|
|
|
|
if arr == nil {
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
_, ok := arr[method]
|
|
|
|
return ok
|
|
|
|
}
|
|
|
|
|
|
|
|
func Roles(arr map[string][]string, method string) []string {
|
|
|
|
if arr == nil {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
return arr[method]
|
2023-06-23 14:54:47 +03:00
|
|
|
}
|
|
|
|
|
2023-07-26 16:19:28 +03:00
|
|
|
func FieldNamePrepare(value string) string {
|
2023-07-18 14:33:58 +03:00
|
|
|
value = strings.Trim(value, " ")
|
|
|
|
if value == "" {
|
|
|
|
log.Fatal("Should be set name for field")
|
2023-06-23 14:54:47 +03:00
|
|
|
}
|
2023-07-18 14:33:58 +03:00
|
|
|
asRunes := []rune(value)
|
2023-06-23 14:54:47 +03:00
|
|
|
|
2023-07-18 14:33:58 +03:00
|
|
|
asRunes[0] = []rune(strings.ToUpper(string([]rune(value)[0])))[0]
|
|
|
|
value = string(asRunes)
|
|
|
|
i := strings.Index(value, "_")
|
2023-06-23 14:54:47 +03:00
|
|
|
for i != -1 {
|
2023-07-18 14:33:58 +03:00
|
|
|
asRunes := []rune(value)
|
|
|
|
if i >= len(value) {
|
2023-06-23 14:54:47 +03:00
|
|
|
break
|
|
|
|
}
|
|
|
|
asRunes[i+1] = []rune(strings.ToUpper(string(asRunes[i+1])))[0]
|
2023-07-18 14:33:58 +03:00
|
|
|
asRunes = append(asRunes[:i], asRunes[i+1:]...)
|
|
|
|
value = string(asRunes)
|
|
|
|
i = strings.Index(value, "_")
|
2023-06-26 15:35:24 +03:00
|
|
|
}
|
2023-07-18 14:33:58 +03:00
|
|
|
return value
|
|
|
|
}
|
|
|
|
|
2023-07-26 16:19:28 +03:00
|
|
|
func FieldNameLowerPrepare(value string) string {
|
2023-07-18 14:33:58 +03:00
|
|
|
var regexpForReplace = regexp.MustCompile(`([A-Z])`)
|
|
|
|
value = strings.ToLower(regexpForReplace.ReplaceAllString(value, "_$1"))
|
|
|
|
if []rune(value)[0] == '_' {
|
|
|
|
value = string([]rune(value)[1:])
|
|
|
|
}
|
|
|
|
value = strings.ReplaceAll(value, "i_d", "id")
|
|
|
|
return value
|
|
|
|
}
|
|
|
|
|
2023-07-26 16:19:28 +03:00
|
|
|
func FieldName(field *structs.Field) string {
|
2023-07-18 14:33:58 +03:00
|
|
|
if field == nil {
|
|
|
|
log.Fatal("Field is null")
|
|
|
|
}
|
|
|
|
field.Name = strings.Trim(field.Name, " ")
|
|
|
|
if field.Name == "" {
|
|
|
|
log.Fatal("Should be set name for field")
|
|
|
|
}
|
2023-07-26 16:19:28 +03:00
|
|
|
field.Name = FieldNamePrepare(field.Name)
|
2023-06-26 15:35:24 +03:00
|
|
|
return field.Name
|
|
|
|
}
|
|
|
|
|
|
|
|
// Возвращает имя в БД
|
2023-07-26 16:19:28 +03:00
|
|
|
func FieldDBName(field *structs.Field) (res string) {
|
2023-06-26 15:35:24 +03:00
|
|
|
res = strings.Trim(field.Name, " ")
|
|
|
|
if res == "" {
|
|
|
|
log.Fatal("Shoudl be set name for field")
|
|
|
|
}
|
|
|
|
res = strings.ToLower(res)
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2023-07-26 16:19:28 +03:00
|
|
|
func FieldType(field *structs.Field) string {
|
2023-06-26 15:35:24 +03:00
|
|
|
if field == nil {
|
|
|
|
log.Fatal("field is empty")
|
|
|
|
}
|
|
|
|
field.Type = strings.ToLower(strings.Trim(field.Type, " "))
|
|
|
|
if field.Type == "" {
|
|
|
|
field.Type = "text"
|
|
|
|
}
|
|
|
|
switch field.Type {
|
|
|
|
case "text":
|
|
|
|
return "*string"
|
|
|
|
case "string":
|
|
|
|
return "*string"
|
|
|
|
case "int":
|
|
|
|
return "*int"
|
|
|
|
case "bigint":
|
|
|
|
return "*int64"
|
2023-07-19 12:05:56 +03:00
|
|
|
case "uuid":
|
|
|
|
return "*uuid.UUID"
|
2023-06-26 15:35:24 +03:00
|
|
|
default:
|
|
|
|
log.Fatalf("Unknow format %s", field.Type)
|
2023-06-23 14:54:47 +03:00
|
|
|
}
|
2023-06-26 15:35:24 +03:00
|
|
|
return ""
|
|
|
|
}
|
|
|
|
|
2023-07-26 16:19:28 +03:00
|
|
|
func HasFieldType(fields []structs.Field, typeName string) (has bool) {
|
2023-07-19 16:02:07 +03:00
|
|
|
for _, field := range fields {
|
|
|
|
if (field.Type == "date" || field.Type == "time") && (typeName == "date" || typeName == "time") {
|
|
|
|
return true
|
|
|
|
}
|
|
|
|
if field.Type == typeName {
|
|
|
|
return true
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
|
2023-07-26 16:19:28 +03:00
|
|
|
func FieldTypeDB(field *structs.Field) string {
|
2023-06-26 15:35:24 +03:00
|
|
|
field.Type = strings.ToLower(strings.Trim(field.Type, " "))
|
|
|
|
switch field.Type {
|
|
|
|
case "text":
|
|
|
|
return "TEXT"
|
|
|
|
case "string":
|
|
|
|
tmp := "VARCHAR"
|
|
|
|
if field.Length != nil && *field.Length == 0 {
|
|
|
|
tmp += fmt.Sprintf("(%d)", *field.Length)
|
|
|
|
} else {
|
|
|
|
tmp += "(255)"
|
|
|
|
}
|
|
|
|
//return "TEXT"
|
|
|
|
return tmp
|
|
|
|
case "int":
|
|
|
|
return "INT"
|
|
|
|
case "bigint":
|
|
|
|
return "BIGINT"
|
2023-07-19 12:05:56 +03:00
|
|
|
case "uuid":
|
|
|
|
return "UUID"
|
2023-06-26 15:35:24 +03:00
|
|
|
default:
|
|
|
|
log.Fatalf("Unknow format %s", field.Type)
|
|
|
|
}
|
|
|
|
return ""
|
|
|
|
}
|
|
|
|
|
|
|
|
// Генерирование описания таблиц в БД
|
2023-07-26 16:19:28 +03:00
|
|
|
func FieldDescript(field *structs.Field) (str string) {
|
|
|
|
str = fmt.Sprintf("`gorm:\"column:%s;type:%s", FieldDBName(field), FieldTypeDB(field))
|
2023-06-26 15:35:24 +03:00
|
|
|
field.Description = strings.Trim(field.Description, " ")
|
|
|
|
if field.Description != "" {
|
|
|
|
str += fmt.Sprintf(";comment:%s", field.Description)
|
|
|
|
}
|
2023-08-02 16:04:17 +03:00
|
|
|
str += "\""
|
|
|
|
str = fmt.Sprintf("%s json:\"%s,omitempty\"`", str, FieldJsonName(field))
|
2023-06-26 15:35:24 +03:00
|
|
|
|
2023-06-23 14:54:47 +03:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2023-07-18 14:33:58 +03:00
|
|
|
// Вернуть название параметра
|
2023-07-26 16:19:28 +03:00
|
|
|
func ConfigParamName(field *structs.ParamConfig) string {
|
2023-07-18 14:33:58 +03:00
|
|
|
if field == nil {
|
|
|
|
log.Fatal("Field is null")
|
|
|
|
}
|
|
|
|
field.Name = strings.Trim(field.Name, " ")
|
|
|
|
if field.Name == "" {
|
|
|
|
log.Fatal("Should be set name for field")
|
|
|
|
}
|
2023-07-26 16:19:28 +03:00
|
|
|
return FieldNamePrepare(field.Name)
|
2023-07-18 14:33:58 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
// Вернуть тип параметра
|
2023-07-26 16:19:28 +03:00
|
|
|
func ConfigParamType(field *structs.ParamConfig) string {
|
2023-07-18 14:33:58 +03:00
|
|
|
if field == nil {
|
|
|
|
log.Fatal("Param should be set")
|
|
|
|
}
|
|
|
|
field.Type = strings.Trim(field.Type, " ")
|
|
|
|
if field.Type == "" {
|
|
|
|
log.Fatal("Param type should be set")
|
|
|
|
}
|
|
|
|
switch field.Type {
|
|
|
|
case "string":
|
|
|
|
return "string"
|
|
|
|
default:
|
|
|
|
log.Fatal("Unknow type")
|
|
|
|
}
|
|
|
|
return ""
|
|
|
|
}
|
|
|
|
|
|
|
|
// Вернуть строку для тэгирования параметров
|
2023-07-26 16:19:28 +03:00
|
|
|
func ConfigParamTag(field *structs.ParamConfig) string {
|
2023-07-18 14:33:58 +03:00
|
|
|
if field == nil {
|
|
|
|
log.Fatal("Param should be set")
|
|
|
|
}
|
|
|
|
if field == nil {
|
|
|
|
log.Fatal("Field is null")
|
|
|
|
}
|
|
|
|
field.Name = strings.Trim(field.Name, " ")
|
|
|
|
if field.Name == "" {
|
|
|
|
log.Fatal("Shoudl be set name for field")
|
|
|
|
}
|
|
|
|
|
|
|
|
tag := fmt.Sprintf("`arg:\"--%s,env:%s\"", strings.ReplaceAll(strings.ToLower(field.Name), "_", "-"), strings.ReplaceAll(strings.ToUpper(field.Name), "-", "_"))
|
|
|
|
field.Help = strings.Trim(field.Help, " ")
|
|
|
|
if field.Help != "" {
|
|
|
|
tag += fmt.Sprintf(" help:\"%s\"", field.Help)
|
|
|
|
}
|
|
|
|
tag += "`"
|
|
|
|
// TODO
|
|
|
|
return tag
|
|
|
|
}
|
|
|
|
|
2023-06-23 14:54:47 +03:00
|
|
|
func WriteTmplFile(filename string, outname string) error {
|
2023-07-21 15:42:28 +03:00
|
|
|
fmt.Printf("Generate: %s\n", outname)
|
2023-07-26 16:19:28 +03:00
|
|
|
if buff, err := Content.ReadFile(filename); err != nil {
|
2023-06-23 14:54:47 +03:00
|
|
|
return err
|
|
|
|
} else {
|
|
|
|
if err = os.WriteFile(outname, buff, 0755); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
// Использование шаблона
|
|
|
|
func PrepareTmplFile(filename string, data interface{}, outname string) (err error) {
|
2023-08-09 14:45:36 +03:00
|
|
|
dir := filepath.Dir(outname)
|
|
|
|
if err = MkdirIsNotExists(dir); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
2023-07-21 15:42:28 +03:00
|
|
|
fmt.Printf("Generate: %s\n", outname)
|
2023-06-23 14:54:47 +03:00
|
|
|
var (
|
|
|
|
buff []byte
|
|
|
|
)
|
2023-07-26 16:19:28 +03:00
|
|
|
if buff, err = Content.ReadFile(filename); err != nil {
|
2023-06-23 14:54:47 +03:00
|
|
|
return err
|
|
|
|
}
|
|
|
|
var (
|
|
|
|
tmp string
|
|
|
|
tmpl *template.Template
|
|
|
|
)
|
|
|
|
if tmp, err = RandomHex(4); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
if tmpl, err = template.New(tmp).Funcs(funcMap).Parse(string(buff)); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
var b bytes.Buffer
|
|
|
|
w := bufio.NewWriter(&b)
|
|
|
|
|
|
|
|
if err = tmpl.Execute(w, data); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
w.Flush()
|
2023-08-09 14:45:36 +03:00
|
|
|
if err = os.WriteFile(outname, b.Bytes(), 0755); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
2023-06-23 14:54:47 +03:00
|
|
|
return
|
|
|
|
}
|
2023-08-02 16:04:17 +03:00
|
|
|
|
|
|
|
func PrepareTmplIsNotExists(filename string, data interface{}, outname string) (err error) {
|
|
|
|
|
|
|
|
if err = MkdirIsNotExists(filepath.Dir(outname)); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
if _, err := os.Stat(outname); errors.Is(err, os.ErrNotExist) {
|
|
|
|
return PrepareTmplFile(filename, data, outname)
|
|
|
|
}
|
|
|
|
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func MkdirIsNotExists(pathdir string) (err error) {
|
|
|
|
if _, err = os.Stat(pathdir); os.IsNotExist(err) {
|
|
|
|
if err = os.MkdirAll(pathdir, 0775); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
}
|
|
|
|
err = nil
|
|
|
|
return
|
|
|
|
}
|