tmpl

Documentation

Index

• Constants

Constants

const AppController = `` /* 248-byte string literal not displayed */

const AppRepository = `` /* 272-byte string literal not displayed */

const AppRouter = `` /* 229-byte string literal not displayed */

const AppService = `` /* 239-byte string literal not displayed */

const CommonController = `
package logic

import (
	"github.com/gin-gonic/gin"
	{{range .ImportPkgPaths}}{{.}} ` + "\n" + `{{end}}
)

type {{.StructName}}Controller struct {
	controller.BaseController
	svcCtx *svc.ControllerContext
}

func New{{.StructName}}Controller(svcCtx *svc.ControllerContext) *{{.StructName}}Controller {
	return &{{.StructName}}Controller{
		svcCtx: svcCtx,
		BaseController: controller.NewBaseController(svcCtx),
	}
}
`

const CommonRepository = `
package logic

import (
	{{range .ImportPkgPaths}}{{.}} ` + "\n" + `{{end}}
)

type {{.StructName}}Repository struct {
	DbEngin *gorm.DB
	Cache   *redis.Client
}

func New{{.StructName}}Repository(svcCtx *svc.RepositoryContext) *{{.StructName}}Repository {
	return &{{.StructName}}Repository{
		DbEngin: svcCtx.DbEngin,
		Cache:   svcCtx.Cache,
	}
}
`

const CommonRouter = `
package logic

import (
	"github.com/gin-gonic/gin"

	{{range .ImportPkgPaths}}{{.}} ` + "\n" + `{{end}}
)

type {{.StructName}}Router struct {
	svcCtx *svc.RouterContext
}

func New{{.StructName}}Router(svcCtx *svc.RouterContext) *{{.StructName}}Router {
	return &{{.StructName}}Router{
		svcCtx: svcCtx,
	}
}
`

const CommonService = `` /* 240-byte string literal not displayed */

const Controller = `
package logic

import (
	"github.com/gin-gonic/gin"
	{{range .ImportPkgPaths}}{{.}} ` + "\n" + `{{end}}
)

type {{.StructName}}Controller struct {
	controller.BaseController
	svcCtx *svc.ControllerContext
}

func New{{.StructName}}Controller(svcCtx *svc.ControllerContext) *{{.StructName}}Controller {
	return &{{.StructName}}Controller{
		svcCtx: svcCtx,
		BaseController: controller.NewBaseController(svcCtx),
	}
}

// @Tags	 {{.StructName}}
// @Summary  创建{{.StructComment}}
// @Security ApiKeyAuth
// @accept 	 application/json
// @Produce  application/json
// @Param 	 data  body 	 entity.{{.StructName}}		true  "请求body"
// @Success  200   {object}  response.Response{data=entity.{{.StructName}}}  	"返回信息"
// @Router /{{.ValueName}}/create [post]
func (s *{{.StructName}}Controller) Create{{.StructName}}(c *gin.Context) {
	reqCtx, err := s.GetRequestContext(c)
	if err != nil {
		s.ResponseError(c, err)
		return
	}

	var {{.ValueName}} entity.{{.StructName}}
	err = s.ShouldBind(c, &{{.ValueName}})
	if err != nil {
		s.ResponseError(c, err)
		return
	}

	data, err := s.svcCtx.{{.StructName}}Service.Create{{.StructName}}(reqCtx, &{{.ValueName}});
	if err != nil {
		s.ResponseError(c, err)
		return
	}

	s.ResponseOk(c, data)
}

// @Tags 	{{.StructName}}
// @Summary 删除{{.StructComment}}
// @Security ApiKeyAuth
// @accept 	application/json
// @Produce application/json
// @Param 	data body	 	entity.{{.StructName}} 		true "请求body"
// @Success 200  {object}  	response.Response{}  	"返回信息"
// @Router /{{.ValueName}}/delete [delete]
func (s *{{.StructName}}Controller) Delete{{.StructName}}(c *gin.Context) {
	reqCtx, err := s.GetRequestContext(c)
	if err != nil {
		s.ResponseError(c, err)
		return
	}

	var {{.ValueName}} entity.{{.StructName}}
	err = s.ShouldBind(c, &{{.ValueName}})
	if err != nil {
		s.ResponseError(c, err)
		return
	}

	data, err := s.svcCtx.{{.StructName}}Service.Delete{{.StructName}}(reqCtx, &{{.ValueName}});
	if err != nil {
		s.ResponseError(c, err)
		return
	}

	s.ResponseOk(c, data)
}

// @Tags 	{{.StructName}}
// @Summary 更新{{.StructComment}}
// @Security ApiKeyAuth
// @accept 	application/json
// @Produce application/json
// @Param 	data body 		entity.{{.StructName}} 		true "请求body"
// @Success 200  {object}  	response.Response{data=entity.{{.StructName}}}  	"返回信息"
// @Router /{{.ValueName}}/update [put]
func (s *{{.StructName}}Controller) Update{{.StructName}}(c *gin.Context) {
	reqCtx, err := s.GetRequestContext(c)
	if err != nil {
		s.ResponseError(c, err)
		return
	}

	var {{.ValueName}} entity.{{.StructName}}
	err = s.ShouldBind(c, &{{.ValueName}})
	if err != nil {
		s.ResponseError(c, err)
		return
	}

	data, err := s.svcCtx.{{.StructName}}Service.Update{{.StructName}}(reqCtx, &{{.ValueName}});
	if err != nil {
		s.ResponseError(c, err)
		return
	}

	s.ResponseOk(c, data)
}

// @Tags 	{{.StructName}}
// @Summary 查询{{.StructComment}}
// @Security ApiKeyAuth
// @accept 	application/json
// @Produce	application/json
// @Param 	data query 		entity.{{.StructName}} 		true "请求body"
// @Success 200  {object}  	response.Response{data=entity.{{.StructName}}}  	"返回信息"
// @Router /{{.ValueName}}/query [get]
func (s *{{.StructName}}Controller) Get{{.StructName}}(c *gin.Context) {
	reqCtx, err := s.GetRequestContext(c)
	if err != nil {
		s.ResponseError(c, err)
		return
	}

	var {{.ValueName}} entity.{{.StructName}}
	err = s.ShouldBind(c, &{{.ValueName}})
	if err != nil {
		s.ResponseError(c, err)
		return
	}

	data, err := s.svcCtx.{{.StructName}}Service.Get{{.StructName}}(reqCtx, &{{.ValueName}});
	if err != nil {
		s.ResponseError(c, err)
		return
	}

	s.ResponseOk(c, data)
}

// @Tags 	{{.StructName}}
// @Summary 批量删除{{.StructComment}}
// @Security ApiKeyAuth
// @accept 	application/json
// @Produce application/json
// @Param 	data body 		[]int 					true "删除id列表"
// @Success 200  {object}  	response.Response{}  	"返回信息"
// @Router /{{.ValueName}}/deleteByIds [delete]
func (s *{{.StructName}}Controller) Delete{{.StructName}}ByIds(c *gin.Context) {
	reqCtx, err := s.GetRequestContext(c)
	if err != nil {
		s.ResponseError(c, err)
		return
	}

	var IDS []int
	err = s.ShouldBind(c, &IDS)
	if err != nil {
		s.ResponseError(c, err)
		return
	}

	data, err := s.svcCtx.{{.StructName}}Service.Delete{{.StructName}}ByIds(reqCtx, IDS);
	if err != nil {
		s.ResponseError(c, err)
		return
	}

	s.ResponseOk(c, data)
}

// @Tags 	{{.StructName}}
// @Summary 分页获取{{.StructComment}}列表
// @Security ApiKeyAuth
// @accept 	application/json
// @Produce	application/json
// @Param 	data query 		request.PageInfo 	true "分页参数"
// @Success 200  {object}  	response.Response{data=response.PageResult{list=[]entity.{{.StructName}}}}  	"返回信息"
// @Router /{{.ValueName}}/list [get]
func (s *{{.StructName}}Controller) Find{{.StructName}}List(c *gin.Context) {
	reqCtx, err := s.GetRequestContext(c)
	if err != nil {
		s.ResponseError(c, err)
		return
	}

	var page request.PageInfo
	err = s.ShouldBind(c, &page)
	if err != nil {
		s.ResponseError(c, err)
		return
	}

	list, total, err := s.svcCtx.{{.StructName}}Service.Find{{.StructName}}List(reqCtx, &page); 
	if err != nil {
		s.ResponseError(c, err)
		return
	}
	
	s.ResponseOk(c, response.PageResult{
		List:     list,
		Total:    total,
		Page:     page.Page,
		PageSize: page.Limit(),
	})
}
`

const ControllerContext = `` /* 345-byte string literal not displayed */

const Header = NotEditMark + `
package {{.Package}}

import(	
	{{range .ImportPkgPaths}}{{.}}` + "\n" + `{{end}}
)
`

const KeyController = "controller"

const KeyModel = "model"

const KeyRepository = "repository"

const KeyRouter = "router"

const KeyService = "service"

const Model = NotEditMark + `
package entity

import (
	"encoding/json"
	"time"

	"gorm.io/datatypes"
	"gorm.io/gorm"
	"gorm.io/gorm/schema"
	{{range .ImportPkgPaths}}{{.}} ` + "\n" + `{{end}}
)

// TableName{{.StructName}} return the table name of <{{.TableName}}>
const TableName{{.StructName}} = "{{.TableName}}"

// {{.StructName}} mapped from table <{{.TableName}}>
type {{.StructName}} struct {
    {{range .Fields}}
	{{if .MultilineComment -}}
	/*
	{{.ColumnComment}}
    */
	{{end -}}
    {{.FieldName}} {{.FieldType}} ` + "`{{.Tags}}` " +
	"{{if not .MultilineComment}}{{if .ColumnComment}}// {{.ColumnComment}}{{end}}{{end}}" +
	`{{end}}
}

{{ if .TableName }}
// TableName {{.StructName}}'s table name
func (*{{.StructName}}) TableName() string {
  return TableName{{.StructName}}
}
{{ end }}
`

const NotEditMark = `` /* 190-byte string literal not displayed */

const Repository = `
package logic

import (
	{{range .ImportPkgPaths}}{{.}} ` + "\n" + `{{end}}
)

type {{.StructName}}Repository struct {
	DbEngin *gorm.DB
	Cache   *redis.Client
}

func New{{.StructName}}Repository(svcCtx *svc.RepositoryContext) *{{.StructName}}Repository {
	return &{{.StructName}}Repository{
		DbEngin: svcCtx.DbEngin,
		Cache:   svcCtx.Cache,
	}
}

// 创建{{.StructName}}记录
func (s *{{.StructName}}Repository) Create{{.StructName}}(ctx context.Context, {{.ValueName}} *entity.{{.StructName}}) (out *entity.{{.StructName}}, err error) {
	db:= s.DbEngin
	err = db.Create(&{{.ValueName}}).Error
	if err != nil {
		return nil, err
	}
	return {{.ValueName}}, err
}

// 删除{{.StructName}}记录
func (s *{{.StructName}}Repository) Delete{{.StructName}}(ctx context.Context, {{.ValueName}} *entity.{{.StructName}}) (rows int64, err error) {
	db:= s.DbEngin	
	query := db.Delete(&{{.ValueName}})
	err = query.Error
	rows = query.RowsAffected
	return rows, err
}

// 更新{{.StructName}}记录
func (s *{{.StructName}}Repository) Update{{.StructName}}(ctx context.Context, {{.ValueName}} *entity.{{.StructName}}) (out *entity.{{.StructName}}, err error) {
	db:= s.DbEngin	
	err = db.Save(&{{.ValueName}}).Error
	if err != nil {
		return nil, err
	}
	return {{.ValueName}}, err
}

// 查询{{.StructName}}记录
func (s *{{.StructName}}Repository) Get{{.StructName}}(ctx context.Context, id int) (out *entity.{{.StructName}}, err error) {
	db:= s.DbEngin	
	err = db.Where("id = ?", id).First(&out).Error
	if err != nil {
		return nil, err
	}
	return out, err
}

// 批量删除{{.StructName}}记录
func (s *{{.StructName}}Repository) Delete{{.StructName}}ByIds(ctx context.Context, ids []int) (rows int64, err error) {
	db:= s.DbEngin	
	query := db.Delete(&[]entity.{{.StructName}}{}, "id in ?", ids)
	err = query.Error
	rows = query.RowsAffected
	return rows, err
}

// 分页查询{{.StructName}}记录
func (s *{{.StructName}}Repository) Find{{.StructName}}List(ctx context.Context, page *request.PageInfo) (list []*entity.{{.StructName}}, total int64, err error) {
	// 创建db
	db := s.DbEngin

	// 如果有搜索条件
	if len(page.Conditions) != 0 {
		query, args := page.WhereClause()
		db = db.Where(query, args...)
	}

	// 如果有排序参数
	if len(page.Orders) != 0 {
		db = db.Order(page.OrderClause())
	}

	// 查询总数,要在使用limit之前
	err = db.Model(&list).Count(&total).Error
	if err != nil {
		return nil, 0, err
	}

	// 如果有分页参数
	if page.Page != 0 || page.PageSize != 0 {
		limit := page.Limit()
		offset := page.Offset()
		db = db.Limit(limit).Offset(offset)
	}

	// 查询数据
	err = db.Find(&list).Error
	if err != nil {
		return nil, 0, err
	}

	return list, total, nil
}
`

const RepositoryContext = `` /* 508-byte string literal not displayed */

const Router = `
package logic

import (
	"github.com/gin-gonic/gin"

	{{range .ImportPkgPaths}}{{.}} ` + "\n" + `{{end}}
)

type {{.StructName}}Router struct {
	svcCtx *svc.RouterContext
}

func New{{.StructName}}Router(svcCtx *svc.RouterContext) *{{.StructName}}Router {
	return &{{.StructName}}Router{
		svcCtx: svcCtx,
	}
}

// 初始化 {{.StructName}} 路由信息
// publicRouter 公开路由，不登录就可以访问
// loginRouter  登录路由，登录后才可以访问
func (s *{{.StructName}}Router) Init{{.StructName}}Router(publicRouter *gin.RouterGroup, loginRouter *gin.RouterGroup) {

	var handler = s.svcCtx.AppController.{{.StructName}}Controller
	{
		publicRouter.POST("{{.ValueName}}/create", handler.Create{{.StructName}})             // 新建{{.StructName}}
		publicRouter.PUT("{{.ValueName}}/update", handler.Update{{.StructName}})              // 更新{{.StructName}}
		publicRouter.DELETE("{{.ValueName}}/delete", handler.Delete{{.StructName}})           // 删除{{.StructName}}
		publicRouter.POST("{{.ValueName}}/query", handler.Get{{.StructName}})				  // 查询{{.StructName}}

		publicRouter.DELETE("{{.ValueName}}/deleteByIds", handler.Delete{{.StructName}}ByIds)	// 批量删除{{.StructName}}列表
		publicRouter.POST("{{.ValueName}}/list", handler.Find{{.StructName}}List)  				// 分页查询{{.StructName}}列表
	}
}
`

const RouterContext = `` /* 351-byte string literal not displayed */

const Service = `
package logic

import (
	{{range .ImportPkgPaths}}{{.}} ` + "\n" + `{{end}}
)

type {{.StructName}}Service struct {
	svcCtx *svc.ServiceContext
}

func New{{.StructName}}Service(svcCtx *svc.ServiceContext) *{{.StructName}}Service {
	return &{{.StructName}}Service{
		svcCtx: svcCtx,
	}
}

// 创建{{.StructName}}记录
func (s *{{.StructName}}Service) Create{{.StructName}}(reqCtx *request.Context, {{.ValueName}} *entity.{{.StructName}}) (data *entity.{{.StructName}}, err error) {
	return s.svcCtx.{{.StructName}}Repository.Create{{.StructName}}(reqCtx, {{.ValueName}})
}

// 删除{{.StructName}}记录
func (s *{{.StructName}}Service) Delete{{.StructName}}(reqCtx *request.Context, {{.ValueName}} *entity.{{.StructName}}) (rows int64, err error) {
	return s.svcCtx.{{.StructName}}Repository.Delete{{.StructName}}(reqCtx, {{.ValueName}})
}

// 更新{{.StructName}}记录
func (s *{{.StructName}}Service) Update{{.StructName}}(reqCtx *request.Context, {{.ValueName}} *entity.{{.StructName}}) (data *entity.{{.StructName}}, err error) {
	return s.svcCtx.{{.StructName}}Repository.Update{{.StructName}}(reqCtx, {{.ValueName}})
}

// 查询{{.StructName}}记录
func (s *{{.StructName}}Service) Get{{.StructName}}(reqCtx *request.Context, {{.ValueName}} *entity.{{.StructName}}) (data *entity.{{.StructName}}, err error) {
	return s.svcCtx.{{.StructName}}Repository.Get{{.StructName}}(reqCtx, {{.ValueName}}.ID)
}

// 批量删除{{.StructName}}记录
func (s *{{.StructName}}Service) Delete{{.StructName}}ByIds(reqCtx *request.Context, ids []int) (rows int64, err error) {
	return s.svcCtx.{{.StructName}}Repository.Delete{{.StructName}}ByIds(reqCtx, ids)
}

// 分页获取{{.StructName}}记录
func (s *{{.StructName}}Service) Find{{.StructName}}List(reqCtx *request.Context, page *request.PageInfo) (list []*entity.{{.StructName}}, total int64, err error) {
	return s.svcCtx.{{.StructName}}Repository.Find{{.StructName}}List(reqCtx, page)
}
`

const ServiceContext = `` /* 311-byte string literal not displayed */