add orm for model

admin/upload.go

@@ -0,0 +1,103 @@
+package admin
+
+import (
+	"fmt"
+	"github.com/gin-gonic/gin"
+	"gopkg.in/gographics/imagick.v3/imagick"
+	setting "icloudapp.cn/tools/config"
+	"icloudapp.cn/tools/entity"
+	"icloudapp.cn/tools/model"
+	sEntity "icloudapp.cn/tools/service/entity"
+	utFile "icloudapp.cn/tools/util/file"
+	utString "icloudapp.cn/tools/util/string"
+	"time"
+)
+
+func Material(ctx *gin.Context) {
+	file, err := ctx.FormFile("files")
+	if err != nil {
+		entity.ResponseNormal(ctx, entity.CodeFileNotExist, err.Error(), []interface{}{})
+		return
+	}
+	upload := utFile.NewUpload(setting.Conf.Upload.Material)
+	upload.SetAllowed(map[string]bool{
+		".jpg":  true,
+		".png":  true,
+		".gif":  true,
+		".jpeg": true,
+	})
+	upload.SetHasHash(true)
+
+	fileInfo, err := upload.Single(*file)
+
+	if err != nil {
+		entity.ResponseNormal(ctx, entity.CodeCreateDirFail, err.Error(), []interface{}{})
+	}
+	image := imagick.NewMagickWand()
+	if err = image.ReadImage(fileInfo.File); err != nil {
+		entity.ResponseNormal(ctx, entity.CodeSystemError, err.Error(), []interface{}{})
+	}
+	defer image.Destroy()
+	size := fmt.Sprintf("%dx%d", image.GetImageWidth(), image.GetImageHeight())
+	material := model.NewMMaterial(ctx)
+	add, err := material.Add(&sEntity.Material{
+		UID:      utString.ConvertInt64(ctx.GetString("uid")),
+		Name:     fileInfo.Name,
+		File:     fileInfo.File,
+		Size:     size,
+		FileSize: fileInfo.Size,
+		Hash:     fileInfo.Hash,
+		Type:     "material",
+		CreateAt: time.Now(),
+	})
+	if err != nil {
+		entity.ResponseNormal(ctx, entity.CodeSystemError, err.Error(), []interface{}{})
+		return
+	}
+	entity.ResponseSuccess(ctx, add)
+}
+
+// Font 字体上传
+
+func Font(ctx *gin.Context) {
+	file, err := ctx.FormFile("files")
+	if err != nil {
+		entity.ResponseNormal(ctx, entity.CodeFileNotExist, err.Error(), []interface{}{})
+		return
+	}
+	upload := utFile.NewUpload(setting.Conf.Upload.Fonts)
+	upload.SetAllowed(map[string]bool{
+		".ttf":  true,
+		".otf":  true,
+		".woff": true,
+		".fon":  true,
+		".font": true,
+		".eot":  true,
+		".ttc":  true,
+	})
+	upload.SetHasHash(true)
+
+	fileInfo, err := upload.Single(*file)
+
+	if err != nil {
+		entity.ResponseNormal(ctx, entity.CodeCreateDirFail, err.Error(), []interface{}{})
+	}
+
+	material := model.NewMFonts(ctx)
+	add, err := material.Add(&sEntity.Font{
+		Name:     ctx.PostForm("name"),
+		Code:     fileInfo.Basename, //basename
+		Path:     fileInfo.File,
+		FileName: fileInfo.Name,
+		FileSize: fileInfo.Size,
+		Hash:     fileInfo.Hash,
+		FileType: fileInfo.Mine,
+		CreateAt: time.Now(),
+	})
+	if err != nil {
+		entity.ResponseNormal(ctx, entity.CodeSystemError, err.Error(), []interface{}{})
+		return
+	}
+
+	entity.ResponseSuccess(ctx, add)
+}

controller/base.go

@@ -0,0 +1,44 @@
+package controller
+
+import (
+	"github.com/gin-gonic/gin"
+	"icloudapp.cn/tools/entity"
+	"icloudapp.cn/tools/errors"
+	"icloudapp.cn/tools/util"
+)
+
+func HandleNext(ctx *gin.Context, err error) bool {
+	if err != nil {
+		entity.ResponseHandleBody(ctx, errors.GetCode(err), errors.GetMsg(err), entity.EmptyBodyObject())
+		return false
+	}
+	return true
+}
+
+// GetUID 获取用户ID，来源jwt中间
+func GetUID(ctx *gin.Context) int64 {
+	uidParam, exist := ctx.Get("jwt_uid")
+	var uid int64 = 0
+	if !exist {
+		return 0
+	}
+	if err := util.ConvertAssign(&uid, uidParam); err != nil {
+		return 0
+	}
+	return uid
+}
+
+// GetUsername 获取用户名，来源jwt中间
+func GetUsername(ctx *gin.Context) string {
+	usernameParam, exist := ctx.Get("jwt_username")
+
+	if !exist {
+		return ""
+	}
+	var username string
+	if err := util.ConvertAssign(&username, usernameParam); err != nil {
+		return ""
+	}
+
+	return username
+}

controller/materials.go

@@ -0,0 +1,16 @@
+package controller
+
+import (
+	"github.com/gin-gonic/gin"
+	"icloudapp.cn/tools/entity"
+	"icloudapp.cn/tools/model"
+	utString "icloudapp.cn/tools/util/string"
+)
+
+func Materials(ctx *gin.Context) {
+	uid := utString.ConvertInt64(ctx.GetString("uid"))
+	mMaterial := model.NewMMaterial(ctx)
+	materials := mMaterial.Materials(uid)
+
+	entity.ResponseNormal(ctx, materials.Code, materials.Msg, materials.Body)
+}

entity/material.go

@@ -0,0 +1,15 @@
+package entity
+
+type MaterialsApi struct {
+	Code ResCode                       `json:"code"`
+	Msg  string                        `json:"msg"`
+	Body map[string][]MaterialsApiData `json:"data"`
+}
+
+type MaterialsApiData struct {
+	ID        int64  `json:"id"`
+	Uid       int64  `json:"uid"`
+	FileName  string `json:"name"`
+	ImageType string `json:"imageType"`
+	Path      string `json:"path"`
+}

errors/t_error.go

@@ -0,0 +1,37 @@
+package errors
+
+import "fmt"
+
+type TError struct {
+	code int
+	msg  string
+}
+
+// 实现 Error 接口
+func (e TError) Error() string {
+	return fmt.Sprintf("code:%d,msg:%v", e.code, e.msg)
+}
+
+// New new Error
+func NewTError(code int, msg string) error {
+	return TError{
+		code: code,
+		msg:  msg,
+	}
+}
+
+// GetCode 获取Code
+func GetCode(err error) int {
+	if e, ok := err.(TError); ok {
+		return e.code
+	}
+	return -1
+}
+
+// GetMsg 获取Msg
+func GetMsg(err error) string {
+	if e, ok := err.(TError); ok {
+		return e.msg
+	}
+	return ""
+}

middleware/jwtcontext.go

@@ -0,0 +1,72 @@
+package middleware
+
+import (
+	"fmt"
+	"github.com/gin-gonic/gin"
+	"icloudapp.cn/tools/entity"
+	"icloudapp.cn/tools/service"
+	"net/http"
+	"strings"
+)
+
+// 基于JWT认证的中间件   验证token的中间件
+func JWTAuthMiddleware() func(c *gin.Context) {
+	return func(ctx *gin.Context) {
+		//携带Token有三种方式
+		//1.放在请求头
+		//2.放在请求体
+		//3.放在URI
+		//这里实现的方法是Token放在header的Authorization，并使用Bearer开头
+		authHeader := ctx.Request.Header.Get("Authorization") //获取请求中头部的token
+		cookie, _ := ctx.Cookie("poster_sid")
+		if authHeader == "" && cookie != "" {
+			authHeader = "Bearer " + cookie
+		}
+		if authHeader == "" {
+			ctx.JSON(http.StatusOK, gin.H{
+				"code": entity.CodeAuthIsNull,
+				"msg":  entity.CodeAuthIsNull.Msg(),
+			})
+			ctx.Abort() //授权失败，调用Abort以确保没有调用此请求的其余处理程序
+			return
+		}
+
+		parts := strings.SplitN(authHeader, " ", 2)
+		if !(len(parts) == 2 && parts[0] == "Bearer") {
+			ctx.JSON(http.StatusOK, gin.H{
+				"code": entity.CodeInvalidToken,
+				"msg":  entity.CodeInvalidToken.Msg(),
+			})
+			ctx.Abort()
+			return
+		}
+
+		posterClaim, err := service.ParseJWTToken(parts[1])
+		if err != nil {
+			ctx.JSON(http.StatusOK, gin.H{
+				"code": entity.CodeTokenExpired,
+				"msg":  entity.CodeTokenExpired.Msg(),
+			})
+			ctx.Abort()
+			return
+		}
+		//token 和 redis 中保存的不匹配，也验证失败
+		token := service.GetJWTTokenFromRedis(posterClaim.Uid)
+		if token == "" || token != parts[1] {
+			ctx.JSON(http.StatusOK, gin.H{
+				"code": entity.CodeAuthFail,
+				"msg":  entity.CodeAuthFail.Msg(),
+			})
+			ctx.Abort()
+			return
+		}
+
+		//将当前请求的username信息保存到请求的上下文c
+		ctx.Set("jwt_uid", posterClaim.Uid)
+		ctx.Set("jwt_username", posterClaim.Username)
+		//设置Request参数
+		ctx.AddParam("jwt_uid", fmt.Sprint(posterClaim.Uid))
+		ctx.AddParam("jwt_username", posterClaim.Username)
+		ctx.Next()
+	}
+}

middleware/role.go

@@ -0,0 +1,143 @@
+package middleware
+
+import (
+	"github.com/gin-gonic/gin"
+	"icloudapp.cn/tools/entity"
+	"icloudapp.cn/tools/model"
+	utString "icloudapp.cn/tools/util/string"
+	"strings"
+)
+
+func RoleMiddleWare() func(c *gin.Context) {
+	return func(ctx *gin.Context) {
+		//获取用户的所有分组
+
+		uid := utString.ConvertInt64(ctx.GetString("uid"))
+		if uid == 0 {
+			accessDenied(ctx, "请先登录后再试")
+			ctx.Abort()
+			return
+		}
+
+		_, err := model.NewMRoles(ctx).Verify(uid, ctx.Request.URL)
+		if err != nil {
+			accessDenied(ctx, err.Error())
+			ctx.Abort()
+			return
+		}
+		ctx.Next()
+		/*
+			url := ctx.Request.URL.String()
+			path := ctx.Request.URL.Path
+			userGroups := service.NewUserGroup(ctx).UserGroups(uid)
+			splitGroups := strings.Split(userGroups.Groups, ",")
+
+			var groupsID []int64
+			for _, v := range splitGroups {
+				groupsID = append(groupsID, utString.ConvertInt64(v))
+			}
+			if len(groupsID) == 0 {
+				accessDenied(ctx, "无访问组权限")
+				ctx.Abort()
+				return
+			}
+
+			//获取分组对应的权限
+			groupsField, _ := service.NewGroup(ctx).Infos(groupsID...)
+
+			var rolesID strings.Builder
+
+			for _, v := range groupsField {
+				if v == nil {
+					continue
+				}
+				rolesID.WriteString(v.Roles + ",")
+			}
+			//获取权限对应的model
+			roles := uniqueToInt64(rolesID.String(), ",")
+
+			if len(roles) == 0 {
+				accessDenied(ctx, "无权限访问")
+				ctx.Abort()
+				return
+			}
+			mRole := service.NewRoles(ctx)
+			modelsField, _ := mRole.Infos(roles...)
+			var modelIds strings.Builder
+			for _, v := range modelsField {
+				modelIds.WriteString(v.ModelIds + ",")
+			}
+			//获取对应的model
+			modulesId := uniqueToInt64(modelIds.String(), ",")
+			modules := service.NewModule(ctx)
+			moduleField, _ := modules.Infos(modulesId...)
+			//验证request是否有权限
+			matchedURL := make([]string, 0)
+			for _, module := range moduleField {
+				moduleURL := module.ModelURL
+				//设置的url和请求的path一样直接通过，如果是带参数或*需要额外处理
+				if moduleURL == path {
+					ctx.Next()
+					return
+				} else if strings.Contains(moduleURL, path) {
+					matchedURL = append(matchedURL, moduleURL)
+				} else if strings.Contains(moduleURL, ".*") {
+					//如果是以.*结尾的，将modelURL才分成两部分，前半部分能匹配上当前的url就可以
+					urlSplit := strings.Split(moduleURL, ",")
+					if strings.Contains(url, urlSplit[0]) {
+						ctx.Next()
+						return
+					}
+				}
+			}
+
+			if len(matchedURL) == 0 {
+				accessDenied(ctx, "无模块访问权限")
+				ctx.Abort()
+				return
+			}
+			for _, singleURL := range matchedURL {
+				//这里需要区分url中有没有参数，没有参数就直接过，有参数就再验证参数
+				parseString, _ := url2.ParseString(singleURL)
+				queries := parseString.Query()
+				for name, _ := range queries {
+					if queries.Get(name) != ctx.Request.URL.Query().Get(name) {
+						accessDenied(ctx, "权限无匹配")
+						ctx.Abort()
+						return
+					}
+				}
+			}
+			ctx.Next()*/
+	}
+}
+
+func accessDenied(ctx *gin.Context, msg string) {
+	entity.ResponseNormal(ctx, entity.CodeDenied, msg, []interface{}{})
+}
+
+func splitStrToInt64(str, sep string) []int64 {
+	splitSlice := strings.Split(str, sep)
+	var res []int64
+	for _, v := range splitSlice {
+		res = append(res, utString.ConvertInt64(v))
+	}
+	return res
+}
+
+func uniqueToInt64(str, sep string) []int64 {
+	var res []int64
+	splitSlice := splitStrToInt64(str, sep)
+	splitMap := make(map[int64]bool, 0)
+	for _, v := range splitSlice {
+		if v == 0 {
+			continue
+		}
+		if _, ok := splitMap[v]; ok {
+			continue
+		}
+		splitMap[v] = true
+		res = append(res, v)
+	}
+	return res
+}

model/fonts.go

@@ -0,0 +1,25 @@
+package model
+
+import (
+	"context"
+	"icloudapp.cn/tools/service"
+	sEntity "icloudapp.cn/tools/service/entity"
+)
+
+type MFonts struct {
+	ctx context.Context
+}
+
+func NewMFonts(ctx context.Context) *MFonts {
+	return &MFonts{
+		ctx: ctx,
+	}
+}
+
+func (m *MFonts) Add(fonts *sEntity.Font) (*sEntity.Font, error) {
+	material, err := service.NewFonts(m.ctx).Add(fonts)
+	if err != nil {
+		return nil, err
+	}
+	return material, nil
+}

model/material.go

@@ -0,0 +1,50 @@
+package model
+
+import (
+	"context"
+	"icloudapp.cn/tools/entity"
+	"icloudapp.cn/tools/service"
+	sEntity "icloudapp.cn/tools/service/entity"
+)
+
+type MMaterial struct {
+	ctx context.Context
+}
+
+func NewMMaterial(ctx context.Context) *MMaterial {
+	return &MMaterial{
+		ctx: ctx,
+	}
+}
+
+func (m *MMaterial) Add(material *sEntity.Material) (*sEntity.Material, error) {
+	material, err := service.NewMaterial(m.ctx).Add(material)
+	if err != nil {
+		return nil, err
+	}
+	return material, nil
+}
+
+func (m *MMaterial) Materials(uid int64) *entity.MaterialsApi {
+	materials := service.NewMaterial(m.ctx).Materials(uid)
+
+	body := make([]entity.MaterialsApiData, 0)
+
+	if len(materials) == 0 {
+		return &entity.MaterialsApi{Code: entity.CodeDataDoesNotExist, Msg: "未找到相关数据", Body: map[string][]entity.MaterialsApiData{
+			"items": {},
+		}}
+	}
+	for _, val := range materials {
+		var material entity.MaterialsApiData
+		material.ID = val.ID
+		material.Uid = val.UID
+		material.FileName = val.Name
+		material.Path = val.File
+		material.ImageType = val.Type
+		body = append(body, material)
+	}
+	return &entity.MaterialsApi{Code: entity.CodeDataDoesNotExist, Msg: "success", Body: map[string][]entity.MaterialsApiData{
+		"items": body,
+	}}
+}

model/roles.go

@@ -0,0 +1,139 @@
+package model
+
+import (
+	"context"
+	"errors"
+	"icloudapp.cn/tools/service"
+	utString "icloudapp.cn/tools/util/string"
+	url2 "icloudapp.cn/tools/util/url"
+	"net/url"
+	"strings"
+)
+
+type MRoles struct {
+	ctx context.Context
+}
+
+func NewMRoles(ctx context.Context) *MRoles {
+	return &MRoles{
+		ctx: ctx,
+	}
+}
+
+func (r *MRoles) Verify(uid int64, URL *url.URL) (bool, error) {
+	if uid == 0 {
+		return false, errors.New("请先登录后再试")
+	}
+
+	userGroups := service.NewUserGroup(r.ctx).UserGroups(uid)
+	if userGroups == nil {
+		return false, errors.New("无访问组权限")
+	}
+
+	splitGroups := strings.Split(userGroups.Groups, ",")
+
+	var groupsID []int64
+	for _, v := range splitGroups {
+		groupsID = append(groupsID, utString.ConvertInt64(v))
+	}
+	if len(groupsID) == 0 {
+		return false, errors.New("无访问组权限")
+	}
+
+	//获取分组对应的权限
+	groupsField, _ := service.NewGroup(r.ctx).Infos(groupsID...)
+
+	if groupsField == nil {
+		return false, errors.New("无权限访问")
+	}
+
+	var rolesID strings.Builder
+
+	for _, v := range groupsField {
+		if v == nil {
+			continue
+		}
+		rolesID.WriteString(v.Roles + ",")
+	}
+	//获取权限对应的model
+	roles := uniqueToInt64(rolesID.String(), ",")
+
+	if len(roles) == 0 {
+		return false, errors.New("无权限访问")
+	}
+	mRole := service.NewRoles(r.ctx)
+	modelsField, _ := mRole.Infos(roles...)
+	if modelsField == nil {
+		return false, errors.New("无模块访问权限")
+	}
+	var modelIds strings.Builder
+	for _, v := range modelsField {
+		modelIds.WriteString(v.ModelIds + ",")
+	}
+	//获取对应的model
+	modulesId := uniqueToInt64(modelIds.String(), ",")
+	modules := service.NewModule(r.ctx)
+	moduleField, _ := modules.Infos(modulesId...)
+
+	if moduleField == nil {
+		return false, errors.New("无模块访问权限")
+	}
+	//验证request是否有权限
+	matchedURL := make([]string, 0)
+	for _, module := range moduleField {
+		moduleURL := module.ModelURL
+		//设置的url和请求的path一样直接通过，如果是带参数或*需要额外处理
+		if moduleURL == URL.Path {
+			return true, nil
+		} else if strings.Contains(moduleURL, URL.Path) {
+			matchedURL = append(matchedURL, moduleURL)
+		} else if strings.Contains(moduleURL, ".*") {
+			//如果是以.*结尾的，将modelURL才分成两部分，前半部分能匹配上当前的url就可以
+			urlSplit := strings.Split(moduleURL, ",")
+			if strings.Contains(URL.String(), urlSplit[0]) {
+				return true, nil
+			}
+		}
+	}
+
+	if len(matchedURL) == 0 {
+		return false, errors.New("无模块访问权限")
+	}
+	for _, singleURL := range matchedURL {
+		//这里需要区分url中有没有参数，没有参数就直接过，有参数就再验证参数
+		parseString, _ := url2.ParseString(singleURL)
+		queries := parseString.Query()
+		for name, _ := range queries {
+			if queries.Get(name) != URL.Query().Get(name) {
+				return false, errors.New("权限无匹配")
+			}
+		}
+	}
+	return true, nil
+}
+
+func splitStrToInt64(str, sep string) []int64 {
+	splitSlice := strings.Split(str, sep)
+	var res []int64
+	for _, v := range splitSlice {
+		res = append(res, utString.ConvertInt64(v))
+	}
+	return res
+}
+
+func uniqueToInt64(str, sep string) []int64 {
+	var res []int64
+	splitSlice := splitStrToInt64(str, sep)
+	splitMap := make(map[int64]bool, 0)
+	for _, v := range splitSlice {
+		if v == 0 {
+			continue
+		}
+		if _, ok := splitMap[v]; ok {
+			continue
+		}
+		splitMap[v] = true
+		res = append(res, v)
+	}
+	return res
+}

router/php_router.go

@@ -0,0 +1,23 @@
+package router
+
+import (
+	"github.com/gin-gonic/gin"
+	"icloudapp.cn/tools/admin"
+	"icloudapp.cn/tools/controller"
+	"icloudapp.cn/tools/middleware"
+)
+
+func SetupPHPRouter(r *gin.Engine) {
+	frontAPI := r.Group("/")
+	frontAPI.Use(middleware.JWTAuthMiddleware())
+	frontAPI.GET("/api/poster/lists.json", controller.Posters)
+	frontAPI.GET("/api/poster/info/:id.json", controller.PosterInfo)
+	frontAPI.GET("/api/user/info.json", controller.Info)
+	frontAPI.GET("/api/materials.json", controller.Materials)
+
+	adminUI := r.Group("/admin")
+	adminUI.Use(middleware.JWTAuthMiddleware())
+	adminUI.Use(middleware.RoleMiddleWare())
+	adminUI.POST("/materials/api/material/lists.json", admin.Material)
+
+}

service/base.go

@@ -0,0 +1,34 @@
+package service
+
+import (
+	"context"
+	"math"
+)
+
+type Base struct {
+}
+
+type Page struct {
+	Count       int64 `json:"total"`
+	CurrentPage int   `json:"currentPage"`
+	TotalPage   int   `json:"totalPage"`
+	Start       int   `json:"start"`
+	End         int   `json:"end"`
+	PageSize    int   `json:"pageSize"`
+	LimitStart  int   `json:"limitStart"`
+}
+
+func NewBase(ctx context.Context) *Base {
+	return &Base{}
+}
+
+func (b *Base) InitPages(count int64, page, pageSize int) Page {
+	var pages Page
+	pages.Count = count
+	page = int(math.Max(1, float64(page)))
+	pages.CurrentPage = int(math.Min(float64(page), float64(count)))
+	pages.TotalPage = int(math.Ceil(float64(count) / float64(pageSize)))
+	pages.PageSize = pageSize
+	pages.LimitStart = (pages.CurrentPage - 1) * pageSize
+	return pages
+}

service/dependency/dependency.go

@@ -0,0 +1,8 @@
+package dependency
+
+import "icloudapp.cn/tools/service/entity"
+
+type IGroupRes interface {
+	Info(groupID int64) (*entity.Group, error)
+	Infos(groupsID ...int64) (map[int64]*entity.Group, error)
+}

service/entity/book_categories.go

@@ -0,0 +1,26 @@
+// Code generated by gorm.io/gen. DO NOT EDIT.
+// Code generated by gorm.io/gen. DO NOT EDIT.
+// Code generated by gorm.io/gen. DO NOT EDIT.
+
+package entity
+
+import (
+	"time"
+)
+
+const TableNameBookCategory = "book_categories"
+
+// BookCategory mapped from table <book_categories>
+
+type BookCategory struct {
+	ID         int64     `gorm:"column:id;type:int;primaryKey;autoIncrement:true" json:"id"`                          // ID
+	BookID     int64     `gorm:"column:book_id;type:int;not null" json:"book_id"`                                     // 书籍ID
+	CategoryID *int64    `gorm:"column:category_id;type:int" json:"category_id"`                                      // 分类ID
+	CreateAt   time.Time `gorm:"column:create_at;type:timestamp;not null" json:"create_at"`                           // 创建时间
+	UpdateAt   time.Time `gorm:"column:update_at;type:timestamp;not null;default:CURRENT_TIMESTAMP" json:"update_at"` // 更新时间
+}
+
+// TableName BookCategory's table name
+func (*BookCategory) TableName() string {
+	return TableNameBookCategory
+}

service/entity/fonts.go

@@ -0,0 +1,32 @@
+// Code generated by gorm.io/gen. DO NOT EDIT.
+// Code generated by gorm.io/gen. DO NOT EDIT.
+// Code generated by gorm.io/gen. DO NOT EDIT.
+
+package entity
+
+import (
+	"time"
+)
+
+const TableNameFont = "fonts"
+
+// Font mapped from table <fonts>
+
+type Font struct {
+	ID       int64     `gorm:"column:id;type:int;primaryKey;autoIncrement:true" json:"id"`
+	Name     string    `gorm:"column:name;type:varchar(50);not null" json:"name"`                                            // 字体名称
+	Code     string    `gorm:"column:code;type:varchar(100);not null" json:"code"`                                           // 字体code
+	Path     string    `gorm:"column:path;type:varchar(100);not null" json:"path"`                                           // 字体路径
+	FileName string    `gorm:"column:file_name;type:varchar(100);not null" json:"file_name"`                                 // 文件名称
+	FileSize int64     `gorm:"column:file_size;type:int;not null" json:"file_size"`                                          // 文件大小
+	Hash     string    `gorm:"column:hash;type:varchar(32);not null" json:"hash"`                                            // 文件hash
+	FileType string    `gorm:"column:file_type;type:varchar(50);not null;default:application/octet-stream" json:"file_type"` // 文件类型
+	Status   int64     `gorm:"column:status;type:tinyint;not null;default:1" json:"status"`                                  // 文字状态
+	CreateAt time.Time `gorm:"column:create_at;type:timestamp;not null" json:"create_at"`                                    // 创建时间
+	UpdateAt time.Time `gorm:"column:update_at;type:timestamp;not null;default:CURRENT_TIMESTAMP" json:"update_at"`          // 更新时间
+}
+
+// TableName Font's table name
+func (*Font) TableName() string {
+	return TableNameFont
+}

service/entity/group.go

@@ -0,0 +1,28 @@
+// Code generated by gorm.io/gen. DO NOT EDIT.
+// Code generated by gorm.io/gen. DO NOT EDIT.
+// Code generated by gorm.io/gen. DO NOT EDIT.
+
+package entity
+
+import (
+	"time"
+)
+
+const TableNameGroup = "group"
+
+// Group mapped from table <group>
+
+type Group struct {
+	GroupID     int64     `gorm:"column:group_id;type:int;primaryKey;autoIncrement:true" json:"group_id"`
+	GroupName   string    `gorm:"column:group_name;type:varchar(30);not null" json:"group_name"`                       // 分组名称
+	Roles       string    `gorm:"column:roles;type:text;not null" json:"roles"`                                        // 权限，roles 的id，对应的模块
+	GroupStatus int64     `gorm:"column:group_status;type:tinyint;not null;default:1" json:"group_status"`             // 分组状态
+	OperatorUID int64     `gorm:"column:operator_uid;type:bigint;not null" json:"operator_uid"`                        // 操作人
+	CreateAt    time.Time `gorm:"column:create_at;type:timestamp;not null" json:"create_at"`                           // 创建时间
+	UpdateAt    time.Time `gorm:"column:update_at;type:timestamp;not null;default:CURRENT_TIMESTAMP" json:"update_at"` // 更新时间
+}
+
+// TableName Group's table name
+func (*Group) TableName() string {
+	return TableNameGroup
+}

service/entity/materials.go

@@ -0,0 +1,32 @@
+// Code generated by gorm.io/gen. DO NOT EDIT.
+// Code generated by gorm.io/gen. DO NOT EDIT.
+// Code generated by gorm.io/gen. DO NOT EDIT.
+
+package entity
+
+import (
+	"time"
+)
+
+const TableNameMaterial = "materials"
+
+// Material mapped from table <materials>
+
+type Material struct {
+	ID       int64     `gorm:"column:id;type:int;primaryKey;autoIncrement:true" json:"id"`                          // 素材ID
+	Name     string    `gorm:"column:name;type:varchar(100);not null" json:"name"`                                  // 素材名称
+	File     string    `gorm:"column:file;type:varchar(255);not null" json:"file"`                                  // 素材地址
+	Size     string    `gorm:"column:size;type:varchar(20);not null;default:0x0" json:"size"`                       // 素材尺寸
+	FileSize int64     `gorm:"column:file_size;type:int;not null" json:"file_size"`                                 // 素材大小
+	Hash     string    `gorm:"column:hash;type:char(32);not null" json:"hash"`                                      // 素材文件hash
+	Type     string    `gorm:"column:type;type:varchar(10);not null;default:material" json:"type"`                  // 素材类型
+	UID      int64     `gorm:"column:uid;type:int;not null" json:"uid"`                                             // 上传用户
+	Status   int64     `gorm:"column:status;type:tinyint;not null;default:1" json:"status"`                         // 素材状态
+	CreateAt time.Time `gorm:"column:create_at;type:timestamp;not null" json:"create_at"`                           // 创建时间
+	UpdateAt time.Time `gorm:"column:update_at;type:timestamp;not null;default:CURRENT_TIMESTAMP" json:"update_at"` // 更新时间
+}
+
+// TableName Material's table name
+func (*Material) TableName() string {
+	return TableNameMaterial
+}

service/entity/modules.go

@@ -0,0 +1,32 @@
+// Code generated by gorm.io/gen. DO NOT EDIT.
+// Code generated by gorm.io/gen. DO NOT EDIT.
+// Code generated by gorm.io/gen. DO NOT EDIT.
+
+package entity
+
+import (
+	"time"
+)
+
+const TableNameModule = "modules"
+
+// Module mapped from table <modules>
+
+type Module struct {
+	ModelID     int64     `gorm:"column:model_id;type:int;primaryKey;autoIncrement:true" json:"model_id"`
+	ModelName   string    `gorm:"column:model_name;type:varchar(100);not null" json:"model_name"`                      // 模块名
+	ModelGroup  string    `gorm:"column:model_group;type:varchar(100);not null" json:"model_group"`                    // 模块分组
+	Menu        string    `gorm:"column:menu;type:varchar(20);not null" json:"menu"`                                   // 菜单项
+	ModelURL    string    `gorm:"column:model_url;type:varchar(255);not null" json:"model_url"`                        // 模块连接
+	ModelIndex  int64     `gorm:"column:model_index;type:int;not null" json:"model_index"`                             // 模块序号
+	Visible     int64     `gorm:"column:visible;type:tinyint;not null;default:1" json:"visible"`                       // 是否显示
+	ModelStatus int64     `gorm:"column:model_status;type:tinyint;not null;default:1" json:"model_status"`             // 模块状态
+	OperatorUID int64     `gorm:"column:operator_uid;type:bigint;not null" json:"operator_uid"`                        // 操作人
+	CreateAt    time.Time `gorm:"column:create_at;type:timestamp;not null" json:"create_at"`                           // 添加时间
+	UpdateAt    time.Time `gorm:"column:update_at;type:timestamp;not null;default:CURRENT_TIMESTAMP" json:"update_at"` // 更新时间
+}
+
+// TableName Module's table name
+func (*Module) TableName() string {
+	return TableNameModule
+}

service/entity/roles.go

@@ -0,0 +1,28 @@
+// Code generated by gorm.io/gen. DO NOT EDIT.
+// Code generated by gorm.io/gen. DO NOT EDIT.
+// Code generated by gorm.io/gen. DO NOT EDIT.
+
+package entity
+
+import (
+	"time"
+)
+
+const TableNameRole = "roles"
+
+// Role mapped from table <roles>
+
+type Role struct {
+	RoleID      int64     `gorm:"column:role_id;type:int;primaryKey;autoIncrement:true" json:"role_id"`                // 权限ID
+	RoleName    string    `gorm:"column:role_name;type:varchar(100);not null" json:"role_name"`                        // 权限名称
+	ModelIds    string    `gorm:"column:model_ids;type:text;not null" json:"model_ids"`                                // 权限对应的模块名
+	RoleStatus  int64     `gorm:"column:role_status;type:tinyint;not null;default:1" json:"role_status"`               // 模块状态
+	OperatorUID int64     `gorm:"column:operator_uid;type:bigint;not null" json:"operator_uid"`                        // 操作人
+	CreateAt    time.Time `gorm:"column:create_at;type:timestamp;not null" json:"create_at"`                           // 添加时间
+	UpdateAt    time.Time `gorm:"column:update_at;type:timestamp;not null;default:CURRENT_TIMESTAMP" json:"update_at"` // 更新时间
+}
+
+// TableName Role's table name
+func (*Role) TableName() string {
+	return TableNameRole
+}

service/entity/user.go

@@ -0,0 +1,30 @@
+// Code generated by gorm.io/gen. DO NOT EDIT.
+// Code generated by gorm.io/gen. DO NOT EDIT.
+// Code generated by gorm.io/gen. DO NOT EDIT.
+
+package entity
+
+import (
+	"time"
+)
+
+const TableNameUser = "user"
+
+// User mapped from table <user>
+
+type User struct {
+	UID      int64     `gorm:"column:uid;type:int;primaryKey;autoIncrement:true" json:"uid"`
+	Nickname string    `gorm:"column:nickname;type:varchar(30);not null" json:"nickname"`
+	Email    string    `gorm:"column:email;type:varchar(50);not null" json:"email"`
+	Password string    `gorm:"column:password;type:char(32);not null" json:"password"`
+	Salt     string    `gorm:"column:salt;type:char(6);not null" json:"salt"`
+	Avatar   *string   `gorm:"column:avatar;type:varchar(200)" json:"avatar"` // 头像
+	Status   int64     `gorm:"column:status;type:tinyint;not null;default:1" json:"status"`
+	CreateAt time.Time `gorm:"column:create_at;type:timestamp;not null" json:"create_at"`                           // 创建时间
+	UpdateAt time.Time `gorm:"column:update_at;type:timestamp;not null;default:CURRENT_TIMESTAMP" json:"update_at"` // 更新时间
+}
+
+// TableName User's table name
+func (*User) TableName() string {
+	return TableNameUser
+}

service/entity/user_group.go

@@ -0,0 +1,27 @@
+// Code generated by gorm.io/gen. DO NOT EDIT.
+// Code generated by gorm.io/gen. DO NOT EDIT.
+// Code generated by gorm.io/gen. DO NOT EDIT.
+
+package entity
+
+import (
+	"time"
+)
+
+const TableNameUserGroup = "user_group"
+
+// UserGroup mapped from table <user_group>
+
+type UserGroup struct {
+	UID         int64     `gorm:"column:uid;type:bigint;primaryKey" json:"uid"`                                        // 用户ID
+	Groups      string    `gorm:"column:groups;type:text;not null" json:"groups"`                                      // 分组权限
+	OperatorUID int64     `gorm:"column:operator_uid;type:bigint;not null" json:"operator_uid"`                        // 操作人
+	Status      int64     `gorm:"column:status;type:tinyint;not null;default:1" json:"status"`                         // 状态
+	CreateAt    time.Time `gorm:"column:create_at;type:timestamp;not null" json:"create_at"`                           // 添加时间
+	UpdateAt    time.Time `gorm:"column:update_at;type:timestamp;not null;default:CURRENT_TIMESTAMP" json:"update_at"` // 更新时间
+}
+
+// TableName UserGroup's table name
+func (*UserGroup) TableName() string {
+	return TableNameUserGroup
+}

service/entity/user_poster.go

@@ -0,0 +1,32 @@
+// Code generated by gorm.io/gen. DO NOT EDIT.
+// Code generated by gorm.io/gen. DO NOT EDIT.
+// Code generated by gorm.io/gen. DO NOT EDIT.
+
+package entity
+
+import (
+	"time"
+)
+
+const TableNameUserPoster = "user_poster"
+
+// UserPoster mapped from table <user_poster>
+
+type UserPoster struct {
+	PosterID       int64     `gorm:"column:poster_id;type:int;primaryKey;autoIncrement:true" json:"poster_id"` // 海报ID
+	PosterName     string    `gorm:"column:poster_name;type:varchar(50);not null" json:"poster_name"`          // 海报名称
+	UUID           string    `gorm:"column:uuid;type:char(20);not null" json:"uuid"`                           // 海报唯一标识
+	UID            int64     `gorm:"column:uid;type:int;not null" json:"uid"`                                  // 用户ID
+	PosterKeywords *string   `gorm:"column:poster_keywords;type:varchar(255)" json:"poster_keywords"`          // 海报关键字
+	PosterJSON     *string   `gorm:"column:poster_json;type:text" json:"poster_json"`                          // 海报数据
+	Preview        *string   `gorm:"column:preview;type:varchar(255)" json:"preview"`                          // 海报预览地址
+	Visits         int64     `gorm:"column:visits;type:int;not null" json:"visits"`                            // 访问次数
+	Status         int64     `gorm:"column:status;type:tinyint;not null;default:1" json:"status"`
+	CreateAt       time.Time `gorm:"column:create_at;type:timestamp;not null" json:"create_at"`                           // 创建时间
+	UpdateAt       time.Time `gorm:"column:update_at;type:timestamp;not null;default:CURRENT_TIMESTAMP" json:"update_at"` // 更新时间
+}
+
+// TableName UserPoster's table name
+func (*UserPoster) TableName() string {
+	return TableNameUserPoster
+}

service/entity/user_poster_batches.go

@@ -0,0 +1,34 @@
+// Code generated by gorm.io/gen. DO NOT EDIT.
+// Code generated by gorm.io/gen. DO NOT EDIT.
+// Code generated by gorm.io/gen. DO NOT EDIT.
+
+package entity
+
+import (
+	"time"
+)
+
+const TableNameUserPosterBatch = "user_poster_batches"
+
+// UserPosterBatch mapped from table <user_poster_batches>
+
+type UserPosterBatch struct {
+	BatchID  int64     `gorm:"column:batch_id;type:int;primaryKey;autoIncrement:true" json:"batch_id"`
+	UID      int64     `gorm:"column:uid;type:int;not null" json:"uid"`                                             // 用户ID
+	PosterID int64     `gorm:"column:poster_id;type:int;not null" json:"poster_id"`                                 // 海报ID
+	Name     string    `gorm:"column:name;type:varchar(50);not null" json:"name"`                                   // 海报名称
+	UUID     string    `gorm:"column:uuid;type:char(20);not null" json:"uuid"`                                      // 海报唯一标识
+	Raw      string    `gorm:"column:raw;type:text;not null" json:"raw"`                                            // 生成的内容
+	Num      int64     `gorm:"column:num;type:int;not null;default:1" json:"num"`                                   // 海报份数
+	DoneNum  int64     `gorm:"column:done_num;type:int;not null" json:"done_num"`                                   // 已经生成的份数
+	Type     string    `gorm:"column:type;type:varchar(10);not null;default:jpeg" json:"type"`                      // 生成图片类型
+	Path     *string   `gorm:"column:path;type:varchar(255)" json:"path"`                                           // 海报存储路径
+	Status   int64     `gorm:"column:status;type:tinyint;not null" json:"status"`                                   // 海报生成状态
+	CreateAt time.Time `gorm:"column:create_at;type:timestamp;not null" json:"create_at"`                           // 创建时间
+	UpdateAt time.Time `gorm:"column:update_at;type:timestamp;not null;default:CURRENT_TIMESTAMP" json:"update_at"` // 更新时间
+}
+
+// TableName UserPosterBatch's table name
+func (*UserPosterBatch) TableName() string {
+	return TableNameUserPosterBatch
+}

service/fonts.go

@@ -0,0 +1,62 @@
+package service
+
+import (
+	"context"
+	"errors"
+	"icloudapp.cn/tools/repository/mysql"
+	sEntity "icloudapp.cn/tools/service/entity"
+	"icloudapp.cn/tools/service/model"
+)
+
+type Fonts struct {
+	ctx context.Context
+	Base
+	query *model.MFont
+}
+
+func NewFonts(ctx context.Context) *Fonts {
+	model.SetDefault(mysql.DBConn)
+	fonts := &Fonts{ctx: ctx}
+	fonts.query = model.Font
+	return fonts
+}
+
+func (f *Fonts) Info(ID int64) (*sEntity.Font, error) {
+	return f.query.WithContext(f.ctx).Where(f.query.ID.Eq(ID)).First()
+}
+
+func (f *Fonts) Infos(IDS ...int64) ([]*sEntity.Font, error) {
+	return f.query.WithContext(f.ctx).Where(f.query.ID.In(IDS...)).Find()
+}
+
+func (f *Fonts) InfoByHash(hash string) (*sEntity.Font, error) {
+	return f.query.WithContext(f.ctx).Where(f.query.Hash.Eq(hash)).First()
+}
+
+func (f *Fonts) Add(fonts *sEntity.Font) (*sEntity.Font, error) {
+	exist, err := f.InfoByHash(fonts.Hash)
+
+	if err != nil {
+		return nil, err
+	}
+
+	if exist.ID > 0 {
+		if exist.Status == -1 {
+			affected, err := f.query.WithContext(f.ctx).Where(f.query.ID.Eq(exist.ID)).Update(f.query.Status, -1)
+			if err != nil {
+				return nil, err
+			}
+			if affected.RowsAffected == 0 {
+				return nil, errors.New("更新数据失败")
+			}
+		}
+		return exist, nil
+	}
+
+	err = f.query.WithContext(f.ctx).Create(fonts)
+	if err != nil {
+		return nil, err
+	}
+
+	return fonts, nil
+}

service/gen_test.go

@@ -0,0 +1,100 @@
+package service
+
+import (
+	"fmt"
+	"gorm.io/driver/mysql"
+	"gorm.io/gen"
+	"gorm.io/gorm"
+	"strings"
+	"testing"
+)
+
+const MysqlConfig = "root:A119328118a@(localhost:3306)/poster?charset=utf8mb4&parseTime=True&loc=Local"
+
+func TestGEN(t *testing.T) {
+	// 连接数据库
+	db, err := gorm.Open(mysql.Open(MysqlConfig))
+	if err != nil {
+		panic(fmt.Errorf("cannot establish db connection: %w", err))
+	}
+	// 生成实例
+	g := gen.NewGenerator(gen.Config{
+		// 相对执行`go run`时的路径, 会自动创建目录
+		OutPath:      "./model",
+		OutFile:      "query_auto.go",
+		ModelPkgPath: "./entity",
+		// WithDefaultQuery 生成默认查询结构体(作为全局变量使用), 即`Q`结构体和其字段(各表模型)
+		// WithoutContext 生成没有context调用限制的代码供查询
+		// WithQueryInterface 生成interface形式的查询代码(可导出), 如`Where()`方法返回的就是一个可导出的接口类型
+		Mode: gen.WithDefaultQuery | gen.WithQueryInterface,
+
+		// 表字段可为 null 值时, 对应结体字段使用指针类型
+		FieldNullable: true, // generate pointer when field is nullable
+
+		// 表字段默认值与模型结构体字段零值不一致的字段, 在插入数据时需要赋值该字段值为零值的, 结构体字段须是指针类型才能成功, 即`FieldCoverable:true`配置下生成的结构体字段.
+		// 因为在插入时遇到字段为零值的会被GORM赋予默认值. 如字段`age`表默认值为10, 即使你显式设置为0最后也会被GORM设为10提交.
+		// 如果该字段没有上面提到的插入时赋零值的特殊需要, 则字段为非指针类型使用起来会比较方便.
+		FieldCoverable: false, // generate pointer when field has default value, to fix problem zero value cannot be assign: https://gorm.io/docs/create.html#Default-Values
+
+		// 模型结构体字段的数字类型的符号表示是否与表字段的一致, `false`指示都用有符号类型
+		FieldSignable: false, // detect integer field's unsigned type, adjust generated data type
+		// 生成 gorm 标签的字段索引属性
+		FieldWithIndexTag: false, // generate with gorm index tag
+		// 生成 gorm 标签的字段类型属性
+		FieldWithTypeTag: true, // generate with gorm column type tag
+	})
+	// 设置目标 db
+	g.UseDB(db)
+
+	// 自定义字段的数据类型
+	// 统一数字类型为int64,兼容protobuf
+	dataMap := map[string]func(detailType string) (dataType string){
+		"tinyint":   func(detailType string) (dataType string) { return "int64" },
+		"smallint":  func(detailType string) (dataType string) { return "int64" },
+		"mediumint": func(detailType string) (dataType string) { return "int64" },
+		"bigint":    func(detailType string) (dataType string) { return "int64" },
+		"int":       func(detailType string) (dataType string) { return "int64" },
+	}
+	// 要先于`ApplyBasic`执行
+	g.WithDataTypeMap(dataMap)
+
+	// 自定义模型结体字段的标签
+	// 将特定字段名的 json 标签加上`string`属性,即 MarshalJSON 时该字段由数字类型转成字符串类型
+	jsonField := gen.FieldJSONTagWithNS(func(columnName string) (tagContent string) {
+		toStringField := `balance, `
+		if strings.Contains(toStringField, columnName) {
+			return columnName + ",string"
+		}
+		return columnName
+	})
+	// 将非默认字段名的字段定义为自动时间戳和软删除字段;
+	// 自动时间戳默认字段名为:`updated_at`、`created_at, 表字段数据类型为: INT 或 DATETIME
+	// 软删除默认字段名为:`deleted_at`, 表字段数据类型为: DATETIME
+	autoUpdateTimeField := gen.FieldGORMTag("update_time", "column:update_time;type:int unsigned;autoUpdateTime")
+	autoCreateTimeField := gen.FieldGORMTag("create_time", "column:create_time;type:int unsigned;autoCreateTime")
+	softDeleteField := gen.FieldType("delete_time", "soft_delete.DeletedAt")
+	// 模型自定义选项组
+	fieldOpts := []gen.ModelOpt{jsonField, autoCreateTimeField, autoUpdateTimeField, softDeleteField}
+
+	// 创建模型的结构体,生成文件在 model 目录; 先创建的结果会被后面创建的覆盖
+	// 这里创建个别模型仅仅是为了拿到`*generate.QueryStructMeta`类型对象用于后面的模型关联操作中
+	//User := g.GenerateModel("user")
+	// 创建全部模型文件, 并覆盖前面创建的同名模型
+	allModel := g.GenerateAllTable(fieldOpts...)
+
+	// 创建有关联关系的模型文件
+	// 可以用于指定外键
+	//Score := g.GenerateModel("score",
+	//	append(
+	//		fieldOpts,
+	//		// user 一对多 address 关联, 外键`uid`在 address 表中
+	//		gen.FieldRelate(field.HasMany, "user", User, &field.RelateConfig{GORMTag: "foreignKey:UID"}),
+	//	)...,
+	//)
+
+	// 创建模型的方法,生成文件在 query 目录; 先创建结果不会被后创建的覆盖
+	//g.ApplyBasic(User)
+	g.ApplyBasic(allModel...)
+
+	g.Execute()
+}

service/group.go

@@ -0,0 +1,52 @@
+package service
+
+import (
+	"context"
+	"icloudapp.cn/tools/service/dependency"
+	"icloudapp.cn/tools/service/entity"
+	"icloudapp.cn/tools/service/model"
+)
+
+type Group struct {
+	ctx context.Context
+	dependency.IGroupRes
+	query *model.MGroup
+}
+
+func NewGroup(ctx context.Context) *Group {
+	group := &Group{ctx: ctx}
+	group.query = model.Group
+	return group
+}
+
+// Info 查询单个group信息
+func (g *Group) Info(groupId int64) (*entity.Group, error) {
+	query := model.Group
+	group, err := query.WithContext(g.ctx).ReadDB().Where(query.GroupID.Eq(groupId)).First()
+	if err != nil {
+		return nil, err
+	}
+
+	return group, nil
+}
+
+// Infos 批量查询 group 信息
+func (g *Group) Infos(groupsID ...int64) (map[int64]*entity.Group, error) {
+	groups := make(map[int64]*entity.Group, len(groupsID))
+	groupsInfo, err := g.query.WithContext(g.ctx).ReadDB().Where(g.query.GroupID.In(groupsID...)).Find()
+
+	if err != nil {
+		return groups, err
+	}
+	for _, val := range groupsInfo {
+		groups[val.GroupID] = val
+	}
+
+	for _, groupID := range groupsID {
+		if _, ok := groups[groupID]; !ok {
+			groups[groupID] = nil
+		}
+	}
+
+	return groups, nil
+}

service/jwt.go

@@ -0,0 +1,82 @@
+package service
+
+import (
+	"errors"
+	"fmt"
+	"github.com/dgrijalva/jwt-go"
+	setting "icloudapp.cn/tools/config"
+	"icloudapp.cn/tools/repository/redis"
+	"time"
+)
+
+// PosterClaims Claims，保存用户id和nickname
+type PosterClaims struct {
+	Uid      int64  `json:"uid"`
+	Username string `json:"username"`
+	jwt.StandardClaims
+}
+
+// GenToken 生成token
+func GenJWTToken(uid int64, username string) (string, error) {
+	C := PosterClaims{
+		uid,
+		username,
+		jwt.StandardClaims{
+			ExpiresAt: time.Now().Add(JWTExpireDuration()).Unix(), //设置超时时间,输出过期的时间，按照格式
+			Issuer:    setting.Conf.JWTConfig.Project,             //签发人
+		},
+	}
+	//使用指定的签名方法创建签名对象
+	token := jwt.NewWithClaims(jwt.SigningMethodHS256, C)
+	//使用指定的secret签名并获得完整的编码后的字符串token
+
+	signed, err := token.SignedString([]byte(setting.Conf.JWTConfig.Secret))
+	if cacheErr := CacheJWTToken(uid, signed); cacheErr != nil {
+		return "", errors.New("token缓存失败")
+	}
+	return signed, err
+}
+
+// ParseToken 验证token
+func ParseJWTToken(tokenString string) (*PosterClaims, error) {
+	token, err := jwt.ParseWithClaims(tokenString, &PosterClaims{}, func(token *jwt.Token) (interface{}, error) {
+		return []byte(setting.Conf.JWTConfig.Secret), nil
+	})
+	if err != nil {
+		return nil, err
+	}
+	if claim, ok := token.Claims.(*PosterClaims); ok && token.Valid { //valid:正确，有效  校验token
+		return claim, err //返回JWT中的字段
+	}
+	return nil, errors.New("Invalid token.")
+}
+
+// RemoveJWTToken 移除用户的token
+func RemoveJWTToken(uid int64) error {
+	return redis.RedisClient.Del(JWTCacheKey(uid)).Err()
+}
+
+// GetJWTTokenFromRedis 获取redis中获取的jwt数据
+func GetJWTTokenFromRedis(uid int64) string {
+	str, err := redis.RedisClient.Get(JWTCacheKey(uid)).Result()
+	if err != nil {
+		return ""
+	}
+	return str
+}
+
+// CacheJWTToken 缓存jwt token到redis
+func CacheJWTToken(uid int64, token string) error {
+	return redis.RedisClient.Set(JWTCacheKey(uid), token, JWTExpireDuration()).Err()
+}
+
+// JWTCacheKey 获取jwt cache key
+func JWTCacheKey(uid int64) string {
+	return fmt.Sprintf("%s_%s_%d", setting.Conf.JWTConfig.Prefix, "uid", uid)
+}
+
+// JWTExpireDuration jwt过期时间
+func JWTExpireDuration() time.Duration {
+	duration := time.Duration(setting.Conf.JWTConfig.ExpireAt) * time.Second
+	return duration
+}

service/jwt_test.go

@@ -0,0 +1,20 @@
+package service
+
+import (
+	"fmt"
+	setting "icloudapp.cn/tools/config"
+	"testing"
+	"time"
+)
+
+func TestGenToken(t *testing.T) {
+	setting.Init("test")
+	fmt.Println("time.Duration", time.Duration(86400)*time.Second)
+	fmt.Println(GenJWTToken(1, "admin"))
+}
+
+func TestParseToken(t *testing.T) {
+	setting.Init("test")
+	s := "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJ1aWQiOiIxIiwidXNlcm5hbWUiOiJhZG1pbiIsImV4cCI6MTY3ODM2NzI1MSwiaXNzIjoicG9zdGVyIn0.K1BC0oXmAP3e8Eb5SDnEoPjj5lvn61fJDB2uIk9XQIw"
+	fmt.Print(ParseJWTToken(s))
+}

service/material.go

@@ -0,0 +1,119 @@
+package service
+
+import (
+	"context"
+	"errors"
+	"icloudapp.cn/tools/service/entity"
+	"icloudapp.cn/tools/service/model"
+)
+
+type Material struct {
+	Base
+	ctx   context.Context
+	query *model.MMaterial
+}
+
+// NewMaterial 实例化素材对象
+func NewMaterial(ctx context.Context) *Material {
+	material := &Material{ctx: ctx}
+	material.query = model.Material
+	return material
+}
+
+// Info 通过ID获取素材信息
+func (m *Material) Info(id int64) (*entity.Material, error) {
+	return m.query.WithContext(m.ctx).Where(m.query.ID.Eq(id)).Take()
+}
+
+// Infos 通过素材ID批量获取素材信息
+func (m *Material) Infos(ids ...int64) ([]*entity.Material, error) {
+	return m.query.WithContext(m.ctx).Where(m.query.ID.In(ids...)).Find()
+}
+
+func (m *Material) InfoByUidAndHash(uid int64, hash string) (*entity.Material, error) {
+	return m.query.WithContext(m.ctx).Where(m.query.UID.Eq(uid), m.query.Hash.Eq(hash)).Take()
+}
+
+func (m *Material) Add(material *entity.Material) (*entity.Material, error) {
+	exist, err := m.InfoByUidAndHash(material.UID, material.Hash)
+	if err != nil {
+		return nil, err
+	}
+	if exist.UID > 0 {
+		//如果是被删除了，就更新此数据
+		if exist.Status < 1 {
+			exist.Status = 1
+			affected, err := m.query.WithContext(m.ctx).Where(m.query.ID.Eq(exist.ID)).Update(m.query.Status, -1)
+			if err != nil {
+				return nil, err
+			}
+			if affected.RowsAffected == 0 {
+				return nil, errors.New("更新数据失败")
+			}
+			return exist, nil
+		}
+		return nil, errors.New("文件" + material.Hash + "已存在")
+	}
+	err = m.query.WithContext(m.ctx).Create(material)
+	if err != nil {
+		return nil, err
+	}
+	return material, nil
+}
+
+func (m *Material) Count(uid int64) int64 {
+	var count int64 = 0
+	var err error
+	if uid > 0 {
+		count, err = m.query.WithContext(m.ctx).Where(m.query.UID.Eq(uid)).Count()
+	} else {
+		count, err = m.query.WithContext(m.ctx).Count()
+	}
+	if err != nil {
+		return 0
+	}
+	return count
+}
+
+func (m *Material) Lists(uid int64, page, pageSize int) (Page, []*entity.Material) {
+	count := m.Count(uid)
+
+	pages := m.InitPages(count, page, pageSize)
+	if count == 0 {
+		return pages, nil
+	}
+	var lists []*entity.Material
+	var err error
+	if uid > 0 {
+		lists, err = m.query.WithContext(m.ctx).Where(m.query.UID.Eq(uid)).Offset(pages.LimitStart).Limit(pageSize).Where(m.query.UID.Eq(uid)).Find()
+	} else {
+		lists, err = m.query.WithContext(m.ctx).Offset(pages.LimitStart).Limit(pageSize).Find()
+	}
+	if err != nil {
+		return pages, nil
+	}
+	return pages, lists
+}
+
+func (m *Material) Materials(uid int64) []*entity.Material {
+	materials, _ := m.query.WithContext(m.ctx).Select(m.query.ID, m.query.UID, m.query.Name, m.query.File, m.query.Type).Where(m.query.UID.Eq(uid), m.query.Status.Eq(1)).Find()
+	return materials
+}
+func (m *Material) Remove(ID int64) (bool, error) {
+	exist, err := m.Info(ID)
+	if err != nil {
+		return false, err
+	}
+	if exist.UID == 0 {
+		return false, errors.New("未找到相关记录")
+	}
+	//如果是被删除了，就更新此数据
+	info, err := m.query.WithContext(m.ctx).Where(m.query.ID.Eq(ID)).Updates(map[string]interface{}{"Status": -1})
+	if err != nil {
+		return false, err
+	}
+	if info.RowsAffected == 0 {
+		return false, errors.New("更新数据失败")
+	}
+	return true, nil
+}

service/model/book_categories.go

@@ -0,0 +1,408 @@
+// Code generated by gorm.io/gen. DO NOT EDIT.
+// Code generated by gorm.io/gen. DO NOT EDIT.
+// Code generated by gorm.io/gen. DO NOT EDIT.
+
+package model
+
+import (
+	"context"
+
+	"gorm.io/gorm"
+	"gorm.io/gorm/clause"
+	"gorm.io/gorm/schema"
+
+	"gorm.io/gen"
+	"gorm.io/gen/field"
+
+	"gorm.io/plugin/dbresolver"
+
+	"icloudapp.cn/tools/service/entity"
+)
+
+func newBookCategory(db *gorm.DB, opts ...gen.DOOption) MBookCategory {
+	_MBookCategory := MBookCategory{}
+
+	_MBookCategory.MBookCategoryDo.UseDB(db, opts...)
+	_MBookCategory.MBookCategoryDo.UseModel(&entity.BookCategory{})
+
+	tableName := _MBookCategory.MBookCategoryDo.TableName()
+	_MBookCategory.ALL = field.NewAsterisk(tableName)
+	_MBookCategory.ID = field.NewInt64(tableName, "id")
+	_MBookCategory.BookID = field.NewInt64(tableName, "book_id")
+	_MBookCategory.CategoryID = field.NewInt64(tableName, "category_id")
+	_MBookCategory.CreateAt = field.NewTime(tableName, "create_at")
+	_MBookCategory.UpdateAt = field.NewTime(tableName, "update_at")
+
+	_MBookCategory.fillFieldMap()
+
+	return _MBookCategory
+}
+
+type MBookCategory struct {
+	MBookCategoryDo MBookCategoryDo
+
+	ALL        field.Asterisk
+	ID         field.Int64 // ID
+	BookID     field.Int64 // 书籍ID
+	CategoryID field.Int64 // 分类ID
+	CreateAt   field.Time  // 创建时间
+	UpdateAt   field.Time  // 更新时间
+
+	fieldMap map[string]field.Expr
+}
+
+func (b MBookCategory) Table(newTableName string) *MBookCategory {
+	b.MBookCategoryDo.UseTable(newTableName)
+	return b.updateTableName(newTableName)
+}
+
+func (b MBookCategory) As(alias string) *MBookCategory {
+	b.MBookCategoryDo.DO = *(b.MBookCategoryDo.As(alias).(*gen.DO))
+	return b.updateTableName(alias)
+}
+
+func (b *MBookCategory) updateTableName(table string) *MBookCategory {
+	b.ALL = field.NewAsterisk(table)
+	b.ID = field.NewInt64(table, "id")
+	b.BookID = field.NewInt64(table, "book_id")
+	b.CategoryID = field.NewInt64(table, "category_id")
+	b.CreateAt = field.NewTime(table, "create_at")
+	b.UpdateAt = field.NewTime(table, "update_at")
+
+	b.fillFieldMap()
+
+	return b
+}
+
+func (b *MBookCategory) WithContext(ctx context.Context) IBookCategoryDo {
+	return b.MBookCategoryDo.WithContext(ctx)
+}
+
+func (b MBookCategory) TableName() string { return b.MBookCategoryDo.TableName() }
+
+func (b MBookCategory) Alias() string { return b.MBookCategoryDo.Alias() }
+
+func (b *MBookCategory) GetFieldByName(fieldName string) (field.OrderExpr, bool) {
+	_f, ok := b.fieldMap[fieldName]
+	if !ok || _f == nil {
+		return nil, false
+	}
+	_oe, ok := _f.(field.OrderExpr)
+	return _oe, ok
+}
+
+func (b *MBookCategory) fillFieldMap() {
+	b.fieldMap = make(map[string]field.Expr, 5)
+	b.fieldMap["id"] = b.ID
+	b.fieldMap["book_id"] = b.BookID
+	b.fieldMap["category_id"] = b.CategoryID
+	b.fieldMap["create_at"] = b.CreateAt
+	b.fieldMap["update_at"] = b.UpdateAt
+}
+
+func (b MBookCategory) clone(db *gorm.DB) MBookCategory {
+	b.MBookCategoryDo.ReplaceConnPool(db.Statement.ConnPool)
+	return b
+}
+
+func (b MBookCategory) replaceDB(db *gorm.DB) MBookCategory {
+	b.MBookCategoryDo.ReplaceDB(db)
+	return b
+}
+
+type MBookCategoryDo struct{ gen.DO }
+
+type IBookCategoryDo interface {
+	gen.SubQuery
+	Debug() IBookCategoryDo
+	WithContext(ctx context.Context) IBookCategoryDo
+	WithResult(fc func(tx gen.Dao)) gen.ResultInfo
+	ReplaceDB(db *gorm.DB)
+	ReadDB() IBookCategoryDo
+	WriteDB() IBookCategoryDo
+	As(alias string) gen.Dao
+	Session(config *gorm.Session) IBookCategoryDo
+	Columns(cols ...field.Expr) gen.Columns
+	Clauses(conds ...clause.Expression) IBookCategoryDo
+	Not(conds ...gen.Condition) IBookCategoryDo
+	Or(conds ...gen.Condition) IBookCategoryDo
+	Select(conds ...field.Expr) IBookCategoryDo
+	Where(conds ...gen.Condition) IBookCategoryDo
+	Order(conds ...field.Expr) IBookCategoryDo
+	Distinct(cols ...field.Expr) IBookCategoryDo
+	Omit(cols ...field.Expr) IBookCategoryDo
+	Join(table schema.Tabler, on ...field.Expr) IBookCategoryDo
+	LeftJoin(table schema.Tabler, on ...field.Expr) IBookCategoryDo
+	RightJoin(table schema.Tabler, on ...field.Expr) IBookCategoryDo
+	Group(cols ...field.Expr) IBookCategoryDo
+	Having(conds ...gen.Condition) IBookCategoryDo
+	Limit(limit int) IBookCategoryDo
+	Offset(offset int) IBookCategoryDo
+	Count() (count int64, err error)
+	Scopes(funcs ...func(gen.Dao) gen.Dao) IBookCategoryDo
+	Unscoped() IBookCategoryDo
+	Create(values ...*entity.BookCategory) error
+	CreateInBatches(values []*entity.BookCategory, batchSize int) error
+	Save(values ...*entity.BookCategory) error
+	First() (*entity.BookCategory, error)
+	Take() (*entity.BookCategory, error)
+	Last() (*entity.BookCategory, error)
+	Find() ([]*entity.BookCategory, error)
+	FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*entity.BookCategory, err error)
+	FindInBatches(result *[]*entity.BookCategory, batchSize int, fc func(tx gen.Dao, batch int) error) error
+	Pluck(column field.Expr, dest interface{}) error
+	Delete(...*entity.BookCategory) (info gen.ResultInfo, err error)
+	Update(column field.Expr, value interface{}) (info gen.ResultInfo, err error)
+	UpdateSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error)
+	Updates(value interface{}) (info gen.ResultInfo, err error)
+	UpdateColumn(column field.Expr, value interface{}) (info gen.ResultInfo, err error)
+	UpdateColumnSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error)
+	UpdateColumns(value interface{}) (info gen.ResultInfo, err error)
+	UpdateFrom(q gen.SubQuery) gen.Dao
+	Attrs(attrs ...field.AssignExpr) IBookCategoryDo
+	Assign(attrs ...field.AssignExpr) IBookCategoryDo
+	Joins(fields ...field.RelationField) IBookCategoryDo
+	Preload(fields ...field.RelationField) IBookCategoryDo
+	FirstOrInit() (*entity.BookCategory, error)
+	FirstOrCreate() (*entity.BookCategory, error)
+	FindByPage(offset int, limit int) (result []*entity.BookCategory, count int64, err error)
+	ScanByPage(result interface{}, offset int, limit int) (count int64, err error)
+	Scan(result interface{}) (err error)
+	Returning(value interface{}, columns ...string) IBookCategoryDo
+	UnderlyingDB() *gorm.DB
+	schema.Tabler
+}
+
+func (b MBookCategoryDo) Debug() IBookCategoryDo {
+	return b.withDO(b.DO.Debug())
+}
+
+func (b MBookCategoryDo) WithContext(ctx context.Context) IBookCategoryDo {
+	return b.withDO(b.DO.WithContext(ctx))
+}
+
+func (b MBookCategoryDo) ReadDB() IBookCategoryDo {
+	return b.Clauses(dbresolver.Read)
+}
+
+func (b MBookCategoryDo) WriteDB() IBookCategoryDo {
+	return b.Clauses(dbresolver.Write)
+}
+
+func (b MBookCategoryDo) Session(config *gorm.Session) IBookCategoryDo {
+	return b.withDO(b.DO.Session(config))
+}
+
+func (b MBookCategoryDo) Clauses(conds ...clause.Expression) IBookCategoryDo {
+	return b.withDO(b.DO.Clauses(conds...))
+}
+
+func (b MBookCategoryDo) Returning(value interface{}, columns ...string) IBookCategoryDo {
+	return b.withDO(b.DO.Returning(value, columns...))
+}
+
+func (b MBookCategoryDo) Not(conds ...gen.Condition) IBookCategoryDo {
+	return b.withDO(b.DO.Not(conds...))
+}
+
+func (b MBookCategoryDo) Or(conds ...gen.Condition) IBookCategoryDo {
+	return b.withDO(b.DO.Or(conds...))
+}
+
+func (b MBookCategoryDo) Select(conds ...field.Expr) IBookCategoryDo {
+	return b.withDO(b.DO.Select(conds...))
+}
+
+func (b MBookCategoryDo) Where(conds ...gen.Condition) IBookCategoryDo {
+	return b.withDO(b.DO.Where(conds...))
+}
+
+func (b MBookCategoryDo) Exists(subquery interface{ UnderlyingDB() *gorm.DB }) IBookCategoryDo {
+	return b.Where(field.CompareSubQuery(field.ExistsOp, nil, subquery.UnderlyingDB()))
+}
+
+func (b MBookCategoryDo) Order(conds ...field.Expr) IBookCategoryDo {
+	return b.withDO(b.DO.Order(conds...))
+}
+
+func (b MBookCategoryDo) Distinct(cols ...field.Expr) IBookCategoryDo {
+	return b.withDO(b.DO.Distinct(cols...))
+}
+
+func (b MBookCategoryDo) Omit(cols ...field.Expr) IBookCategoryDo {
+	return b.withDO(b.DO.Omit(cols...))
+}
+
+func (b MBookCategoryDo) Join(table schema.Tabler, on ...field.Expr) IBookCategoryDo {
+	return b.withDO(b.DO.Join(table, on...))
+}
+
+func (b MBookCategoryDo) LeftJoin(table schema.Tabler, on ...field.Expr) IBookCategoryDo {
+	return b.withDO(b.DO.LeftJoin(table, on...))
+}
+
+func (b MBookCategoryDo) RightJoin(table schema.Tabler, on ...field.Expr) IBookCategoryDo {
+	return b.withDO(b.DO.RightJoin(table, on...))
+}
+
+func (b MBookCategoryDo) Group(cols ...field.Expr) IBookCategoryDo {
+	return b.withDO(b.DO.Group(cols...))
+}
+
+func (b MBookCategoryDo) Having(conds ...gen.Condition) IBookCategoryDo {
+	return b.withDO(b.DO.Having(conds...))
+}
+
+func (b MBookCategoryDo) Limit(limit int) IBookCategoryDo {
+	return b.withDO(b.DO.Limit(limit))
+}
+
+func (b MBookCategoryDo) Offset(offset int) IBookCategoryDo {
+	return b.withDO(b.DO.Offset(offset))
+}
+
+func (b MBookCategoryDo) Scopes(funcs ...func(gen.Dao) gen.Dao) IBookCategoryDo {
+	return b.withDO(b.DO.Scopes(funcs...))
+}
+
+func (b MBookCategoryDo) Unscoped() IBookCategoryDo {
+	return b.withDO(b.DO.Unscoped())
+}
+
+func (b MBookCategoryDo) Create(values ...*entity.BookCategory) error {
+	if len(values) == 0 {
+		return nil
+	}
+	return b.DO.Create(values)
+}
+
+func (b MBookCategoryDo) CreateInBatches(values []*entity.BookCategory, batchSize int) error {
+	return b.DO.CreateInBatches(values, batchSize)
+}
+
+// Save : !!! underlying implementation is different with GORM
+// The method is equivalent to executing the statement: db.Clauses(clause.OnConflict{UpdateAll: true}).Create(values)
+func (b MBookCategoryDo) Save(values ...*entity.BookCategory) error {
+	if len(values) == 0 {
+		return nil
+	}
+	return b.DO.Save(values)
+}
+
+func (b MBookCategoryDo) First() (*entity.BookCategory, error) {
+	if result, err := b.DO.First(); err != nil {
+		return nil, err
+	} else {
+		return result.(*entity.BookCategory), nil
+	}
+}
+
+func (b MBookCategoryDo) Take() (*entity.BookCategory, error) {
+	if result, err := b.DO.Take(); err != nil {
+		return nil, err
+	} else {
+		return result.(*entity.BookCategory), nil
+	}
+}
+
+func (b MBookCategoryDo) Last() (*entity.BookCategory, error) {
+	if result, err := b.DO.Last(); err != nil {
+		return nil, err
+	} else {
+		return result.(*entity.BookCategory), nil
+	}
+}
+
+func (b MBookCategoryDo) Find() ([]*entity.BookCategory, error) {
+	result, err := b.DO.Find()
+	return result.([]*entity.BookCategory), err
+}
+
+func (b MBookCategoryDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*entity.BookCategory, err error) {
+	buf := make([]*entity.BookCategory, 0, batchSize)
+	err = b.DO.FindInBatches(&buf, batchSize, func(tx gen.Dao, batch int) error {
+		defer func() { results = append(results, buf...) }()
+		return fc(tx, batch)
+	})
+	return results, err
+}
+
+func (b MBookCategoryDo) FindInBatches(result *[]*entity.BookCategory, batchSize int, fc func(tx gen.Dao, batch int) error) error {
+	return b.DO.FindInBatches(result, batchSize, fc)
+}
+
+func (b MBookCategoryDo) Attrs(attrs ...field.AssignExpr) IBookCategoryDo {
+	return b.withDO(b.DO.Attrs(attrs...))
+}
+
+func (b MBookCategoryDo) Assign(attrs ...field.AssignExpr) IBookCategoryDo {
+	return b.withDO(b.DO.Assign(attrs...))
+}
+
+func (b MBookCategoryDo) Joins(fields ...field.RelationField) IBookCategoryDo {
+	for _, _f := range fields {
+		b = *b.withDO(b.DO.Joins(_f))
+	}
+	return &b
+}
+
+func (b MBookCategoryDo) Preload(fields ...field.RelationField) IBookCategoryDo {
+	for _, _f := range fields {
+		b = *b.withDO(b.DO.Preload(_f))
+	}
+	return &b
+}
+
+func (b MBookCategoryDo) FirstOrInit() (*entity.BookCategory, error) {
+	if result, err := b.DO.FirstOrInit(); err != nil {
+		return nil, err
+	} else {
+		return result.(*entity.BookCategory), nil
+	}
+}
+
+func (b MBookCategoryDo) FirstOrCreate() (*entity.BookCategory, error) {
+	if result, err := b.DO.FirstOrCreate(); err != nil {
+		return nil, err
+	} else {
+		return result.(*entity.BookCategory), nil
+	}
+}
+
+func (b MBookCategoryDo) FindByPage(offset int, limit int) (result []*entity.BookCategory, count int64, err error) {
+	result, err = b.Offset(offset).Limit(limit).Find()
+	if err != nil {
+		return
+	}
+
+	if size := len(result); 0 < limit && 0 < size && size < limit {
+		count = int64(size + offset)
+		return
+	}
+
+	count, err = b.Offset(-1).Limit(-1).Count()
+	return
+}
+
+func (b MBookCategoryDo) ScanByPage(result interface{}, offset int, limit int) (count int64, err error) {
+	count, err = b.Count()
+	if err != nil {
+		return
+	}
+
+	err = b.Offset(offset).Limit(limit).Scan(result)
+	return
+}
+
+func (b MBookCategoryDo) Scan(result interface{}) (err error) {
+	return b.DO.Scan(result)
+}
+
+func (b MBookCategoryDo) Delete(models ...*entity.BookCategory) (result gen.ResultInfo, err error) {
+	return b.DO.Delete(models)
+}
+
+func (b *MBookCategoryDo) withDO(do gen.Dao) *MBookCategoryDo {
+	b.DO = *do.(*gen.DO)
+	return b
+}

service/model/fonts.go

@@ -0,0 +1,430 @@
+// Code generated by gorm.io/gen. DO NOT EDIT.
+// Code generated by gorm.io/gen. DO NOT EDIT.
+// Code generated by gorm.io/gen. DO NOT EDIT.
+
+package model
+
+import (
+	"context"
+
+	"gorm.io/gorm"
+	"gorm.io/gorm/clause"
+	"gorm.io/gorm/schema"
+
+	"gorm.io/gen"
+	"gorm.io/gen/field"
+
+	"gorm.io/plugin/dbresolver"
+
+	"icloudapp.cn/tools/service/entity"
+)
+
+func newFont(db *gorm.DB, opts ...gen.DOOption) MFont {
+	_MFont := MFont{}
+
+	_MFont.MFontDo.UseDB(db, opts...)
+	_MFont.MFontDo.UseModel(&entity.Font{})
+
+	tableName := _MFont.MFontDo.TableName()
+	_MFont.ALL = field.NewAsterisk(tableName)
+	_MFont.ID = field.NewInt64(tableName, "id")
+	_MFont.Name = field.NewString(tableName, "name")
+	_MFont.Code = field.NewString(tableName, "code")
+	_MFont.Path = field.NewString(tableName, "path")
+	_MFont.FileName = field.NewString(tableName, "file_name")
+	_MFont.FileSize = field.NewInt64(tableName, "file_size")
+	_MFont.Hash = field.NewString(tableName, "hash")
+	_MFont.FileType = field.NewString(tableName, "file_type")
+	_MFont.Status = field.NewInt64(tableName, "status")
+	_MFont.CreateAt = field.NewTime(tableName, "create_at")
+	_MFont.UpdateAt = field.NewTime(tableName, "update_at")
+
+	_MFont.fillFieldMap()
+
+	return _MFont
+}
+
+type MFont struct {
+	MFontDo MFontDo
+
+	ALL      field.Asterisk
+	ID       field.Int64
+	Name     field.String // 字体名称
+	Code     field.String // 字体code
+	Path     field.String // 字体路径
+	FileName field.String // 文件名称
+	FileSize field.Int64  // 文件大小
+	Hash     field.String // 文件hash
+	FileType field.String // 文件类型
+	Status   field.Int64  // 文字状态
+	CreateAt field.Time   // 创建时间
+	UpdateAt field.Time   // 更新时间
+
+	fieldMap map[string]field.Expr
+}
+
+func (f MFont) Table(newTableName string) *MFont {
+	f.MFontDo.UseTable(newTableName)
+	return f.updateTableName(newTableName)
+}
+
+func (f MFont) As(alias string) *MFont {
+	f.MFontDo.DO = *(f.MFontDo.As(alias).(*gen.DO))
+	return f.updateTableName(alias)
+}
+
+func (f *MFont) updateTableName(table string) *MFont {
+	f.ALL = field.NewAsterisk(table)
+	f.ID = field.NewInt64(table, "id")
+	f.Name = field.NewString(table, "name")
+	f.Code = field.NewString(table, "code")
+	f.Path = field.NewString(table, "path")
+	f.FileName = field.NewString(table, "file_name")
+	f.FileSize = field.NewInt64(table, "file_size")
+	f.Hash = field.NewString(table, "hash")
+	f.FileType = field.NewString(table, "file_type")
+	f.Status = field.NewInt64(table, "status")
+	f.CreateAt = field.NewTime(table, "create_at")
+	f.UpdateAt = field.NewTime(table, "update_at")
+
+	f.fillFieldMap()
+
+	return f
+}
+
+func (f *MFont) WithContext(ctx context.Context) IFontDo { return f.MFontDo.WithContext(ctx) }
+
+func (f MFont) TableName() string { return f.MFontDo.TableName() }
+
+func (f MFont) Alias() string { return f.MFontDo.Alias() }
+
+func (f *MFont) GetFieldByName(fieldName string) (field.OrderExpr, bool) {
+	_f, ok := f.fieldMap[fieldName]
+	if !ok || _f == nil {
+		return nil, false
+	}
+	_oe, ok := _f.(field.OrderExpr)
+	return _oe, ok
+}
+
+func (f *MFont) fillFieldMap() {
+	f.fieldMap = make(map[string]field.Expr, 11)
+	f.fieldMap["id"] = f.ID
+	f.fieldMap["name"] = f.Name
+	f.fieldMap["code"] = f.Code
+	f.fieldMap["path"] = f.Path
+	f.fieldMap["file_name"] = f.FileName
+	f.fieldMap["file_size"] = f.FileSize
+	f.fieldMap["hash"] = f.Hash
+	f.fieldMap["file_type"] = f.FileType
+	f.fieldMap["status"] = f.Status
+	f.fieldMap["create_at"] = f.CreateAt
+	f.fieldMap["update_at"] = f.UpdateAt
+}
+
+func (f MFont) clone(db *gorm.DB) MFont {
+	f.MFontDo.ReplaceConnPool(db.Statement.ConnPool)
+	return f
+}
+
+func (f MFont) replaceDB(db *gorm.DB) MFont {
+	f.MFontDo.ReplaceDB(db)
+	return f
+}
+
+type MFontDo struct{ gen.DO }
+
+type IFontDo interface {
+	gen.SubQuery
+	Debug() IFontDo
+	WithContext(ctx context.Context) IFontDo
+	WithResult(fc func(tx gen.Dao)) gen.ResultInfo
+	ReplaceDB(db *gorm.DB)
+	ReadDB() IFontDo
+	WriteDB() IFontDo
+	As(alias string) gen.Dao
+	Session(config *gorm.Session) IFontDo
+	Columns(cols ...field.Expr) gen.Columns
+	Clauses(conds ...clause.Expression) IFontDo
+	Not(conds ...gen.Condition) IFontDo
+	Or(conds ...gen.Condition) IFontDo
+	Select(conds ...field.Expr) IFontDo
+	Where(conds ...gen.Condition) IFontDo
+	Order(conds ...field.Expr) IFontDo
+	Distinct(cols ...field.Expr) IFontDo
+	Omit(cols ...field.Expr) IFontDo
+	Join(table schema.Tabler, on ...field.Expr) IFontDo
+	LeftJoin(table schema.Tabler, on ...field.Expr) IFontDo
+	RightJoin(table schema.Tabler, on ...field.Expr) IFontDo
+	Group(cols ...field.Expr) IFontDo
+	Having(conds ...gen.Condition) IFontDo
+	Limit(limit int) IFontDo
+	Offset(offset int) IFontDo
+	Count() (count int64, err error)
+	Scopes(funcs ...func(gen.Dao) gen.Dao) IFontDo
+	Unscoped() IFontDo
+	Create(values ...*entity.Font) error
+	CreateInBatches(values []*entity.Font, batchSize int) error
+	Save(values ...*entity.Font) error
+	First() (*entity.Font, error)
+	Take() (*entity.Font, error)
+	Last() (*entity.Font, error)
+	Find() ([]*entity.Font, error)
+	FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*entity.Font, err error)
+	FindInBatches(result *[]*entity.Font, batchSize int, fc func(tx gen.Dao, batch int) error) error
+	Pluck(column field.Expr, dest interface{}) error
+	Delete(...*entity.Font) (info gen.ResultInfo, err error)
+	Update(column field.Expr, value interface{}) (info gen.ResultInfo, err error)
+	UpdateSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error)
+	Updates(value interface{}) (info gen.ResultInfo, err error)
+	UpdateColumn(column field.Expr, value interface{}) (info gen.ResultInfo, err error)
+	UpdateColumnSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error)
+	UpdateColumns(value interface{}) (info gen.ResultInfo, err error)
+	UpdateFrom(q gen.SubQuery) gen.Dao
+	Attrs(attrs ...field.AssignExpr) IFontDo
+	Assign(attrs ...field.AssignExpr) IFontDo
+	Joins(fields ...field.RelationField) IFontDo
+	Preload(fields ...field.RelationField) IFontDo
+	FirstOrInit() (*entity.Font, error)
+	FirstOrCreate() (*entity.Font, error)
+	FindByPage(offset int, limit int) (result []*entity.Font, count int64, err error)
+	ScanByPage(result interface{}, offset int, limit int) (count int64, err error)
+	Scan(result interface{}) (err error)
+	Returning(value interface{}, columns ...string) IFontDo
+	UnderlyingDB() *gorm.DB
+	schema.Tabler
+}
+
+func (f MFontDo) Debug() IFontDo {
+	return f.withDO(f.DO.Debug())
+}
+
+func (f MFontDo) WithContext(ctx context.Context) IFontDo {
+	return f.withDO(f.DO.WithContext(ctx))
+}
+
+func (f MFontDo) ReadDB() IFontDo {
+	return f.Clauses(dbresolver.Read)
+}
+
+func (f MFontDo) WriteDB() IFontDo {
+	return f.Clauses(dbresolver.Write)
+}
+
+func (f MFontDo) Session(config *gorm.Session) IFontDo {
+	return f.withDO(f.DO.Session(config))
+}
+
+func (f MFontDo) Clauses(conds ...clause.Expression) IFontDo {
+	return f.withDO(f.DO.Clauses(conds...))
+}
+
+func (f MFontDo) Returning(value interface{}, columns ...string) IFontDo {
+	return f.withDO(f.DO.Returning(value, columns...))
+}
+
+func (f MFontDo) Not(conds ...gen.Condition) IFontDo {
+	return f.withDO(f.DO.Not(conds...))
+}
+
+func (f MFontDo) Or(conds ...gen.Condition) IFontDo {
+	return f.withDO(f.DO.Or(conds...))
+}
+
+func (f MFontDo) Select(conds ...field.Expr) IFontDo {
+	return f.withDO(f.DO.Select(conds...))
+}
+
+func (f MFontDo) Where(conds ...gen.Condition) IFontDo {
+	return f.withDO(f.DO.Where(conds...))
+}
+
+func (f MFontDo) Exists(subquery interface{ UnderlyingDB() *gorm.DB }) IFontDo {
+	return f.Where(field.CompareSubQuery(field.ExistsOp, nil, subquery.UnderlyingDB()))
+}
+
+func (f MFontDo) Order(conds ...field.Expr) IFontDo {
+	return f.withDO(f.DO.Order(conds...))
+}
+
+func (f MFontDo) Distinct(cols ...field.Expr) IFontDo {
+	return f.withDO(f.DO.Distinct(cols...))
+}
+
+func (f MFontDo) Omit(cols ...field.Expr) IFontDo {
+	return f.withDO(f.DO.Omit(cols...))
+}
+
+func (f MFontDo) Join(table schema.Tabler, on ...field.Expr) IFontDo {
+	return f.withDO(f.DO.Join(table, on...))
+}
+
+func (f MFontDo) LeftJoin(table schema.Tabler, on ...field.Expr) IFontDo {
+	return f.withDO(f.DO.LeftJoin(table, on...))
+}
+
+func (f MFontDo) RightJoin(table schema.Tabler, on ...field.Expr) IFontDo {
+	return f.withDO(f.DO.RightJoin(table, on...))
+}
+
+func (f MFontDo) Group(cols ...field.Expr) IFontDo {
+	return f.withDO(f.DO.Group(cols...))
+}
+
+func (f MFontDo) Having(conds ...gen.Condition) IFontDo {
+	return f.withDO(f.DO.Having(conds...))
+}
+
+func (f MFontDo) Limit(limit int) IFontDo {
+	return f.withDO(f.DO.Limit(limit))
+}
+
+func (f MFontDo) Offset(offset int) IFontDo {
+	return f.withDO(f.DO.Offset(offset))
+}
+
+func (f MFontDo) Scopes(funcs ...func(gen.Dao) gen.Dao) IFontDo {
+	return f.withDO(f.DO.Scopes(funcs...))
+}
+
+func (f MFontDo) Unscoped() IFontDo {
+	return f.withDO(f.DO.Unscoped())
+}
+
+func (f MFontDo) Create(values ...*entity.Font) error {
+	if len(values) == 0 {
+		return nil
+	}
+	return f.DO.Create(values)
+}
+
+func (f MFontDo) CreateInBatches(values []*entity.Font, batchSize int) error {
+	return f.DO.CreateInBatches(values, batchSize)
+}
+
+// Save : !!! underlying implementation is different with GORM
+// The method is equivalent to executing the statement: db.Clauses(clause.OnConflict{UpdateAll: true}).Create(values)
+func (f MFontDo) Save(values ...*entity.Font) error {
+	if len(values) == 0 {
+		return nil
+	}
+	return f.DO.Save(values)
+}
+
+func (f MFontDo) First() (*entity.Font, error) {
+	if result, err := f.DO.First(); err != nil {
+		return nil, err
+	} else {
+		return result.(*entity.Font), nil
+	}
+}
+
+func (f MFontDo) Take() (*entity.Font, error) {
+	if result, err := f.DO.Take(); err != nil {
+		return nil, err
+	} else {
+		return result.(*entity.Font), nil
+	}
+}
+
+func (f MFontDo) Last() (*entity.Font, error) {
+	if result, err := f.DO.Last(); err != nil {
+		return nil, err
+	} else {
+		return result.(*entity.Font), nil
+	}
+}
+
+func (f MFontDo) Find() ([]*entity.Font, error) {
+	result, err := f.DO.Find()
+	return result.([]*entity.Font), err
+}
+
+func (f MFontDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*entity.Font, err error) {
+	buf := make([]*entity.Font, 0, batchSize)
+	err = f.DO.FindInBatches(&buf, batchSize, func(tx gen.Dao, batch int) error {
+		defer func() { results = append(results, buf...) }()
+		return fc(tx, batch)
+	})
+	return results, err
+}
+
+func (f MFontDo) FindInBatches(result *[]*entity.Font, batchSize int, fc func(tx gen.Dao, batch int) error) error {
+	return f.DO.FindInBatches(result, batchSize, fc)
+}
+
+func (f MFontDo) Attrs(attrs ...field.AssignExpr) IFontDo {
+	return f.withDO(f.DO.Attrs(attrs...))
+}
+
+func (f MFontDo) Assign(attrs ...field.AssignExpr) IFontDo {
+	return f.withDO(f.DO.Assign(attrs...))
+}
+
+func (f MFontDo) Joins(fields ...field.RelationField) IFontDo {
+	for _, _f := range fields {
+		f = *f.withDO(f.DO.Joins(_f))
+	}
+	return &f
+}
+
+func (f MFontDo) Preload(fields ...field.RelationField) IFontDo {
+	for _, _f := range fields {
+		f = *f.withDO(f.DO.Preload(_f))
+	}
+	return &f
+}
+
+func (f MFontDo) FirstOrInit() (*entity.Font, error) {
+	if result, err := f.DO.FirstOrInit(); err != nil {
+		return nil, err
+	} else {
+		return result.(*entity.Font), nil
+	}
+}
+
+func (f MFontDo) FirstOrCreate() (*entity.Font, error) {
+	if result, err := f.DO.FirstOrCreate(); err != nil {
+		return nil, err
+	} else {
+		return result.(*entity.Font), nil
+	}
+}
+
+func (f MFontDo) FindByPage(offset int, limit int) (result []*entity.Font, count int64, err error) {
+	result, err = f.Offset(offset).Limit(limit).Find()
+	if err != nil {
+		return
+	}
+
+	if size := len(result); 0 < limit && 0 < size && size < limit {
+		count = int64(size + offset)
+		return
+	}
+
+	count, err = f.Offset(-1).Limit(-1).Count()
+	return
+}
+
+func (f MFontDo) ScanByPage(result interface{}, offset int, limit int) (count int64, err error) {
+	count, err = f.Count()
+	if err != nil {
+		return
+	}
+
+	err = f.Offset(offset).Limit(limit).Scan(result)
+	return
+}
+
+func (f MFontDo) Scan(result interface{}) (err error) {
+	return f.DO.Scan(result)
+}
+
+func (f MFontDo) Delete(models ...*entity.Font) (result gen.ResultInfo, err error) {
+	return f.DO.Delete(models)
+}
+
+func (f *MFontDo) withDO(do gen.Dao) *MFontDo {
+	f.DO = *do.(*gen.DO)
+	return f
+}

service/model/group.go

@@ -0,0 +1,414 @@
+// Code generated by gorm.io/gen. DO NOT EDIT.
+// Code generated by gorm.io/gen. DO NOT EDIT.
+// Code generated by gorm.io/gen. DO NOT EDIT.
+
+package model
+
+import (
+	"context"
+
+	"gorm.io/gorm"
+	"gorm.io/gorm/clause"
+	"gorm.io/gorm/schema"
+
+	"gorm.io/gen"
+	"gorm.io/gen/field"
+
+	"gorm.io/plugin/dbresolver"
+
+	"icloudapp.cn/tools/service/entity"
+)
+
+func newGroup(db *gorm.DB, opts ...gen.DOOption) MGroup {
+	_MGroup := MGroup{}
+
+	_MGroup.MGroupDo.UseDB(db, opts...)
+	_MGroup.MGroupDo.UseModel(&entity.Group{})
+
+	tableName := _MGroup.MGroupDo.TableName()
+	_MGroup.ALL = field.NewAsterisk(tableName)
+	_MGroup.GroupID = field.NewInt64(tableName, "group_id")
+	_MGroup.GroupName = field.NewString(tableName, "group_name")
+	_MGroup.Roles = field.NewString(tableName, "roles")
+	_MGroup.GroupStatus = field.NewInt64(tableName, "group_status")
+	_MGroup.OperatorUID = field.NewInt64(tableName, "operator_uid")
+	_MGroup.CreateAt = field.NewTime(tableName, "create_at")
+	_MGroup.UpdateAt = field.NewTime(tableName, "update_at")
+
+	_MGroup.fillFieldMap()
+
+	return _MGroup
+}
+
+type MGroup struct {
+	MGroupDo MGroupDo
+
+	ALL         field.Asterisk
+	GroupID     field.Int64
+	GroupName   field.String // 分组名称
+	Roles       field.String // 权限，roles 的id，对应的模块
+	GroupStatus field.Int64  // 分组状态
+	OperatorUID field.Int64  // 操作人
+	CreateAt    field.Time   // 创建时间
+	UpdateAt    field.Time   // 更新时间
+
+	fieldMap map[string]field.Expr
+}
+
+func (g MGroup) Table(newTableName string) *MGroup {
+	g.MGroupDo.UseTable(newTableName)
+	return g.updateTableName(newTableName)
+}
+
+func (g MGroup) As(alias string) *MGroup {
+	g.MGroupDo.DO = *(g.MGroupDo.As(alias).(*gen.DO))
+	return g.updateTableName(alias)
+}
+
+func (g *MGroup) updateTableName(table string) *MGroup {
+	g.ALL = field.NewAsterisk(table)
+	g.GroupID = field.NewInt64(table, "group_id")
+	g.GroupName = field.NewString(table, "group_name")
+	g.Roles = field.NewString(table, "roles")
+	g.GroupStatus = field.NewInt64(table, "group_status")
+	g.OperatorUID = field.NewInt64(table, "operator_uid")
+	g.CreateAt = field.NewTime(table, "create_at")
+	g.UpdateAt = field.NewTime(table, "update_at")
+
+	g.fillFieldMap()
+
+	return g
+}
+
+func (g *MGroup) WithContext(ctx context.Context) IGroupDo { return g.MGroupDo.WithContext(ctx) }
+
+func (g MGroup) TableName() string { return g.MGroupDo.TableName() }
+
+func (g MGroup) Alias() string { return g.MGroupDo.Alias() }
+
+func (g *MGroup) GetFieldByName(fieldName string) (field.OrderExpr, bool) {
+	_f, ok := g.fieldMap[fieldName]
+	if !ok || _f == nil {
+		return nil, false
+	}
+	_oe, ok := _f.(field.OrderExpr)
+	return _oe, ok
+}
+
+func (g *MGroup) fillFieldMap() {
+	g.fieldMap = make(map[string]field.Expr, 7)
+	g.fieldMap["group_id"] = g.GroupID
+	g.fieldMap["group_name"] = g.GroupName
+	g.fieldMap["roles"] = g.Roles
+	g.fieldMap["group_status"] = g.GroupStatus
+	g.fieldMap["operator_uid"] = g.OperatorUID
+	g.fieldMap["create_at"] = g.CreateAt
+	g.fieldMap["update_at"] = g.UpdateAt
+}
+
+func (g MGroup) clone(db *gorm.DB) MGroup {
+	g.MGroupDo.ReplaceConnPool(db.Statement.ConnPool)
+	return g
+}
+
+func (g MGroup) replaceDB(db *gorm.DB) MGroup {
+	g.MGroupDo.ReplaceDB(db)
+	return g
+}
+
+type MGroupDo struct{ gen.DO }
+
+type IGroupDo interface {
+	gen.SubQuery
+	Debug() IGroupDo
+	WithContext(ctx context.Context) IGroupDo
+	WithResult(fc func(tx gen.Dao)) gen.ResultInfo
+	ReplaceDB(db *gorm.DB)
+	ReadDB() IGroupDo
+	WriteDB() IGroupDo
+	As(alias string) gen.Dao
+	Session(config *gorm.Session) IGroupDo
+	Columns(cols ...field.Expr) gen.Columns
+	Clauses(conds ...clause.Expression) IGroupDo
+	Not(conds ...gen.Condition) IGroupDo
+	Or(conds ...gen.Condition) IGroupDo
+	Select(conds ...field.Expr) IGroupDo
+	Where(conds ...gen.Condition) IGroupDo
+	Order(conds ...field.Expr) IGroupDo
+	Distinct(cols ...field.Expr) IGroupDo
+	Omit(cols ...field.Expr) IGroupDo
+	Join(table schema.Tabler, on ...field.Expr) IGroupDo
+	LeftJoin(table schema.Tabler, on ...field.Expr) IGroupDo
+	RightJoin(table schema.Tabler, on ...field.Expr) IGroupDo
+	Group(cols ...field.Expr) IGroupDo
+	Having(conds ...gen.Condition) IGroupDo
+	Limit(limit int) IGroupDo
+	Offset(offset int) IGroupDo
+	Count() (count int64, err error)
+	Scopes(funcs ...func(gen.Dao) gen.Dao) IGroupDo
+	Unscoped() IGroupDo
+	Create(values ...*entity.Group) error
+	CreateInBatches(values []*entity.Group, batchSize int) error
+	Save(values ...*entity.Group) error
+	First() (*entity.Group, error)
+	Take() (*entity.Group, error)
+	Last() (*entity.Group, error)
+	Find() ([]*entity.Group, error)
+	FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*entity.Group, err error)
+	FindInBatches(result *[]*entity.Group, batchSize int, fc func(tx gen.Dao, batch int) error) error
+	Pluck(column field.Expr, dest interface{}) error
+	Delete(...*entity.Group) (info gen.ResultInfo, err error)
+	Update(column field.Expr, value interface{}) (info gen.ResultInfo, err error)
+	UpdateSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error)
+	Updates(value interface{}) (info gen.ResultInfo, err error)
+	UpdateColumn(column field.Expr, value interface{}) (info gen.ResultInfo, err error)
+	UpdateColumnSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error)
+	UpdateColumns(value interface{}) (info gen.ResultInfo, err error)
+	UpdateFrom(q gen.SubQuery) gen.Dao
+	Attrs(attrs ...field.AssignExpr) IGroupDo
+	Assign(attrs ...field.AssignExpr) IGroupDo
+	Joins(fields ...field.RelationField) IGroupDo
+	Preload(fields ...field.RelationField) IGroupDo
+	FirstOrInit() (*entity.Group, error)
+	FirstOrCreate() (*entity.Group, error)
+	FindByPage(offset int, limit int) (result []*entity.Group, count int64, err error)
+	ScanByPage(result interface{}, offset int, limit int) (count int64, err error)
+	Scan(result interface{}) (err error)
+	Returning(value interface{}, columns ...string) IGroupDo
+	UnderlyingDB() *gorm.DB
+	schema.Tabler
+}
+
+func (g MGroupDo) Debug() IGroupDo {
+	return g.withDO(g.DO.Debug())
+}
+
+func (g MGroupDo) WithContext(ctx context.Context) IGroupDo {
+	return g.withDO(g.DO.WithContext(ctx))
+}
+
+func (g MGroupDo) ReadDB() IGroupDo {
+	return g.Clauses(dbresolver.Read)
+}
+
+func (g MGroupDo) WriteDB() IGroupDo {
+	return g.Clauses(dbresolver.Write)
+}
+
+func (g MGroupDo) Session(config *gorm.Session) IGroupDo {
+	return g.withDO(g.DO.Session(config))
+}
+
+func (g MGroupDo) Clauses(conds ...clause.Expression) IGroupDo {
+	return g.withDO(g.DO.Clauses(conds...))
+}
+
+func (g MGroupDo) Returning(value interface{}, columns ...string) IGroupDo {
+	return g.withDO(g.DO.Returning(value, columns...))
+}
+
+func (g MGroupDo) Not(conds ...gen.Condition) IGroupDo {
+	return g.withDO(g.DO.Not(conds...))
+}
+
+func (g MGroupDo) Or(conds ...gen.Condition) IGroupDo {
+	return g.withDO(g.DO.Or(conds...))
+}
+
+func (g MGroupDo) Select(conds ...field.Expr) IGroupDo {
+	return g.withDO(g.DO.Select(conds...))
+}
+
+func (g MGroupDo) Where(conds ...gen.Condition) IGroupDo {
+	return g.withDO(g.DO.Where(conds...))
+}
+
+func (g MGroupDo) Exists(subquery interface{ UnderlyingDB() *gorm.DB }) IGroupDo {
+	return g.Where(field.CompareSubQuery(field.ExistsOp, nil, subquery.UnderlyingDB()))
+}
+
+func (g MGroupDo) Order(conds ...field.Expr) IGroupDo {
+	return g.withDO(g.DO.Order(conds...))
+}
+
+func (g MGroupDo) Distinct(cols ...field.Expr) IGroupDo {
+	return g.withDO(g.DO.Distinct(cols...))
+}
+
+func (g MGroupDo) Omit(cols ...field.Expr) IGroupDo {
+	return g.withDO(g.DO.Omit(cols...))
+}
+
+func (g MGroupDo) Join(table schema.Tabler, on ...field.Expr) IGroupDo {
+	return g.withDO(g.DO.Join(table, on...))
+}
+
+func (g MGroupDo) LeftJoin(table schema.Tabler, on ...field.Expr) IGroupDo {
+	return g.withDO(g.DO.LeftJoin(table, on...))
+}
+
+func (g MGroupDo) RightJoin(table schema.Tabler, on ...field.Expr) IGroupDo {
+	return g.withDO(g.DO.RightJoin(table, on...))
+}
+
+func (g MGroupDo) Group(cols ...field.Expr) IGroupDo {
+	return g.withDO(g.DO.Group(cols...))
+}
+
+func (g MGroupDo) Having(conds ...gen.Condition) IGroupDo {
+	return g.withDO(g.DO.Having(conds...))
+}
+
+func (g MGroupDo) Limit(limit int) IGroupDo {
+	return g.withDO(g.DO.Limit(limit))
+}
+
+func (g MGroupDo) Offset(offset int) IGroupDo {
+	return g.withDO(g.DO.Offset(offset))
+}
+
+func (g MGroupDo) Scopes(funcs ...func(gen.Dao) gen.Dao) IGroupDo {
+	return g.withDO(g.DO.Scopes(funcs...))
+}
+
+func (g MGroupDo) Unscoped() IGroupDo {
+	return g.withDO(g.DO.Unscoped())
+}
+
+func (g MGroupDo) Create(values ...*entity.Group) error {
+	if len(values) == 0 {
+		return nil
+	}
+	return g.DO.Create(values)
+}
+
+func (g MGroupDo) CreateInBatches(values []*entity.Group, batchSize int) error {
+	return g.DO.CreateInBatches(values, batchSize)
+}
+
+// Save : !!! underlying implementation is different with GORM
+// The method is equivalent to executing the statement: db.Clauses(clause.OnConflict{UpdateAll: true}).Create(values)
+func (g MGroupDo) Save(values ...*entity.Group) error {
+	if len(values) == 0 {
+		return nil
+	}
+	return g.DO.Save(values)
+}
+
+func (g MGroupDo) First() (*entity.Group, error) {
+	if result, err := g.DO.First(); err != nil {
+		return nil, err
+	} else {
+		return result.(*entity.Group), nil
+	}
+}
+
+func (g MGroupDo) Take() (*entity.Group, error) {
+	if result, err := g.DO.Take(); err != nil {
+		return nil, err
+	} else {
+		return result.(*entity.Group), nil
+	}
+}
+
+func (g MGroupDo) Last() (*entity.Group, error) {
+	if result, err := g.DO.Last(); err != nil {
+		return nil, err
+	} else {
+		return result.(*entity.Group), nil
+	}
+}
+
+func (g MGroupDo) Find() ([]*entity.Group, error) {
+	result, err := g.DO.Find()
+	return result.([]*entity.Group), err
+}
+
+func (g MGroupDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*entity.Group, err error) {
+	buf := make([]*entity.Group, 0, batchSize)
+	err = g.DO.FindInBatches(&buf, batchSize, func(tx gen.Dao, batch int) error {
+		defer func() { results = append(results, buf...) }()
+		return fc(tx, batch)
+	})
+	return results, err
+}
+
+func (g MGroupDo) FindInBatches(result *[]*entity.Group, batchSize int, fc func(tx gen.Dao, batch int) error) error {
+	return g.DO.FindInBatches(result, batchSize, fc)
+}
+
+func (g MGroupDo) Attrs(attrs ...field.AssignExpr) IGroupDo {
+	return g.withDO(g.DO.Attrs(attrs...))
+}
+
+func (g MGroupDo) Assign(attrs ...field.AssignExpr) IGroupDo {
+	return g.withDO(g.DO.Assign(attrs...))
+}
+
+func (g MGroupDo) Joins(fields ...field.RelationField) IGroupDo {
+	for _, _f := range fields {
+		g = *g.withDO(g.DO.Joins(_f))
+	}
+	return &g
+}
+
+func (g MGroupDo) Preload(fields ...field.RelationField) IGroupDo {
+	for _, _f := range fields {
+		g = *g.withDO(g.DO.Preload(_f))
+	}
+	return &g
+}
+
+func (g MGroupDo) FirstOrInit() (*entity.Group, error) {
+	if result, err := g.DO.FirstOrInit(); err != nil {
+		return nil, err
+	} else {
+		return result.(*entity.Group), nil
+	}
+}
+
+func (g MGroupDo) FirstOrCreate() (*entity.Group, error) {
+	if result, err := g.DO.FirstOrCreate(); err != nil {
+		return nil, err
+	} else {
+		return result.(*entity.Group), nil
+	}
+}
+
+func (g MGroupDo) FindByPage(offset int, limit int) (result []*entity.Group, count int64, err error) {
+	result, err = g.Offset(offset).Limit(limit).Find()
+	if err != nil {
+		return
+	}
+
+	if size := len(result); 0 < limit && 0 < size && size < limit {
+		count = int64(size + offset)
+		return
+	}
+
+	count, err = g.Offset(-1).Limit(-1).Count()
+	return
+}
+
+func (g MGroupDo) ScanByPage(result interface{}, offset int, limit int) (count int64, err error) {
+	count, err = g.Count()
+	if err != nil {
+		return
+	}
+
+	err = g.Offset(offset).Limit(limit).Scan(result)
+	return
+}
+
+func (g MGroupDo) Scan(result interface{}) (err error) {
+	return g.DO.Scan(result)
+}
+
+func (g MGroupDo) Delete(models ...*entity.Group) (result gen.ResultInfo, err error) {
+	return g.DO.Delete(models)
+}
+
+func (g *MGroupDo) withDO(do gen.Dao) *MGroupDo {
+	g.DO = *do.(*gen.DO)
+	return g
+}

service/model/materials.go

@@ -0,0 +1,432 @@
+// Code generated by gorm.io/gen. DO NOT EDIT.
+// Code generated by gorm.io/gen. DO NOT EDIT.
+// Code generated by gorm.io/gen. DO NOT EDIT.
+
+package model
+
+import (
+	"context"
+
+	"gorm.io/gorm"
+	"gorm.io/gorm/clause"
+	"gorm.io/gorm/schema"
+
+	"gorm.io/gen"
+	"gorm.io/gen/field"
+
+	"gorm.io/plugin/dbresolver"
+
+	"icloudapp.cn/tools/service/entity"
+)
+
+func newMaterial(db *gorm.DB, opts ...gen.DOOption) MMaterial {
+	_MMaterial := MMaterial{}
+
+	_MMaterial.MMaterialDo.UseDB(db, opts...)
+	_MMaterial.MMaterialDo.UseModel(&entity.Material{})
+
+	tableName := _MMaterial.MMaterialDo.TableName()
+	_MMaterial.ALL = field.NewAsterisk(tableName)
+	_MMaterial.ID = field.NewInt64(tableName, "id")
+	_MMaterial.Name = field.NewString(tableName, "name")
+	_MMaterial.File = field.NewString(tableName, "file")
+	_MMaterial.Size = field.NewString(tableName, "size")
+	_MMaterial.FileSize = field.NewInt64(tableName, "file_size")
+	_MMaterial.Hash = field.NewString(tableName, "hash")
+	_MMaterial.Type = field.NewString(tableName, "type")
+	_MMaterial.UID = field.NewInt64(tableName, "uid")
+	_MMaterial.Status = field.NewInt64(tableName, "status")
+	_MMaterial.CreateAt = field.NewTime(tableName, "create_at")
+	_MMaterial.UpdateAt = field.NewTime(tableName, "update_at")
+
+	_MMaterial.fillFieldMap()
+
+	return _MMaterial
+}
+
+type MMaterial struct {
+	MMaterialDo MMaterialDo
+
+	ALL      field.Asterisk
+	ID       field.Int64  // 素材ID
+	Name     field.String // 素材名称
+	File     field.String // 素材地址
+	Size     field.String // 素材尺寸
+	FileSize field.Int64  // 素材大小
+	Hash     field.String // 素材文件hash
+	Type     field.String // 素材类型
+	UID      field.Int64  // 上传用户
+	Status   field.Int64  // 素材状态
+	CreateAt field.Time   // 创建时间
+	UpdateAt field.Time   // 更新时间
+
+	fieldMap map[string]field.Expr
+}
+
+func (m MMaterial) Table(newTableName string) *MMaterial {
+	m.MMaterialDo.UseTable(newTableName)
+	return m.updateTableName(newTableName)
+}
+
+func (m MMaterial) As(alias string) *MMaterial {
+	m.MMaterialDo.DO = *(m.MMaterialDo.As(alias).(*gen.DO))
+	return m.updateTableName(alias)
+}
+
+func (m *MMaterial) updateTableName(table string) *MMaterial {
+	m.ALL = field.NewAsterisk(table)
+	m.ID = field.NewInt64(table, "id")
+	m.Name = field.NewString(table, "name")
+	m.File = field.NewString(table, "file")
+	m.Size = field.NewString(table, "size")
+	m.FileSize = field.NewInt64(table, "file_size")
+	m.Hash = field.NewString(table, "hash")
+	m.Type = field.NewString(table, "type")
+	m.UID = field.NewInt64(table, "uid")
+	m.Status = field.NewInt64(table, "status")
+	m.CreateAt = field.NewTime(table, "create_at")
+	m.UpdateAt = field.NewTime(table, "update_at")
+
+	m.fillFieldMap()
+
+	return m
+}
+
+func (m *MMaterial) WithContext(ctx context.Context) IMaterialDo {
+	return m.MMaterialDo.WithContext(ctx)
+}
+
+func (m MMaterial) TableName() string { return m.MMaterialDo.TableName() }
+
+func (m MMaterial) Alias() string { return m.MMaterialDo.Alias() }
+
+func (m *MMaterial) GetFieldByName(fieldName string) (field.OrderExpr, bool) {
+	_f, ok := m.fieldMap[fieldName]
+	if !ok || _f == nil {
+		return nil, false
+	}
+	_oe, ok := _f.(field.OrderExpr)
+	return _oe, ok
+}
+
+func (m *MMaterial) fillFieldMap() {
+	m.fieldMap = make(map[string]field.Expr, 11)
+	m.fieldMap["id"] = m.ID
+	m.fieldMap["name"] = m.Name
+	m.fieldMap["file"] = m.File
+	m.fieldMap["size"] = m.Size
+	m.fieldMap["file_size"] = m.FileSize
+	m.fieldMap["hash"] = m.Hash
+	m.fieldMap["type"] = m.Type
+	m.fieldMap["uid"] = m.UID
+	m.fieldMap["status"] = m.Status
+	m.fieldMap["create_at"] = m.CreateAt
+	m.fieldMap["update_at"] = m.UpdateAt
+}
+
+func (m MMaterial) clone(db *gorm.DB) MMaterial {
+	m.MMaterialDo.ReplaceConnPool(db.Statement.ConnPool)
+	return m
+}
+
+func (m MMaterial) replaceDB(db *gorm.DB) MMaterial {
+	m.MMaterialDo.ReplaceDB(db)
+	return m
+}
+
+type MMaterialDo struct{ gen.DO }
+
+type IMaterialDo interface {
+	gen.SubQuery
+	Debug() IMaterialDo
+	WithContext(ctx context.Context) IMaterialDo
+	WithResult(fc func(tx gen.Dao)) gen.ResultInfo
+	ReplaceDB(db *gorm.DB)
+	ReadDB() IMaterialDo
+	WriteDB() IMaterialDo
+	As(alias string) gen.Dao
+	Session(config *gorm.Session) IMaterialDo
+	Columns(cols ...field.Expr) gen.Columns
+	Clauses(conds ...clause.Expression) IMaterialDo
+	Not(conds ...gen.Condition) IMaterialDo
+	Or(conds ...gen.Condition) IMaterialDo
+	Select(conds ...field.Expr) IMaterialDo
+	Where(conds ...gen.Condition) IMaterialDo
+	Order(conds ...field.Expr) IMaterialDo
+	Distinct(cols ...field.Expr) IMaterialDo
+	Omit(cols ...field.Expr) IMaterialDo
+	Join(table schema.Tabler, on ...field.Expr) IMaterialDo
+	LeftJoin(table schema.Tabler, on ...field.Expr) IMaterialDo
+	RightJoin(table schema.Tabler, on ...field.Expr) IMaterialDo
+	Group(cols ...field.Expr) IMaterialDo
+	Having(conds ...gen.Condition) IMaterialDo
+	Limit(limit int) IMaterialDo
+	Offset(offset int) IMaterialDo
+	Count() (count int64, err error)
+	Scopes(funcs ...func(gen.Dao) gen.Dao) IMaterialDo
+	Unscoped() IMaterialDo
+	Create(values ...*entity.Material) error
+	CreateInBatches(values []*entity.Material, batchSize int) error
+	Save(values ...*entity.Material) error
+	First() (*entity.Material, error)
+	Take() (*entity.Material, error)
+	Last() (*entity.Material, error)
+	Find() ([]*entity.Material, error)
+	FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*entity.Material, err error)
+	FindInBatches(result *[]*entity.Material, batchSize int, fc func(tx gen.Dao, batch int) error) error
+	Pluck(column field.Expr, dest interface{}) error
+	Delete(...*entity.Material) (info gen.ResultInfo, err error)
+	Update(column field.Expr, value interface{}) (info gen.ResultInfo, err error)
+	UpdateSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error)
+	Updates(value interface{}) (info gen.ResultInfo, err error)
+	UpdateColumn(column field.Expr, value interface{}) (info gen.ResultInfo, err error)
+	UpdateColumnSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error)
+	UpdateColumns(value interface{}) (info gen.ResultInfo, err error)
+	UpdateFrom(q gen.SubQuery) gen.Dao
+	Attrs(attrs ...field.AssignExpr) IMaterialDo
+	Assign(attrs ...field.AssignExpr) IMaterialDo
+	Joins(fields ...field.RelationField) IMaterialDo
+	Preload(fields ...field.RelationField) IMaterialDo
+	FirstOrInit() (*entity.Material, error)
+	FirstOrCreate() (*entity.Material, error)
+	FindByPage(offset int, limit int) (result []*entity.Material, count int64, err error)
+	ScanByPage(result interface{}, offset int, limit int) (count int64, err error)
+	Scan(result interface{}) (err error)
+	Returning(value interface{}, columns ...string) IMaterialDo
+	UnderlyingDB() *gorm.DB
+	schema.Tabler
+}
+
+func (m MMaterialDo) Debug() IMaterialDo {
+	return m.withDO(m.DO.Debug())
+}
+
+func (m MMaterialDo) WithContext(ctx context.Context) IMaterialDo {
+	return m.withDO(m.DO.WithContext(ctx))
+}
+
+func (m MMaterialDo) ReadDB() IMaterialDo {
+	return m.Clauses(dbresolver.Read)
+}
+
+func (m MMaterialDo) WriteDB() IMaterialDo {
+	return m.Clauses(dbresolver.Write)
+}
+
+func (m MMaterialDo) Session(config *gorm.Session) IMaterialDo {
+	return m.withDO(m.DO.Session(config))
+}
+
+func (m MMaterialDo) Clauses(conds ...clause.Expression) IMaterialDo {
+	return m.withDO(m.DO.Clauses(conds...))
+}
+
+func (m MMaterialDo) Returning(value interface{}, columns ...string) IMaterialDo {
+	return m.withDO(m.DO.Returning(value, columns...))
+}
+
+func (m MMaterialDo) Not(conds ...gen.Condition) IMaterialDo {
+	return m.withDO(m.DO.Not(conds...))
+}
+
+func (m MMaterialDo) Or(conds ...gen.Condition) IMaterialDo {
+	return m.withDO(m.DO.Or(conds...))
+}
+
+func (m MMaterialDo) Select(conds ...field.Expr) IMaterialDo {
+	return m.withDO(m.DO.Select(conds...))
+}
+
+func (m MMaterialDo) Where(conds ...gen.Condition) IMaterialDo {
+	return m.withDO(m.DO.Where(conds...))
+}
+
+func (m MMaterialDo) Exists(subquery interface{ UnderlyingDB() *gorm.DB }) IMaterialDo {
+	return m.Where(field.CompareSubQuery(field.ExistsOp, nil, subquery.UnderlyingDB()))
+}
+
+func (m MMaterialDo) Order(conds ...field.Expr) IMaterialDo {
+	return m.withDO(m.DO.Order(conds...))
+}
+
+func (m MMaterialDo) Distinct(cols ...field.Expr) IMaterialDo {
+	return m.withDO(m.DO.Distinct(cols...))
+}
+
+func (m MMaterialDo) Omit(cols ...field.Expr) IMaterialDo {
+	return m.withDO(m.DO.Omit(cols...))
+}
+
+func (m MMaterialDo) Join(table schema.Tabler, on ...field.Expr) IMaterialDo {
+	return m.withDO(m.DO.Join(table, on...))
+}
+
+func (m MMaterialDo) LeftJoin(table schema.Tabler, on ...field.Expr) IMaterialDo {
+	return m.withDO(m.DO.LeftJoin(table, on...))
+}
+
+func (m MMaterialDo) RightJoin(table schema.Tabler, on ...field.Expr) IMaterialDo {
+	return m.withDO(m.DO.RightJoin(table, on...))
+}
+
+func (m MMaterialDo) Group(cols ...field.Expr) IMaterialDo {
+	return m.withDO(m.DO.Group(cols...))
+}
+
+func (m MMaterialDo) Having(conds ...gen.Condition) IMaterialDo {
+	return m.withDO(m.DO.Having(conds...))
+}
+
+func (m MMaterialDo) Limit(limit int) IMaterialDo {
+	return m.withDO(m.DO.Limit(limit))
+}
+
+func (m MMaterialDo) Offset(offset int) IMaterialDo {
+	return m.withDO(m.DO.Offset(offset))
+}
+
+func (m MMaterialDo) Scopes(funcs ...func(gen.Dao) gen.Dao) IMaterialDo {
+	return m.withDO(m.DO.Scopes(funcs...))
+}
+
+func (m MMaterialDo) Unscoped() IMaterialDo {
+	return m.withDO(m.DO.Unscoped())
+}
+
+func (m MMaterialDo) Create(values ...*entity.Material) error {
+	if len(values) == 0 {
+		return nil
+	}
+	return m.DO.Create(values)
+}
+
+func (m MMaterialDo) CreateInBatches(values []*entity.Material, batchSize int) error {
+	return m.DO.CreateInBatches(values, batchSize)
+}
+
+// Save : !!! underlying implementation is different with GORM
+// The method is equivalent to executing the statement: db.Clauses(clause.OnConflict{UpdateAll: true}).Create(values)
+func (m MMaterialDo) Save(values ...*entity.Material) error {
+	if len(values) == 0 {
+		return nil
+	}
+	return m.DO.Save(values)
+}
+
+func (m MMaterialDo) First() (*entity.Material, error) {
+	if result, err := m.DO.First(); err != nil {
+		return nil, err
+	} else {
+		return result.(*entity.Material), nil
+	}
+}
+
+func (m MMaterialDo) Take() (*entity.Material, error) {
+	if result, err := m.DO.Take(); err != nil {
+		return nil, err
+	} else {
+		return result.(*entity.Material), nil
+	}
+}
+
+func (m MMaterialDo) Last() (*entity.Material, error) {
+	if result, err := m.DO.Last(); err != nil {
+		return nil, err
+	} else {
+		return result.(*entity.Material), nil
+	}
+}
+
+func (m MMaterialDo) Find() ([]*entity.Material, error) {
+	result, err := m.DO.Find()
+	return result.([]*entity.Material), err
+}
+
+func (m MMaterialDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*entity.Material, err error) {
+	buf := make([]*entity.Material, 0, batchSize)
+	err = m.DO.FindInBatches(&buf, batchSize, func(tx gen.Dao, batch int) error {
+		defer func() { results = append(results, buf...) }()
+		return fc(tx, batch)
+	})
+	return results, err
+}
+
+func (m MMaterialDo) FindInBatches(result *[]*entity.Material, batchSize int, fc func(tx gen.Dao, batch int) error) error {
+	return m.DO.FindInBatches(result, batchSize, fc)
+}
+
+func (m MMaterialDo) Attrs(attrs ...field.AssignExpr) IMaterialDo {
+	return m.withDO(m.DO.Attrs(attrs...))
+}
+
+func (m MMaterialDo) Assign(attrs ...field.AssignExpr) IMaterialDo {
+	return m.withDO(m.DO.Assign(attrs...))
+}
+
+func (m MMaterialDo) Joins(fields ...field.RelationField) IMaterialDo {
+	for _, _f := range fields {
+		m = *m.withDO(m.DO.Joins(_f))
+	}
+	return &m
+}
+
+func (m MMaterialDo) Preload(fields ...field.RelationField) IMaterialDo {
+	for _, _f := range fields {
+		m = *m.withDO(m.DO.Preload(_f))
+	}
+	return &m
+}
+
+func (m MMaterialDo) FirstOrInit() (*entity.Material, error) {
+	if result, err := m.DO.FirstOrInit(); err != nil {
+		return nil, err
+	} else {
+		return result.(*entity.Material), nil
+	}
+}
+
+func (m MMaterialDo) FirstOrCreate() (*entity.Material, error) {
+	if result, err := m.DO.FirstOrCreate(); err != nil {
+		return nil, err
+	} else {
+		return result.(*entity.Material), nil
+	}
+}
+
+func (m MMaterialDo) FindByPage(offset int, limit int) (result []*entity.Material, count int64, err error) {
+	result, err = m.Offset(offset).Limit(limit).Find()
+	if err != nil {
+		return
+	}
+
+	if size := len(result); 0 < limit && 0 < size && size < limit {
+		count = int64(size + offset)
+		return
+	}
+
+	count, err = m.Offset(-1).Limit(-1).Count()
+	return
+}
+
+func (m MMaterialDo) ScanByPage(result interface{}, offset int, limit int) (count int64, err error) {
+	count, err = m.Count()
+	if err != nil {
+		return
+	}
+
+	err = m.Offset(offset).Limit(limit).Scan(result)
+	return
+}
+
+func (m MMaterialDo) Scan(result interface{}) (err error) {
+	return m.DO.Scan(result)
+}
+
+func (m MMaterialDo) Delete(models ...*entity.Material) (result gen.ResultInfo, err error) {
+	return m.DO.Delete(models)
+}
+
+func (m *MMaterialDo) withDO(do gen.Dao) *MMaterialDo {
+	m.DO = *do.(*gen.DO)
+	return m
+}

service/model/modules.go

@@ -0,0 +1,430 @@
+// Code generated by gorm.io/gen. DO NOT EDIT.
+// Code generated by gorm.io/gen. DO NOT EDIT.
+// Code generated by gorm.io/gen. DO NOT EDIT.
+
+package model
+
+import (
+	"context"
+
+	"gorm.io/gorm"
+	"gorm.io/gorm/clause"
+	"gorm.io/gorm/schema"
+
+	"gorm.io/gen"
+	"gorm.io/gen/field"
+
+	"gorm.io/plugin/dbresolver"
+
+	"icloudapp.cn/tools/service/entity"
+)
+
+func newModule(db *gorm.DB, opts ...gen.DOOption) MModule {
+	_MModule := MModule{}
+
+	_MModule.MModuleDo.UseDB(db, opts...)
+	_MModule.MModuleDo.UseModel(&entity.Module{})
+
+	tableName := _MModule.MModuleDo.TableName()
+	_MModule.ALL = field.NewAsterisk(tableName)
+	_MModule.ModelID = field.NewInt64(tableName, "model_id")
+	_MModule.ModelName = field.NewString(tableName, "model_name")
+	_MModule.ModelGroup = field.NewString(tableName, "model_group")
+	_MModule.Menu = field.NewString(tableName, "menu")
+	_MModule.ModelURL = field.NewString(tableName, "model_url")
+	_MModule.ModelIndex = field.NewInt64(tableName, "model_index")
+	_MModule.Visible = field.NewInt64(tableName, "visible")
+	_MModule.ModelStatus = field.NewInt64(tableName, "model_status")
+	_MModule.OperatorUID = field.NewInt64(tableName, "operator_uid")
+	_MModule.CreateAt = field.NewTime(tableName, "create_at")
+	_MModule.UpdateAt = field.NewTime(tableName, "update_at")
+
+	_MModule.fillFieldMap()
+
+	return _MModule
+}
+
+type MModule struct {
+	MModuleDo MModuleDo
+
+	ALL         field.Asterisk
+	ModelID     field.Int64
+	ModelName   field.String // 模块名
+	ModelGroup  field.String // 模块分组
+	Menu        field.String // 菜单项
+	ModelURL    field.String // 模块连接
+	ModelIndex  field.Int64  // 模块序号
+	Visible     field.Int64  // 是否显示
+	ModelStatus field.Int64  // 模块状态
+	OperatorUID field.Int64  // 操作人
+	CreateAt    field.Time   // 添加时间
+	UpdateAt    field.Time   // 更新时间
+
+	fieldMap map[string]field.Expr
+}
+
+func (m MModule) Table(newTableName string) *MModule {
+	m.MModuleDo.UseTable(newTableName)
+	return m.updateTableName(newTableName)
+}
+
+func (m MModule) As(alias string) *MModule {
+	m.MModuleDo.DO = *(m.MModuleDo.As(alias).(*gen.DO))
+	return m.updateTableName(alias)
+}
+
+func (m *MModule) updateTableName(table string) *MModule {
+	m.ALL = field.NewAsterisk(table)
+	m.ModelID = field.NewInt64(table, "model_id")
+	m.ModelName = field.NewString(table, "model_name")
+	m.ModelGroup = field.NewString(table, "model_group")
+	m.Menu = field.NewString(table, "menu")
+	m.ModelURL = field.NewString(table, "model_url")
+	m.ModelIndex = field.NewInt64(table, "model_index")
+	m.Visible = field.NewInt64(table, "visible")
+	m.ModelStatus = field.NewInt64(table, "model_status")
+	m.OperatorUID = field.NewInt64(table, "operator_uid")
+	m.CreateAt = field.NewTime(table, "create_at")
+	m.UpdateAt = field.NewTime(table, "update_at")
+
+	m.fillFieldMap()
+
+	return m
+}
+
+func (m *MModule) WithContext(ctx context.Context) IModuleDo { return m.MModuleDo.WithContext(ctx) }
+
+func (m MModule) TableName() string { return m.MModuleDo.TableName() }
+
+func (m MModule) Alias() string { return m.MModuleDo.Alias() }
+
+func (m *MModule) GetFieldByName(fieldName string) (field.OrderExpr, bool) {
+	_f, ok := m.fieldMap[fieldName]
+	if !ok || _f == nil {
+		return nil, false
+	}
+	_oe, ok := _f.(field.OrderExpr)
+	return _oe, ok
+}
+
+func (m *MModule) fillFieldMap() {
+	m.fieldMap = make(map[string]field.Expr, 11)
+	m.fieldMap["model_id"] = m.ModelID
+	m.fieldMap["model_name"] = m.ModelName
+	m.fieldMap["model_group"] = m.ModelGroup
+	m.fieldMap["menu"] = m.Menu
+	m.fieldMap["model_url"] = m.ModelURL
+	m.fieldMap["model_index"] = m.ModelIndex
+	m.fieldMap["visible"] = m.Visible
+	m.fieldMap["model_status"] = m.ModelStatus
+	m.fieldMap["operator_uid"] = m.OperatorUID
+	m.fieldMap["create_at"] = m.CreateAt
+	m.fieldMap["update_at"] = m.UpdateAt
+}
+
+func (m MModule) clone(db *gorm.DB) MModule {
+	m.MModuleDo.ReplaceConnPool(db.Statement.ConnPool)
+	return m
+}
+
+func (m MModule) replaceDB(db *gorm.DB) MModule {
+	m.MModuleDo.ReplaceDB(db)
+	return m
+}
+
+type MModuleDo struct{ gen.DO }
+
+type IModuleDo interface {
+	gen.SubQuery
+	Debug() IModuleDo
+	WithContext(ctx context.Context) IModuleDo
+	WithResult(fc func(tx gen.Dao)) gen.ResultInfo
+	ReplaceDB(db *gorm.DB)
+	ReadDB() IModuleDo
+	WriteDB() IModuleDo
+	As(alias string) gen.Dao
+	Session(config *gorm.Session) IModuleDo
+	Columns(cols ...field.Expr) gen.Columns
+	Clauses(conds ...clause.Expression) IModuleDo
+	Not(conds ...gen.Condition) IModuleDo
+	Or(conds ...gen.Condition) IModuleDo
+	Select(conds ...field.Expr) IModuleDo
+	Where(conds ...gen.Condition) IModuleDo
+	Order(conds ...field.Expr) IModuleDo
+	Distinct(cols ...field.Expr) IModuleDo
+	Omit(cols ...field.Expr) IModuleDo
+	Join(table schema.Tabler, on ...field.Expr) IModuleDo
+	LeftJoin(table schema.Tabler, on ...field.Expr) IModuleDo
+	RightJoin(table schema.Tabler, on ...field.Expr) IModuleDo
+	Group(cols ...field.Expr) IModuleDo
+	Having(conds ...gen.Condition) IModuleDo
+	Limit(limit int) IModuleDo
+	Offset(offset int) IModuleDo
+	Count() (count int64, err error)
+	Scopes(funcs ...func(gen.Dao) gen.Dao) IModuleDo
+	Unscoped() IModuleDo
+	Create(values ...*entity.Module) error
+	CreateInBatches(values []*entity.Module, batchSize int) error
+	Save(values ...*entity.Module) error
+	First() (*entity.Module, error)
+	Take() (*entity.Module, error)
+	Last() (*entity.Module, error)
+	Find() ([]*entity.Module, error)
+	FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*entity.Module, err error)
+	FindInBatches(result *[]*entity.Module, batchSize int, fc func(tx gen.Dao, batch int) error) error
+	Pluck(column field.Expr, dest interface{}) error
+	Delete(...*entity.Module) (info gen.ResultInfo, err error)
+	Update(column field.Expr, value interface{}) (info gen.ResultInfo, err error)
+	UpdateSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error)
+	Updates(value interface{}) (info gen.ResultInfo, err error)
+	UpdateColumn(column field.Expr, value interface{}) (info gen.ResultInfo, err error)
+	UpdateColumnSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error)
+	UpdateColumns(value interface{}) (info gen.ResultInfo, err error)
+	UpdateFrom(q gen.SubQuery) gen.Dao
+	Attrs(attrs ...field.AssignExpr) IModuleDo
+	Assign(attrs ...field.AssignExpr) IModuleDo
+	Joins(fields ...field.RelationField) IModuleDo
+	Preload(fields ...field.RelationField) IModuleDo
+	FirstOrInit() (*entity.Module, error)
+	FirstOrCreate() (*entity.Module, error)
+	FindByPage(offset int, limit int) (result []*entity.Module, count int64, err error)
+	ScanByPage(result interface{}, offset int, limit int) (count int64, err error)
+	Scan(result interface{}) (err error)
+	Returning(value interface{}, columns ...string) IModuleDo
+	UnderlyingDB() *gorm.DB
+	schema.Tabler
+}
+
+func (m MModuleDo) Debug() IModuleDo {
+	return m.withDO(m.DO.Debug())
+}
+
+func (m MModuleDo) WithContext(ctx context.Context) IModuleDo {
+	return m.withDO(m.DO.WithContext(ctx))
+}
+
+func (m MModuleDo) ReadDB() IModuleDo {
+	return m.Clauses(dbresolver.Read)
+}
+
+func (m MModuleDo) WriteDB() IModuleDo {
+	return m.Clauses(dbresolver.Write)
+}
+
+func (m MModuleDo) Session(config *gorm.Session) IModuleDo {
+	return m.withDO(m.DO.Session(config))
+}
+
+func (m MModuleDo) Clauses(conds ...clause.Expression) IModuleDo {
+	return m.withDO(m.DO.Clauses(conds...))
+}
+
+func (m MModuleDo) Returning(value interface{}, columns ...string) IModuleDo {
+	return m.withDO(m.DO.Returning(value, columns...))
+}
+
+func (m MModuleDo) Not(conds ...gen.Condition) IModuleDo {
+	return m.withDO(m.DO.Not(conds...))
+}
+
+func (m MModuleDo) Or(conds ...gen.Condition) IModuleDo {
+	return m.withDO(m.DO.Or(conds...))
+}
+
+func (m MModuleDo) Select(conds ...field.Expr) IModuleDo {
+	return m.withDO(m.DO.Select(conds...))
+}
+
+func (m MModuleDo) Where(conds ...gen.Condition) IModuleDo {
+	return m.withDO(m.DO.Where(conds...))
+}
+
+func (m MModuleDo) Exists(subquery interface{ UnderlyingDB() *gorm.DB }) IModuleDo {
+	return m.Where(field.CompareSubQuery(field.ExistsOp, nil, subquery.UnderlyingDB()))
+}
+
+func (m MModuleDo) Order(conds ...field.Expr) IModuleDo {
+	return m.withDO(m.DO.Order(conds...))
+}
+
+func (m MModuleDo) Distinct(cols ...field.Expr) IModuleDo {
+	return m.withDO(m.DO.Distinct(cols...))
+}
+
+func (m MModuleDo) Omit(cols ...field.Expr) IModuleDo {
+	return m.withDO(m.DO.Omit(cols...))
+}
+
+func (m MModuleDo) Join(table schema.Tabler, on ...field.Expr) IModuleDo {
+	return m.withDO(m.DO.Join(table, on...))
+}
+
+func (m MModuleDo) LeftJoin(table schema.Tabler, on ...field.Expr) IModuleDo {
+	return m.withDO(m.DO.LeftJoin(table, on...))
+}
+
+func (m MModuleDo) RightJoin(table schema.Tabler, on ...field.Expr) IModuleDo {
+	return m.withDO(m.DO.RightJoin(table, on...))
+}
+
+func (m MModuleDo) Group(cols ...field.Expr) IModuleDo {
+	return m.withDO(m.DO.Group(cols...))
+}
+
+func (m MModuleDo) Having(conds ...gen.Condition) IModuleDo {
+	return m.withDO(m.DO.Having(conds...))
+}
+
+func (m MModuleDo) Limit(limit int) IModuleDo {
+	return m.withDO(m.DO.Limit(limit))
+}
+
+func (m MModuleDo) Offset(offset int) IModuleDo {
+	return m.withDO(m.DO.Offset(offset))
+}
+
+func (m MModuleDo) Scopes(funcs ...func(gen.Dao) gen.Dao) IModuleDo {
+	return m.withDO(m.DO.Scopes(funcs...))
+}
+
+func (m MModuleDo) Unscoped() IModuleDo {
+	return m.withDO(m.DO.Unscoped())
+}
+
+func (m MModuleDo) Create(values ...*entity.Module) error {
+	if len(values) == 0 {
+		return nil
+	}
+	return m.DO.Create(values)
+}
+
+func (m MModuleDo) CreateInBatches(values []*entity.Module, batchSize int) error {
+	return m.DO.CreateInBatches(values, batchSize)
+}
+
+// Save : !!! underlying implementation is different with GORM
+// The method is equivalent to executing the statement: db.Clauses(clause.OnConflict{UpdateAll: true}).Create(values)
+func (m MModuleDo) Save(values ...*entity.Module) error {
+	if len(values) == 0 {
+		return nil
+	}
+	return m.DO.Save(values)
+}
+
+func (m MModuleDo) First() (*entity.Module, error) {
+	if result, err := m.DO.First(); err != nil {
+		return nil, err
+	} else {
+		return result.(*entity.Module), nil
+	}
+}
+
+func (m MModuleDo) Take() (*entity.Module, error) {
+	if result, err := m.DO.Take(); err != nil {
+		return nil, err
+	} else {
+		return result.(*entity.Module), nil
+	}
+}
+
+func (m MModuleDo) Last() (*entity.Module, error) {
+	if result, err := m.DO.Last(); err != nil {
+		return nil, err
+	} else {
+		return result.(*entity.Module), nil
+	}
+}
+
+func (m MModuleDo) Find() ([]*entity.Module, error) {
+	result, err := m.DO.Find()
+	return result.([]*entity.Module), err
+}
+
+func (m MModuleDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*entity.Module, err error) {
+	buf := make([]*entity.Module, 0, batchSize)
+	err = m.DO.FindInBatches(&buf, batchSize, func(tx gen.Dao, batch int) error {
+		defer func() { results = append(results, buf...) }()
+		return fc(tx, batch)
+	})
+	return results, err
+}
+
+func (m MModuleDo) FindInBatches(result *[]*entity.Module, batchSize int, fc func(tx gen.Dao, batch int) error) error {
+	return m.DO.FindInBatches(result, batchSize, fc)
+}
+
+func (m MModuleDo) Attrs(attrs ...field.AssignExpr) IModuleDo {
+	return m.withDO(m.DO.Attrs(attrs...))
+}
+
+func (m MModuleDo) Assign(attrs ...field.AssignExpr) IModuleDo {
+	return m.withDO(m.DO.Assign(attrs...))
+}
+
+func (m MModuleDo) Joins(fields ...field.RelationField) IModuleDo {
+	for _, _f := range fields {
+		m = *m.withDO(m.DO.Joins(_f))
+	}
+	return &m
+}
+
+func (m MModuleDo) Preload(fields ...field.RelationField) IModuleDo {
+	for _, _f := range fields {
+		m = *m.withDO(m.DO.Preload(_f))
+	}
+	return &m
+}
+
+func (m MModuleDo) FirstOrInit() (*entity.Module, error) {
+	if result, err := m.DO.FirstOrInit(); err != nil {
+		return nil, err
+	} else {
+		return result.(*entity.Module), nil
+	}
+}
+
+func (m MModuleDo) FirstOrCreate() (*entity.Module, error) {
+	if result, err := m.DO.FirstOrCreate(); err != nil {
+		return nil, err
+	} else {
+		return result.(*entity.Module), nil
+	}
+}
+
+func (m MModuleDo) FindByPage(offset int, limit int) (result []*entity.Module, count int64, err error) {
+	result, err = m.Offset(offset).Limit(limit).Find()
+	if err != nil {
+		return
+	}
+
+	if size := len(result); 0 < limit && 0 < size && size < limit {
+		count = int64(size + offset)
+		return
+	}
+
+	count, err = m.Offset(-1).Limit(-1).Count()
+	return
+}
+
+func (m MModuleDo) ScanByPage(result interface{}, offset int, limit int) (count int64, err error) {
+	count, err = m.Count()
+	if err != nil {
+		return
+	}
+
+	err = m.Offset(offset).Limit(limit).Scan(result)
+	return
+}
+
+func (m MModuleDo) Scan(result interface{}) (err error) {
+	return m.DO.Scan(result)
+}
+
+func (m MModuleDo) Delete(models ...*entity.Module) (result gen.ResultInfo, err error) {
+	return m.DO.Delete(models)
+}
+
+func (m *MModuleDo) withDO(do gen.Dao) *MModuleDo {
+	m.DO = *do.(*gen.DO)
+	return m
+}

service/model/query_auto.go

@@ -0,0 +1,171 @@
+// Code generated by gorm.io/gen. DO NOT EDIT.
+// Code generated by gorm.io/gen. DO NOT EDIT.
+// Code generated by gorm.io/gen. DO NOT EDIT.
+
+package model
+
+import (
+	"context"
+	"database/sql"
+
+	"gorm.io/gorm"
+
+	"gorm.io/gen"
+
+	"gorm.io/plugin/dbresolver"
+)
+
+var (
+	Q               = new(Query)
+	BookCategory    *MBookCategory
+	Font            *MFont
+	Group           *MGroup
+	Material        *MMaterial
+	Module          *MModule
+	Role            *MRole
+	User            *MUser
+	UserGroup       *MUserGroup
+	UserPoster      *MUserPoster
+	UserPosterBatch *MUserPosterBatch
+)
+
+func SetDefault(db *gorm.DB, opts ...gen.DOOption) {
+	*Q = *Use(db, opts...)
+	BookCategory = &Q.BookCategory
+	Font = &Q.Font
+	Group = &Q.Group
+	Material = &Q.Material
+	Module = &Q.Module
+	Role = &Q.Role
+	User = &Q.User
+	UserGroup = &Q.UserGroup
+	UserPoster = &Q.UserPoster
+	UserPosterBatch = &Q.UserPosterBatch
+}
+
+func Use(db *gorm.DB, opts ...gen.DOOption) *Query {
+	return &Query{
+		db:              db,
+		BookCategory:    newBookCategory(db, opts...),
+		Font:            newFont(db, opts...),
+		Group:           newGroup(db, opts...),
+		Material:        newMaterial(db, opts...),
+		Module:          newModule(db, opts...),
+		Role:            newRole(db, opts...),
+		User:            newUser(db, opts...),
+		UserGroup:       newUserGroup(db, opts...),
+		UserPoster:      newUserPoster(db, opts...),
+		UserPosterBatch: newUserPosterBatch(db, opts...),
+	}
+}
+
+type Query struct {
+	db *gorm.DB
+
+	BookCategory    MBookCategory
+	Font            MFont
+	Group           MGroup
+	Material        MMaterial
+	Module          MModule
+	Role            MRole
+	User            MUser
+	UserGroup       MUserGroup
+	UserPoster      MUserPoster
+	UserPosterBatch MUserPosterBatch
+}
+
+func (q *Query) Available() bool { return q.db != nil }
+
+func (q *Query) clone(db *gorm.DB) *Query {
+	return &Query{
+		db:              db,
+		BookCategory:    q.BookCategory.clone(db),
+		Font:            q.Font.clone(db),
+		Group:           q.Group.clone(db),
+		Material:        q.Material.clone(db),
+		Module:          q.Module.clone(db),
+		Role:            q.Role.clone(db),
+		User:            q.User.clone(db),
+		UserGroup:       q.UserGroup.clone(db),
+		UserPoster:      q.UserPoster.clone(db),
+		UserPosterBatch: q.UserPosterBatch.clone(db),
+	}
+}
+
+func (q *Query) ReadDB() *Query {
+	return q.ReplaceDB(q.db.Clauses(dbresolver.Read))
+}
+
+func (q *Query) WriteDB() *Query {
+	return q.ReplaceDB(q.db.Clauses(dbresolver.Write))
+}
+
+func (q *Query) ReplaceDB(db *gorm.DB) *Query {
+	return &Query{
+		db:              db,
+		BookCategory:    q.BookCategory.replaceDB(db),
+		Font:            q.Font.replaceDB(db),
+		Group:           q.Group.replaceDB(db),
+		Material:        q.Material.replaceDB(db),
+		Module:          q.Module.replaceDB(db),
+		Role:            q.Role.replaceDB(db),
+		User:            q.User.replaceDB(db),
+		UserGroup:       q.UserGroup.replaceDB(db),
+		UserPoster:      q.UserPoster.replaceDB(db),
+		UserPosterBatch: q.UserPosterBatch.replaceDB(db),
+	}
+}
+
+type queryCtx struct {
+	BookCategory    IBookCategoryDo
+	Font            IFontDo
+	Group           IGroupDo
+	Material        IMaterialDo
+	Module          IModuleDo
+	Role            IRoleDo
+	User            IUserDo
+	UserGroup       IUserGroupDo
+	UserPoster      IUserPosterDo
+	UserPosterBatch IUserPosterBatchDo
+}
+
+func (q *Query) WithContext(ctx context.Context) *queryCtx {
+	return &queryCtx{
+		BookCategory:    q.BookCategory.WithContext(ctx),
+		Font:            q.Font.WithContext(ctx),
+		Group:           q.Group.WithContext(ctx),
+		Material:        q.Material.WithContext(ctx),
+		Module:          q.Module.WithContext(ctx),
+		Role:            q.Role.WithContext(ctx),
+		User:            q.User.WithContext(ctx),
+		UserGroup:       q.UserGroup.WithContext(ctx),
+		UserPoster:      q.UserPoster.WithContext(ctx),
+		UserPosterBatch: q.UserPosterBatch.WithContext(ctx),
+	}
+}
+
+func (q *Query) Transaction(fc func(tx *Query) error, opts ...*sql.TxOptions) error {
+	return q.db.Transaction(func(tx *gorm.DB) error { return fc(q.clone(tx)) }, opts...)
+}
+
+func (q *Query) Begin(opts ...*sql.TxOptions) *QueryTx {
+	return &QueryTx{q.clone(q.db.Begin(opts...))}
+}
+
+type QueryTx struct{ *Query }
+
+func (q *QueryTx) Commit() error {
+	return q.db.Commit().Error
+}
+
+func (q *QueryTx) Rollback() error {
+	return q.db.Rollback().Error
+}
+
+func (q *QueryTx) SavePoint(name string) error {
+	return q.db.SavePoint(name).Error
+}
+
+func (q *QueryTx) RollbackTo(name string) error {
+	return q.db.RollbackTo(name).Error
+}

service/model/roles.go

@@ -0,0 +1,414 @@
+// Code generated by gorm.io/gen. DO NOT EDIT.
+// Code generated by gorm.io/gen. DO NOT EDIT.
+// Code generated by gorm.io/gen. DO NOT EDIT.
+
+package model
+
+import (
+	"context"
+
+	"gorm.io/gorm"
+	"gorm.io/gorm/clause"
+	"gorm.io/gorm/schema"
+
+	"gorm.io/gen"
+	"gorm.io/gen/field"
+
+	"gorm.io/plugin/dbresolver"
+
+	"icloudapp.cn/tools/service/entity"
+)
+
+func newRole(db *gorm.DB, opts ...gen.DOOption) MRole {
+	_MRole := MRole{}
+
+	_MRole.MRoleDo.UseDB(db, opts...)
+	_MRole.MRoleDo.UseModel(&entity.Role{})
+
+	tableName := _MRole.MRoleDo.TableName()
+	_MRole.ALL = field.NewAsterisk(tableName)
+	_MRole.RoleID = field.NewInt64(tableName, "role_id")
+	_MRole.RoleName = field.NewString(tableName, "role_name")
+	_MRole.ModelIds = field.NewString(tableName, "model_ids")
+	_MRole.RoleStatus = field.NewInt64(tableName, "role_status")
+	_MRole.OperatorUID = field.NewInt64(tableName, "operator_uid")
+	_MRole.CreateAt = field.NewTime(tableName, "create_at")
+	_MRole.UpdateAt = field.NewTime(tableName, "update_at")
+
+	_MRole.fillFieldMap()
+
+	return _MRole
+}
+
+type MRole struct {
+	MRoleDo MRoleDo
+
+	ALL         field.Asterisk
+	RoleID      field.Int64  // 权限ID
+	RoleName    field.String // 权限名称
+	ModelIds    field.String // 权限对应的模块名
+	RoleStatus  field.Int64  // 模块状态
+	OperatorUID field.Int64  // 操作人
+	CreateAt    field.Time   // 添加时间
+	UpdateAt    field.Time   // 更新时间
+
+	fieldMap map[string]field.Expr
+}
+
+func (r MRole) Table(newTableName string) *MRole {
+	r.MRoleDo.UseTable(newTableName)
+	return r.updateTableName(newTableName)
+}
+
+func (r MRole) As(alias string) *MRole {
+	r.MRoleDo.DO = *(r.MRoleDo.As(alias).(*gen.DO))
+	return r.updateTableName(alias)
+}
+
+func (r *MRole) updateTableName(table string) *MRole {
+	r.ALL = field.NewAsterisk(table)
+	r.RoleID = field.NewInt64(table, "role_id")
+	r.RoleName = field.NewString(table, "role_name")
+	r.ModelIds = field.NewString(table, "model_ids")
+	r.RoleStatus = field.NewInt64(table, "role_status")
+	r.OperatorUID = field.NewInt64(table, "operator_uid")
+	r.CreateAt = field.NewTime(table, "create_at")
+	r.UpdateAt = field.NewTime(table, "update_at")
+
+	r.fillFieldMap()
+
+	return r
+}
+
+func (r *MRole) WithContext(ctx context.Context) IRoleDo { return r.MRoleDo.WithContext(ctx) }
+
+func (r MRole) TableName() string { return r.MRoleDo.TableName() }
+
+func (r MRole) Alias() string { return r.MRoleDo.Alias() }
+
+func (r *MRole) GetFieldByName(fieldName string) (field.OrderExpr, bool) {
+	_f, ok := r.fieldMap[fieldName]
+	if !ok || _f == nil {
+		return nil, false
+	}
+	_oe, ok := _f.(field.OrderExpr)
+	return _oe, ok
+}
+
+func (r *MRole) fillFieldMap() {
+	r.fieldMap = make(map[string]field.Expr, 7)
+	r.fieldMap["role_id"] = r.RoleID
+	r.fieldMap["role_name"] = r.RoleName
+	r.fieldMap["model_ids"] = r.ModelIds
+	r.fieldMap["role_status"] = r.RoleStatus
+	r.fieldMap["operator_uid"] = r.OperatorUID
+	r.fieldMap["create_at"] = r.CreateAt
+	r.fieldMap["update_at"] = r.UpdateAt
+}
+
+func (r MRole) clone(db *gorm.DB) MRole {
+	r.MRoleDo.ReplaceConnPool(db.Statement.ConnPool)
+	return r
+}
+
+func (r MRole) replaceDB(db *gorm.DB) MRole {
+	r.MRoleDo.ReplaceDB(db)
+	return r
+}
+
+type MRoleDo struct{ gen.DO }
+
+type IRoleDo interface {
+	gen.SubQuery
+	Debug() IRoleDo
+	WithContext(ctx context.Context) IRoleDo
+	WithResult(fc func(tx gen.Dao)) gen.ResultInfo
+	ReplaceDB(db *gorm.DB)
+	ReadDB() IRoleDo
+	WriteDB() IRoleDo
+	As(alias string) gen.Dao
+	Session(config *gorm.Session) IRoleDo
+	Columns(cols ...field.Expr) gen.Columns
+	Clauses(conds ...clause.Expression) IRoleDo
+	Not(conds ...gen.Condition) IRoleDo
+	Or(conds ...gen.Condition) IRoleDo
+	Select(conds ...field.Expr) IRoleDo
+	Where(conds ...gen.Condition) IRoleDo
+	Order(conds ...field.Expr) IRoleDo
+	Distinct(cols ...field.Expr) IRoleDo
+	Omit(cols ...field.Expr) IRoleDo
+	Join(table schema.Tabler, on ...field.Expr) IRoleDo
+	LeftJoin(table schema.Tabler, on ...field.Expr) IRoleDo
+	RightJoin(table schema.Tabler, on ...field.Expr) IRoleDo
+	Group(cols ...field.Expr) IRoleDo
+	Having(conds ...gen.Condition) IRoleDo
+	Limit(limit int) IRoleDo
+	Offset(offset int) IRoleDo
+	Count() (count int64, err error)
+	Scopes(funcs ...func(gen.Dao) gen.Dao) IRoleDo
+	Unscoped() IRoleDo
+	Create(values ...*entity.Role) error
+	CreateInBatches(values []*entity.Role, batchSize int) error
+	Save(values ...*entity.Role) error
+	First() (*entity.Role, error)
+	Take() (*entity.Role, error)
+	Last() (*entity.Role, error)
+	Find() ([]*entity.Role, error)
+	FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*entity.Role, err error)
+	FindInBatches(result *[]*entity.Role, batchSize int, fc func(tx gen.Dao, batch int) error) error
+	Pluck(column field.Expr, dest interface{}) error
+	Delete(...*entity.Role) (info gen.ResultInfo, err error)
+	Update(column field.Expr, value interface{}) (info gen.ResultInfo, err error)
+	UpdateSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error)
+	Updates(value interface{}) (info gen.ResultInfo, err error)
+	UpdateColumn(column field.Expr, value interface{}) (info gen.ResultInfo, err error)
+	UpdateColumnSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error)
+	UpdateColumns(value interface{}) (info gen.ResultInfo, err error)
+	UpdateFrom(q gen.SubQuery) gen.Dao
+	Attrs(attrs ...field.AssignExpr) IRoleDo
+	Assign(attrs ...field.AssignExpr) IRoleDo
+	Joins(fields ...field.RelationField) IRoleDo
+	Preload(fields ...field.RelationField) IRoleDo
+	FirstOrInit() (*entity.Role, error)
+	FirstOrCreate() (*entity.Role, error)
+	FindByPage(offset int, limit int) (result []*entity.Role, count int64, err error)
+	ScanByPage(result interface{}, offset int, limit int) (count int64, err error)
+	Scan(result interface{}) (err error)
+	Returning(value interface{}, columns ...string) IRoleDo
+	UnderlyingDB() *gorm.DB
+	schema.Tabler
+}
+
+func (r MRoleDo) Debug() IRoleDo {
+	return r.withDO(r.DO.Debug())
+}
+
+func (r MRoleDo) WithContext(ctx context.Context) IRoleDo {
+	return r.withDO(r.DO.WithContext(ctx))
+}
+
+func (r MRoleDo) ReadDB() IRoleDo {
+	return r.Clauses(dbresolver.Read)
+}
+
+func (r MRoleDo) WriteDB() IRoleDo {
+	return r.Clauses(dbresolver.Write)
+}
+
+func (r MRoleDo) Session(config *gorm.Session) IRoleDo {
+	return r.withDO(r.DO.Session(config))
+}
+
+func (r MRoleDo) Clauses(conds ...clause.Expression) IRoleDo {
+	return r.withDO(r.DO.Clauses(conds...))
+}
+
+func (r MRoleDo) Returning(value interface{}, columns ...string) IRoleDo {
+	return r.withDO(r.DO.Returning(value, columns...))
+}
+
+func (r MRoleDo) Not(conds ...gen.Condition) IRoleDo {
+	return r.withDO(r.DO.Not(conds...))
+}
+
+func (r MRoleDo) Or(conds ...gen.Condition) IRoleDo {
+	return r.withDO(r.DO.Or(conds...))
+}
+
+func (r MRoleDo) Select(conds ...field.Expr) IRoleDo {
+	return r.withDO(r.DO.Select(conds...))
+}
+
+func (r MRoleDo) Where(conds ...gen.Condition) IRoleDo {
+	return r.withDO(r.DO.Where(conds...))
+}
+
+func (r MRoleDo) Exists(subquery interface{ UnderlyingDB() *gorm.DB }) IRoleDo {
+	return r.Where(field.CompareSubQuery(field.ExistsOp, nil, subquery.UnderlyingDB()))
+}
+
+func (r MRoleDo) Order(conds ...field.Expr) IRoleDo {
+	return r.withDO(r.DO.Order(conds...))
+}
+
+func (r MRoleDo) Distinct(cols ...field.Expr) IRoleDo {
+	return r.withDO(r.DO.Distinct(cols...))
+}
+
+func (r MRoleDo) Omit(cols ...field.Expr) IRoleDo {
+	return r.withDO(r.DO.Omit(cols...))
+}
+
+func (r MRoleDo) Join(table schema.Tabler, on ...field.Expr) IRoleDo {
+	return r.withDO(r.DO.Join(table, on...))
+}
+
+func (r MRoleDo) LeftJoin(table schema.Tabler, on ...field.Expr) IRoleDo {
+	return r.withDO(r.DO.LeftJoin(table, on...))
+}
+
+func (r MRoleDo) RightJoin(table schema.Tabler, on ...field.Expr) IRoleDo {
+	return r.withDO(r.DO.RightJoin(table, on...))
+}
+
+func (r MRoleDo) Group(cols ...field.Expr) IRoleDo {
+	return r.withDO(r.DO.Group(cols...))
+}
+
+func (r MRoleDo) Having(conds ...gen.Condition) IRoleDo {
+	return r.withDO(r.DO.Having(conds...))
+}
+
+func (r MRoleDo) Limit(limit int) IRoleDo {
+	return r.withDO(r.DO.Limit(limit))
+}
+
+func (r MRoleDo) Offset(offset int) IRoleDo {
+	return r.withDO(r.DO.Offset(offset))
+}
+
+func (r MRoleDo) Scopes(funcs ...func(gen.Dao) gen.Dao) IRoleDo {
+	return r.withDO(r.DO.Scopes(funcs...))
+}
+
+func (r MRoleDo) Unscoped() IRoleDo {
+	return r.withDO(r.DO.Unscoped())
+}
+
+func (r MRoleDo) Create(values ...*entity.Role) error {
+	if len(values) == 0 {
+		return nil
+	}
+	return r.DO.Create(values)
+}
+
+func (r MRoleDo) CreateInBatches(values []*entity.Role, batchSize int) error {
+	return r.DO.CreateInBatches(values, batchSize)
+}
+
+// Save : !!! underlying implementation is different with GORM
+// The method is equivalent to executing the statement: db.Clauses(clause.OnConflict{UpdateAll: true}).Create(values)
+func (r MRoleDo) Save(values ...*entity.Role) error {
+	if len(values) == 0 {
+		return nil
+	}
+	return r.DO.Save(values)
+}
+
+func (r MRoleDo) First() (*entity.Role, error) {
+	if result, err := r.DO.First(); err != nil {
+		return nil, err
+	} else {
+		return result.(*entity.Role), nil
+	}
+}
+
+func (r MRoleDo) Take() (*entity.Role, error) {
+	if result, err := r.DO.Take(); err != nil {
+		return nil, err
+	} else {
+		return result.(*entity.Role), nil
+	}
+}
+
+func (r MRoleDo) Last() (*entity.Role, error) {
+	if result, err := r.DO.Last(); err != nil {
+		return nil, err
+	} else {
+		return result.(*entity.Role), nil
+	}
+}
+
+func (r MRoleDo) Find() ([]*entity.Role, error) {
+	result, err := r.DO.Find()
+	return result.([]*entity.Role), err
+}
+
+func (r MRoleDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*entity.Role, err error) {
+	buf := make([]*entity.Role, 0, batchSize)
+	err = r.DO.FindInBatches(&buf, batchSize, func(tx gen.Dao, batch int) error {
+		defer func() { results = append(results, buf...) }()
+		return fc(tx, batch)
+	})
+	return results, err
+}
+
+func (r MRoleDo) FindInBatches(result *[]*entity.Role, batchSize int, fc func(tx gen.Dao, batch int) error) error {
+	return r.DO.FindInBatches(result, batchSize, fc)
+}
+
+func (r MRoleDo) Attrs(attrs ...field.AssignExpr) IRoleDo {
+	return r.withDO(r.DO.Attrs(attrs...))
+}
+
+func (r MRoleDo) Assign(attrs ...field.AssignExpr) IRoleDo {
+	return r.withDO(r.DO.Assign(attrs...))
+}
+
+func (r MRoleDo) Joins(fields ...field.RelationField) IRoleDo {
+	for _, _f := range fields {
+		r = *r.withDO(r.DO.Joins(_f))
+	}
+	return &r
+}
+
+func (r MRoleDo) Preload(fields ...field.RelationField) IRoleDo {
+	for _, _f := range fields {
+		r = *r.withDO(r.DO.Preload(_f))
+	}
+	return &r
+}
+
+func (r MRoleDo) FirstOrInit() (*entity.Role, error) {
+	if result, err := r.DO.FirstOrInit(); err != nil {
+		return nil, err
+	} else {
+		return result.(*entity.Role), nil
+	}
+}
+
+func (r MRoleDo) FirstOrCreate() (*entity.Role, error) {
+	if result, err := r.DO.FirstOrCreate(); err != nil {
+		return nil, err
+	} else {
+		return result.(*entity.Role), nil
+	}
+}
+
+func (r MRoleDo) FindByPage(offset int, limit int) (result []*entity.Role, count int64, err error) {
+	result, err = r.Offset(offset).Limit(limit).Find()
+	if err != nil {
+		return
+	}
+
+	if size := len(result); 0 < limit && 0 < size && size < limit {
+		count = int64(size + offset)
+		return
+	}
+
+	count, err = r.Offset(-1).Limit(-1).Count()
+	return
+}
+
+func (r MRoleDo) ScanByPage(result interface{}, offset int, limit int) (count int64, err error) {
+	count, err = r.Count()
+	if err != nil {
+		return
+	}
+
+	err = r.Offset(offset).Limit(limit).Scan(result)
+	return
+}
+
+func (r MRoleDo) Scan(result interface{}) (err error) {
+	return r.DO.Scan(result)
+}
+
+func (r MRoleDo) Delete(models ...*entity.Role) (result gen.ResultInfo, err error) {
+	return r.DO.Delete(models)
+}
+
+func (r *MRoleDo) withDO(do gen.Dao) *MRoleDo {
+	r.DO = *do.(*gen.DO)
+	return r
+}

service/model/user.go

@@ -0,0 +1,422 @@
+// Code generated by gorm.io/gen. DO NOT EDIT.
+// Code generated by gorm.io/gen. DO NOT EDIT.
+// Code generated by gorm.io/gen. DO NOT EDIT.
+
+package model
+
+import (
+	"context"
+
+	"gorm.io/gorm"
+	"gorm.io/gorm/clause"
+	"gorm.io/gorm/schema"
+
+	"gorm.io/gen"
+	"gorm.io/gen/field"
+
+	"gorm.io/plugin/dbresolver"
+
+	"icloudapp.cn/tools/service/entity"
+)
+
+func newUser(db *gorm.DB, opts ...gen.DOOption) MUser {
+	_MUser := MUser{}
+
+	_MUser.MUserDo.UseDB(db, opts...)
+	_MUser.MUserDo.UseModel(&entity.User{})
+
+	tableName := _MUser.MUserDo.TableName()
+	_MUser.ALL = field.NewAsterisk(tableName)
+	_MUser.UID = field.NewInt64(tableName, "uid")
+	_MUser.Nickname = field.NewString(tableName, "nickname")
+	_MUser.Email = field.NewString(tableName, "email")
+	_MUser.Password = field.NewString(tableName, "password")
+	_MUser.Salt = field.NewString(tableName, "salt")
+	_MUser.Avatar = field.NewString(tableName, "avatar")
+	_MUser.Status = field.NewInt64(tableName, "status")
+	_MUser.CreateAt = field.NewTime(tableName, "create_at")
+	_MUser.UpdateAt = field.NewTime(tableName, "update_at")
+
+	_MUser.fillFieldMap()
+
+	return _MUser
+}
+
+type MUser struct {
+	MUserDo MUserDo
+
+	ALL      field.Asterisk
+	UID      field.Int64
+	Nickname field.String
+	Email    field.String
+	Password field.String
+	Salt     field.String
+	Avatar   field.String // 头像
+	Status   field.Int64
+	CreateAt field.Time // 创建时间
+	UpdateAt field.Time // 更新时间
+
+	fieldMap map[string]field.Expr
+}
+
+func (u MUser) Table(newTableName string) *MUser {
+	u.MUserDo.UseTable(newTableName)
+	return u.updateTableName(newTableName)
+}
+
+func (u MUser) As(alias string) *MUser {
+	u.MUserDo.DO = *(u.MUserDo.As(alias).(*gen.DO))
+	return u.updateTableName(alias)
+}
+
+func (u *MUser) updateTableName(table string) *MUser {
+	u.ALL = field.NewAsterisk(table)
+	u.UID = field.NewInt64(table, "uid")
+	u.Nickname = field.NewString(table, "nickname")
+	u.Email = field.NewString(table, "email")
+	u.Password = field.NewString(table, "password")
+	u.Salt = field.NewString(table, "salt")
+	u.Avatar = field.NewString(table, "avatar")
+	u.Status = field.NewInt64(table, "status")
+	u.CreateAt = field.NewTime(table, "create_at")
+	u.UpdateAt = field.NewTime(table, "update_at")
+
+	u.fillFieldMap()
+
+	return u
+}
+
+func (u *MUser) WithContext(ctx context.Context) IUserDo { return u.MUserDo.WithContext(ctx) }
+
+func (u MUser) TableName() string { return u.MUserDo.TableName() }
+
+func (u MUser) Alias() string { return u.MUserDo.Alias() }
+
+func (u *MUser) GetFieldByName(fieldName string) (field.OrderExpr, bool) {
+	_f, ok := u.fieldMap[fieldName]
+	if !ok || _f == nil {
+		return nil, false
+	}
+	_oe, ok := _f.(field.OrderExpr)
+	return _oe, ok
+}
+
+func (u *MUser) fillFieldMap() {
+	u.fieldMap = make(map[string]field.Expr, 9)
+	u.fieldMap["uid"] = u.UID
+	u.fieldMap["nickname"] = u.Nickname
+	u.fieldMap["email"] = u.Email
+	u.fieldMap["password"] = u.Password
+	u.fieldMap["salt"] = u.Salt
+	u.fieldMap["avatar"] = u.Avatar
+	u.fieldMap["status"] = u.Status
+	u.fieldMap["create_at"] = u.CreateAt
+	u.fieldMap["update_at"] = u.UpdateAt
+}
+
+func (u MUser) clone(db *gorm.DB) MUser {
+	u.MUserDo.ReplaceConnPool(db.Statement.ConnPool)
+	return u
+}
+
+func (u MUser) replaceDB(db *gorm.DB) MUser {
+	u.MUserDo.ReplaceDB(db)
+	return u
+}
+
+type MUserDo struct{ gen.DO }
+
+type IUserDo interface {
+	gen.SubQuery
+	Debug() IUserDo
+	WithContext(ctx context.Context) IUserDo
+	WithResult(fc func(tx gen.Dao)) gen.ResultInfo
+	ReplaceDB(db *gorm.DB)
+	ReadDB() IUserDo
+	WriteDB() IUserDo
+	As(alias string) gen.Dao
+	Session(config *gorm.Session) IUserDo
+	Columns(cols ...field.Expr) gen.Columns
+	Clauses(conds ...clause.Expression) IUserDo
+	Not(conds ...gen.Condition) IUserDo
+	Or(conds ...gen.Condition) IUserDo
+	Select(conds ...field.Expr) IUserDo
+	Where(conds ...gen.Condition) IUserDo
+	Order(conds ...field.Expr) IUserDo
+	Distinct(cols ...field.Expr) IUserDo
+	Omit(cols ...field.Expr) IUserDo
+	Join(table schema.Tabler, on ...field.Expr) IUserDo
+	LeftJoin(table schema.Tabler, on ...field.Expr) IUserDo
+	RightJoin(table schema.Tabler, on ...field.Expr) IUserDo
+	Group(cols ...field.Expr) IUserDo
+	Having(conds ...gen.Condition) IUserDo
+	Limit(limit int) IUserDo
+	Offset(offset int) IUserDo
+	Count() (count int64, err error)
+	Scopes(funcs ...func(gen.Dao) gen.Dao) IUserDo
+	Unscoped() IUserDo
+	Create(values ...*entity.User) error
+	CreateInBatches(values []*entity.User, batchSize int) error
+	Save(values ...*entity.User) error
+	First() (*entity.User, error)
+	Take() (*entity.User, error)
+	Last() (*entity.User, error)
+	Find() ([]*entity.User, error)
+	FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*entity.User, err error)
+	FindInBatches(result *[]*entity.User, batchSize int, fc func(tx gen.Dao, batch int) error) error
+	Pluck(column field.Expr, dest interface{}) error
+	Delete(...*entity.User) (info gen.ResultInfo, err error)
+	Update(column field.Expr, value interface{}) (info gen.ResultInfo, err error)
+	UpdateSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error)
+	Updates(value interface{}) (info gen.ResultInfo, err error)
+	UpdateColumn(column field.Expr, value interface{}) (info gen.ResultInfo, err error)
+	UpdateColumnSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error)
+	UpdateColumns(value interface{}) (info gen.ResultInfo, err error)
+	UpdateFrom(q gen.SubQuery) gen.Dao
+	Attrs(attrs ...field.AssignExpr) IUserDo
+	Assign(attrs ...field.AssignExpr) IUserDo
+	Joins(fields ...field.RelationField) IUserDo
+	Preload(fields ...field.RelationField) IUserDo
+	FirstOrInit() (*entity.User, error)
+	FirstOrCreate() (*entity.User, error)
+	FindByPage(offset int, limit int) (result []*entity.User, count int64, err error)
+	ScanByPage(result interface{}, offset int, limit int) (count int64, err error)
+	Scan(result interface{}) (err error)
+	Returning(value interface{}, columns ...string) IUserDo
+	UnderlyingDB() *gorm.DB
+	schema.Tabler
+}
+
+func (u MUserDo) Debug() IUserDo {
+	return u.withDO(u.DO.Debug())
+}
+
+func (u MUserDo) WithContext(ctx context.Context) IUserDo {
+	return u.withDO(u.DO.WithContext(ctx))
+}
+
+func (u MUserDo) ReadDB() IUserDo {
+	return u.Clauses(dbresolver.Read)
+}
+
+func (u MUserDo) WriteDB() IUserDo {
+	return u.Clauses(dbresolver.Write)
+}
+
+func (u MUserDo) Session(config *gorm.Session) IUserDo {
+	return u.withDO(u.DO.Session(config))
+}
+
+func (u MUserDo) Clauses(conds ...clause.Expression) IUserDo {
+	return u.withDO(u.DO.Clauses(conds...))
+}
+
+func (u MUserDo) Returning(value interface{}, columns ...string) IUserDo {
+	return u.withDO(u.DO.Returning(value, columns...))
+}
+
+func (u MUserDo) Not(conds ...gen.Condition) IUserDo {
+	return u.withDO(u.DO.Not(conds...))
+}
+
+func (u MUserDo) Or(conds ...gen.Condition) IUserDo {
+	return u.withDO(u.DO.Or(conds...))
+}
+
+func (u MUserDo) Select(conds ...field.Expr) IUserDo {
+	return u.withDO(u.DO.Select(conds...))
+}
+
+func (u MUserDo) Where(conds ...gen.Condition) IUserDo {
+	return u.withDO(u.DO.Where(conds...))
+}
+
+func (u MUserDo) Exists(subquery interface{ UnderlyingDB() *gorm.DB }) IUserDo {
+	return u.Where(field.CompareSubQuery(field.ExistsOp, nil, subquery.UnderlyingDB()))
+}
+
+func (u MUserDo) Order(conds ...field.Expr) IUserDo {
+	return u.withDO(u.DO.Order(conds...))
+}
+
+func (u MUserDo) Distinct(cols ...field.Expr) IUserDo {
+	return u.withDO(u.DO.Distinct(cols...))
+}
+
+func (u MUserDo) Omit(cols ...field.Expr) IUserDo {
+	return u.withDO(u.DO.Omit(cols...))
+}
+
+func (u MUserDo) Join(table schema.Tabler, on ...field.Expr) IUserDo {
+	return u.withDO(u.DO.Join(table, on...))
+}
+
+func (u MUserDo) LeftJoin(table schema.Tabler, on ...field.Expr) IUserDo {
+	return u.withDO(u.DO.LeftJoin(table, on...))
+}
+
+func (u MUserDo) RightJoin(table schema.Tabler, on ...field.Expr) IUserDo {
+	return u.withDO(u.DO.RightJoin(table, on...))
+}
+
+func (u MUserDo) Group(cols ...field.Expr) IUserDo {
+	return u.withDO(u.DO.Group(cols...))
+}
+
+func (u MUserDo) Having(conds ...gen.Condition) IUserDo {
+	return u.withDO(u.DO.Having(conds...))
+}
+
+func (u MUserDo) Limit(limit int) IUserDo {
+	return u.withDO(u.DO.Limit(limit))
+}
+
+func (u MUserDo) Offset(offset int) IUserDo {
+	return u.withDO(u.DO.Offset(offset))
+}
+
+func (u MUserDo) Scopes(funcs ...func(gen.Dao) gen.Dao) IUserDo {
+	return u.withDO(u.DO.Scopes(funcs...))
+}
+
+func (u MUserDo) Unscoped() IUserDo {
+	return u.withDO(u.DO.Unscoped())
+}
+
+func (u MUserDo) Create(values ...*entity.User) error {
+	if len(values) == 0 {
+		return nil
+	}
+	return u.DO.Create(values)
+}
+
+func (u MUserDo) CreateInBatches(values []*entity.User, batchSize int) error {
+	return u.DO.CreateInBatches(values, batchSize)
+}
+
+// Save : !!! underlying implementation is different with GORM
+// The method is equivalent to executing the statement: db.Clauses(clause.OnConflict{UpdateAll: true}).Create(values)
+func (u MUserDo) Save(values ...*entity.User) error {
+	if len(values) == 0 {
+		return nil
+	}
+	return u.DO.Save(values)
+}
+
+func (u MUserDo) First() (*entity.User, error) {
+	if result, err := u.DO.First(); err != nil {
+		return nil, err
+	} else {
+		return result.(*entity.User), nil
+	}
+}
+
+func (u MUserDo) Take() (*entity.User, error) {
+	if result, err := u.DO.Take(); err != nil {
+		return nil, err
+	} else {
+		return result.(*entity.User), nil
+	}
+}
+
+func (u MUserDo) Last() (*entity.User, error) {
+	if result, err := u.DO.Last(); err != nil {
+		return nil, err
+	} else {
+		return result.(*entity.User), nil
+	}
+}
+
+func (u MUserDo) Find() ([]*entity.User, error) {
+	result, err := u.DO.Find()
+	return result.([]*entity.User), err
+}
+
+func (u MUserDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*entity.User, err error) {
+	buf := make([]*entity.User, 0, batchSize)
+	err = u.DO.FindInBatches(&buf, batchSize, func(tx gen.Dao, batch int) error {
+		defer func() { results = append(results, buf...) }()
+		return fc(tx, batch)
+	})
+	return results, err
+}
+
+func (u MUserDo) FindInBatches(result *[]*entity.User, batchSize int, fc func(tx gen.Dao, batch int) error) error {
+	return u.DO.FindInBatches(result, batchSize, fc)
+}
+
+func (u MUserDo) Attrs(attrs ...field.AssignExpr) IUserDo {
+	return u.withDO(u.DO.Attrs(attrs...))
+}
+
+func (u MUserDo) Assign(attrs ...field.AssignExpr) IUserDo {
+	return u.withDO(u.DO.Assign(attrs...))
+}
+
+func (u MUserDo) Joins(fields ...field.RelationField) IUserDo {
+	for _, _f := range fields {
+		u = *u.withDO(u.DO.Joins(_f))
+	}
+	return &u
+}
+
+func (u MUserDo) Preload(fields ...field.RelationField) IUserDo {
+	for _, _f := range fields {
+		u = *u.withDO(u.DO.Preload(_f))
+	}
+	return &u
+}
+
+func (u MUserDo) FirstOrInit() (*entity.User, error) {
+	if result, err := u.DO.FirstOrInit(); err != nil {
+		return nil, err
+	} else {
+		return result.(*entity.User), nil
+	}
+}
+
+func (u MUserDo) FirstOrCreate() (*entity.User, error) {
+	if result, err := u.DO.FirstOrCreate(); err != nil {
+		return nil, err
+	} else {
+		return result.(*entity.User), nil
+	}
+}
+
+func (u MUserDo) FindByPage(offset int, limit int) (result []*entity.User, count int64, err error) {
+	result, err = u.Offset(offset).Limit(limit).Find()
+	if err != nil {
+		return
+	}
+
+	if size := len(result); 0 < limit && 0 < size && size < limit {
+		count = int64(size + offset)
+		return
+	}
+
+	count, err = u.Offset(-1).Limit(-1).Count()
+	return
+}
+
+func (u MUserDo) ScanByPage(result interface{}, offset int, limit int) (count int64, err error) {
+	count, err = u.Count()
+	if err != nil {
+		return
+	}
+
+	err = u.Offset(offset).Limit(limit).Scan(result)
+	return
+}
+
+func (u MUserDo) Scan(result interface{}) (err error) {
+	return u.DO.Scan(result)
+}
+
+func (u MUserDo) Delete(models ...*entity.User) (result gen.ResultInfo, err error) {
+	return u.DO.Delete(models)
+}
+
+func (u *MUserDo) withDO(do gen.Dao) *MUserDo {
+	u.DO = *do.(*gen.DO)
+	return u
+}

service/model/user_group.go

@@ -0,0 +1,412 @@
+// Code generated by gorm.io/gen. DO NOT EDIT.
+// Code generated by gorm.io/gen. DO NOT EDIT.
+// Code generated by gorm.io/gen. DO NOT EDIT.
+
+package model
+
+import (
+	"context"
+
+	"gorm.io/gorm"
+	"gorm.io/gorm/clause"
+	"gorm.io/gorm/schema"
+
+	"gorm.io/gen"
+	"gorm.io/gen/field"
+
+	"gorm.io/plugin/dbresolver"
+
+	"icloudapp.cn/tools/service/entity"
+)
+
+func newUserGroup(db *gorm.DB, opts ...gen.DOOption) MUserGroup {
+	_MUserGroup := MUserGroup{}
+
+	_MUserGroup.MUserGroupDo.UseDB(db, opts...)
+	_MUserGroup.MUserGroupDo.UseModel(&entity.UserGroup{})
+
+	tableName := _MUserGroup.MUserGroupDo.TableName()
+	_MUserGroup.ALL = field.NewAsterisk(tableName)
+	_MUserGroup.UID = field.NewInt64(tableName, "uid")
+	_MUserGroup.Groups = field.NewString(tableName, "groups")
+	_MUserGroup.OperatorUID = field.NewInt64(tableName, "operator_uid")
+	_MUserGroup.Status = field.NewInt64(tableName, "status")
+	_MUserGroup.CreateAt = field.NewTime(tableName, "create_at")
+	_MUserGroup.UpdateAt = field.NewTime(tableName, "update_at")
+
+	_MUserGroup.fillFieldMap()
+
+	return _MUserGroup
+}
+
+type MUserGroup struct {
+	MUserGroupDo MUserGroupDo
+
+	ALL         field.Asterisk
+	UID         field.Int64  // 用户ID
+	Groups      field.String // 分组权限
+	OperatorUID field.Int64  // 操作人
+	Status      field.Int64  // 状态
+	CreateAt    field.Time   // 添加时间
+	UpdateAt    field.Time   // 更新时间
+
+	fieldMap map[string]field.Expr
+}
+
+func (u MUserGroup) Table(newTableName string) *MUserGroup {
+	u.MUserGroupDo.UseTable(newTableName)
+	return u.updateTableName(newTableName)
+}
+
+func (u MUserGroup) As(alias string) *MUserGroup {
+	u.MUserGroupDo.DO = *(u.MUserGroupDo.As(alias).(*gen.DO))
+	return u.updateTableName(alias)
+}
+
+func (u *MUserGroup) updateTableName(table string) *MUserGroup {
+	u.ALL = field.NewAsterisk(table)
+	u.UID = field.NewInt64(table, "uid")
+	u.Groups = field.NewString(table, "groups")
+	u.OperatorUID = field.NewInt64(table, "operator_uid")
+	u.Status = field.NewInt64(table, "status")
+	u.CreateAt = field.NewTime(table, "create_at")
+	u.UpdateAt = field.NewTime(table, "update_at")
+
+	u.fillFieldMap()
+
+	return u
+}
+
+func (u *MUserGroup) WithContext(ctx context.Context) IUserGroupDo {
+	return u.MUserGroupDo.WithContext(ctx)
+}
+
+func (u MUserGroup) TableName() string { return u.MUserGroupDo.TableName() }
+
+func (u MUserGroup) Alias() string { return u.MUserGroupDo.Alias() }
+
+func (u *MUserGroup) GetFieldByName(fieldName string) (field.OrderExpr, bool) {
+	_f, ok := u.fieldMap[fieldName]
+	if !ok || _f == nil {
+		return nil, false
+	}
+	_oe, ok := _f.(field.OrderExpr)
+	return _oe, ok
+}
+
+func (u *MUserGroup) fillFieldMap() {
+	u.fieldMap = make(map[string]field.Expr, 6)
+	u.fieldMap["uid"] = u.UID
+	u.fieldMap["groups"] = u.Groups
+	u.fieldMap["operator_uid"] = u.OperatorUID
+	u.fieldMap["status"] = u.Status
+	u.fieldMap["create_at"] = u.CreateAt
+	u.fieldMap["update_at"] = u.UpdateAt
+}
+
+func (u MUserGroup) clone(db *gorm.DB) MUserGroup {
+	u.MUserGroupDo.ReplaceConnPool(db.Statement.ConnPool)
+	return u
+}
+
+func (u MUserGroup) replaceDB(db *gorm.DB) MUserGroup {
+	u.MUserGroupDo.ReplaceDB(db)
+	return u
+}
+
+type MUserGroupDo struct{ gen.DO }
+
+type IUserGroupDo interface {
+	gen.SubQuery
+	Debug() IUserGroupDo
+	WithContext(ctx context.Context) IUserGroupDo
+	WithResult(fc func(tx gen.Dao)) gen.ResultInfo
+	ReplaceDB(db *gorm.DB)
+	ReadDB() IUserGroupDo
+	WriteDB() IUserGroupDo
+	As(alias string) gen.Dao
+	Session(config *gorm.Session) IUserGroupDo
+	Columns(cols ...field.Expr) gen.Columns
+	Clauses(conds ...clause.Expression) IUserGroupDo
+	Not(conds ...gen.Condition) IUserGroupDo
+	Or(conds ...gen.Condition) IUserGroupDo
+	Select(conds ...field.Expr) IUserGroupDo
+	Where(conds ...gen.Condition) IUserGroupDo
+	Order(conds ...field.Expr) IUserGroupDo
+	Distinct(cols ...field.Expr) IUserGroupDo
+	Omit(cols ...field.Expr) IUserGroupDo
+	Join(table schema.Tabler, on ...field.Expr) IUserGroupDo
+	LeftJoin(table schema.Tabler, on ...field.Expr) IUserGroupDo
+	RightJoin(table schema.Tabler, on ...field.Expr) IUserGroupDo
+	Group(cols ...field.Expr) IUserGroupDo
+	Having(conds ...gen.Condition) IUserGroupDo
+	Limit(limit int) IUserGroupDo
+	Offset(offset int) IUserGroupDo
+	Count() (count int64, err error)
+	Scopes(funcs ...func(gen.Dao) gen.Dao) IUserGroupDo
+	Unscoped() IUserGroupDo
+	Create(values ...*entity.UserGroup) error
+	CreateInBatches(values []*entity.UserGroup, batchSize int) error
+	Save(values ...*entity.UserGroup) error
+	First() (*entity.UserGroup, error)
+	Take() (*entity.UserGroup, error)
+	Last() (*entity.UserGroup, error)
+	Find() ([]*entity.UserGroup, error)
+	FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*entity.UserGroup, err error)
+	FindInBatches(result *[]*entity.UserGroup, batchSize int, fc func(tx gen.Dao, batch int) error) error
+	Pluck(column field.Expr, dest interface{}) error
+	Delete(...*entity.UserGroup) (info gen.ResultInfo, err error)
+	Update(column field.Expr, value interface{}) (info gen.ResultInfo, err error)
+	UpdateSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error)
+	Updates(value interface{}) (info gen.ResultInfo, err error)
+	UpdateColumn(column field.Expr, value interface{}) (info gen.ResultInfo, err error)
+	UpdateColumnSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error)
+	UpdateColumns(value interface{}) (info gen.ResultInfo, err error)
+	UpdateFrom(q gen.SubQuery) gen.Dao
+	Attrs(attrs ...field.AssignExpr) IUserGroupDo
+	Assign(attrs ...field.AssignExpr) IUserGroupDo
+	Joins(fields ...field.RelationField) IUserGroupDo
+	Preload(fields ...field.RelationField) IUserGroupDo
+	FirstOrInit() (*entity.UserGroup, error)
+	FirstOrCreate() (*entity.UserGroup, error)
+	FindByPage(offset int, limit int) (result []*entity.UserGroup, count int64, err error)
+	ScanByPage(result interface{}, offset int, limit int) (count int64, err error)
+	Scan(result interface{}) (err error)
+	Returning(value interface{}, columns ...string) IUserGroupDo
+	UnderlyingDB() *gorm.DB
+	schema.Tabler
+}
+
+func (u MUserGroupDo) Debug() IUserGroupDo {
+	return u.withDO(u.DO.Debug())
+}
+
+func (u MUserGroupDo) WithContext(ctx context.Context) IUserGroupDo {
+	return u.withDO(u.DO.WithContext(ctx))
+}
+
+func (u MUserGroupDo) ReadDB() IUserGroupDo {
+	return u.Clauses(dbresolver.Read)
+}
+
+func (u MUserGroupDo) WriteDB() IUserGroupDo {
+	return u.Clauses(dbresolver.Write)
+}
+
+func (u MUserGroupDo) Session(config *gorm.Session) IUserGroupDo {
+	return u.withDO(u.DO.Session(config))
+}
+
+func (u MUserGroupDo) Clauses(conds ...clause.Expression) IUserGroupDo {
+	return u.withDO(u.DO.Clauses(conds...))
+}
+
+func (u MUserGroupDo) Returning(value interface{}, columns ...string) IUserGroupDo {
+	return u.withDO(u.DO.Returning(value, columns...))
+}
+
+func (u MUserGroupDo) Not(conds ...gen.Condition) IUserGroupDo {
+	return u.withDO(u.DO.Not(conds...))
+}
+
+func (u MUserGroupDo) Or(conds ...gen.Condition) IUserGroupDo {
+	return u.withDO(u.DO.Or(conds...))
+}
+
+func (u MUserGroupDo) Select(conds ...field.Expr) IUserGroupDo {
+	return u.withDO(u.DO.Select(conds...))
+}
+
+func (u MUserGroupDo) Where(conds ...gen.Condition) IUserGroupDo {
+	return u.withDO(u.DO.Where(conds...))
+}
+
+func (u MUserGroupDo) Exists(subquery interface{ UnderlyingDB() *gorm.DB }) IUserGroupDo {
+	return u.Where(field.CompareSubQuery(field.ExistsOp, nil, subquery.UnderlyingDB()))
+}
+
+func (u MUserGroupDo) Order(conds ...field.Expr) IUserGroupDo {
+	return u.withDO(u.DO.Order(conds...))
+}
+
+func (u MUserGroupDo) Distinct(cols ...field.Expr) IUserGroupDo {
+	return u.withDO(u.DO.Distinct(cols...))
+}
+
+func (u MUserGroupDo) Omit(cols ...field.Expr) IUserGroupDo {
+	return u.withDO(u.DO.Omit(cols...))
+}
+
+func (u MUserGroupDo) Join(table schema.Tabler, on ...field.Expr) IUserGroupDo {
+	return u.withDO(u.DO.Join(table, on...))
+}
+
+func (u MUserGroupDo) LeftJoin(table schema.Tabler, on ...field.Expr) IUserGroupDo {
+	return u.withDO(u.DO.LeftJoin(table, on...))
+}
+
+func (u MUserGroupDo) RightJoin(table schema.Tabler, on ...field.Expr) IUserGroupDo {
+	return u.withDO(u.DO.RightJoin(table, on...))
+}
+
+func (u MUserGroupDo) Group(cols ...field.Expr) IUserGroupDo {
+	return u.withDO(u.DO.Group(cols...))
+}
+
+func (u MUserGroupDo) Having(conds ...gen.Condition) IUserGroupDo {
+	return u.withDO(u.DO.Having(conds...))
+}
+
+func (u MUserGroupDo) Limit(limit int) IUserGroupDo {
+	return u.withDO(u.DO.Limit(limit))
+}
+
+func (u MUserGroupDo) Offset(offset int) IUserGroupDo {
+	return u.withDO(u.DO.Offset(offset))
+}
+
+func (u MUserGroupDo) Scopes(funcs ...func(gen.Dao) gen.Dao) IUserGroupDo {
+	return u.withDO(u.DO.Scopes(funcs...))
+}
+
+func (u MUserGroupDo) Unscoped() IUserGroupDo {
+	return u.withDO(u.DO.Unscoped())
+}
+
+func (u MUserGroupDo) Create(values ...*entity.UserGroup) error {
+	if len(values) == 0 {
+		return nil
+	}
+	return u.DO.Create(values)
+}
+
+func (u MUserGroupDo) CreateInBatches(values []*entity.UserGroup, batchSize int) error {
+	return u.DO.CreateInBatches(values, batchSize)
+}
+
+// Save : !!! underlying implementation is different with GORM
+// The method is equivalent to executing the statement: db.Clauses(clause.OnConflict{UpdateAll: true}).Create(values)
+func (u MUserGroupDo) Save(values ...*entity.UserGroup) error {
+	if len(values) == 0 {
+		return nil
+	}
+	return u.DO.Save(values)
+}
+
+func (u MUserGroupDo) First() (*entity.UserGroup, error) {
+	if result, err := u.DO.First(); err != nil {
+		return nil, err
+	} else {
+		return result.(*entity.UserGroup), nil
+	}
+}
+
+func (u MUserGroupDo) Take() (*entity.UserGroup, error) {
+	if result, err := u.DO.Take(); err != nil {
+		return nil, err
+	} else {
+		return result.(*entity.UserGroup), nil
+	}
+}
+
+func (u MUserGroupDo) Last() (*entity.UserGroup, error) {
+	if result, err := u.DO.Last(); err != nil {
+		return nil, err
+	} else {
+		return result.(*entity.UserGroup), nil
+	}
+}
+
+func (u MUserGroupDo) Find() ([]*entity.UserGroup, error) {
+	result, err := u.DO.Find()
+	return result.([]*entity.UserGroup), err
+}
+
+func (u MUserGroupDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*entity.UserGroup, err error) {
+	buf := make([]*entity.UserGroup, 0, batchSize)
+	err = u.DO.FindInBatches(&buf, batchSize, func(tx gen.Dao, batch int) error {
+		defer func() { results = append(results, buf...) }()
+		return fc(tx, batch)
+	})
+	return results, err
+}
+
+func (u MUserGroupDo) FindInBatches(result *[]*entity.UserGroup, batchSize int, fc func(tx gen.Dao, batch int) error) error {
+	return u.DO.FindInBatches(result, batchSize, fc)
+}
+
+func (u MUserGroupDo) Attrs(attrs ...field.AssignExpr) IUserGroupDo {
+	return u.withDO(u.DO.Attrs(attrs...))
+}
+
+func (u MUserGroupDo) Assign(attrs ...field.AssignExpr) IUserGroupDo {
+	return u.withDO(u.DO.Assign(attrs...))
+}
+
+func (u MUserGroupDo) Joins(fields ...field.RelationField) IUserGroupDo {
+	for _, _f := range fields {
+		u = *u.withDO(u.DO.Joins(_f))
+	}
+	return &u
+}
+
+func (u MUserGroupDo) Preload(fields ...field.RelationField) IUserGroupDo {
+	for _, _f := range fields {
+		u = *u.withDO(u.DO.Preload(_f))
+	}
+	return &u
+}
+
+func (u MUserGroupDo) FirstOrInit() (*entity.UserGroup, error) {
+	if result, err := u.DO.FirstOrInit(); err != nil {
+		return nil, err
+	} else {
+		return result.(*entity.UserGroup), nil
+	}
+}
+
+func (u MUserGroupDo) FirstOrCreate() (*entity.UserGroup, error) {
+	if result, err := u.DO.FirstOrCreate(); err != nil {
+		return nil, err
+	} else {
+		return result.(*entity.UserGroup), nil
+	}
+}
+
+func (u MUserGroupDo) FindByPage(offset int, limit int) (result []*entity.UserGroup, count int64, err error) {
+	result, err = u.Offset(offset).Limit(limit).Find()
+	if err != nil {
+		return
+	}
+
+	if size := len(result); 0 < limit && 0 < size && size < limit {
+		count = int64(size + offset)
+		return
+	}
+
+	count, err = u.Offset(-1).Limit(-1).Count()
+	return
+}
+
+func (u MUserGroupDo) ScanByPage(result interface{}, offset int, limit int) (count int64, err error) {
+	count, err = u.Count()
+	if err != nil {
+		return
+	}
+
+	err = u.Offset(offset).Limit(limit).Scan(result)
+	return
+}
+
+func (u MUserGroupDo) Scan(result interface{}) (err error) {
+	return u.DO.Scan(result)
+}
+
+func (u MUserGroupDo) Delete(models ...*entity.UserGroup) (result gen.ResultInfo, err error) {
+	return u.DO.Delete(models)
+}
+
+func (u *MUserGroupDo) withDO(do gen.Dao) *MUserGroupDo {
+	u.DO = *do.(*gen.DO)
+	return u
+}

service/model/user_poster.go

@@ -0,0 +1,432 @@
+// Code generated by gorm.io/gen. DO NOT EDIT.
+// Code generated by gorm.io/gen. DO NOT EDIT.
+// Code generated by gorm.io/gen. DO NOT EDIT.
+
+package model
+
+import (
+	"context"
+
+	"gorm.io/gorm"
+	"gorm.io/gorm/clause"
+	"gorm.io/gorm/schema"
+
+	"gorm.io/gen"
+	"gorm.io/gen/field"
+
+	"gorm.io/plugin/dbresolver"
+
+	"icloudapp.cn/tools/service/entity"
+)
+
+func newUserPoster(db *gorm.DB, opts ...gen.DOOption) MUserPoster {
+	_MUserPoster := MUserPoster{}
+
+	_MUserPoster.MUserPosterDo.UseDB(db, opts...)
+	_MUserPoster.MUserPosterDo.UseModel(&entity.UserPoster{})
+
+	tableName := _MUserPoster.MUserPosterDo.TableName()
+	_MUserPoster.ALL = field.NewAsterisk(tableName)
+	_MUserPoster.PosterID = field.NewInt64(tableName, "poster_id")
+	_MUserPoster.PosterName = field.NewString(tableName, "poster_name")
+	_MUserPoster.UUID = field.NewString(tableName, "uuid")
+	_MUserPoster.UID = field.NewInt64(tableName, "uid")
+	_MUserPoster.PosterKeywords = field.NewString(tableName, "poster_keywords")
+	_MUserPoster.PosterJSON = field.NewString(tableName, "poster_json")
+	_MUserPoster.Preview = field.NewString(tableName, "preview")
+	_MUserPoster.Visits = field.NewInt64(tableName, "visits")
+	_MUserPoster.Status = field.NewInt64(tableName, "status")
+	_MUserPoster.CreateAt = field.NewTime(tableName, "create_at")
+	_MUserPoster.UpdateAt = field.NewTime(tableName, "update_at")
+
+	_MUserPoster.fillFieldMap()
+
+	return _MUserPoster
+}
+
+type MUserPoster struct {
+	MUserPosterDo MUserPosterDo
+
+	ALL            field.Asterisk
+	PosterID       field.Int64  // 海报ID
+	PosterName     field.String // 海报名称
+	UUID           field.String // 海报唯一标识
+	UID            field.Int64  // 用户ID
+	PosterKeywords field.String // 海报关键字
+	PosterJSON     field.String // 海报数据
+	Preview        field.String // 海报预览地址
+	Visits         field.Int64  // 访问次数
+	Status         field.Int64
+	CreateAt       field.Time // 创建时间
+	UpdateAt       field.Time // 更新时间
+
+	fieldMap map[string]field.Expr
+}
+
+func (u MUserPoster) Table(newTableName string) *MUserPoster {
+	u.MUserPosterDo.UseTable(newTableName)
+	return u.updateTableName(newTableName)
+}
+
+func (u MUserPoster) As(alias string) *MUserPoster {
+	u.MUserPosterDo.DO = *(u.MUserPosterDo.As(alias).(*gen.DO))
+	return u.updateTableName(alias)
+}
+
+func (u *MUserPoster) updateTableName(table string) *MUserPoster {
+	u.ALL = field.NewAsterisk(table)
+	u.PosterID = field.NewInt64(table, "poster_id")
+	u.PosterName = field.NewString(table, "poster_name")
+	u.UUID = field.NewString(table, "uuid")
+	u.UID = field.NewInt64(table, "uid")
+	u.PosterKeywords = field.NewString(table, "poster_keywords")
+	u.PosterJSON = field.NewString(table, "poster_json")
+	u.Preview = field.NewString(table, "preview")
+	u.Visits = field.NewInt64(table, "visits")
+	u.Status = field.NewInt64(table, "status")
+	u.CreateAt = field.NewTime(table, "create_at")
+	u.UpdateAt = field.NewTime(table, "update_at")
+
+	u.fillFieldMap()
+
+	return u
+}
+
+func (u *MUserPoster) WithContext(ctx context.Context) IUserPosterDo {
+	return u.MUserPosterDo.WithContext(ctx)
+}
+
+func (u MUserPoster) TableName() string { return u.MUserPosterDo.TableName() }
+
+func (u MUserPoster) Alias() string { return u.MUserPosterDo.Alias() }
+
+func (u *MUserPoster) GetFieldByName(fieldName string) (field.OrderExpr, bool) {
+	_f, ok := u.fieldMap[fieldName]
+	if !ok || _f == nil {
+		return nil, false
+	}
+	_oe, ok := _f.(field.OrderExpr)
+	return _oe, ok
+}
+
+func (u *MUserPoster) fillFieldMap() {
+	u.fieldMap = make(map[string]field.Expr, 11)
+	u.fieldMap["poster_id"] = u.PosterID
+	u.fieldMap["poster_name"] = u.PosterName
+	u.fieldMap["uuid"] = u.UUID
+	u.fieldMap["uid"] = u.UID
+	u.fieldMap["poster_keywords"] = u.PosterKeywords
+	u.fieldMap["poster_json"] = u.PosterJSON
+	u.fieldMap["preview"] = u.Preview
+	u.fieldMap["visits"] = u.Visits
+	u.fieldMap["status"] = u.Status
+	u.fieldMap["create_at"] = u.CreateAt
+	u.fieldMap["update_at"] = u.UpdateAt
+}
+
+func (u MUserPoster) clone(db *gorm.DB) MUserPoster {
+	u.MUserPosterDo.ReplaceConnPool(db.Statement.ConnPool)
+	return u
+}
+
+func (u MUserPoster) replaceDB(db *gorm.DB) MUserPoster {
+	u.MUserPosterDo.ReplaceDB(db)
+	return u
+}
+
+type MUserPosterDo struct{ gen.DO }
+
+type IUserPosterDo interface {
+	gen.SubQuery
+	Debug() IUserPosterDo
+	WithContext(ctx context.Context) IUserPosterDo
+	WithResult(fc func(tx gen.Dao)) gen.ResultInfo
+	ReplaceDB(db *gorm.DB)
+	ReadDB() IUserPosterDo
+	WriteDB() IUserPosterDo
+	As(alias string) gen.Dao
+	Session(config *gorm.Session) IUserPosterDo
+	Columns(cols ...field.Expr) gen.Columns
+	Clauses(conds ...clause.Expression) IUserPosterDo
+	Not(conds ...gen.Condition) IUserPosterDo
+	Or(conds ...gen.Condition) IUserPosterDo
+	Select(conds ...field.Expr) IUserPosterDo
+	Where(conds ...gen.Condition) IUserPosterDo
+	Order(conds ...field.Expr) IUserPosterDo
+	Distinct(cols ...field.Expr) IUserPosterDo
+	Omit(cols ...field.Expr) IUserPosterDo
+	Join(table schema.Tabler, on ...field.Expr) IUserPosterDo
+	LeftJoin(table schema.Tabler, on ...field.Expr) IUserPosterDo
+	RightJoin(table schema.Tabler, on ...field.Expr) IUserPosterDo
+	Group(cols ...field.Expr) IUserPosterDo
+	Having(conds ...gen.Condition) IUserPosterDo
+	Limit(limit int) IUserPosterDo
+	Offset(offset int) IUserPosterDo
+	Count() (count int64, err error)
+	Scopes(funcs ...func(gen.Dao) gen.Dao) IUserPosterDo
+	Unscoped() IUserPosterDo
+	Create(values ...*entity.UserPoster) error
+	CreateInBatches(values []*entity.UserPoster, batchSize int) error
+	Save(values ...*entity.UserPoster) error
+	First() (*entity.UserPoster, error)
+	Take() (*entity.UserPoster, error)
+	Last() (*entity.UserPoster, error)
+	Find() ([]*entity.UserPoster, error)
+	FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*entity.UserPoster, err error)
+	FindInBatches(result *[]*entity.UserPoster, batchSize int, fc func(tx gen.Dao, batch int) error) error
+	Pluck(column field.Expr, dest interface{}) error
+	Delete(...*entity.UserPoster) (info gen.ResultInfo, err error)
+	Update(column field.Expr, value interface{}) (info gen.ResultInfo, err error)
+	UpdateSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error)
+	Updates(value interface{}) (info gen.ResultInfo, err error)
+	UpdateColumn(column field.Expr, value interface{}) (info gen.ResultInfo, err error)
+	UpdateColumnSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error)
+	UpdateColumns(value interface{}) (info gen.ResultInfo, err error)
+	UpdateFrom(q gen.SubQuery) gen.Dao
+	Attrs(attrs ...field.AssignExpr) IUserPosterDo
+	Assign(attrs ...field.AssignExpr) IUserPosterDo
+	Joins(fields ...field.RelationField) IUserPosterDo
+	Preload(fields ...field.RelationField) IUserPosterDo
+	FirstOrInit() (*entity.UserPoster, error)
+	FirstOrCreate() (*entity.UserPoster, error)
+	FindByPage(offset int, limit int) (result []*entity.UserPoster, count int64, err error)
+	ScanByPage(result interface{}, offset int, limit int) (count int64, err error)
+	Scan(result interface{}) (err error)
+	Returning(value interface{}, columns ...string) IUserPosterDo
+	UnderlyingDB() *gorm.DB
+	schema.Tabler
+}
+
+func (u MUserPosterDo) Debug() IUserPosterDo {
+	return u.withDO(u.DO.Debug())
+}
+
+func (u MUserPosterDo) WithContext(ctx context.Context) IUserPosterDo {
+	return u.withDO(u.DO.WithContext(ctx))
+}
+
+func (u MUserPosterDo) ReadDB() IUserPosterDo {
+	return u.Clauses(dbresolver.Read)
+}
+
+func (u MUserPosterDo) WriteDB() IUserPosterDo {
+	return u.Clauses(dbresolver.Write)
+}
+
+func (u MUserPosterDo) Session(config *gorm.Session) IUserPosterDo {
+	return u.withDO(u.DO.Session(config))
+}
+
+func (u MUserPosterDo) Clauses(conds ...clause.Expression) IUserPosterDo {
+	return u.withDO(u.DO.Clauses(conds...))
+}
+
+func (u MUserPosterDo) Returning(value interface{}, columns ...string) IUserPosterDo {
+	return u.withDO(u.DO.Returning(value, columns...))
+}
+
+func (u MUserPosterDo) Not(conds ...gen.Condition) IUserPosterDo {
+	return u.withDO(u.DO.Not(conds...))
+}
+
+func (u MUserPosterDo) Or(conds ...gen.Condition) IUserPosterDo {
+	return u.withDO(u.DO.Or(conds...))
+}
+
+func (u MUserPosterDo) Select(conds ...field.Expr) IUserPosterDo {
+	return u.withDO(u.DO.Select(conds...))
+}
+
+func (u MUserPosterDo) Where(conds ...gen.Condition) IUserPosterDo {
+	return u.withDO(u.DO.Where(conds...))
+}
+
+func (u MUserPosterDo) Exists(subquery interface{ UnderlyingDB() *gorm.DB }) IUserPosterDo {
+	return u.Where(field.CompareSubQuery(field.ExistsOp, nil, subquery.UnderlyingDB()))
+}
+
+func (u MUserPosterDo) Order(conds ...field.Expr) IUserPosterDo {
+	return u.withDO(u.DO.Order(conds...))
+}
+
+func (u MUserPosterDo) Distinct(cols ...field.Expr) IUserPosterDo {
+	return u.withDO(u.DO.Distinct(cols...))
+}
+
+func (u MUserPosterDo) Omit(cols ...field.Expr) IUserPosterDo {
+	return u.withDO(u.DO.Omit(cols...))
+}
+
+func (u MUserPosterDo) Join(table schema.Tabler, on ...field.Expr) IUserPosterDo {
+	return u.withDO(u.DO.Join(table, on...))
+}
+
+func (u MUserPosterDo) LeftJoin(table schema.Tabler, on ...field.Expr) IUserPosterDo {
+	return u.withDO(u.DO.LeftJoin(table, on...))
+}
+
+func (u MUserPosterDo) RightJoin(table schema.Tabler, on ...field.Expr) IUserPosterDo {
+	return u.withDO(u.DO.RightJoin(table, on...))
+}
+
+func (u MUserPosterDo) Group(cols ...field.Expr) IUserPosterDo {
+	return u.withDO(u.DO.Group(cols...))
+}
+
+func (u MUserPosterDo) Having(conds ...gen.Condition) IUserPosterDo {
+	return u.withDO(u.DO.Having(conds...))
+}
+
+func (u MUserPosterDo) Limit(limit int) IUserPosterDo {
+	return u.withDO(u.DO.Limit(limit))
+}
+
+func (u MUserPosterDo) Offset(offset int) IUserPosterDo {
+	return u.withDO(u.DO.Offset(offset))
+}
+
+func (u MUserPosterDo) Scopes(funcs ...func(gen.Dao) gen.Dao) IUserPosterDo {
+	return u.withDO(u.DO.Scopes(funcs...))
+}
+
+func (u MUserPosterDo) Unscoped() IUserPosterDo {
+	return u.withDO(u.DO.Unscoped())
+}
+
+func (u MUserPosterDo) Create(values ...*entity.UserPoster) error {
+	if len(values) == 0 {
+		return nil
+	}
+	return u.DO.Create(values)
+}
+
+func (u MUserPosterDo) CreateInBatches(values []*entity.UserPoster, batchSize int) error {
+	return u.DO.CreateInBatches(values, batchSize)
+}
+
+// Save : !!! underlying implementation is different with GORM
+// The method is equivalent to executing the statement: db.Clauses(clause.OnConflict{UpdateAll: true}).Create(values)
+func (u MUserPosterDo) Save(values ...*entity.UserPoster) error {
+	if len(values) == 0 {
+		return nil
+	}
+	return u.DO.Save(values)
+}
+
+func (u MUserPosterDo) First() (*entity.UserPoster, error) {
+	if result, err := u.DO.First(); err != nil {
+		return nil, err
+	} else {
+		return result.(*entity.UserPoster), nil
+	}
+}
+
+func (u MUserPosterDo) Take() (*entity.UserPoster, error) {
+	if result, err := u.DO.Take(); err != nil {
+		return nil, err
+	} else {
+		return result.(*entity.UserPoster), nil
+	}
+}
+
+func (u MUserPosterDo) Last() (*entity.UserPoster, error) {
+	if result, err := u.DO.Last(); err != nil {
+		return nil, err
+	} else {
+		return result.(*entity.UserPoster), nil
+	}
+}
+
+func (u MUserPosterDo) Find() ([]*entity.UserPoster, error) {
+	result, err := u.DO.Find()
+	return result.([]*entity.UserPoster), err
+}
+
+func (u MUserPosterDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*entity.UserPoster, err error) {
+	buf := make([]*entity.UserPoster, 0, batchSize)
+	err = u.DO.FindInBatches(&buf, batchSize, func(tx gen.Dao, batch int) error {
+		defer func() { results = append(results, buf...) }()
+		return fc(tx, batch)
+	})
+	return results, err
+}
+
+func (u MUserPosterDo) FindInBatches(result *[]*entity.UserPoster, batchSize int, fc func(tx gen.Dao, batch int) error) error {
+	return u.DO.FindInBatches(result, batchSize, fc)
+}
+
+func (u MUserPosterDo) Attrs(attrs ...field.AssignExpr) IUserPosterDo {
+	return u.withDO(u.DO.Attrs(attrs...))
+}
+
+func (u MUserPosterDo) Assign(attrs ...field.AssignExpr) IUserPosterDo {
+	return u.withDO(u.DO.Assign(attrs...))
+}
+
+func (u MUserPosterDo) Joins(fields ...field.RelationField) IUserPosterDo {
+	for _, _f := range fields {
+		u = *u.withDO(u.DO.Joins(_f))
+	}
+	return &u
+}
+
+func (u MUserPosterDo) Preload(fields ...field.RelationField) IUserPosterDo {
+	for _, _f := range fields {
+		u = *u.withDO(u.DO.Preload(_f))
+	}
+	return &u
+}
+
+func (u MUserPosterDo) FirstOrInit() (*entity.UserPoster, error) {
+	if result, err := u.DO.FirstOrInit(); err != nil {
+		return nil, err
+	} else {
+		return result.(*entity.UserPoster), nil
+	}
+}
+
+func (u MUserPosterDo) FirstOrCreate() (*entity.UserPoster, error) {
+	if result, err := u.DO.FirstOrCreate(); err != nil {
+		return nil, err
+	} else {
+		return result.(*entity.UserPoster), nil
+	}
+}
+
+func (u MUserPosterDo) FindByPage(offset int, limit int) (result []*entity.UserPoster, count int64, err error) {
+	result, err = u.Offset(offset).Limit(limit).Find()
+	if err != nil {
+		return
+	}
+
+	if size := len(result); 0 < limit && 0 < size && size < limit {
+		count = int64(size + offset)
+		return
+	}
+
+	count, err = u.Offset(-1).Limit(-1).Count()
+	return
+}
+
+func (u MUserPosterDo) ScanByPage(result interface{}, offset int, limit int) (count int64, err error) {
+	count, err = u.Count()
+	if err != nil {
+		return
+	}
+
+	err = u.Offset(offset).Limit(limit).Scan(result)
+	return
+}
+
+func (u MUserPosterDo) Scan(result interface{}) (err error) {
+	return u.DO.Scan(result)
+}
+
+func (u MUserPosterDo) Delete(models ...*entity.UserPoster) (result gen.ResultInfo, err error) {
+	return u.DO.Delete(models)
+}
+
+func (u *MUserPosterDo) withDO(do gen.Dao) *MUserPosterDo {
+	u.DO = *do.(*gen.DO)
+	return u
+}

service/model/user_poster_batches.go

@@ -0,0 +1,440 @@
+// Code generated by gorm.io/gen. DO NOT EDIT.
+// Code generated by gorm.io/gen. DO NOT EDIT.
+// Code generated by gorm.io/gen. DO NOT EDIT.
+
+package model
+
+import (
+	"context"
+
+	"gorm.io/gorm"
+	"gorm.io/gorm/clause"
+	"gorm.io/gorm/schema"
+
+	"gorm.io/gen"
+	"gorm.io/gen/field"
+
+	"gorm.io/plugin/dbresolver"
+
+	"icloudapp.cn/tools/service/entity"
+)
+
+func newUserPosterBatch(db *gorm.DB, opts ...gen.DOOption) MUserPosterBatch {
+	_MUserPosterBatch := MUserPosterBatch{}
+
+	_MUserPosterBatch.MUserPosterBatchDo.UseDB(db, opts...)
+	_MUserPosterBatch.MUserPosterBatchDo.UseModel(&entity.UserPosterBatch{})
+
+	tableName := _MUserPosterBatch.MUserPosterBatchDo.TableName()
+	_MUserPosterBatch.ALL = field.NewAsterisk(tableName)
+	_MUserPosterBatch.BatchID = field.NewInt64(tableName, "batch_id")
+	_MUserPosterBatch.UID = field.NewInt64(tableName, "uid")
+	_MUserPosterBatch.PosterID = field.NewInt64(tableName, "poster_id")
+	_MUserPosterBatch.Name = field.NewString(tableName, "name")
+	_MUserPosterBatch.UUID = field.NewString(tableName, "uuid")
+	_MUserPosterBatch.Raw = field.NewString(tableName, "raw")
+	_MUserPosterBatch.Num = field.NewInt64(tableName, "num")
+	_MUserPosterBatch.DoneNum = field.NewInt64(tableName, "done_num")
+	_MUserPosterBatch.Type = field.NewString(tableName, "type")
+	_MUserPosterBatch.Path = field.NewString(tableName, "path")
+	_MUserPosterBatch.Status = field.NewInt64(tableName, "status")
+	_MUserPosterBatch.CreateAt = field.NewTime(tableName, "create_at")
+	_MUserPosterBatch.UpdateAt = field.NewTime(tableName, "update_at")
+
+	_MUserPosterBatch.fillFieldMap()
+
+	return _MUserPosterBatch
+}
+
+type MUserPosterBatch struct {
+	MUserPosterBatchDo MUserPosterBatchDo
+
+	ALL      field.Asterisk
+	BatchID  field.Int64
+	UID      field.Int64  // 用户ID
+	PosterID field.Int64  // 海报ID
+	Name     field.String // 海报名称
+	UUID     field.String // 海报唯一标识
+	Raw      field.String // 生成的内容
+	Num      field.Int64  // 海报份数
+	DoneNum  field.Int64  // 已经生成的份数
+	Type     field.String // 生成图片类型
+	Path     field.String // 海报存储路径
+	Status   field.Int64  // 海报生成状态
+	CreateAt field.Time   // 创建时间
+	UpdateAt field.Time   // 更新时间
+
+	fieldMap map[string]field.Expr
+}
+
+func (u MUserPosterBatch) Table(newTableName string) *MUserPosterBatch {
+	u.MUserPosterBatchDo.UseTable(newTableName)
+	return u.updateTableName(newTableName)
+}
+
+func (u MUserPosterBatch) As(alias string) *MUserPosterBatch {
+	u.MUserPosterBatchDo.DO = *(u.MUserPosterBatchDo.As(alias).(*gen.DO))
+	return u.updateTableName(alias)
+}
+
+func (u *MUserPosterBatch) updateTableName(table string) *MUserPosterBatch {
+	u.ALL = field.NewAsterisk(table)
+	u.BatchID = field.NewInt64(table, "batch_id")
+	u.UID = field.NewInt64(table, "uid")
+	u.PosterID = field.NewInt64(table, "poster_id")
+	u.Name = field.NewString(table, "name")
+	u.UUID = field.NewString(table, "uuid")
+	u.Raw = field.NewString(table, "raw")
+	u.Num = field.NewInt64(table, "num")
+	u.DoneNum = field.NewInt64(table, "done_num")
+	u.Type = field.NewString(table, "type")
+	u.Path = field.NewString(table, "path")
+	u.Status = field.NewInt64(table, "status")
+	u.CreateAt = field.NewTime(table, "create_at")
+	u.UpdateAt = field.NewTime(table, "update_at")
+
+	u.fillFieldMap()
+
+	return u
+}
+
+func (u *MUserPosterBatch) WithContext(ctx context.Context) IUserPosterBatchDo {
+	return u.MUserPosterBatchDo.WithContext(ctx)
+}
+
+func (u MUserPosterBatch) TableName() string { return u.MUserPosterBatchDo.TableName() }
+
+func (u MUserPosterBatch) Alias() string { return u.MUserPosterBatchDo.Alias() }
+
+func (u *MUserPosterBatch) GetFieldByName(fieldName string) (field.OrderExpr, bool) {
+	_f, ok := u.fieldMap[fieldName]
+	if !ok || _f == nil {
+		return nil, false
+	}
+	_oe, ok := _f.(field.OrderExpr)
+	return _oe, ok
+}
+
+func (u *MUserPosterBatch) fillFieldMap() {
+	u.fieldMap = make(map[string]field.Expr, 13)
+	u.fieldMap["batch_id"] = u.BatchID
+	u.fieldMap["uid"] = u.UID
+	u.fieldMap["poster_id"] = u.PosterID
+	u.fieldMap["name"] = u.Name
+	u.fieldMap["uuid"] = u.UUID
+	u.fieldMap["raw"] = u.Raw
+	u.fieldMap["num"] = u.Num
+	u.fieldMap["done_num"] = u.DoneNum
+	u.fieldMap["type"] = u.Type
+	u.fieldMap["path"] = u.Path
+	u.fieldMap["status"] = u.Status
+	u.fieldMap["create_at"] = u.CreateAt
+	u.fieldMap["update_at"] = u.UpdateAt
+}
+
+func (u MUserPosterBatch) clone(db *gorm.DB) MUserPosterBatch {
+	u.MUserPosterBatchDo.ReplaceConnPool(db.Statement.ConnPool)
+	return u
+}
+
+func (u MUserPosterBatch) replaceDB(db *gorm.DB) MUserPosterBatch {
+	u.MUserPosterBatchDo.ReplaceDB(db)
+	return u
+}
+
+type MUserPosterBatchDo struct{ gen.DO }
+
+type IUserPosterBatchDo interface {
+	gen.SubQuery
+	Debug() IUserPosterBatchDo
+	WithContext(ctx context.Context) IUserPosterBatchDo
+	WithResult(fc func(tx gen.Dao)) gen.ResultInfo
+	ReplaceDB(db *gorm.DB)
+	ReadDB() IUserPosterBatchDo
+	WriteDB() IUserPosterBatchDo
+	As(alias string) gen.Dao
+	Session(config *gorm.Session) IUserPosterBatchDo
+	Columns(cols ...field.Expr) gen.Columns
+	Clauses(conds ...clause.Expression) IUserPosterBatchDo
+	Not(conds ...gen.Condition) IUserPosterBatchDo
+	Or(conds ...gen.Condition) IUserPosterBatchDo
+	Select(conds ...field.Expr) IUserPosterBatchDo
+	Where(conds ...gen.Condition) IUserPosterBatchDo
+	Order(conds ...field.Expr) IUserPosterBatchDo
+	Distinct(cols ...field.Expr) IUserPosterBatchDo
+	Omit(cols ...field.Expr) IUserPosterBatchDo
+	Join(table schema.Tabler, on ...field.Expr) IUserPosterBatchDo
+	LeftJoin(table schema.Tabler, on ...field.Expr) IUserPosterBatchDo
+	RightJoin(table schema.Tabler, on ...field.Expr) IUserPosterBatchDo
+	Group(cols ...field.Expr) IUserPosterBatchDo
+	Having(conds ...gen.Condition) IUserPosterBatchDo
+	Limit(limit int) IUserPosterBatchDo
+	Offset(offset int) IUserPosterBatchDo
+	Count() (count int64, err error)
+	Scopes(funcs ...func(gen.Dao) gen.Dao) IUserPosterBatchDo
+	Unscoped() IUserPosterBatchDo
+	Create(values ...*entity.UserPosterBatch) error
+	CreateInBatches(values []*entity.UserPosterBatch, batchSize int) error
+	Save(values ...*entity.UserPosterBatch) error
+	First() (*entity.UserPosterBatch, error)
+	Take() (*entity.UserPosterBatch, error)
+	Last() (*entity.UserPosterBatch, error)
+	Find() ([]*entity.UserPosterBatch, error)
+	FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*entity.UserPosterBatch, err error)
+	FindInBatches(result *[]*entity.UserPosterBatch, batchSize int, fc func(tx gen.Dao, batch int) error) error
+	Pluck(column field.Expr, dest interface{}) error
+	Delete(...*entity.UserPosterBatch) (info gen.ResultInfo, err error)
+	Update(column field.Expr, value interface{}) (info gen.ResultInfo, err error)
+	UpdateSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error)
+	Updates(value interface{}) (info gen.ResultInfo, err error)
+	UpdateColumn(column field.Expr, value interface{}) (info gen.ResultInfo, err error)
+	UpdateColumnSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error)
+	UpdateColumns(value interface{}) (info gen.ResultInfo, err error)
+	UpdateFrom(q gen.SubQuery) gen.Dao
+	Attrs(attrs ...field.AssignExpr) IUserPosterBatchDo
+	Assign(attrs ...field.AssignExpr) IUserPosterBatchDo
+	Joins(fields ...field.RelationField) IUserPosterBatchDo
+	Preload(fields ...field.RelationField) IUserPosterBatchDo
+	FirstOrInit() (*entity.UserPosterBatch, error)
+	FirstOrCreate() (*entity.UserPosterBatch, error)
+	FindByPage(offset int, limit int) (result []*entity.UserPosterBatch, count int64, err error)
+	ScanByPage(result interface{}, offset int, limit int) (count int64, err error)
+	Scan(result interface{}) (err error)
+	Returning(value interface{}, columns ...string) IUserPosterBatchDo
+	UnderlyingDB() *gorm.DB
+	schema.Tabler
+}
+
+func (u MUserPosterBatchDo) Debug() IUserPosterBatchDo {
+	return u.withDO(u.DO.Debug())
+}
+
+func (u MUserPosterBatchDo) WithContext(ctx context.Context) IUserPosterBatchDo {
+	return u.withDO(u.DO.WithContext(ctx))
+}
+
+func (u MUserPosterBatchDo) ReadDB() IUserPosterBatchDo {
+	return u.Clauses(dbresolver.Read)
+}
+
+func (u MUserPosterBatchDo) WriteDB() IUserPosterBatchDo {
+	return u.Clauses(dbresolver.Write)
+}
+
+func (u MUserPosterBatchDo) Session(config *gorm.Session) IUserPosterBatchDo {
+	return u.withDO(u.DO.Session(config))
+}
+
+func (u MUserPosterBatchDo) Clauses(conds ...clause.Expression) IUserPosterBatchDo {
+	return u.withDO(u.DO.Clauses(conds...))
+}
+
+func (u MUserPosterBatchDo) Returning(value interface{}, columns ...string) IUserPosterBatchDo {
+	return u.withDO(u.DO.Returning(value, columns...))
+}
+
+func (u MUserPosterBatchDo) Not(conds ...gen.Condition) IUserPosterBatchDo {
+	return u.withDO(u.DO.Not(conds...))
+}
+
+func (u MUserPosterBatchDo) Or(conds ...gen.Condition) IUserPosterBatchDo {
+	return u.withDO(u.DO.Or(conds...))
+}
+
+func (u MUserPosterBatchDo) Select(conds ...field.Expr) IUserPosterBatchDo {
+	return u.withDO(u.DO.Select(conds...))
+}
+
+func (u MUserPosterBatchDo) Where(conds ...gen.Condition) IUserPosterBatchDo {
+	return u.withDO(u.DO.Where(conds...))
+}
+
+func (u MUserPosterBatchDo) Exists(subquery interface{ UnderlyingDB() *gorm.DB }) IUserPosterBatchDo {
+	return u.Where(field.CompareSubQuery(field.ExistsOp, nil, subquery.UnderlyingDB()))
+}
+
+func (u MUserPosterBatchDo) Order(conds ...field.Expr) IUserPosterBatchDo {
+	return u.withDO(u.DO.Order(conds...))
+}
+
+func (u MUserPosterBatchDo) Distinct(cols ...field.Expr) IUserPosterBatchDo {
+	return u.withDO(u.DO.Distinct(cols...))
+}
+
+func (u MUserPosterBatchDo) Omit(cols ...field.Expr) IUserPosterBatchDo {
+	return u.withDO(u.DO.Omit(cols...))
+}
+
+func (u MUserPosterBatchDo) Join(table schema.Tabler, on ...field.Expr) IUserPosterBatchDo {
+	return u.withDO(u.DO.Join(table, on...))
+}
+
+func (u MUserPosterBatchDo) LeftJoin(table schema.Tabler, on ...field.Expr) IUserPosterBatchDo {
+	return u.withDO(u.DO.LeftJoin(table, on...))
+}
+
+func (u MUserPosterBatchDo) RightJoin(table schema.Tabler, on ...field.Expr) IUserPosterBatchDo {
+	return u.withDO(u.DO.RightJoin(table, on...))
+}
+
+func (u MUserPosterBatchDo) Group(cols ...field.Expr) IUserPosterBatchDo {
+	return u.withDO(u.DO.Group(cols...))
+}
+
+func (u MUserPosterBatchDo) Having(conds ...gen.Condition) IUserPosterBatchDo {
+	return u.withDO(u.DO.Having(conds...))
+}
+
+func (u MUserPosterBatchDo) Limit(limit int) IUserPosterBatchDo {
+	return u.withDO(u.DO.Limit(limit))
+}
+
+func (u MUserPosterBatchDo) Offset(offset int) IUserPosterBatchDo {
+	return u.withDO(u.DO.Offset(offset))
+}
+
+func (u MUserPosterBatchDo) Scopes(funcs ...func(gen.Dao) gen.Dao) IUserPosterBatchDo {
+	return u.withDO(u.DO.Scopes(funcs...))
+}
+
+func (u MUserPosterBatchDo) Unscoped() IUserPosterBatchDo {
+	return u.withDO(u.DO.Unscoped())
+}
+
+func (u MUserPosterBatchDo) Create(values ...*entity.UserPosterBatch) error {
+	if len(values) == 0 {
+		return nil
+	}
+	return u.DO.Create(values)
+}
+
+func (u MUserPosterBatchDo) CreateInBatches(values []*entity.UserPosterBatch, batchSize int) error {
+	return u.DO.CreateInBatches(values, batchSize)
+}
+
+// Save : !!! underlying implementation is different with GORM
+// The method is equivalent to executing the statement: db.Clauses(clause.OnConflict{UpdateAll: true}).Create(values)
+func (u MUserPosterBatchDo) Save(values ...*entity.UserPosterBatch) error {
+	if len(values) == 0 {
+		return nil
+	}
+	return u.DO.Save(values)
+}
+
+func (u MUserPosterBatchDo) First() (*entity.UserPosterBatch, error) {
+	if result, err := u.DO.First(); err != nil {
+		return nil, err
+	} else {
+		return result.(*entity.UserPosterBatch), nil
+	}
+}
+
+func (u MUserPosterBatchDo) Take() (*entity.UserPosterBatch, error) {
+	if result, err := u.DO.Take(); err != nil {
+		return nil, err
+	} else {
+		return result.(*entity.UserPosterBatch), nil
+	}
+}
+
+func (u MUserPosterBatchDo) Last() (*entity.UserPosterBatch, error) {
+	if result, err := u.DO.Last(); err != nil {
+		return nil, err
+	} else {
+		return result.(*entity.UserPosterBatch), nil
+	}
+}
+
+func (u MUserPosterBatchDo) Find() ([]*entity.UserPosterBatch, error) {
+	result, err := u.DO.Find()
+	return result.([]*entity.UserPosterBatch), err
+}
+
+func (u MUserPosterBatchDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*entity.UserPosterBatch, err error) {
+	buf := make([]*entity.UserPosterBatch, 0, batchSize)
+	err = u.DO.FindInBatches(&buf, batchSize, func(tx gen.Dao, batch int) error {
+		defer func() { results = append(results, buf...) }()
+		return fc(tx, batch)
+	})
+	return results, err
+}
+
+func (u MUserPosterBatchDo) FindInBatches(result *[]*entity.UserPosterBatch, batchSize int, fc func(tx gen.Dao, batch int) error) error {
+	return u.DO.FindInBatches(result, batchSize, fc)
+}
+
+func (u MUserPosterBatchDo) Attrs(attrs ...field.AssignExpr) IUserPosterBatchDo {
+	return u.withDO(u.DO.Attrs(attrs...))
+}
+
+func (u MUserPosterBatchDo) Assign(attrs ...field.AssignExpr) IUserPosterBatchDo {
+	return u.withDO(u.DO.Assign(attrs...))
+}
+
+func (u MUserPosterBatchDo) Joins(fields ...field.RelationField) IUserPosterBatchDo {
+	for _, _f := range fields {
+		u = *u.withDO(u.DO.Joins(_f))
+	}
+	return &u
+}
+
+func (u MUserPosterBatchDo) Preload(fields ...field.RelationField) IUserPosterBatchDo {
+	for _, _f := range fields {
+		u = *u.withDO(u.DO.Preload(_f))
+	}
+	return &u
+}
+
+func (u MUserPosterBatchDo) FirstOrInit() (*entity.UserPosterBatch, error) {
+	if result, err := u.DO.FirstOrInit(); err != nil {
+		return nil, err
+	} else {
+		return result.(*entity.UserPosterBatch), nil
+	}
+}
+
+func (u MUserPosterBatchDo) FirstOrCreate() (*entity.UserPosterBatch, error) {
+	if result, err := u.DO.FirstOrCreate(); err != nil {
+		return nil, err
+	} else {
+		return result.(*entity.UserPosterBatch), nil
+	}
+}
+
+func (u MUserPosterBatchDo) FindByPage(offset int, limit int) (result []*entity.UserPosterBatch, count int64, err error) {
+	result, err = u.Offset(offset).Limit(limit).Find()
+	if err != nil {
+		return
+	}
+
+	if size := len(result); 0 < limit && 0 < size && size < limit {
+		count = int64(size + offset)
+		return
+	}
+
+	count, err = u.Offset(-1).Limit(-1).Count()
+	return
+}
+
+func (u MUserPosterBatchDo) ScanByPage(result interface{}, offset int, limit int) (count int64, err error) {
+	count, err = u.Count()
+	if err != nil {
+		return
+	}
+
+	err = u.Offset(offset).Limit(limit).Scan(result)
+	return
+}
+
+func (u MUserPosterBatchDo) Scan(result interface{}) (err error) {
+	return u.DO.Scan(result)
+}
+
+func (u MUserPosterBatchDo) Delete(models ...*entity.UserPosterBatch) (result gen.ResultInfo, err error) {
+	return u.DO.Delete(models)
+}
+
+func (u *MUserPosterBatchDo) withDO(do gen.Dao) *MUserPosterBatchDo {
+	u.DO = *do.(*gen.DO)
+	return u
+}

service/module.go

@@ -0,0 +1,26 @@
+package service
+
+import (
+	"context"
+	"icloudapp.cn/tools/service/entity"
+	"icloudapp.cn/tools/service/model"
+)
+
+type Module struct {
+	ctx   context.Context
+	query *model.MModule
+}
+
+func NewModule(ctx context.Context) *Module {
+	module := &Module{ctx: ctx}
+	module.query = model.Module
+	return module
+}
+
+func (m *Module) Info(modelID int64) (*entity.Module, error) {
+	return m.query.WithContext(m.ctx).Where(m.query.ModelID.Eq(modelID)).Take()
+}
+
+func (m *Module) Infos(modelIds ...int64) ([]*entity.Module, error) {
+	return m.query.WithContext(m.ctx).Where(m.query.ModelID.In(modelIds...)).Find()
+}

service/roles.go

@@ -0,0 +1,44 @@
+package service
+
+import (
+	"context"
+	"icloudapp.cn/tools/service/entity"
+	"icloudapp.cn/tools/service/model"
+)
+
+type Roles struct {
+	ctx context.Context
+	Base
+	query *model.MRole
+}
+
+func NewRoles(ctx context.Context) *Roles {
+	roles := &Roles{ctx: ctx}
+	roles.query = model.Role
+
+	return roles
+}
+func (r *Roles) Info(roleID int64) (*entity.Role, error) {
+	return r.query.WithContext(r.ctx).Where(r.query.RoleID.Eq(roleID)).Take()
+}
+
+func (r *Roles) Infos(rolesID ...int64) (map[int64]*entity.Role, error) {
+	roles := make(map[int64]*entity.Role, len(rolesID))
+
+	rolesInfo, err := r.query.WithContext(r.ctx).Where(r.query.RoleID.In(rolesID...)).Find()
+	if err != nil {
+		return nil, err
+	}
+
+	for _, val := range rolesInfo {
+		roles[val.RoleID] = val
+	}
+
+	for _, roleID := range rolesID {
+		if _, ok := roles[roleID]; !ok {
+			roles[roleID] = nil
+		}
+	}
+
+	return roles, nil
+}

service/user_group.go

@@ -0,0 +1,64 @@
+package service
+
+import (
+	"context"
+	"icloudapp.cn/tools/repository/mysql"
+	"icloudapp.cn/tools/service/entity"
+	"icloudapp.cn/tools/service/model"
+)
+
+type UserGroup struct {
+	ctx context.Context
+	Base
+	query *model.MUserGroup
+}
+
+type UserGroupList struct {
+	Pages Page                `json:"pages"`
+	Lists []*entity.UserGroup `json:"lists"`
+}
+
+func NewUserGroup(ctx context.Context) *UserGroup {
+	model.SetDefault(mysql.DBConn)
+	userGroup := &UserGroup{ctx: ctx}
+	userGroup.query = model.UserGroup
+	return userGroup
+}
+
+func (g *UserGroup) Info(uid int64) (*entity.UserGroup, error) {
+	return g.query.WithContext(g.ctx).Where(g.query.UID.Eq(uid)).Take()
+}
+
+// Count 获取group总数量
+func (g *UserGroup) Count() int64 {
+	count, err := g.query.WithContext(g.ctx).Count()
+	if err != nil {
+		return 0
+	}
+	return count
+}
+
+func (g *UserGroup) Scan(page, pageSize int) UserGroupList {
+	var userGroupList UserGroupList
+	count := g.Count()
+	pages := g.InitPages(count, page, pageSize)
+	userGroupList.Pages = pages
+	if pages.Count == 0 {
+
+	}
+	lists, err := g.query.WithContext(g.ctx).Offset(int(pages.LimitStart)).Limit(pages.PageSize).Find()
+	userGroupList.Lists = lists
+	if err != nil {
+		return userGroupList
+	}
+
+	return userGroupList
+}
+
+func (g *UserGroup) UserGroups(uid int64) *entity.UserGroup {
+	userGroup, err := g.query.WithContext(g.ctx).Where(g.query.UID.Eq(uid)).Take()
+	if err != nil {
+		return nil
+	}
+	return userGroup
+}

util/convert.go

@@ -0,0 +1,370 @@
+package util
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"strconv"
+	"time"
+)
+
+// RawBytes is a byte slice that holds a reference to memory owned by
+// the database itself. After a Scan into a RawBytes, the slice is only
+// valid until the next call to Next, Scan, or Close.
+type RawBytes []byte
+
+var errNilPtr = errors.New("destination pointer is nil") // embedded in descriptive error
+
+// ConvertAssign copies to dest the value in src, converting it if possible.
+// An error is returned if the copy would result in loss of information.
+// dest should be a pointer type.
+func ConvertAssign(dest, src interface{}) error {
+	// Common cases, without reflect.
+	switch s := src.(type) {
+	case string:
+		switch d := dest.(type) {
+		case *string:
+			if d == nil {
+				return errNilPtr
+			}
+			*d = s
+			return nil
+		case *[]byte:
+			if d == nil {
+				return errNilPtr
+			}
+			*d = []byte(s)
+			return nil
+		case *RawBytes:
+			if d == nil {
+				return errNilPtr
+			}
+			*d = append((*d)[:0], s...)
+			return nil
+		}
+	case []byte:
+		switch d := dest.(type) {
+		case *string:
+			if d == nil {
+				return errNilPtr
+			}
+			*d = string(s)
+			return nil
+		case *interface{}:
+			if d == nil {
+				return errNilPtr
+			}
+			*d = cloneBytes(s)
+			return nil
+		case *[]byte:
+			if d == nil {
+				return errNilPtr
+			}
+			*d = cloneBytes(s)
+			return nil
+		case *RawBytes:
+			if d == nil {
+				return errNilPtr
+			}
+			*d = s
+			return nil
+		}
+	case time.Time:
+		switch d := dest.(type) {
+		case *time.Time:
+			*d = s
+			return nil
+		case *string:
+			*d = s.Format(time.RFC3339Nano)
+			return nil
+		case *[]byte:
+			if d == nil {
+				return errNilPtr
+			}
+			*d = []byte(s.Format(time.RFC3339Nano))
+			return nil
+		case *RawBytes:
+			if d == nil {
+				return errNilPtr
+			}
+			*d = s.AppendFormat((*d)[:0], time.RFC3339Nano)
+			return nil
+		}
+	case nil:
+		switch d := dest.(type) {
+		case *interface{}:
+			if d == nil {
+				return errNilPtr
+			}
+			*d = nil
+			return nil
+		case *[]byte:
+			if d == nil {
+				return errNilPtr
+			}
+			*d = nil
+			return nil
+		case *RawBytes:
+			if d == nil {
+				return errNilPtr
+			}
+			*d = nil
+			return nil
+		}
+	}
+
+	var sv reflect.Value
+
+	switch d := dest.(type) {
+	case *string:
+		sv = reflect.ValueOf(src)
+		switch sv.Kind() {
+		case reflect.Bool,
+			reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64,
+			reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64,
+			reflect.Float32, reflect.Float64:
+			*d = asString(src)
+			return nil
+		}
+	case *[]byte:
+		sv = reflect.ValueOf(src)
+		if b, ok := asBytes(nil, sv); ok {
+			*d = b
+			return nil
+		}
+	case *RawBytes:
+		sv = reflect.ValueOf(src)
+		if b, ok := asBytes([]byte(*d)[:0], sv); ok {
+			*d = RawBytes(b)
+			return nil
+		}
+	case *bool:
+		bv, err := Bool.ConvertValue(src)
+		if err == nil {
+			*d = bv.(bool)
+		}
+		return err
+	case *interface{}:
+		*d = src
+		return nil
+	}
+
+	if scanner, ok := dest.(Scanner); ok {
+		return scanner.Scan(src)
+	}
+
+	dpv := reflect.ValueOf(dest)
+	if dpv.Kind() != reflect.Ptr {
+		return errors.New("destination not a pointer")
+	}
+	if dpv.IsNil() {
+		return errNilPtr
+	}
+
+	if !sv.IsValid() {
+		sv = reflect.ValueOf(src)
+	}
+
+	dv := reflect.Indirect(dpv)
+	if sv.IsValid() && sv.Type().AssignableTo(dv.Type()) {
+		switch b := src.(type) {
+		case []byte:
+			dv.Set(reflect.ValueOf(cloneBytes(b)))
+		default:
+			dv.Set(sv)
+		}
+		return nil
+	}
+
+	if dv.Kind() == sv.Kind() && sv.Type().ConvertibleTo(dv.Type()) {
+		dv.Set(sv.Convert(dv.Type()))
+		return nil
+	}
+
+	// The following conversions use a string value as an intermediate representation
+	// to convert between various numeric types.
+	//
+	// This also allows scanning into user defined types such as "type Int int64".
+	// For symmetry, also check for string destination types.
+	switch dv.Kind() {
+	case reflect.Ptr:
+		if src == nil {
+			dv.Set(reflect.Zero(dv.Type()))
+			return nil
+		}
+		dv.Set(reflect.New(dv.Type().Elem()))
+		return ConvertAssign(dv.Interface(), src)
+	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+		s := asString(src)
+		i64, err := strconv.ParseInt(s, 10, dv.Type().Bits())
+		if err != nil {
+			err = strconvErr(err)
+			return fmt.Errorf("converting driver.Value type %T (%q) to a %s: %v", src, s, dv.Kind(), err)
+		}
+		dv.SetInt(i64)
+		return nil
+	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
+		s := asString(src)
+		u64, err := strconv.ParseUint(s, 10, dv.Type().Bits())
+		if err != nil {
+			err = strconvErr(err)
+			return fmt.Errorf("converting driver.Value type %T (%q) to a %s: %v", src, s, dv.Kind(), err)
+		}
+		dv.SetUint(u64)
+		return nil
+	case reflect.Float32, reflect.Float64:
+		s := asString(src)
+		f64, err := strconv.ParseFloat(s, dv.Type().Bits())
+		if err != nil {
+			err = strconvErr(err)
+			return fmt.Errorf("converting driver.Value type %T (%q) to a %s: %v", src, s, dv.Kind(), err)
+		}
+		dv.SetFloat(f64)
+		return nil
+	case reflect.String:
+		switch v := src.(type) {
+		case string:
+			dv.SetString(v)
+			return nil
+		case []byte:
+			dv.SetString(string(v))
+			return nil
+		}
+	}
+
+	return fmt.Errorf("unsupported Scan, storing driver.Value type %T into type %T", src, dest)
+}
+
+func strconvErr(err error) error {
+	if ne, ok := err.(*strconv.NumError); ok {
+		return ne.Err
+	}
+	return err
+}
+
+func cloneBytes(b []byte) []byte {
+	if b == nil {
+		return nil
+	}
+	c := make([]byte, len(b))
+	copy(c, b)
+	return c
+}
+
+func asString(src interface{}) string {
+	switch v := src.(type) {
+	case string:
+		return v
+	case []byte:
+		return string(v)
+	}
+	rv := reflect.ValueOf(src)
+	switch rv.Kind() {
+	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+		return strconv.FormatInt(rv.Int(), 10)
+	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
+		return strconv.FormatUint(rv.Uint(), 10)
+	case reflect.Float64:
+		return strconv.FormatFloat(rv.Float(), 'g', -1, 64)
+	case reflect.Float32:
+		return strconv.FormatFloat(rv.Float(), 'g', -1, 32)
+	case reflect.Bool:
+		return strconv.FormatBool(rv.Bool())
+	}
+	return fmt.Sprintf("%v", src)
+}
+
+func asBytes(buf []byte, rv reflect.Value) (b []byte, ok bool) {
+	switch rv.Kind() {
+	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+		return strconv.AppendInt(buf, rv.Int(), 10), true
+	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
+		return strconv.AppendUint(buf, rv.Uint(), 10), true
+	case reflect.Float32:
+		return strconv.AppendFloat(buf, rv.Float(), 'g', -1, 32), true
+	case reflect.Float64:
+		return strconv.AppendFloat(buf, rv.Float(), 'g', -1, 64), true
+	case reflect.Bool:
+		return strconv.AppendBool(buf, rv.Bool()), true
+	case reflect.String:
+		s := rv.String()
+		return append(buf, s...), true
+	}
+	return
+}
+
+// Value is a value that drivers must be able to handle.
+// It is either nil, a type handled by a database driver's NamedValueChecker
+// interface, or an instance of one of these types:
+//
+//	int64
+//	float64
+//	bool
+//	[]byte
+//	string
+//	time.Time
+type Value interface{}
+
+type boolType struct{}
+
+var Bool boolType
+
+func (boolType) String() string { return "Bool" }
+func (boolType) ConvertValue(src interface{}) (Value, error) {
+	switch s := src.(type) {
+	case bool:
+		return s, nil
+	case string:
+		b, err := strconv.ParseBool(s)
+		if err != nil {
+			return nil, fmt.Errorf("sql/driver: couldn't convert %q into type bool", s)
+		}
+		return b, nil
+	case []byte:
+		b, err := strconv.ParseBool(string(s))
+		if err != nil {
+			return nil, fmt.Errorf("sql/driver: couldn't convert %q into type bool", s)
+		}
+		return b, nil
+	}
+
+	sv := reflect.ValueOf(src)
+	switch sv.Kind() {
+	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+		iv := sv.Int()
+		if iv == 1 || iv == 0 {
+			return iv == 1, nil
+		}
+		return nil, fmt.Errorf("sql/driver: couldn't convert %d into type bool", iv)
+	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
+		uv := sv.Uint()
+		if uv == 1 || uv == 0 {
+			return uv == 1, nil
+		}
+		return nil, fmt.Errorf("sql/driver: couldn't convert %d into type bool", uv)
+	}
+
+	return nil, fmt.Errorf("sql/driver: couldn't convert %v (%T) into type bool", src, src)
+}
+
+type Scanner interface {
+	// Scan assigns a value from a database driver.
+	//
+	// The src value will be of one of the following types:
+	//
+	//    int64
+	//    float64
+	//    bool
+	//    []byte
+	//    string
+	//    time.Time
+	//    nil - for NULL values
+	//
+	// An error should be returned if the value cannot be stored
+	// without loss of information.
+	//
+	// Reference types such as []byte are only valid until the next call to Scan
+	// and should not be retained. Their underlying memory is owned by the driver.
+	// If retention is necessary, copy their values before the next call to Scan.
+	Scan(src interface{}) error
+}

util/file/upload.go

@@ -0,0 +1,128 @@
+package file
+
+import (
+	"crypto/md5"
+	"encoding/hex"
+	"icloudapp.cn/tools/util"
+	"io"
+	"mime/multipart"
+	"os"
+	"path"
+	"strconv"
+	"strings"
+	"time"
+)
+
+type Upload struct {
+	Path    string
+	Allowed map[string]bool
+	HasHash bool
+}
+
+// FileWithErr 用于返回一组上传的文件信息
+type FileWithErr struct {
+	Err      error
+	FileInfo *File
+}
+
+type File struct {
+	//上传文件名
+	Name string `json:"name"`
+	//上传后文件路径
+	File     string `json:"file"`
+	Basename string `json:"basename"`
+	//文件大小
+	Size int64 `json:"size"`
+	//文件Hash
+	Hash string `json:"hash"`
+	//文件类型
+	Mine string `json:"mine"`
+}
+
+func NewUpload(dir string) *Upload {
+	return &Upload{
+		Path: dir,
+	}
+}
+
+// 是否返回文件的hash
+func (u *Upload) SetHasHash(hashash bool) {
+	u.HasHash = hashash
+}
+
+// 设置上传目录
+func (u *Upload) SetUploadPath(dir string) {
+	u.Path = dir
+}
+
+// 设置允许的文件类型
+func (u *Upload) SetAllowed(allowed map[string]bool) {
+	u.Allowed = allowed
+}
+
+// 追加允许的文件类型
+func (u *Upload) AppendAllow(ext string) {
+	u.Allowed[ext] = true
+}
+
+// 上传单个文件
+func (u *Upload) Single(file multipart.FileHeader) (*File, error) {
+	res := &File{}
+	extName := strings.ToLower(path.Ext(file.Filename))
+	if _, ok := u.Allowed[extName]; !ok {
+		return res, util.NewError("不允许的上传类型")
+	}
+	res.Name = file.Filename
+	res.Size = file.Size
+	res.Mine = file.Header.Get("Content-Type")
+
+	if !IsDir(u.Path) {
+		if err := os.MkdirAll(u.Path, 0750); err != nil {
+			return nil, util.NewError("目录创建失败", u.Path)
+		}
+	}
+
+	fileUnixName := strconv.FormatInt(time.Now().UnixNano(), 10)
+	res.Basename = fileUnixName + extName
+	savePath := path.Join(u.Path, res.Basename)
+	res.File = savePath
+
+	src, err := file.Open()
+	if err != nil {
+		return nil, util.NewError("文件打开失败：", err.Error())
+	}
+	defer src.Close()
+
+	out, err := os.Create(savePath)
+	if err != nil {
+		return nil, util.NewError("文件创建失败：", err.Error())
+	}
+	defer out.Close()
+	if u.HasHash {
+		res.Hash = u.FileHash(savePath)
+	}
+	_, err = io.Copy(out, src)
+	return res, nil
+}
+
+// Multiple 上传多个文件
+func (u *Upload) Multiple(files []multipart.FileHeader) ([]*FileWithErr, error) {
+	var res []*FileWithErr
+	for key, file := range files {
+		uploaded, err := u.Single(file)
+		res[key] = &FileWithErr{Err: err, FileInfo: uploaded}
+	}
+	return res, nil
+}
+
+// FileHash 获取文件的hash值
+func (u *Upload) FileHash(path string) string {
+	file, _ := os.Open(path)
+	m := md5.New()
+	_, err := io.Copy(m, file)
+	if err == nil {
+		hash := m.Sum(nil)
+		return hex.EncodeToString(hash)
+	}
+	return ""
+}

util/poster_cookie.go

@@ -0,0 +1,32 @@
+package util
+
+import (
+	"github.com/gin-gonic/gin"
+)
+
+type PosterCookie struct {
+	Cookie map[string]string
+	ctx    *gin.Context
+}
+
+// NewPosterCookie 实例化Cookie
+func NewPosterCookie(ctx *gin.Context) *PosterCookie {
+	return &PosterCookie{ctx: ctx, Cookie: map[string]string{}}
+}
+
+// SetCookie 设置cookie
+func (cookie *PosterCookie) SetCookie(name, value string, expireAt int) {
+	cookie.Cookie[name] = value
+	for key, val := range cookie.Cookie {
+		cookie.ctx.SetCookie(key, val, expireAt, "/", "", true, false)
+	}
+}
+
+// Get 获取cookie
+func (cookie *PosterCookie) Get(name string) *string {
+	val, err := cookie.ctx.Cookie(name)
+	if err != nil {
+		return nil
+	}
+	return &val
+}