284 lines
8.3 KiB
Go
284 lines
8.3 KiB
Go
package main
|
||
|
||
import (
|
||
"bytes"
|
||
"fmt"
|
||
"os"
|
||
"path/filepath"
|
||
"strings"
|
||
"text/template"
|
||
|
||
"github.com/tealeg/xlsx"
|
||
"mongo.games.com/goserver/core"
|
||
)
|
||
|
||
type SheetColumnMetaStruct struct {
|
||
ColIndex int
|
||
ColName string
|
||
ColType int
|
||
CTString string
|
||
IsArray bool
|
||
IsMap bool
|
||
}
|
||
|
||
type SheetMetaStruct struct {
|
||
AbsPath string
|
||
FileName string
|
||
ProtoName string
|
||
Cols []*SheetColumnMetaStruct
|
||
}
|
||
|
||
const (
|
||
INTTYPE string = "(int)"
|
||
INT64TYPE string = "(int64)"
|
||
STRTYPE = "(str)"
|
||
ARRINTTYPE = "(arrint)"
|
||
ARRINT64TYPE = "(arrint64)"
|
||
ARRSTRTYPE = "(arrstr)"
|
||
INTTYPE_PROTO = "int32"
|
||
INT64TYPE_PROTO = "int64"
|
||
STRTYPE_PROTO = "string"
|
||
MAPTYPE string = "(map)"
|
||
MAP_PROTO = "map"
|
||
)
|
||
|
||
var templates *template.Template
|
||
|
||
func main() {
|
||
|
||
defer core.ClosePackages()
|
||
core.LoadPackages("config.json")
|
||
|
||
smsMap := make(map[string]*SheetMetaStruct)
|
||
for xlsxFileName, xlsxFilePath := range XlsxFiles {
|
||
xlsxFile, err := xlsx.OpenFile(xlsxFilePath)
|
||
if err != nil {
|
||
fmt.Println("excel file open error:", err, " filePath:", xlsxFilePath)
|
||
continue
|
||
}
|
||
|
||
for _, sheet := range xlsxFile.Sheets {
|
||
sms := &SheetMetaStruct{
|
||
AbsPath: xlsxFilePath,
|
||
FileName: xlsxFileName,
|
||
ProtoName: strings.TrimSuffix(xlsxFileName, ".xlsx"),
|
||
Cols: make([]*SheetColumnMetaStruct, 0, sheet.MaxCol)}
|
||
|
||
for _, row := range sheet.Rows {
|
||
for i, cell := range row.Cells {
|
||
s := cell.String()
|
||
if strings.HasSuffix(s, INTTYPE) {
|
||
sms.Cols = append(sms.Cols, &SheetColumnMetaStruct{i, strings.TrimSuffix(s, INTTYPE), 1, INTTYPE_PROTO, false, false})
|
||
} else if strings.HasSuffix(s, STRTYPE) {
|
||
sms.Cols = append(sms.Cols, &SheetColumnMetaStruct{i, strings.TrimSuffix(s, STRTYPE), 2, STRTYPE_PROTO, false, false})
|
||
} else if strings.HasSuffix(s, ARRINTTYPE) {
|
||
sms.Cols = append(sms.Cols, &SheetColumnMetaStruct{i, strings.TrimSuffix(s, ARRINTTYPE), 3, INTTYPE_PROTO, true, false})
|
||
} else if strings.HasSuffix(s, ARRSTRTYPE) {
|
||
sms.Cols = append(sms.Cols, &SheetColumnMetaStruct{i, strings.TrimSuffix(s, ARRSTRTYPE), 4, STRTYPE_PROTO, true, false})
|
||
} else if strings.HasSuffix(s, INT64TYPE) {
|
||
sms.Cols = append(sms.Cols, &SheetColumnMetaStruct{i, strings.TrimSuffix(s, INT64TYPE), 5, INT64TYPE_PROTO, false, false})
|
||
} else if strings.HasSuffix(s, ARRINT64TYPE) {
|
||
sms.Cols = append(sms.Cols, &SheetColumnMetaStruct{i, strings.TrimSuffix(s, ARRINT64TYPE), 6, INT64TYPE_PROTO, true, false})
|
||
} else if strings.HasSuffix(s, MAPTYPE) {
|
||
sms.Cols = append(sms.Cols, &SheetColumnMetaStruct{i, strings.TrimSuffix(s, MAPTYPE), 7, MAP_PROTO, false, true})
|
||
}
|
||
}
|
||
break //only fetch first row
|
||
}
|
||
|
||
smsMap[sms.ProtoName] = sms
|
||
break //only fetch first sheet
|
||
}
|
||
}
|
||
|
||
geneProto(smsMap)
|
||
}
|
||
|
||
func geneProto(xlsxs map[string]*SheetMetaStruct) {
|
||
if xlsxs == nil {
|
||
return
|
||
}
|
||
|
||
geneAgcHelper(xlsxs) //生成 xlsx转二进制文件（.json,.dat）
|
||
geneDataStructProto(xlsxs) //生成 xlsx转protobuf结构文件(pbdata.proto)
|
||
//geneDataSingleStructProto(xlsxs)
|
||
//geneChhDataMgrHeader(xlsxs)//生成 c头文件
|
||
//geneCppDataMgrHeader(xlsxs)//生成 c源文件
|
||
//copyNoDataProtoToLua()
|
||
for _, val := range xlsxs {
|
||
genGoDataMgr(val) // 生成Go对象文件
|
||
genTsDataMgr(val) // 生成TypeScript对象文件
|
||
}
|
||
}
|
||
|
||
// geneAgcHelper 生成go代码，读取xlsx数据
|
||
func geneAgcHelper(xlsxs map[string]*SheetMetaStruct) {
|
||
dm := map[string]interface{}{
|
||
"data": xlsxs,
|
||
"opath": filepath.Join(Config.WorkPath, Config.DataPath),
|
||
"isMapCol": isMapColumn(xlsxs),
|
||
}
|
||
outputHelper := bytes.NewBuffer(nil)
|
||
err := templates.ExecuteTemplate(outputHelper, "agc", dm)
|
||
if err != nil {
|
||
fmt.Println("geneProto ExecuteTemplate error:", err)
|
||
return
|
||
}
|
||
|
||
helperGoFile := filepath.Join(Config.WorkPath, Config.ConvertToolPath, "agc.go")
|
||
err = os.WriteFile(helperGoFile, outputHelper.Bytes(), os.ModePerm)
|
||
if err != nil {
|
||
fmt.Println("geneProto WriteFile error:", err)
|
||
return
|
||
}
|
||
}
|
||
|
||
// geneDataStructProto 生成xlsx的proto文件
|
||
func geneDataStructProto(xlsxs map[string]*SheetMetaStruct) {
|
||
|
||
outputHelper := bytes.NewBuffer(nil)
|
||
err := templates.ExecuteTemplate(outputHelper, "gpb", xlsxs)
|
||
if err != nil {
|
||
fmt.Println("geneDataStructProto ExecuteTemplate error:", err)
|
||
return
|
||
}
|
||
|
||
protoFile := filepath.Join(Config.WorkPath, Config.ProtoPath, Config.ProtoFile)
|
||
err = os.WriteFile(protoFile, outputHelper.Bytes(), os.ModePerm)
|
||
if err != nil {
|
||
fmt.Println("geneDataStructProto error:", err)
|
||
}
|
||
}
|
||
|
||
func geneDataSingleStructProto(xlsxs map[string]*SheetMetaStruct) {
|
||
for k, v := range xlsxs {
|
||
outputHelper := bytes.NewBuffer(nil)
|
||
err := templates.ExecuteTemplate(outputHelper, "gpb_single", v)
|
||
if err != nil {
|
||
fmt.Println("geneDataSingleStructProto ExecuteTemplate error:", err)
|
||
return
|
||
}
|
||
|
||
protoFile := filepath.Join(Config.WorkPath, Config.ProtoLuaPath, strings.ToLower(k)+".proto")
|
||
err = os.WriteFile(protoFile, outputHelper.Bytes(), os.ModePerm)
|
||
if err != nil {
|
||
fmt.Println("geneDataSingleStructProto error:", err)
|
||
}
|
||
}
|
||
}
|
||
|
||
// genGoDataMgr 生成go代码，读取.dat文件数据
|
||
func genGoDataMgr(sms *SheetMetaStruct) {
|
||
if sms == nil {
|
||
return
|
||
}
|
||
|
||
outputHelper := bytes.NewBuffer(nil)
|
||
err := templates.ExecuteTemplate(outputHelper, "gpb_mgr", sms)
|
||
if err != nil {
|
||
fmt.Println("genGoDataMgr ExecuteTemplate error:", err)
|
||
return
|
||
}
|
||
opath := filepath.Join(Config.WorkPath, Config.GoFilePath, strings.ToLower(fmt.Sprintf("%v.go", sms.ProtoName)))
|
||
err = os.WriteFile(opath, outputHelper.Bytes(), os.ModePerm)
|
||
if err != nil {
|
||
fmt.Println("genGoDataMgr WriteFile error:", err)
|
||
return
|
||
}
|
||
}
|
||
|
||
// genTsDataMgr 生成ts类模板
|
||
func genTsDataMgr(sms *SheetMetaStruct) {
|
||
if sms == nil {
|
||
return
|
||
}
|
||
|
||
outputHelper := bytes.NewBuffer(nil)
|
||
err := templates.ExecuteTemplate(outputHelper, "gpb_mgr_ts", sms)
|
||
if err != nil {
|
||
fmt.Println("genTsDataMgr ExecuteTemplate error:", err)
|
||
return
|
||
}
|
||
//opath := filepath.Join(Config.WorkPath, Config.TsFilePath, strings.ToLower(fmt.Sprintf("%v.ts", sms.ProtoName)))
|
||
opath := fmt.Sprintf("%v/%v", Config.TsFilePath, strings.ToLower(fmt.Sprintf("%v.ts", sms.ProtoName)))
|
||
err = os.WriteFile(opath, outputHelper.Bytes(), os.ModePerm)
|
||
if err != nil {
|
||
fmt.Println("genTsDataMgr WriteFile error:", err)
|
||
return
|
||
}
|
||
}
|
||
|
||
func geneChhDataMgrHeader(xlsxs map[string]*SheetMetaStruct) {
|
||
dm := map[string]interface{}{
|
||
"data": xlsxs,
|
||
}
|
||
outputHelper := bytes.NewBuffer(nil)
|
||
err := templates.ExecuteTemplate(outputHelper, "gpb_mgr_h", dm)
|
||
if err != nil {
|
||
fmt.Println("geneProto ExecuteTemplate error:", err)
|
||
return
|
||
}
|
||
|
||
helperChhFile := filepath.Join(Config.WorkPath, Config.CppFilePath, "DataMgrAgc.h")
|
||
err = os.WriteFile(helperChhFile, outputHelper.Bytes(), os.ModePerm)
|
||
if err != nil {
|
||
fmt.Println("geneProto WriteFile error:", err)
|
||
return
|
||
}
|
||
}
|
||
|
||
func geneCppDataMgrHeader(xlsxs map[string]*SheetMetaStruct) {
|
||
dm := map[string]interface{}{
|
||
"data": xlsxs,
|
||
}
|
||
outputHelper := bytes.NewBuffer(nil)
|
||
err := templates.ExecuteTemplate(outputHelper, "gpb_mgr_c", dm)
|
||
if err != nil {
|
||
fmt.Println("geneProto ExecuteTemplate error:", err)
|
||
return
|
||
}
|
||
|
||
helperChhFile := filepath.Join(Config.WorkPath, Config.CppFilePath, "DataMgrAgc.cpp")
|
||
err = os.WriteFile(helperChhFile, outputHelper.Bytes(), os.ModePerm)
|
||
if err != nil {
|
||
fmt.Println("geneProto WriteFile error:", err)
|
||
return
|
||
}
|
||
}
|
||
|
||
func copyNoDataProtoToLua() {
|
||
protoFile := filepath.Join(Config.WorkPath, Config.ProtoPath)
|
||
rootdir, pathopen := os.Open(protoFile)
|
||
if pathopen != nil {
|
||
fmt.Println("Path open error.")
|
||
} else {
|
||
files, _ := rootdir.Readdir(0)
|
||
for _, fi := range files {
|
||
if strings.HasSuffix(fi.Name(), ".proto") && !strings.Contains(fi.Name(), "pbdata.proto") {
|
||
datas, err := os.ReadFile(filepath.Join(Config.WorkPath, Config.ProtoPath, fi.Name()))
|
||
if err == nil {
|
||
strContent := string(datas[:])
|
||
strContent = strings.Replace(strContent, `"protocol/`, `"`, -1)
|
||
dest := filepath.Join(Config.WorkPath, Config.ProtoLuaPath, fi.Name())
|
||
fmt.Println("==========dest", dest)
|
||
os.WriteFile(dest, []byte(strContent), os.ModePerm)
|
||
} else {
|
||
fmt.Println(err)
|
||
}
|
||
}
|
||
|
||
}
|
||
}
|
||
}
|
||
|
||
func isMapColumn(xlsxs map[string]*SheetMetaStruct) bool {
|
||
for _, sheet := range xlsxs {
|
||
for _, col := range sheet.Cols {
|
||
if col.IsMap {
|
||
return true
|
||
}
|
||
}
|
||
}
|
||
return false
|
||
}
|