server

Documentation

Index

• Variables
• type BaseProjectInfo
• type ControllerInfo
• type Field
• type ModelInfo
• type RouterInfo
• type SqlInfo
• type StructInfo

Variables

var CreateBaseProjectHandler handler.HandlerTablesFunc = func(table []*common.Table) {

	beego.Debug("CreateBaseProjectHandler")
	info := BaseProjectInfo{}
	info.SetUp()

	createServerFile("api/base.go", "api.base.y", info)
	createServerFile("api/login.go", "api.login.y", info)
	createServerFile("cmd/main.go", "main.y", info)
	createServerFile("cmd/conf/app.conf", "app.conf.y", info)
	createServerFile("cmd/conf/db.conf", "db.conf.y", info)
	createServerFile("cmd/conf/upload.conf", "upload.conf.y", info)
	createServerFile("common/common.go", "common.y", info)
	createServerFile("db/db.go", "db.y", info)
	createServerFile("filter/filter.go", "filter.y", info)
	createServerFile("model/base.go", "model.base.y", info)
	createServerFile("msg/base.go", "msg.y", info)
}

var CreateControllerHandler handler.HandlerOneTableFunc = func(table *common.Table, columns []*common.Column) {

	beego.Debug("CreateControllerHandler")

	fileds := make([]Field, 0)
	fieldCommont := ""
	fieldName := ""
	for _, column := range columns {

		fieldCommont = "`db:\"" + column.Name + "\"` //" + handler.ConvertComment(column.Comment)

		fieldName = strings.ToUpper(column.Name[:1]) + strings.ToLower(column.Name[1:])
		fieldType, ok := db.DBTYPE[column.SQLType.Name]
		if !ok {
			fieldType = "string"
		}

		fileds = append(fileds, Field{fieldName, fieldType, fieldCommont})
	}

	scontrollerinfo := ControllerInfo{}
	scontrollerinfo.SetUp()

	scontrollerinfo.ControllerName = strings.ToUpper(table.Name) + "_CONTROLLER"
	scontrollerinfo.ModelName = strings.ToUpper(table.Name) + "_MODEL"
	scontrollerinfo.Package = "api"
	scontrollerinfo.TableNameLow = strings.ToLower(table.Name)
	scontrollerinfo.TableNameUpper = strings.ToUpper(table.Name)
	scontrollerinfo.FirstColumnName = columns[0].Name
	if len(columns) > 1 {
		scontrollerinfo.SecondColumnName = columns[1].Name
	} else {
		scontrollerinfo.SecondColumnName = "y" + columns[0].Name
	}
	scontrollerinfo.Fields = fileds
	scontrollerinfo.Columns = columns

	createServerFile("api/"+"api_"+strings.ToLower(table.Name)+".go", "controller.y", scontrollerinfo)
}

const ControllerTemplate = `//{{.Auth}} package {{.Package}}

type {{.ControllerName}} scontroller { {{with .Fields}}

{{range .}}
{{.Name}}        {{.Type}}     {{.Comment}}
{{end}}

{{end}} } `

var CreateDirHandler handler.HandlerTablesFunc = func(table []*common.Table) {

	beego.Debug("CreateDirHandler")

	filemode := os.ModePerm

	os.MkdirAll(cfg.Cfg.GetServerProjcetPath(), filemode)

	os.MkdirAll(cfg.Cfg.GetServerProjcetPath()+"api", filemode)
	os.MkdirAll(cfg.Cfg.GetServerProjcetPath()+"cmd", filemode)
	os.MkdirAll(cfg.Cfg.GetServerProjcetPath()+"cmd/logs", filemode)
	os.MkdirAll(cfg.Cfg.GetServerProjcetPath()+"cmd/conf", filemode)
	os.MkdirAll(cfg.Cfg.GetServerProjcetPath()+"cmd/sql/mysql", filemode)
	os.MkdirAll(cfg.Cfg.GetServerProjcetPath()+"common", filemode)
	os.MkdirAll(cfg.Cfg.GetServerProjcetPath()+"db", filemode)
	os.MkdirAll(cfg.Cfg.GetServerProjcetPath()+"filter", filemode)
	os.MkdirAll(cfg.Cfg.GetServerProjcetPath()+"model", filemode)
	os.MkdirAll(cfg.Cfg.GetServerProjcetPath()+"msg", filemode)
	os.MkdirAll(cfg.Cfg.GetServerProjcetPath()+"router", filemode)
}

var CreateModelHandler handler.HandlerOneTableFunc = func(table *common.Table, columns []*common.Column) {
	beego.Debug("CreateModelHandler")

	fileds := make([]Field, 0)
	fieldCommont := ""
	fieldName := ""
	for _, column := range columns {

		fieldCommont = "`db:\"" + column.Name + "\"` //" + handler.ConvertComment(column.Comment)

		fieldName = strings.ToUpper(column.Name[:1]) + strings.ToLower(column.Name[1:])
		fieldType, ok := db.DBTYPE[column.SQLType.Name]
		if !ok {
			fieldType = "string"
		}

		fileds = append(fileds, Field{fieldName, fieldType, fieldCommont})
	}

	info := ModelInfo{}
	info.SetUp()
	info.ControllerName = strings.ToUpper(table.Name) + "_CONTROLLER"
	info.ModelName = strings.ToUpper(table.Name) + "_MODEL"
	info.Package = "model"
	info.TableNameLow = strings.ToLower(table.Name)
	info.TableNameUpper = strings.ToUpper(table.Name)
	info.FirstColumnName = columns[0].Name
	if len(columns) > 1 {
		info.SecondColumnName = columns[1].Name
	} else {
		info.SecondColumnName = "y" + columns[0].Name
	}
	info.Fields = fileds
	info.Columns = columns

	createServerFile("model/"+"model_"+strings.ToLower(table.Name)+".go", "model.y", info)
}

var CreateRouterHandler handler.HandlerTablesFunc = func(table []*common.Table) {

	beego.Debug("CreateRouterHandler")

	info := RouterInfo{}
	info.SetUp()
	info.Package = "router"
	info.Tables = table

	createServerFile("router/router.go", "router.y", info)
}

var CreateSqlHandler handler.HandlerOneTableFunc = func(table *common.Table, columns []*common.Column) {
	beego.Debug("CreateSqlHandler")

	fileds := make([]Field, 0)
	fieldCommont := ""
	fieldName := ""
	for _, column := range columns {

		fieldCommont = "`db:\"" + column.Name + "\"` //" + handler.ConvertComment(column.Comment)

		fieldName = strings.ToUpper(column.Name[:1]) + strings.ToLower(column.Name[1:])
		fieldType, ok := db.DBTYPE[column.SQLType.Name]
		if !ok {
			fieldType = "string"
		}

		fileds = append(fileds, Field{fieldName, fieldType, fieldCommont})
	}

	info := SqlInfo{}
	info.SetUp()
	info.SqlName = strings.ToUpper(table.Name)
	info.Package = "api"
	info.TableNameLow = strings.ToLower(table.Name)
	info.FirstColumnName = strings.ToLower(columns[0].Name)
	if len(columns) > 1 {
		info.SecondColumnName = strings.ToLower(columns[1].Name)
	} else {
		info.SecondColumnName = strings.ToLower("y" + columns[0].Name)
	}
	info.Fields = fileds
	info.Columns = columns

	createServerFile("cmd/sql/mysql/"+""+strings.ToLower(table.Name)+".base.xsql", "sql.base.y", info)
	createServerFile("cmd/sql/mysql/"+""+strings.ToLower(table.Name)+".read.stpl", "sql.read.y", info)
	createServerFile("cmd/sql/mysql/"+""+strings.ToLower(table.Name)+".count.stpl", "sql.count.y", info)
}

var CreateStructHandler handler.HandlerOneTableFunc = func(table *common.Table, columns []*common.Column) {

	beego.Debug("CreateStructHandler")

	fileds := make([]Field, 0)
	fieldCommont := ""
	fieldName := ""
	for _, column := range columns {

		fieldCommont = "`" + "json:" + "\"" + strings.ToLower(column.Name) + "\"" + "` //" + handler.ConvertComment(column.Comment)

		fieldName = strings.ToUpper(column.Name[:1]) + strings.ToLower(column.Name[1:])

		fieldType, ok := db.DBTYPE[column.SQLType.Name]

		if !ok {
			fieldType = "string"
		}

		fileds = append(fileds, Field{fieldName, fieldType, fieldCommont})
	}

	info := StructInfo{}
	info.SetUp()
	info.StructName = strings.ToUpper(table.Name)
	info.Package = "db"
	info.Fields = fileds

	createServerFile("db/"+"db_"+strings.ToLower(table.Name)+".go", "struct.y", info)
}

var DownloadTemplateHandler handler.HandlerTablesFunc = func(table []*common.Table) {

	beego.Debug("DownloadTemplateHandler")

	filemode := os.ModePerm
	now := common.GetNowTimeYYYYMMDDhhmmss()
	tempdir := cfg.Cfg.GetServerTempPath() + now + "/"
	e := os.MkdirAll(tempdir, filemode)
	if e != nil {
		panic(e)
	}
	savefilepath := tempdir + "server.zip"
	handler.DownloadFile(common.SvrTemplateZipUrl, savefilepath)

	handler.Unzip(savefilepath, tempdir)

	cfg.Cfg.ServerTemplatePath = tempdir + "server/"
}

Types

type BaseProjectInfo

type BaseProjectInfo struct {
	handler.BaseInfo
}

type ControllerInfo

type ControllerInfo struct {
	ControllerName string
	ModelName      string
	//Package          string
	//PreUrl           string
	//FirstColumnName  string
	//SecondColumnName string
	//TableNameLow     string
	//TableNameUpper   string
	Fields []Field
	//Columns          []*core.Column
	handler.BaseInfo
}

type Field

type Field struct {
	Name    string
	Type    string
	Comment string
}

type ModelInfo

type ModelInfo struct {
	//Auth             string
	ControllerName string
	ModelName      string
	//Package          string
	//ProjectUri       string
	//PreUrl           string
	//FirstColumnName  string
	//SecondColumnName string
	//TableNameLow     string
	//TableNameUpper   string
	Fields []Field
	//Columns          []*core.Column
	handler.BaseInfo
}

type RouterInfo

type RouterInfo struct {
	handler.BaseInfo
}

type SqlInfo

type SqlInfo struct {
	SqlName string
	Fields  []Field
	handler.BaseInfo
}

type StructInfo

type StructInfo struct {
	StructName string
	Fields     []Field
	handler.BaseInfo
}