🏗️ update

app/auth/api/auth.api

@@ -171,6 +171,9 @@ service auth {
 
 	@handler messageWebsocket
 	get /message
+
+	@handler fileWebsocket
+	get /file
 }
 
 @server (
@@ -249,3 +252,168 @@ service auth {
 	get /slide/generate returns (SlideCaptchaResponse)
 }
 
+type (
+	// 评论提交请求参数
+	CommentRequest {
+		Content string   `json:"content"`
+		Images  []string `json:"images,optional"`
+		TopicId string   `json:"topic_id"`
+		Author  string   `json:"author"`
+		Key     string   `json:"key"`
+		Point   []int64  `json:"point"`
+	}
+	// 回复评论提交请求参数
+	ReplyCommentRequest {
+		Content   string   `json:"content"`
+		Images    []string `json:"images,optional"`
+		TopicId   string   `json:"topic_id" `
+		ReplyId   int64    `json:"reply_id" `
+		ReplyUser string   `json:"reply_user" `
+		Author    string   `json:"author"`
+		Key       string   `json:"key"`
+		Point     []int64  `json:"point"`
+	}
+	//  回复回复请求参数
+	ReplyReplyRequest {
+		Content   string   `json:"content"`
+		Images    []string `json:"images,optional"`
+		TopicId   string   `json:"topic_id"`
+		ReplyTo   int64    `json:"reply_to"`
+		ReplyId   int64    `json:"reply_id"`
+		ReplyUser string   `json:"reply_user" `
+		Author    string   `json:"author"`
+		Key       string   `json:"key"`
+		Point     []int64  `json:"point"`
+	}
+	// 评论列表请求参数
+	CommentListRequest {
+		TopicId string `json:"topic_id"`
+		Page    int    `json:"page,default=1,optional"`
+		Size    int    `json:"size,default=5,optional"`
+		IsHot   bool   `json:"is_hot,default=true,optional"`
+	}
+	// 回复列表请求参数
+	ReplyListRequest {
+		TopicId   string `json:"topic_id"`
+		CommentId int64  `json:"comment_id"`
+		Page      int    `json:"page,default=1,optional"`
+		Size      int    `json:"size,default=5,optional"`
+	}
+	// 点赞评论的请求参数
+	CommentLikeRequest {
+		TopicId   string `json:"topic_id"`
+		CommentId int64  `json:"comment_id"`
+	}
+	CommentDisLikeRequest {
+		TopicId   string `json:"topic_id"`
+		CommentId int64  `json:"comment_id"`
+	}
+)
+
+// 响应参数
+type (
+	// CommentContent 评论内容
+	CommentContent {
+		NickName        string   `json:"nickname"`
+		Avatar          string   `json:"avatar"`
+		Level           int64    `json:"level,omitempty" default:"0"`
+		Id              int64    `json:"id"`
+		UserId          string   `json:"user_id"`
+		TopicId         string   `json:"topic_id"`
+		Content         string   `json:"content"`
+		ReplyTo         int64    `json:"reply_to,omitempty"`
+		ReplyId         int64    `json:"reply_id,omitempty"`
+		ReplyUser       string   `json:"reply_user,omitempty"`
+		ReplyNickname   string   `json:"reply_nickname,omitempty"`
+		IsAuthor        int64    `json:"is_author"`
+		Likes           int64    `json:"likes"`
+		ReplyCount      int64    `json:"reply_count"`
+		CreatedTime     string   `json:"created_time"`
+		Location        string   `json:"location"`
+		Browser         string   `json:"browser"`
+		OperatingSystem string   `json:"operating_system"`
+		IsLiked         bool     `json:"is_liked" default:"false"`
+		Images          []string `json:"images,omitempty"`
+	}
+	// CommentListPageResponse 评论返回值
+	CommentListPageResponse {
+		Size     int              `json:"size"`
+		Total    int64            `json:"total"`
+		Current  int              `json:"current"`
+		Comments []CommentContent `json:"comments"`
+	}
+	// CommentResponse 提交评论响应
+	CommentResponse {
+		Id              int64  `json:"id"`
+		Content         string `json:"content"`
+		UserId          string `json:"user_id"`
+		TopicId         string `json:"topic_id"`
+		Author          int64  `json:"author"`
+		Location        string `json:"location"`
+		Browser         string `json:"browser"`
+		OperatingSystem string `json:"operating_system"`
+		CreatedTime     string `json:"created_time"`
+		ReplyId         int64  `json:"reply_id,omitempty"`
+		ReplyUser       string `json:"reply_user,omitempty"`
+		ReplyTo         int64  `json:"reply_to,omitempty"`
+	}
+)
+
+@server (
+	group:      comment // 微服务分组
+	prefix:     /api/auth/comment // 微服务前缀
+	timeout:    10s // 超时时间
+	maxBytes:   1048576 // 最大请求大小
+	signature:  false // 是否开启签名验证
+	middleware: SecurityHeadersMiddleware,CasbinVerifyMiddleware,AuthorizationMiddleware,NonceMiddleware // 注册中间件
+	MaxConns:   true // 是否开启最大连接数限制
+	Recover:    true // 是否开启自动恢复
+	jwt:        Auth // 是否开启jwt验证
+)
+service auth {
+	@handler getCommentList
+	post /list (CommentListRequest) returns (CommentListPageResponse)
+
+	@handler getReplyList
+	post /reply/list (ReplyListRequest) returns (CommentListPageResponse)
+
+	@handler submitComment
+	post /submit (CommentRequest) returns (CommentResponse)
+
+	@handler submitReplyComment
+	post /reply/submit (ReplyCommentRequest) returns (CommentResponse)
+
+	@handler submitReplyReply
+	post /reply/reply/submit (ReplyReplyRequest) returns (CommentResponse)
+
+	@handler likeComment
+	post /like (CommentLikeRequest)
+
+	@handler dislikeComment
+	post /dislike (CommentDisLikeRequest)
+}
+
+// 上传图片请求参数
+type (
+	UploadRequest {
+		Image       string `json:"image"`
+		AccessToken string `json:"access_token"`
+		userId      string `json:"user_id"`
+	}
+)
+
+@server (
+	group:      upscale // 微服务分组
+	prefix:     /api/auth/upscale // 微服务前缀
+	timeout:    10s // 超时时间
+	maxBytes:   10485760 // 最大请求大小
+	signature:  false // 是否开启签名验证
+	middleware: SecurityHeadersMiddleware,NonceMiddleware // 注册中间件
+	MaxConns:   true // 是否开启最大连接数限制
+	Recover:    true // 是否开启自动恢复
+)
+service auth {
+	@handler uploadImage
+	post /upload (UploadRequest)
+}
+

app/auth/api/auth.go

@@ -13,7 +13,7 @@ import (
 	"schisandra-album-cloud-microservices/app/auth/api/internal/svc"
 )
 
-var configFile = flag.String("f", "etc/auth.yaml", "the config file")
+var configFile = flag.String("f", "api/etc/auth.yaml", "the config file")
 
 func main() {
 	flag.Parse()

app/auth/api/etc/auth.yaml

@@ -3,7 +3,7 @@ Name: schisandra-auth-service
 # 监听地址
 Host: 0.0.0.0
 # 监听端口
-Port: 8080
+Port: 80
 # 服务的环境，目前我们预定义了 dev。在dev 环境我们会开启反射 dev,test,rt,pre, pro
 Mode: pro
 # 打点上报，将一些 metrics 上报到对应的地址，如果为空，则不上报
@@ -64,6 +64,18 @@ Mysql:
   MaxOpenConn: 10
   # 最大空闲连接数
   MaxIdleConn: 5
+# Mongo 配置
+Mongo:
+  # MongoDB 地址
+  Uri: mongodb://1.95.0.111:27017
+  # MongoDB 用户名
+  Username: landaiqing
+  # MongoDB 密码
+  Password: LDQ20020618xxx
+  # MongoDB 数据库
+  Database: schisandra-cloud-album
+  # MongoDB 认证源
+  AuthSource: admin
 # Auth 配置
 Auth:
   # 访问密钥
@@ -77,7 +89,7 @@ Signature:
   # 签名私钥文件
   PrivateKeys:
     - Fingerprint: idm0jdoau38lwourb4pbjk4dxkat0kcx
-      KeyFile: etc/rsa_private_key.pem
+      KeyFile: api/etc/rsa_private_key.pem
 # 加密配置
 Encrypt:
   # 密钥（32）

app/auth/api/internal/config/config.go

@@ -19,6 +19,13 @@ type Config struct {
 		MaxOpenConn int
 		MaxIdleConn int
 	}
+	Mongo struct {
+		Uri        string
+		Username   string
+		Password   string
+		AuthSource string
+		Database   string
+	}
 	Redis struct {
 		Host string
 		Pass string

app/auth/api/internal/handler/comment/dislike_comment_handler.go

@@ -0,0 +1,25 @@
+package comment
+
+import (
+	"github.com/zeromicro/go-zero/rest/httpx"
+	"net/http"
+	"schisandra-album-cloud-microservices/app/auth/api/internal/logic/comment"
+	"schisandra-album-cloud-microservices/app/auth/api/internal/svc"
+	"schisandra-album-cloud-microservices/app/auth/api/internal/types"
+
+	"schisandra-album-cloud-microservices/common/xhttp"
+)
+
+func DislikeCommentHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		var req types.CommentDisLikeRequest
+		if err := httpx.Parse(r, &req); err != nil {
+			xhttp.JsonBaseResponseCtx(r.Context(), w, err)
+			return
+		}
+
+		l := comment.NewDislikeCommentLogic(r.Context(), svcCtx)
+		err := l.DislikeComment(&req)
+		xhttp.JsonBaseResponseCtx(r.Context(), w, err)
+	}
+}

app/auth/api/internal/handler/comment/get_comment_list_handler.go

@@ -0,0 +1,28 @@
+package comment
+
+import (
+	"github.com/zeromicro/go-zero/rest/httpx"
+	"net/http"
+	"schisandra-album-cloud-microservices/app/auth/api/internal/logic/comment"
+	"schisandra-album-cloud-microservices/app/auth/api/internal/svc"
+	"schisandra-album-cloud-microservices/app/auth/api/internal/types"
+	"schisandra-album-cloud-microservices/common/xhttp"
+)
+
+func GetCommentListHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		var req types.CommentListRequest
+		if err := httpx.Parse(r, &req); err != nil {
+			xhttp.JsonBaseResponseCtx(r.Context(), w, err)
+			return
+		}
+
+		l := comment.NewGetCommentListLogic(r.Context(), svcCtx)
+		resp, err := l.GetCommentList(&req)
+		if err != nil {
+			xhttp.JsonBaseResponseCtx(r.Context(), w, err)
+		} else {
+			xhttp.JsonBaseResponseCtx(r.Context(), w, resp)
+		}
+	}
+}

app/auth/api/internal/handler/comment/get_reply_list_handler.go

@@ -0,0 +1,29 @@
+package comment
+
+import (
+	"github.com/zeromicro/go-zero/rest/httpx"
+	"net/http"
+	"schisandra-album-cloud-microservices/app/auth/api/internal/logic/comment"
+	"schisandra-album-cloud-microservices/app/auth/api/internal/svc"
+	"schisandra-album-cloud-microservices/app/auth/api/internal/types"
+
+	"schisandra-album-cloud-microservices/common/xhttp"
+)
+
+func GetReplyListHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		var req types.ReplyListRequest
+		if err := httpx.Parse(r, &req); err != nil {
+			xhttp.JsonBaseResponseCtx(r.Context(), w, err)
+			return
+		}
+
+		l := comment.NewGetReplyListLogic(r.Context(), svcCtx)
+		resp, err := l.GetReplyList(&req)
+		if err != nil {
+			xhttp.JsonBaseResponseCtx(r.Context(), w, err)
+		} else {
+			xhttp.JsonBaseResponseCtx(r.Context(), w, resp)
+		}
+	}
+}

app/auth/api/internal/handler/comment/like_comment_handler.go

@@ -0,0 +1,25 @@
+package comment
+
+import (
+	"github.com/zeromicro/go-zero/rest/httpx"
+	"net/http"
+	"schisandra-album-cloud-microservices/app/auth/api/internal/logic/comment"
+	"schisandra-album-cloud-microservices/app/auth/api/internal/svc"
+	"schisandra-album-cloud-microservices/app/auth/api/internal/types"
+
+	"schisandra-album-cloud-microservices/common/xhttp"
+)
+
+func LikeCommentHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		var req types.CommentLikeRequest
+		if err := httpx.Parse(r, &req); err != nil {
+			xhttp.JsonBaseResponseCtx(r.Context(), w, err)
+			return
+		}
+
+		l := comment.NewLikeCommentLogic(r.Context(), svcCtx)
+		err := l.LikeComment(&req)
+		xhttp.JsonBaseResponseCtx(r.Context(), w, err)
+	}
+}

app/auth/api/internal/handler/comment/submit_comment_handler.go

@@ -0,0 +1,29 @@
+package comment
+
+import (
+	"github.com/zeromicro/go-zero/rest/httpx"
+	"net/http"
+	"schisandra-album-cloud-microservices/app/auth/api/internal/logic/comment"
+	"schisandra-album-cloud-microservices/app/auth/api/internal/svc"
+	"schisandra-album-cloud-microservices/app/auth/api/internal/types"
+
+	"schisandra-album-cloud-microservices/common/xhttp"
+)
+
+func SubmitCommentHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		var req types.CommentRequest
+		if err := httpx.Parse(r, &req); err != nil {
+			xhttp.JsonBaseResponseCtx(r.Context(), w, err)
+			return
+		}
+
+		l := comment.NewSubmitCommentLogic(r.Context(), svcCtx)
+		resp, err := l.SubmitComment(r, &req)
+		if err != nil {
+			xhttp.JsonBaseResponseCtx(r.Context(), w, err)
+		} else {
+			xhttp.JsonBaseResponseCtx(r.Context(), w, resp)
+		}
+	}
+}

app/auth/api/internal/handler/comment/submit_reply_comment_handler.go

@@ -0,0 +1,29 @@
+package comment
+
+import (
+	"github.com/zeromicro/go-zero/rest/httpx"
+	"net/http"
+	"schisandra-album-cloud-microservices/app/auth/api/internal/logic/comment"
+	"schisandra-album-cloud-microservices/app/auth/api/internal/svc"
+	"schisandra-album-cloud-microservices/app/auth/api/internal/types"
+
+	"schisandra-album-cloud-microservices/common/xhttp"
+)
+
+func SubmitReplyCommentHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		var req types.ReplyCommentRequest
+		if err := httpx.Parse(r, &req); err != nil {
+			xhttp.JsonBaseResponseCtx(r.Context(), w, err)
+			return
+		}
+
+		l := comment.NewSubmitReplyCommentLogic(r.Context(), svcCtx)
+		resp, err := l.SubmitReplyComment(r, &req)
+		if err != nil {
+			xhttp.JsonBaseResponseCtx(r.Context(), w, err)
+		} else {
+			xhttp.JsonBaseResponseCtx(r.Context(), w, resp)
+		}
+	}
+}

app/auth/api/internal/handler/comment/submit_reply_reply_handler.go

@@ -0,0 +1,29 @@
+package comment
+
+import (
+	"github.com/zeromicro/go-zero/rest/httpx"
+	"net/http"
+	"schisandra-album-cloud-microservices/app/auth/api/internal/logic/comment"
+	"schisandra-album-cloud-microservices/app/auth/api/internal/svc"
+	"schisandra-album-cloud-microservices/app/auth/api/internal/types"
+
+	"schisandra-album-cloud-microservices/common/xhttp"
+)
+
+func SubmitReplyReplyHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		var req types.ReplyReplyRequest
+		if err := httpx.Parse(r, &req); err != nil {
+			xhttp.JsonBaseResponseCtx(r.Context(), w, err)
+			return
+		}
+
+		l := comment.NewSubmitReplyReplyLogic(r.Context(), svcCtx)
+		resp, err := l.SubmitReplyReply(r, &req)
+		if err != nil {
+			xhttp.JsonBaseResponseCtx(r.Context(), w, err)
+		} else {
+			xhttp.JsonBaseResponseCtx(r.Context(), w, resp)
+		}
+	}
+}

app/auth/api/internal/handler/routes.go

@@ -9,9 +9,11 @@ import (
 
 	captcha "schisandra-album-cloud-microservices/app/auth/api/internal/handler/captcha"
 	client "schisandra-album-cloud-microservices/app/auth/api/internal/handler/client"
+	comment "schisandra-album-cloud-microservices/app/auth/api/internal/handler/comment"
 	oauth "schisandra-album-cloud-microservices/app/auth/api/internal/handler/oauth"
 	sms "schisandra-album-cloud-microservices/app/auth/api/internal/handler/sms"
 	token "schisandra-album-cloud-microservices/app/auth/api/internal/handler/token"
+	upscale "schisandra-album-cloud-microservices/app/auth/api/internal/handler/upscale"
 	user "schisandra-album-cloud-microservices/app/auth/api/internal/handler/user"
 	websocket "schisandra-album-cloud-microservices/app/auth/api/internal/handler/websocket"
 	"schisandra-album-cloud-microservices/app/auth/api/internal/svc"
@@ -57,6 +59,53 @@ func RegisterHandlers(server *rest.Server, serverCtx *svc.ServiceContext) {
 		rest.WithMaxBytes(1048576),
 	)
 
+	server.AddRoutes(
+		rest.WithMiddlewares(
+			[]rest.Middleware{serverCtx.SecurityHeadersMiddleware, serverCtx.CasbinVerifyMiddleware, serverCtx.AuthorizationMiddleware, serverCtx.NonceMiddleware},
+			[]rest.Route{
+				{
+					Method:  http.MethodPost,
+					Path:    "/dislike",
+					Handler: comment.DislikeCommentHandler(serverCtx),
+				},
+				{
+					Method:  http.MethodPost,
+					Path:    "/like",
+					Handler: comment.LikeCommentHandler(serverCtx),
+				},
+				{
+					Method:  http.MethodPost,
+					Path:    "/list",
+					Handler: comment.GetCommentListHandler(serverCtx),
+				},
+				{
+					Method:  http.MethodPost,
+					Path:    "/reply/list",
+					Handler: comment.GetReplyListHandler(serverCtx),
+				},
+				{
+					Method:  http.MethodPost,
+					Path:    "/reply/reply/submit",
+					Handler: comment.SubmitReplyReplyHandler(serverCtx),
+				},
+				{
+					Method:  http.MethodPost,
+					Path:    "/reply/submit",
+					Handler: comment.SubmitReplyCommentHandler(serverCtx),
+				},
+				{
+					Method:  http.MethodPost,
+					Path:    "/submit",
+					Handler: comment.SubmitCommentHandler(serverCtx),
+				},
+			}...,
+		),
+		rest.WithJwt(serverCtx.Config.Auth.AccessSecret),
+		rest.WithPrefix("/api/auth/comment"),
+		rest.WithTimeout(10000*time.Millisecond),
+		rest.WithMaxBytes(1048576),
+	)
+
 	server.AddRoutes(
 		rest.WithMiddlewares(
 			[]rest.Middleware{serverCtx.SecurityHeadersMiddleware},
@@ -151,6 +200,22 @@ func RegisterHandlers(server *rest.Server, serverCtx *svc.ServiceContext) {
 		rest.WithMaxBytes(1048576),
 	)
 
+	server.AddRoutes(
+		rest.WithMiddlewares(
+			[]rest.Middleware{serverCtx.SecurityHeadersMiddleware, serverCtx.NonceMiddleware},
+			[]rest.Route{
+				{
+					Method:  http.MethodPost,
+					Path:    "/upload",
+					Handler: upscale.UploadImageHandler(serverCtx),
+				},
+			}...,
+		),
+		rest.WithPrefix("/api/auth/upscale"),
+		rest.WithTimeout(10000*time.Millisecond),
+		rest.WithMaxBytes(10485760),
+	)
+
 	server.AddRoutes(
 		rest.WithMiddlewares(
 			[]rest.Middleware{serverCtx.SecurityHeadersMiddleware, serverCtx.NonceMiddleware},
@@ -190,6 +255,11 @@ func RegisterHandlers(server *rest.Server, serverCtx *svc.ServiceContext) {
 
 	server.AddRoutes(
 		[]rest.Route{
+			{
+				Method:  http.MethodGet,
+				Path:    "/file",
+				Handler: websocket.FileWebsocketHandler(serverCtx),
+			},
 			{
 				Method:  http.MethodGet,
 				Path:    "/message",

app/auth/api/internal/handler/upscale/upload_image_handler.go

@@ -0,0 +1,25 @@
+package upscale
+
+import (
+	"github.com/zeromicro/go-zero/rest/httpx"
+	"net/http"
+	"schisandra-album-cloud-microservices/app/auth/api/internal/logic/upscale"
+	"schisandra-album-cloud-microservices/app/auth/api/internal/svc"
+	"schisandra-album-cloud-microservices/app/auth/api/internal/types"
+
+	"schisandra-album-cloud-microservices/common/xhttp"
+)
+
+func UploadImageHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		var req types.UploadRequest
+		if err := httpx.Parse(r, &req); err != nil {
+			xhttp.JsonBaseResponseCtx(r.Context(), w, err)
+			return
+		}
+
+		l := upscale.NewUploadImageLogic(r.Context(), svcCtx)
+		err := l.UploadImage(r, &req)
+		xhttp.JsonBaseResponseCtx(r.Context(), w, err)
+	}
+}

app/auth/api/internal/handler/websocket/file_websocket_handler.go

@@ -0,0 +1,14 @@
+package websocket
+
+import (
+	"net/http"
+	"schisandra-album-cloud-microservices/app/auth/api/internal/logic/websocket"
+	"schisandra-album-cloud-microservices/app/auth/api/internal/svc"
+)
+
+func FileWebsocketHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		l := websocket.NewFileWebsocketLogic(r.Context(), svcCtx)
+		l.FileWebsocket(w, r)
+	}
+}

app/auth/api/internal/logic/comment/dislike_comment_logic.go

@@ -0,0 +1,59 @@
+package comment
+
+import (
+	"context"
+	"errors"
+	"github.com/zeromicro/go-zero/core/logx"
+	"net/http"
+	"schisandra-album-cloud-microservices/app/auth/api/internal/svc"
+	"schisandra-album-cloud-microservices/app/auth/api/internal/types"
+	errors2 "schisandra-album-cloud-microservices/common/errors"
+	"schisandra-album-cloud-microservices/common/i18n"
+)
+
+type DislikeCommentLogic struct {
+	logx.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+func NewDislikeCommentLogic(ctx context.Context, svcCtx *svc.ServiceContext) *DislikeCommentLogic {
+	return &DislikeCommentLogic{
+		Logger: logx.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *DislikeCommentLogic) DislikeComment(req *types.CommentDisLikeRequest) (err error) {
+	uid, ok := l.ctx.Value("user_id").(string)
+	if !ok {
+		return errors.New("user_id not found")
+	}
+	tx := l.svcCtx.DB.Begin()
+	commentLike := l.svcCtx.DB.ScaCommentLike
+	resultInfo, err := tx.ScaCommentLike.Where(commentLike.TopicID.Eq(req.TopicId), commentLike.CommentID.Eq(req.CommentId), commentLike.UserID.Eq(uid)).Delete()
+	if err != nil {
+		_ = tx.Rollback()
+		return err
+	}
+	if resultInfo.RowsAffected == 0 {
+		_ = tx.Rollback()
+		return errors2.New(http.StatusInternalServerError, i18n.FormatText(l.ctx, "comment.LikeError"))
+	}
+	comment := l.svcCtx.DB.ScaCommentReply
+	updates, err := tx.ScaCommentReply.Where(comment.TopicID.Eq(req.TopicId), comment.ID.Eq(req.CommentId)).Update(comment.Likes, comment.Likes.Sub(1))
+	if err != nil {
+		_ = tx.Rollback()
+		return err
+	}
+	if updates.RowsAffected == 0 {
+		_ = tx.Rollback()
+		return errors2.New(http.StatusInternalServerError, i18n.FormatText(l.ctx, "comment.LikeError"))
+	}
+	err = tx.Commit()
+	if err != nil {
+		return err
+	}
+	return nil
+}

app/auth/api/internal/logic/comment/get_comment_list_logic.go

@@ -0,0 +1,162 @@
+package comment
+
+import (
+	"context"
+	"encoding/base64"
+	"errors"
+	"fmt"
+	"schisandra-album-cloud-microservices/app/auth/api/internal/svc"
+	"schisandra-album-cloud-microservices/app/auth/api/internal/types"
+	"schisandra-album-cloud-microservices/app/auth/model/mongodb"
+	"schisandra-album-cloud-microservices/common/constant"
+	"schisandra-album-cloud-microservices/common/utils"
+	"sync"
+
+	"github.com/chenmingyong0423/go-mongox/v2/builder/query"
+	"github.com/zeromicro/go-zero/core/logx"
+	"gorm.io/gen/field"
+)
+
+type GetCommentListLogic struct {
+	logx.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+	wg     sync.WaitGroup
+}
+
+func NewGetCommentListLogic(ctx context.Context, svcCtx *svc.ServiceContext) *GetCommentListLogic {
+	return &GetCommentListLogic{
+		Logger: logx.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *GetCommentListLogic) GetCommentList(req *types.CommentListRequest) (resp *types.CommentListPageResponse, err error) {
+	// 获取用户ID
+	uid, ok := l.ctx.Value("user_id").(string)
+	if !ok {
+		return nil, errors.New("user_id not found")
+	}
+	var commentQueryList []types.CommentListQueryResult
+	comment := l.svcCtx.DB.ScaCommentReply
+	user := l.svcCtx.DB.ScaAuthUser
+	var orderConditions []field.Expr
+
+	if req.IsHot {
+		orderConditions = append(orderConditions, comment.Likes.Desc(), comment.ReplyCount.Desc())
+	} else {
+		orderConditions = append(orderConditions, comment.CreatedAt.Desc())
+	}
+	count, err := comment.Select(
+		comment.ID,
+		comment.UserID,
+		comment.TopicID,
+		comment.Content,
+		comment.CreatedAt,
+		comment.Author,
+		comment.Likes,
+		comment.ReplyCount,
+		comment.Browser,
+		comment.OperatingSystem,
+		comment.Location,
+		user.Avatar,
+		user.Nickname,
+	).LeftJoin(user, comment.UserID.EqCol(user.UID)).
+		Where(comment.TopicID.Eq(req.TopicId), comment.CommentType.Eq(constant.COMMENT)).
+		Order(orderConditions...).
+		ScanByPage(&commentQueryList, (req.Page-1)*req.Size, req.Size)
+	if err != nil {
+		return nil, err
+	}
+	if count == 0 || len(commentQueryList) == 0 {
+		return &types.CommentListPageResponse{
+			Total:    count,
+			Size:     req.Size,
+			Current:  req.Page,
+			Comments: []types.CommentContent{},
+		}, nil
+	}
+	// **************** 获取评论Id和用户Id ************
+	commentIds := make([]int64, 0, len(commentQueryList))
+	for _, commentList := range commentQueryList {
+		commentIds = append(commentIds, commentList.ID)
+	}
+	l.wg.Add(2)
+
+	// *************** 获取评论点赞状态 **********
+	likeMap := make(map[int64]bool)
+	go func() {
+		defer l.wg.Done()
+		commentLike := l.svcCtx.DB.ScaCommentLike
+		likeList, err := commentLike.Where(
+			commentLike.TopicID.Eq(req.TopicId),
+			commentLike.UserID.Eq(uid),
+			commentLike.CommentID.In(commentIds...)).
+			Find()
+		if err != nil {
+			logx.Error(err)
+			return
+		}
+		for _, like := range likeList {
+			likeMap[like.CommentID] = true
+		}
+	}()
+	// ***************获取评论图片 **********
+	commentImageMap := make(map[int64][]string)
+	go func() {
+		defer l.wg.Done()
+		newCollection := mongodb.MustNewCollection[types.CommentImages](l.svcCtx.MongoClient, constant.COMMENT_IMAGES)
+		commentImages, err := newCollection.Finder().
+			Filter(query.Eq("topic_id", req.TopicId)).
+			Filter(query.In("comment_id", commentIds...)).
+			Find(l.ctx)
+		if err != nil {
+			logx.Error(err)
+			return
+		}
+
+		for _, image := range commentImages {
+			if len(image.Images) == 0 {
+				continue
+			}
+			imagesBase64 := make([]string, len(image.Images))
+			for i, img := range image.Images {
+				imagesBase64[i] = fmt.Sprintf("data:%s;base64,%s", utils.GetMimeType(img), base64.StdEncoding.EncodeToString(img))
+			}
+			commentImageMap[image.CommentId] = imagesBase64
+		}
+	}()
+	l.wg.Wait()
+
+	// *************** 组装数据 **********
+	result := make([]types.CommentContent, 0, len(commentQueryList))
+	for _, commentData := range commentQueryList {
+		commentContent := types.CommentContent{
+			Avatar:          commentData.Avatar,
+			NickName:        commentData.Nickname,
+			Content:         commentData.Content,
+			CreatedTime:     commentData.CreatedAt.Format(constant.TimeFormat),
+			Level:           0,
+			Id:              commentData.ID,
+			UserId:          commentData.UserID,
+			TopicId:         commentData.TopicID,
+			IsAuthor:        commentData.Author,
+			Likes:           commentData.Likes,
+			ReplyCount:      commentData.ReplyCount,
+			Location:        commentData.Location,
+			Browser:         commentData.Browser,
+			OperatingSystem: commentData.OperatingSystem,
+			IsLiked:         likeMap[commentData.ID],
+			Images:          commentImageMap[commentData.ID],
+		}
+		result = append(result, commentContent)
+	}
+	commentListPageResponse := &types.CommentListPageResponse{
+		Total:    count,
+		Size:     req.Size,
+		Current:  req.Page,
+		Comments: result,
+	}
+	return commentListPageResponse, nil
+}

app/auth/api/internal/logic/comment/get_reply_list_logic.go

@@ -0,0 +1,166 @@
+package comment
+
+import (
+	"context"
+	"encoding/base64"
+	"errors"
+	"fmt"
+	"schisandra-album-cloud-microservices/app/auth/api/internal/svc"
+	"schisandra-album-cloud-microservices/app/auth/api/internal/types"
+	"schisandra-album-cloud-microservices/app/auth/model/mongodb"
+	"schisandra-album-cloud-microservices/common/constant"
+	"schisandra-album-cloud-microservices/common/utils"
+	"sync"
+
+	"github.com/chenmingyong0423/go-mongox/v2/builder/query"
+
+	"github.com/zeromicro/go-zero/core/logx"
+)
+
+type GetReplyListLogic struct {
+	logx.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+	wg     sync.WaitGroup
+}
+
+func NewGetReplyListLogic(ctx context.Context, svcCtx *svc.ServiceContext) *GetReplyListLogic {
+	return &GetReplyListLogic{
+		Logger: logx.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *GetReplyListLogic) GetReplyList(req *types.ReplyListRequest) (resp *types.CommentListPageResponse, err error) {
+	// 获取用户ID
+	uid, ok := l.ctx.Value("user_id").(string)
+	if !ok {
+		return nil, errors.New("user_id not found")
+	}
+	var replyQueryList []types.ReplyListQueryResult
+	reply := l.svcCtx.DB.ScaCommentReply
+	user := l.svcCtx.DB.ScaAuthUser
+	commentUser := user.As("comment_user")
+	replyUser := user.As("reply_user")
+
+	count, err := reply.Select(
+		reply.ID,
+		reply.UserID,
+		reply.TopicID,
+		reply.Content,
+		reply.CreatedAt,
+		reply.Author,
+		reply.ReplyCount,
+		reply.Likes,
+		reply.Browser,
+		reply.OperatingSystem,
+		reply.Location,
+		reply.ReplyUser,
+		reply.ReplyTo,
+		reply.ReplyID,
+		commentUser.Avatar,
+		commentUser.Nickname,
+		replyUser.Nickname.As("reply_nickname"),
+	).LeftJoin(commentUser, reply.UserID.EqCol(commentUser.UID)).
+		LeftJoin(replyUser, reply.ReplyUser.EqCol(replyUser.UID)).
+		Where(reply.TopicID.Eq(req.TopicId), reply.ReplyID.Eq(req.CommentId), reply.CommentType.Eq(constant.REPLY)).
+		Order(reply.Likes.Desc(), reply.CreatedAt.Desc()).
+		ScanByPage(&replyQueryList, (req.Page-1)*req.Size, req.Size)
+	if err != nil {
+		return nil, err
+	}
+	if count == 0 || len(replyQueryList) == 0 {
+		return &types.CommentListPageResponse{
+			Total:   count,
+			Size:    req.Size,
+			Current: req.Page,
+		}, nil
+	}
+	// **************** 获取评论Id和用户Id ************
+	commentIds := make([]int64, 0, len(replyQueryList))
+	for _, commentList := range replyQueryList {
+		commentIds = append(commentIds, commentList.ID)
+	}
+	l.wg.Add(2)
+
+	// *************** 获取评论点赞状态 **********
+	likeMap := make(map[int64]bool)
+	go func() {
+		defer l.wg.Done()
+		commentLike := l.svcCtx.DB.ScaCommentLike
+		likeList, err := commentLike.Where(
+			commentLike.TopicID.Eq(req.TopicId),
+			commentLike.UserID.Eq(uid),
+			commentLike.CommentID.In(commentIds...)).
+			Find()
+		if err != nil {
+			logx.Error(err)
+			return
+		}
+		for _, like := range likeList {
+			likeMap[like.CommentID] = true
+		}
+	}()
+	// ***************获取评论图片 **********
+	commentImageMap := make(map[int64][]string)
+	go func() {
+		defer l.wg.Done()
+		newCollection := mongodb.MustNewCollection[types.CommentImages](l.svcCtx.MongoClient, constant.COMMENT_IMAGES)
+		commentImages, err := newCollection.Finder().
+			Filter(query.Eq("topic_id", req.TopicId)).
+			Filter(query.In("comment_id", commentIds...)).
+			Find(l.ctx)
+		if err != nil {
+			logx.Error(err)
+			return
+		}
+
+		for _, image := range commentImages {
+			if len(image.Images) == 0 {
+				continue
+			}
+			imagesBase64 := make([]string, len(image.Images))
+			for i, img := range image.Images {
+				imagesBase64[i] = fmt.Sprintf("data:%s;base64,%s", utils.GetMimeType(img), base64.StdEncoding.EncodeToString(img))
+			}
+			commentImageMap[image.CommentId] = imagesBase64
+		}
+	}()
+	l.wg.Wait()
+
+	// *************** 组装数据 **********
+	result := make([]types.CommentContent, 0, len(replyQueryList))
+	for _, replyData := range replyQueryList {
+		commentContent := types.CommentContent{
+			Avatar:          replyData.Avatar,
+			NickName:        replyData.Nickname,
+			Content:         replyData.Content,
+			CreatedTime:     replyData.CreatedAt.Format(constant.TimeFormat),
+			Level:           0,
+			Id:              replyData.ID,
+			UserId:          replyData.UserID,
+			TopicId:         replyData.TopicID,
+			IsAuthor:        replyData.Author,
+			Likes:           replyData.Likes,
+			ReplyCount:      replyData.ReplyCount,
+			Location:        replyData.Location,
+			Browser:         replyData.Browser,
+			OperatingSystem: replyData.OperatingSystem,
+			IsLiked:         likeMap[replyData.ID],
+			Images:          commentImageMap[replyData.ID],
+			ReplyUser:       replyData.ReplyUser,
+			ReplyTo:         replyData.ReplyTo,
+			ReplyId:         replyData.ReplyId,
+			ReplyNickname:   replyData.ReplyNickname,
+		}
+		result = append(result, commentContent)
+	}
+	commentListPageResponse := &types.CommentListPageResponse{
+		Total:    count,
+		Size:     req.Size,
+		Current:  req.Page,
+		Comments: result,
+	}
+	return commentListPageResponse, nil
+}

app/auth/api/internal/logic/comment/like_comment_logic.go

@@ -0,0 +1,61 @@
+package comment
+
+import (
+	"context"
+	"errors"
+	"schisandra-album-cloud-microservices/app/auth/api/internal/svc"
+	"schisandra-album-cloud-microservices/app/auth/api/internal/types"
+	"schisandra-album-cloud-microservices/app/auth/model/mysql/model"
+	"schisandra-album-cloud-microservices/common/i18n"
+	"time"
+
+	"github.com/zeromicro/go-zero/core/logx"
+)
+
+type LikeCommentLogic struct {
+	logx.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+func NewLikeCommentLogic(ctx context.Context, svcCtx *svc.ServiceContext) *LikeCommentLogic {
+	return &LikeCommentLogic{
+		Logger: logx.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *LikeCommentLogic) LikeComment(req *types.CommentLikeRequest) (err error) {
+	uid, ok := l.ctx.Value("user_id").(string)
+	if !ok {
+		return errors.New("user_id not found")
+	}
+	tx := l.svcCtx.DB.Begin()
+	commentLike := &model.ScaCommentLike{
+		CommentID: req.CommentId,
+		TopicID:   req.TopicId,
+		UserID:    uid,
+		LikeTime:  time.Now(),
+	}
+	err = tx.ScaCommentLike.Create(commentLike)
+	if err != nil {
+		_ = tx.Rollback()
+		return err
+	}
+	comment := l.svcCtx.DB.ScaCommentReply
+	updates, err := tx.ScaCommentReply.Where(comment.TopicID.Eq(req.TopicId), comment.ID.Eq(req.CommentId)).Update(comment.Likes, comment.Likes.Add(1))
+	if err != nil {
+		_ = tx.Rollback()
+		return err
+	}
+	if updates.RowsAffected == 0 {
+		_ = tx.Rollback()
+		return errors.New(i18n.FormatText(l.ctx, "comment.LikeError"))
+	}
+	err = tx.Commit()
+	if err != nil {
+		return err
+	}
+	return nil
+}

app/auth/api/internal/logic/comment/submit_comment_logic.go

@@ -0,0 +1,125 @@
+package comment
+
+import (
+	"context"
+	"errors"
+	"net/http"
+	"schisandra-album-cloud-microservices/app/auth/api/internal/svc"
+	"schisandra-album-cloud-microservices/app/auth/api/internal/types"
+	"schisandra-album-cloud-microservices/app/auth/model/mongodb"
+	"schisandra-album-cloud-microservices/app/auth/model/mysql/model"
+
+	"schisandra-album-cloud-microservices/common/captcha/verify"
+	"schisandra-album-cloud-microservices/common/constant"
+	errors2 "schisandra-album-cloud-microservices/common/errors"
+	"schisandra-album-cloud-microservices/common/i18n"
+	"schisandra-album-cloud-microservices/common/utils"
+	"time"
+
+	"github.com/mssola/useragent"
+
+	"github.com/zeromicro/go-zero/core/logx"
+)
+
+type SubmitCommentLogic struct {
+	logx.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+func NewSubmitCommentLogic(ctx context.Context, svcCtx *svc.ServiceContext) *SubmitCommentLogic {
+	return &SubmitCommentLogic{
+		Logger: logx.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *SubmitCommentLogic) SubmitComment(r *http.Request, req *types.CommentRequest) (resp *types.CommentResponse, err error) {
+
+	res := verify.VerifySlideCaptcha(l.ctx, l.svcCtx.RedisClient, req.Point, req.Key)
+	if !res {
+		return nil, errors2.New(http.StatusInternalServerError, i18n.FormatText(l.ctx, "captcha.verificationFailure"))
+	}
+	if len(req.Images) > 3 {
+		return nil, errors2.New(http.StatusInternalServerError, i18n.FormatText(l.ctx, "comment.tooManyImages"))
+	}
+	userAgent := r.Header.Get("User-Agent")
+	if userAgent == "" {
+		return nil, errors2.New(http.StatusInternalServerError, i18n.FormatText(l.ctx, "comment.commentError"))
+	}
+	ua := useragent.New(userAgent)
+
+	ip := utils.GetClientIP(r)
+	location, err := l.svcCtx.Ip2Region.SearchByStr(ip)
+	if err != nil {
+		return nil, err
+	}
+	location = utils.RemoveZeroAndAdjust(location)
+
+	browser, _ := ua.Browser()
+	operatingSystem := ua.OS()
+	var isAuthor int64 = 0
+	uid, ok := l.ctx.Value("user_id").(string)
+	if !ok {
+		return nil, errors.New("user_id not found in context")
+	}
+	if uid == req.Author {
+		isAuthor = 1
+	}
+	xssFilterContent := utils.XssFilter(req.Content)
+	if xssFilterContent == "" {
+		return nil, errors2.New(http.StatusInternalServerError, i18n.FormatText(l.ctx, "comment.commentError"))
+	}
+	commentContent := l.svcCtx.Sensitive.Replace(xssFilterContent, '*')
+	topicType := constant.CommentTopicType
+	commentType := constant.COMMENT
+	comment := &model.ScaCommentReply{
+		Content:         commentContent,
+		UserID:          uid,
+		TopicID:         req.TopicId,
+		TopicType:       topicType,
+		CommentType:     commentType,
+		Author:          isAuthor,
+		CommentIP:       ip,
+		Location:        location,
+		Browser:         browser,
+		OperatingSystem: operatingSystem,
+		Agent:           userAgent,
+	}
+	err = l.svcCtx.DB.ScaCommentReply.Create(comment)
+	if err != nil {
+		return nil, err
+	}
+
+	if len(req.Images) > 0 {
+		imagesData, err := utils.ProcessImages(req.Images)
+		if err != nil {
+			return nil, err
+		}
+		commentImages := &types.CommentImages{
+			UserId:    uid,
+			TopicId:   req.TopicId,
+			CommentId: comment.ID,
+			Images:    imagesData,
+		}
+
+		newCollection := mongodb.MustNewCollection[types.CommentImages](l.svcCtx.MongoClient, constant.COMMENT_IMAGES)
+		_, err = newCollection.Creator().InsertOne(l.ctx, commentImages)
+		if err != nil {
+			return nil, err
+		}
+	}
+	commentResponse := &types.CommentResponse{
+		Id:              comment.ID,
+		Content:         commentContent,
+		UserId:          uid,
+		TopicId:         req.TopicId,
+		Author:          isAuthor,
+		Location:        location,
+		Browser:         browser,
+		OperatingSystem: operatingSystem,
+		CreatedTime:     time.Now().Format(constant.TimeFormat),
+	}
+	return commentResponse, nil
+}

app/auth/api/internal/logic/comment/submit_reply_comment_logic.go

@@ -0,0 +1,146 @@
+package comment
+
+import (
+	"context"
+	"errors"
+	"net/http"
+	"schisandra-album-cloud-microservices/app/auth/api/internal/svc"
+	"schisandra-album-cloud-microservices/app/auth/api/internal/types"
+	"schisandra-album-cloud-microservices/app/auth/model/mongodb"
+	"schisandra-album-cloud-microservices/app/auth/model/mysql/model"
+	"schisandra-album-cloud-microservices/common/captcha/verify"
+	"schisandra-album-cloud-microservices/common/constant"
+	errors2 "schisandra-album-cloud-microservices/common/errors"
+	"schisandra-album-cloud-microservices/common/i18n"
+	"schisandra-album-cloud-microservices/common/utils"
+	"time"
+
+	"github.com/mssola/useragent"
+
+	"github.com/zeromicro/go-zero/core/logx"
+)
+
+type SubmitReplyCommentLogic struct {
+	logx.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+func NewSubmitReplyCommentLogic(ctx context.Context, svcCtx *svc.ServiceContext) *SubmitReplyCommentLogic {
+	return &SubmitReplyCommentLogic{
+		Logger: logx.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *SubmitReplyCommentLogic) SubmitReplyComment(r *http.Request, req *types.ReplyCommentRequest) (resp *types.CommentResponse, err error) {
+	res := verify.VerifySlideCaptcha(l.ctx, l.svcCtx.RedisClient, req.Point, req.Key)
+	if !res {
+		return nil, errors2.New(http.StatusInternalServerError, i18n.FormatText(l.ctx, "captcha.verificationFailure"))
+	}
+	if len(req.Images) > 3 {
+		return nil, errors2.New(http.StatusInternalServerError, i18n.FormatText(l.ctx, "comment.tooManyImages"))
+	}
+	userAgent := r.Header.Get("User-Agent")
+	if userAgent == "" {
+		return nil, errors2.New(http.StatusInternalServerError, i18n.FormatText(l.ctx, "comment.commentError"))
+	}
+	ua := useragent.New(userAgent)
+
+	ip := utils.GetClientIP(r)
+	location, err := l.svcCtx.Ip2Region.SearchByStr(ip)
+	if err != nil {
+		return nil, err
+	}
+	location = utils.RemoveZeroAndAdjust(location)
+
+	browser, _ := ua.Browser()
+	operatingSystem := ua.OS()
+	uid, ok := l.ctx.Value("user_id").(string)
+	if !ok {
+		return nil, errors.New("user_id not found in context")
+	}
+	var isAuthor int64 = 0
+	if uid == req.Author {
+		isAuthor = 1
+	}
+
+	xssFilterContent := utils.XssFilter(req.Content)
+	if xssFilterContent == "" {
+		return nil, errors2.New(http.StatusInternalServerError, i18n.FormatText(l.ctx, "comment.commentError"))
+
+	}
+	commentContent := l.svcCtx.Sensitive.Replace(xssFilterContent, '*')
+
+	tx := l.svcCtx.DB.Begin()
+	topicType := constant.CommentTopicType
+	commentType := constant.REPLY
+	reply := &model.ScaCommentReply{
+		Content:         commentContent,
+		UserID:          uid,
+		TopicID:         req.TopicId,
+		TopicType:       topicType,
+		CommentType:     commentType,
+		Author:          isAuthor,
+		CommentIP:       ip,
+		Location:        location,
+		Browser:         browser,
+		OperatingSystem: operatingSystem,
+		Agent:           userAgent,
+		ReplyID:         req.ReplyId,
+		ReplyUser:       req.ReplyUser,
+	}
+	err = tx.ScaCommentReply.Create(reply)
+	if err != nil {
+		return nil, err
+	}
+	commentReply := l.svcCtx.DB.ScaCommentReply
+	update, err := tx.ScaCommentReply.Where(commentReply.ID.Eq(req.ReplyId)).Update(commentReply.ReplyCount, commentReply.ReplyCount.Add(1))
+	if err != nil {
+		return nil, err
+	}
+	if update.RowsAffected == 0 {
+		return nil, errors2.New(http.StatusInternalServerError, i18n.FormatText(l.ctx, "comment.commentError"))
+
+	}
+
+	if len(req.Images) > 0 {
+		imagesData, err := utils.ProcessImages(req.Images)
+		if err != nil {
+			return nil, err
+		}
+
+		commentImages := &types.CommentImages{
+			UserId:    uid,
+			TopicId:   req.TopicId,
+			CommentId: reply.ID,
+			Images:    imagesData,
+		}
+
+		newCollection := mongodb.MustNewCollection[types.CommentImages](l.svcCtx.MongoClient, constant.COMMENT_IMAGES)
+		_, err = newCollection.Creator().InsertOne(l.ctx, commentImages)
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	commentResponse := &types.CommentResponse{
+		Id:              reply.ID,
+		Content:         commentContent,
+		UserId:          uid,
+		TopicId:         reply.TopicID,
+		Author:          isAuthor,
+		Location:        location,
+		Browser:         browser,
+		OperatingSystem: operatingSystem,
+		CreatedTime:     time.Now().Format(constant.TimeFormat),
+		ReplyId:         reply.ReplyID,
+		ReplyUser:       reply.ReplyUser,
+	}
+	err = tx.Commit()
+	if err != nil {
+		return nil, err
+	}
+	return commentResponse, nil
+}

app/auth/api/internal/logic/comment/submit_reply_reply_logic.go

@@ -0,0 +1,156 @@
+package comment
+
+import (
+	"context"
+	"errors"
+	"net/http"
+	"schisandra-album-cloud-microservices/app/auth/api/internal/svc"
+	"schisandra-album-cloud-microservices/app/auth/api/internal/types"
+	"schisandra-album-cloud-microservices/app/auth/model/mongodb"
+	"schisandra-album-cloud-microservices/app/auth/model/mysql/model"
+	"schisandra-album-cloud-microservices/common/captcha/verify"
+	"schisandra-album-cloud-microservices/common/constant"
+	errors2 "schisandra-album-cloud-microservices/common/errors"
+	"schisandra-album-cloud-microservices/common/i18n"
+	"schisandra-album-cloud-microservices/common/utils"
+	"time"
+
+	"github.com/mssola/useragent"
+
+	"github.com/zeromicro/go-zero/core/logx"
+)
+
+type SubmitReplyReplyLogic struct {
+	logx.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+func NewSubmitReplyReplyLogic(ctx context.Context, svcCtx *svc.ServiceContext) *SubmitReplyReplyLogic {
+	return &SubmitReplyReplyLogic{
+		Logger: logx.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *SubmitReplyReplyLogic) SubmitReplyReply(r *http.Request, req *types.ReplyReplyRequest) (resp *types.CommentResponse, err error) {
+	res := verify.VerifySlideCaptcha(l.ctx, l.svcCtx.RedisClient, req.Point, req.Key)
+	if !res {
+		return nil, errors2.New(http.StatusInternalServerError, i18n.FormatText(l.ctx, "captcha.verificationFailure"))
+	}
+	if len(req.Images) > 3 {
+		return nil, errors2.New(http.StatusInternalServerError, i18n.FormatText(l.ctx, "comment.tooManyImages"))
+	}
+	userAgent := r.Header.Get("User-Agent")
+	if userAgent == "" {
+		return nil, errors2.New(http.StatusInternalServerError, i18n.FormatText(l.ctx, "comment.commentError"))
+	}
+	ua := useragent.New(userAgent)
+
+	// 获取客户端IP及位置信息
+	ip := utils.GetClientIP(r)
+	location, err := l.svcCtx.Ip2Region.SearchByStr(ip)
+	if err != nil {
+		return nil, err
+	}
+	location = utils.RemoveZeroAndAdjust(location)
+
+	// 获取浏览器与操作系统信息
+	browser, _ := ua.Browser()
+	operatingSystem := ua.OS()
+
+	uid, ok := l.ctx.Value("user_id").(string)
+	if !ok {
+		return nil, errors.New("user_id not found in context")
+	}
+
+	// 判断作者身份
+	var isAuthor int64 = 0
+	if uid == req.Author {
+		isAuthor = 1
+	}
+
+	// XSS过滤
+	xssFilterContent := utils.XssFilter(req.Content)
+	if xssFilterContent == "" {
+		return nil, errors2.New(http.StatusInternalServerError, i18n.FormatText(l.ctx, "comment.commentError"))
+
+	}
+	commentContent := l.svcCtx.Sensitive.Replace(xssFilterContent, '*')
+
+	tx := l.svcCtx.DB.Begin()
+	topicType := constant.CommentTopicType
+	commentType := constant.REPLY
+	replyReply := &model.ScaCommentReply{
+		Content:         commentContent,
+		UserID:          uid,
+		TopicID:         req.TopicId,
+		TopicType:       topicType,
+		CommentType:     commentType,
+		Author:          isAuthor,
+		CommentIP:       ip,
+		Location:        location,
+		Browser:         browser,
+		OperatingSystem: operatingSystem,
+		Agent:           userAgent,
+		ReplyID:         req.ReplyId,
+		ReplyUser:       req.ReplyUser,
+		ReplyTo:         req.ReplyTo,
+	}
+	err = tx.ScaCommentReply.Create(replyReply)
+	if err != nil {
+		return nil, err
+	}
+	commentReply := l.svcCtx.DB.ScaCommentReply
+	update, err := tx.ScaCommentReply.Where(commentReply.ID.Eq(req.ReplyId)).Update(commentReply.ReplyCount, commentReply.ReplyCount.Add(1))
+	if err != nil {
+		return nil, err
+	}
+	if update.RowsAffected == 0 {
+		return nil, errors2.New(http.StatusInternalServerError, i18n.FormatText(l.ctx, "comment.commentError"))
+
+	}
+
+	// 处理图片
+	if len(req.Images) > 0 {
+		imagesData, err := utils.ProcessImages(req.Images)
+		if err != nil {
+			return nil, err
+		}
+		commentImages := &types.CommentImages{
+			UserId:    uid,
+			TopicId:   req.TopicId,
+			CommentId: replyReply.ID,
+			Images:    imagesData,
+		}
+
+		newCollection := mongodb.MustNewCollection[types.CommentImages](l.svcCtx.MongoClient, constant.COMMENT_IMAGES)
+		_, err = newCollection.Creator().InsertOne(l.ctx, commentImages)
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	// 构建响应
+	commentResponse := &types.CommentResponse{
+		Id:              replyReply.ID,
+		Content:         commentContent,
+		UserId:          uid,
+		TopicId:         replyReply.TopicID,
+		Author:          isAuthor,
+		Location:        location,
+		Browser:         browser,
+		OperatingSystem: operatingSystem,
+		CreatedTime:     time.Now().Format(constant.TimeFormat),
+		ReplyId:         replyReply.ReplyID,
+		ReplyUser:       replyReply.ReplyUser,
+		ReplyTo:         replyReply.ReplyTo,
+	}
+
+	// 提交事务
+	if err = tx.Commit(); err != nil {
+		return nil, err
+	}
+	return commentResponse, nil
+}

app/auth/api/internal/logic/oauth/gitee_callback_logic.go

@@ -6,7 +6,7 @@ import (
 	"errors"
 	"fmt"
 	"net/http"
-	"schisandra-album-cloud-microservices/app/auth/api/model/mysql/model"
+	model2 "schisandra-album-cloud-microservices/app/auth/model/mysql/model"
 	"schisandra-album-cloud-microservices/common/constant"
 	"schisandra-album-cloud-microservices/common/xhttp"
 	"strconv"
@@ -119,7 +119,7 @@ func (l *GiteeCallbackLogic) GiteeCallback(r *http.Request, req *types.OAuthCall
 		// 创建用户
 		uid := idgen.NextId()
 		uidStr := strconv.FormatInt(uid, 10)
-		addUser := &model.ScaAuthUser{
+		addUser := &model2.ScaAuthUser{
 			UID:      uidStr,
 			Avatar:   giteeUser.AvatarURL,
 			Username: giteeUser.Login,
@@ -134,7 +134,7 @@ func (l *GiteeCallbackLogic) GiteeCallback(r *http.Request, req *types.OAuthCall
 			return "", err
 		}
 		gitee := constant.OAuthSourceGitee
-		newSocialUser := &model.ScaAuthUserSocial{
+		newSocialUser := &model2.ScaAuthUserSocial{
 			UserID: uidStr,
 			OpenID: Id,
 			Source: gitee,
@@ -180,7 +180,7 @@ func (l *GiteeCallbackLogic) GiteeCallback(r *http.Request, req *types.OAuthCall
 }
 
 // HandleOauthLoginResponse 处理登录响应
-func HandleOauthLoginResponse(scaAuthUser *model.ScaAuthUser, svcCtx *svc.ServiceContext, r *http.Request, ctx context.Context) (string, error) {
+func HandleOauthLoginResponse(scaAuthUser *model2.ScaAuthUser, svcCtx *svc.ServiceContext, r *http.Request, ctx context.Context) (string, error) {
 	data, err := user.HandleLoginJWT(scaAuthUser, svcCtx, true, r, ctx)
 	if err != nil {
 		return "", err

app/auth/api/internal/logic/oauth/github_callback_logic.go

@@ -6,7 +6,7 @@ import (
 	"errors"
 	"fmt"
 	"net/http"
-	"schisandra-album-cloud-microservices/app/auth/api/model/mysql/model"
+	model2 "schisandra-album-cloud-microservices/app/auth/model/mysql/model"
 	"schisandra-album-cloud-microservices/common/constant"
 	"strconv"
 
@@ -117,7 +117,7 @@ func (l *GithubCallbackLogic) GithubCallback(r *http.Request, req *types.OAuthCa
 		uidStr := strconv.FormatInt(uid, 10)
 
 		male := constant.Male
-		addUser := &model.ScaAuthUser{
+		addUser := &model2.ScaAuthUser{
 			UID:      uidStr,
 			Avatar:   gitHubUser.AvatarURL,
 			Username: gitHubUser.Login,
@@ -133,7 +133,7 @@ func (l *GithubCallbackLogic) GithubCallback(r *http.Request, req *types.OAuthCa
 			return "", err
 		}
 		githubUser := constant.OAuthSourceGithub
-		newSocialUser := &model.ScaAuthUserSocial{
+		newSocialUser := &model2.ScaAuthUserSocial{
 			UserID: uidStr,
 			OpenID: Id,
 			Source: githubUser,

app/auth/api/internal/logic/oauth/qq_callback_logic.go

@@ -6,7 +6,7 @@ import (
 	"errors"
 	"fmt"
 	"net/http"
-	"schisandra-album-cloud-microservices/app/auth/api/model/mysql/model"
+	model2 "schisandra-album-cloud-microservices/app/auth/model/mysql/model"
 	"schisandra-album-cloud-microservices/common/constant"
 	"strconv"
 	"strings"
@@ -119,7 +119,7 @@ func (l *QqCallbackLogic) QqCallback(r *http.Request, req *types.OAuthCallbackRe
 
 		male := constant.Male
 		avatarUrl := strings.Replace(qqUserInfo.FigureurlQq1, "http://", "https://", 1)
-		addUser := &model.ScaAuthUser{
+		addUser := &model2.ScaAuthUser{
 			UID:      uidStr,
 			Avatar:   avatarUrl,
 			Username: authQQme.OpenID,
@@ -133,7 +133,7 @@ func (l *QqCallbackLogic) QqCallback(r *http.Request, req *types.OAuthCallbackRe
 		}
 
 		githubUser := constant.OAuthSourceQQ
-		newSocialUser := &model.ScaAuthUserSocial{
+		newSocialUser := &model2.ScaAuthUserSocial{
 			UserID: uidStr,
 			OpenID: authQQme.OpenID,
 			Source: githubUser,

app/auth/api/internal/logic/upscale/upload_image_logic.go

@@ -0,0 +1,60 @@
+package upscale
+
+import (
+	"context"
+	"encoding/json"
+	"net/http"
+	"schisandra-album-cloud-microservices/app/auth/api/internal/logic/websocket"
+	"schisandra-album-cloud-microservices/app/auth/api/internal/svc"
+	"schisandra-album-cloud-microservices/app/auth/api/internal/types"
+
+	"schisandra-album-cloud-microservices/common/xhttp"
+
+	"schisandra-album-cloud-microservices/common/errors"
+	"schisandra-album-cloud-microservices/common/jwt"
+
+	"github.com/zeromicro/go-zero/core/logx"
+)
+
+type UploadImageLogic struct {
+	logx.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+func NewUploadImageLogic(ctx context.Context, svcCtx *svc.ServiceContext) *UploadImageLogic {
+	return &UploadImageLogic{
+		Logger: logx.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *UploadImageLogic) UploadImage(r *http.Request, req *types.UploadRequest) (err error) {
+	token, ok := jwt.ParseAccessToken(l.svcCtx.Config.Auth.AccessSecret, req.AccessToken)
+	if !ok {
+		return errors.New(http.StatusForbidden, "invalid access token")
+	}
+	if token.UserID != req.UserId {
+		return errors.New(http.StatusForbidden, "invalid user id")
+	}
+
+	correct, err := l.svcCtx.CasbinEnforcer.Enforce(req.UserId, r.URL.Path, r.Method)
+	if err != nil || !correct {
+		return errors.New(http.StatusForbidden, "permission denied")
+	}
+
+	data, err := json.Marshal(xhttp.BaseResponse[string]{
+		Data: req.Image,
+		Msg:  "success",
+		Code: http.StatusOK,
+	})
+	if err != nil {
+		return errors.New(http.StatusForbidden, err.Error())
+	}
+	err = websocket.FileWebSocketHandler.SendMessageToClient(req.UserId, data)
+	if err != nil {
+		return errors.New(http.StatusForbidden, err.Error())
+	}
+	return nil
+}

app/auth/api/internal/logic/user/account_login_logic.go

@@ -6,8 +6,8 @@ import (
 	"github.com/lionsoul2014/ip2region/binding/golang/xdb"
 	"github.com/mssola/useragent"
 	"net/http"
-	"schisandra-album-cloud-microservices/app/auth/api/model/mysql/model"
-	"schisandra-album-cloud-microservices/app/auth/api/model/mysql/query"
+	model2 "schisandra-album-cloud-microservices/app/auth/model/mysql/model"
+	query2 "schisandra-album-cloud-microservices/app/auth/model/mysql/query"
 	"schisandra-album-cloud-microservices/common/captcha/verify"
 	"schisandra-album-cloud-microservices/common/constant"
 	"schisandra-album-cloud-microservices/common/errors"
@@ -44,7 +44,7 @@ func (l *AccountLoginLogic) AccountLogin(r *http.Request, req *types.AccountLogi
 	}
 
 	user := l.svcCtx.DB.ScaAuthUser
-	var selectedUser query.IScaAuthUserDo
+	var selectedUser query2.IScaAuthUserDo
 
 	switch {
 	case utils.IsPhone(req.Account):
@@ -75,7 +75,7 @@ func (l *AccountLoginLogic) AccountLogin(r *http.Request, req *types.AccountLogi
 }
 
 // HandleLoginJWT 处理用户登录
-func HandleLoginJWT(user *model.ScaAuthUser, svcCtx *svc.ServiceContext, autoLogin bool, r *http.Request, ctx context.Context) (*types.LoginResponse, error) {
+func HandleLoginJWT(user *model2.ScaAuthUser, svcCtx *svc.ServiceContext, autoLogin bool, r *http.Request, ctx context.Context) (*types.LoginResponse, error) {
 	// 获取用户登录设备
 	err := GetUserLoginDevice(user.UID, r, svcCtx.Ip2Region, svcCtx.DB)
 	if err != nil {
@@ -124,7 +124,7 @@ func HandleLoginJWT(user *model.ScaAuthUser, svcCtx *svc.ServiceContext, autoLog
 }
 
 // GetUserLoginDevice 获取用户登录设备
-func GetUserLoginDevice(userId string, r *http.Request, ip2location *xdb.Searcher, DB *query.Query) error {
+func GetUserLoginDevice(userId string, r *http.Request, ip2location *xdb.Searcher, DB *query2.Query) error {
 	userAgent := r.UserAgent()
 	if userAgent == "" {
 		return errors2.New("user agent not found")
@@ -157,7 +157,7 @@ func GetUserLoginDevice(userId string, r *http.Request, ip2location *xdb.Searche
 	if err != nil && !errors2.Is(err, gorm.ErrRecordNotFound) {
 		return err
 	}
-	newDevice := &model.ScaAuthUserDevice{
+	newDevice := &model2.ScaAuthUserDevice{
 		UserID:          userId,
 		Bot:             newIsBot,
 		Agent:           userAgent,

app/auth/api/internal/logic/user/phone_login_logic.go

@@ -4,7 +4,7 @@ import (
 	"context"
 	"errors"
 	"net/http"
-	"schisandra-album-cloud-microservices/app/auth/api/model/mysql/model"
+	"schisandra-album-cloud-microservices/app/auth/model/mysql/model"
 	constant2 "schisandra-album-cloud-microservices/common/constant"
 	errors2 "schisandra-album-cloud-microservices/common/errors"
 	"schisandra-album-cloud-microservices/common/i18n"

app/auth/api/internal/logic/user/wechat_offiaccount_login_logic.go

@@ -6,7 +6,7 @@ import (
 	"github.com/yitter/idgenerator-go/idgen"
 	"gorm.io/gorm"
 	"net/http"
-	"schisandra-album-cloud-microservices/app/auth/api/model/mysql/model"
+	model2 "schisandra-album-cloud-microservices/app/auth/model/mysql/model"
 	"schisandra-album-cloud-microservices/common/constant"
 	"schisandra-album-cloud-microservices/common/encrypt"
 	errors2 "schisandra-album-cloud-microservices/common/errors"
@@ -61,7 +61,7 @@ func (l *WechatOffiaccountLoginLogic) WechatOffiaccountLogin(r *http.Request, re
 		avatar := utils.GenerateAvatar(uidStr)
 		name := randomname.GenerateName()
 
-		addUser := &model.ScaAuthUser{
+		addUser := &model2.ScaAuthUser{
 			UID:      uidStr,
 			Avatar:   avatar,
 			Username: Openid,
@@ -74,7 +74,7 @@ func (l *WechatOffiaccountLoginLogic) WechatOffiaccountLogin(r *http.Request, re
 			return nil, err
 		}
 
-		newSocialUser := &model.ScaAuthUserSocial{
+		newSocialUser := &model2.ScaAuthUserSocial{
 			UserID: uidStr,
 			OpenID: Openid,
 			Source: constant.OAuthSourceWechat,

app/auth/api/internal/logic/websocket/file_websocket_logic.go

@@ -0,0 +1,126 @@
+package websocket
+
+import (
+	"context"
+	"fmt"
+	"github.com/lxzan/gws"
+	"net/http"
+	"schisandra-album-cloud-microservices/app/auth/api/internal/svc"
+
+	"schisandra-album-cloud-microservices/common/jwt"
+	"time"
+
+	"github.com/zeromicro/go-zero/core/logx"
+)
+
+type FileWebsocketLogic struct {
+	logx.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+func NewFileWebsocketLogic(ctx context.Context, svcCtx *svc.ServiceContext) *FileWebsocketLogic {
+	return &FileWebsocketLogic{
+		Logger: logx.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+type FileWebSocket struct {
+	ctx context.Context
+	gws.BuiltinEventHandler
+	sessions *gws.ConcurrentMap[string, *gws.Conn]
+}
+
+var FileWebSocketHandler = NewFileWebSocket()
+
+func (l *FileWebsocketLogic) FileWebsocket(w http.ResponseWriter, r *http.Request) {
+	token := r.Header.Get("Sec-Websocket-Protocol")
+	accessToken, res := jwt.ParseAccessToken(l.svcCtx.Config.Auth.AccessSecret, token)
+	if !res {
+		return
+	}
+	upGrader := gws.NewUpgrader(FileWebSocketHandler, &gws.ServerOption{
+		HandshakeTimeout: 5 * time.Second, // 握手超时时间
+		ReadBufferSize:   1024,            // 读缓冲区大小
+		ParallelEnabled:  true,            // 开启并行消息处理
+		Recovery:         gws.Recovery,    // 开启异常恢复
+		CheckUtf8Enabled: false,           // 关闭UTF8校验
+		PermessageDeflate: gws.PermessageDeflate{
+			Enabled: true, // 开启压缩
+		},
+		Authorize: func(r *http.Request, session gws.SessionStorage) bool {
+			var clientId = r.URL.Query().Get("user_id")
+			if clientId == "" {
+				return false
+			}
+			if accessToken.UserID != clientId {
+				return false
+			}
+			session.Store("user_id", clientId)
+			return true
+		},
+		SubProtocols: []string{token},
+	})
+	socket, err := upGrader.Upgrade(w, r)
+	if err != nil {
+		panic(err)
+	}
+	go func() {
+		socket.ReadLoop()
+	}()
+}
+
+func NewFileWebSocket() *FileWebSocket {
+	return &FileWebSocket{
+		ctx:      context.Background(),
+		sessions: gws.NewConcurrentMap[string, *gws.Conn](64, 128),
+	}
+}
+
+// OnOpen 连接建立
+func (c *FileWebSocket) OnOpen(socket *gws.Conn) {
+	clientId := MustLoad[string](socket.Session(), "user_id")
+	c.sessions.Store(clientId, socket)
+	// 订阅该用户的频道
+	fmt.Printf("websocket client %s connected\n", clientId)
+}
+
+// OnClose 关闭连接
+func (c *FileWebSocket) OnClose(socket *gws.Conn, err error) {
+	name := MustLoad[string](socket.Session(), "user_id")
+	sharding := c.sessions.GetSharding(name)
+	c.sessions.Delete(name)
+	sharding.Lock()
+	defer sharding.Unlock()
+	fmt.Printf("websocket closed, name=%s, msg=%s\n", name, err.Error())
+}
+
+// OnPing 处理客户端的Ping消息
+func (c *FileWebSocket) OnPing(socket *gws.Conn, payload []byte) {
+	_ = socket.SetDeadline(time.Now().Add(PingInterval + HeartbeatWaitTimeout))
+	_ = socket.WritePong(payload)
+}
+
+// OnPong 处理客户端的Pong消息
+func (c *FileWebSocket) OnPong(_ *gws.Conn, _ []byte) {}
+
+// OnMessage 接受消息
+func (c *FileWebSocket) OnMessage(socket *gws.Conn, message *gws.Message) {
+	defer message.Close()
+	clientId := MustLoad[string](socket.Session(), "user_id")
+	if conn, ok := c.sessions.Load(clientId); ok {
+		_ = conn.WriteMessage(gws.OpcodeText, message.Bytes())
+	}
+	// fmt.Printf("received message from client %s\n", message.Data)
+}
+
+// SendMessageToClient 向指定客户端发送消息
+func (c *FileWebSocket) SendMessageToClient(clientId string, message []byte) error {
+	conn, ok := c.sessions.Load(clientId)
+	if ok {
+		return conn.WriteMessage(gws.OpcodeText, message)
+	}
+	return fmt.Errorf("client %s not found", clientId)
+}

app/auth/api/internal/svc/service_context.go

@@ -8,14 +8,18 @@ import (
 	"github.com/wenlng/go-captcha/v2/rotate"
 	"github.com/wenlng/go-captcha/v2/slide"
 	"github.com/zeromicro/go-zero/rest"
+	sensitive "github.com/zmexing/go-sensitive-word"
+	"go.mongodb.org/mongo-driver/v2/mongo"
 	"schisandra-album-cloud-microservices/app/auth/api/internal/config"
 	"schisandra-album-cloud-microservices/app/auth/api/internal/middleware"
-	"schisandra-album-cloud-microservices/app/auth/api/model/mysql"
-	"schisandra-album-cloud-microservices/app/auth/api/model/mysql/query"
+	"schisandra-album-cloud-microservices/app/auth/model/mongodb"
+	"schisandra-album-cloud-microservices/app/auth/model/mysql"
+	"schisandra-album-cloud-microservices/app/auth/model/mysql/query"
 	"schisandra-album-cloud-microservices/common/captcha/initialize"
 	"schisandra-album-cloud-microservices/common/casbinx"
 	"schisandra-album-cloud-microservices/common/ip2region"
 	"schisandra-album-cloud-microservices/common/redisx"
+	"schisandra-album-cloud-microservices/common/sensitivex"
 	"schisandra-album-cloud-microservices/common/wechat_official"
 )
 
@@ -30,9 +34,10 @@ type ServiceContext struct {
 	Ip2Region                 *xdb.Searcher
 	CasbinEnforcer            *casbin.SyncedCachedEnforcer
 	WechatOfficial            *officialAccount.OfficialAccount
-
-	RotateCaptcha rotate.Captcha
-	SlideCaptcha  slide.Captcha
+	MongoClient               *mongo.Database
+	RotateCaptcha             rotate.Captcha
+	SlideCaptcha              slide.Captcha
+	Sensitive                 *sensitive.Manager
 }
 
 func NewServiceContext(c config.Config) *ServiceContext {
@@ -52,5 +57,7 @@ func NewServiceContext(c config.Config) *ServiceContext {
 		WechatOfficial:            wechat_official.NewWechatPublic(c.Wechat.AppID, c.Wechat.AppSecret, c.Wechat.Token, c.Wechat.AESKey, c.Redis.Host, c.Redis.Pass, c.Redis.DB),
 		RotateCaptcha:             initialize.NewRotateCaptcha(),
 		SlideCaptcha:              initialize.NewSlideCaptcha(),
+		MongoClient:               mongodb.NewMongoDB(c.Mongo.Uri, c.Mongo.Username, c.Mongo.Password, c.Mongo.AuthSource, c.Mongo.Database),
+		Sensitive:                 sensitivex.NewSensitive(),
 	}
 }

app/auth/api/internal/types/comment.go

@@ -0,0 +1,54 @@
+package types
+
+import (
+	"time"
+
+	"github.com/chenmingyong0423/go-mongox/v2"
+)
+
+// CommentImages 评论 图片
+type CommentImages struct {
+	mongox.Model `bson:",inline"`
+	TopicId      string   `json:"topic_id" bson:"topic_id"`
+	CommentId    int64    `json:"comment_id" bson:"comment_id"`
+	UserId       string   `json:"user_id" bson:"user_id"`
+	Images       [][]byte `json:"images" bson:"images"`
+}
+
+// CommentListQueryResult 评论列表查询结果
+type CommentListQueryResult struct {
+	ID              int64     `json:"id"`
+	UserID          string    `json:"user_id"`
+	TopicID         string    `json:"topic_id"`
+	Content         string    `json:"content"`
+	CreatedAt       time.Time `json:"created_at"`
+	Author          int64     `json:"author"`
+	Likes           int64     `json:"likes"`
+	ReplyCount      int64     `json:"reply_count"`
+	Browser         string    `json:"browser"`
+	OperatingSystem string    `json:"operating_system"`
+	Location        string    `json:"location"`
+	Avatar          string    `json:"avatar"`
+	Nickname        string    `json:"nickname"`
+}
+
+// ReplyListQueryResult 回复列表查询结果
+type ReplyListQueryResult struct {
+	ID              int64     `json:"id"`
+	UserID          string    `json:"user_id"`
+	TopicID         string    `json:"topic_id"`
+	Content         string    `json:"content"`
+	CreatedAt       time.Time `json:"created_at"`
+	Author          int64     `json:"author"`
+	Likes           int64     `json:"likes"`
+	ReplyCount      int64     `json:"reply_count"`
+	Browser         string    `json:"browser"`
+	OperatingSystem string    `json:"operating_system"`
+	Location        string    `json:"location"`
+	Avatar          string    `json:"avatar"`
+	Nickname        string    `json:"nickname"`
+	ReplyUser       string    `json:"reply_user"`
+	ReplyId         int64     `json:"reply_id"`
+	ReplyTo         int64     `json:"reply_to"`
+	ReplyNickname   string    `json:"reply_nickname"`
+}

app/auth/api/internal/types/types.go

@@ -11,6 +11,77 @@ type AccountLoginRequest struct {
 	Key       string `json:"key"`
 }
 
+type CommentContent struct {
+	NickName        string   `json:"nickname"`
+	Avatar          string   `json:"avatar"`
+	Level           int64    `json:"level,omitempty" default:"0"`
+	Id              int64    `json:"id"`
+	UserId          string   `json:"user_id"`
+	TopicId         string   `json:"topic_id"`
+	Content         string   `json:"content"`
+	ReplyTo         int64    `json:"reply_to,omitempty"`
+	ReplyId         int64    `json:"reply_id,omitempty"`
+	ReplyUser       string   `json:"reply_user,omitempty"`
+	ReplyNickname   string   `json:"reply_nickname,omitempty"`
+	IsAuthor        int64    `json:"is_author"`
+	Likes           int64    `json:"likes"`
+	ReplyCount      int64    `json:"reply_count"`
+	CreatedTime     string   `json:"created_time"`
+	Location        string   `json:"location"`
+	Browser         string   `json:"browser"`
+	OperatingSystem string   `json:"operating_system"`
+	IsLiked         bool     `json:"is_liked" default:"false"`
+	Images          []string `json:"images,omitempty"`
+}
+
+type CommentDisLikeRequest struct {
+	TopicId   string `json:"topic_id"`
+	CommentId int64  `json:"comment_id"`
+}
+
+type CommentLikeRequest struct {
+	TopicId   string `json:"topic_id"`
+	CommentId int64  `json:"comment_id"`
+}
+
+type CommentListPageResponse struct {
+	Size     int              `json:"size"`
+	Total    int64            `json:"total"`
+	Current  int              `json:"current"`
+	Comments []CommentContent `json:"comments"`
+}
+
+type CommentListRequest struct {
+	TopicId string `json:"topic_id"`
+	Page    int    `json:"page,default=1,optional"`
+	Size    int    `json:"size,default=5,optional"`
+	IsHot   bool   `json:"is_hot,default=true,optional"`
+}
+
+type CommentRequest struct {
+	Content string   `json:"content"`
+	Images  []string `json:"images,optional"`
+	TopicId string   `json:"topic_id"`
+	Author  string   `json:"author"`
+	Key     string   `json:"key"`
+	Point   []int64  `json:"point"`
+}
+
+type CommentResponse struct {
+	Id              int64  `json:"id"`
+	Content         string `json:"content"`
+	UserId          string `json:"user_id"`
+	TopicId         string `json:"topic_id"`
+	Author          int64  `json:"author"`
+	Location        string `json:"location"`
+	Browser         string `json:"browser"`
+	OperatingSystem string `json:"operating_system"`
+	CreatedTime     string `json:"created_time"`
+	ReplyId         int64  `json:"reply_id,omitempty"`
+	ReplyUser       string `json:"reply_user,omitempty"`
+	ReplyTo         int64  `json:"reply_to,omitempty"`
+}
+
 type LoginResponse struct {
 	AccessToken string `json:"access_token"`
 	ExpireAt    int64  `json:"expire_at"`
@@ -44,6 +115,36 @@ type RefreshTokenResponse struct {
 	ExpireAt    int64  `json:"expire_at"`
 }
 
+type ReplyCommentRequest struct {
+	Content   string   `json:"content"`
+	Images    []string `json:"images,optional"`
+	TopicId   string   `json:"topic_id" `
+	ReplyId   int64    `json:"reply_id" `
+	ReplyUser string   `json:"reply_user" `
+	Author    string   `json:"author"`
+	Key       string   `json:"key"`
+	Point     []int64  `json:"point"`
+}
+
+type ReplyListRequest struct {
+	TopicId   string `json:"topic_id"`
+	CommentId int64  `json:"comment_id"`
+	Page      int    `json:"page,default=1,optional"`
+	Size      int    `json:"size,default=5,optional"`
+}
+
+type ReplyReplyRequest struct {
+	Content   string   `json:"content"`
+	Images    []string `json:"images,optional"`
+	TopicId   string   `json:"topic_id"`
+	ReplyTo   int64    `json:"reply_to"`
+	ReplyId   int64    `json:"reply_id"`
+	ReplyUser string   `json:"reply_user" `
+	Author    string   `json:"author"`
+	Key       string   `json:"key"`
+	Point     []int64  `json:"point"`
+}
+
 type ResetPasswordRequest struct {
 	Phone      string `json:"phone"`
 	Captcha    string `json:"captcha"`
@@ -73,6 +174,12 @@ type SmsSendRequest struct {
 	Key   string `json:"key"`
 }
 
+type UploadRequest struct {
+	Image       string `json:"image"`
+	AccessToken string `json:"access_token"`
+	UserId      string `json:"user_id"`
+}
+
 type WechatOffiaccountLoginRequest struct {
 	Openid   string `json:"openid"`
 	ClientId string `json:"client_id"`

app/auth/api/model/mysql/generate/generate.go

@@ -1,107 +0,0 @@
-package main
-
-import (
-	"os"
-	"path/filepath"
-	"strings"
-
-	"gorm.io/driver/mysql"
-	"gorm.io/gen"
-	"gorm.io/gen/field"
-	"gorm.io/gorm"
-)
-
-const MySQLDSN = "root:1611@(localhost:3306)/schisandra-cloud-album?charset=utf8mb4&parseTime=True&loc=Local"
-
-func main() {
-
-	// 连接数据库
-	db, err := gorm.Open(mysql.Open(MySQLDSN))
-	if err != nil {
-		panic(err)
-	}
-
-	dir, err := os.Getwd()
-	if err != nil {
-		panic(err)
-	}
-	path := filepath.Join(dir, "app/auth/api/model/mysql/", "query")
-	// 生成实例
-	g := gen.NewGenerator(gen.Config{
-		// 相对执行`go run`时的路径, 会自动创建目录
-		OutPath: path,
-		// 生成的文件名，默认gen.go
-		OutFile: "gen.go",
-		// 生成DAO代码的包名，默认是：model
-		ModelPkgPath: "model",
-		// 是否为DAO包生成单元测试代码，默认：false
-		WithUnitTest: false,
-
-		// WithDefaultQuery 生成默认查询结构体(作为全局变量使用), 即`Q`结构体和其字段(各表模型)
-		// WithoutContext 生成没有context调用限制的代码供查询
-		// WithQueryInterface 生成interface形式的查询代码(可导出), 如`Where()`方法返回的就是一个可导出的接口类型
-		Mode: gen.WithDefaultQuery | gen.WithQueryInterface | gen.WithoutContext,
-
-		// 表字段可为 null 值时, 对应结体字段使用指针类型
-		FieldNullable: false, // generate pointer when field is nullable
-
-		// 表字段默认值与模型结构体字段零值不一致的字段, 在插入数据时需要赋值该字段值为零值的, 结构体字段须是指针类型才能成功, 即`FieldCoverable:true`配置下生成的结构体字段.
-		// 因为在插入时遇到字段为零值的会被GORM赋予默认值. 如字段`age`表默认值为10, 即使你显式设置为0最后也会被GORM设为10提交.
-		// 如果该字段没有上面提到的插入时赋零值的特殊需要, 则字段为非指针类型使用起来会比较方便.
-		FieldCoverable: true,
-
-		// 模型结构体字段的数字类型的符号表示是否与表字段的一致, `false`指示都用有符号类型
-		FieldSignable: false,
-		// 生成 gorm 标签的字段索引属性
-		FieldWithIndexTag: true,
-		// 生成 gorm 标签的字段类型属性
-		FieldWithTypeTag: true,
-	})
-	// 设置目标 db
-	g.UseDB(db)
-
-	// 自定义字段的数据类型
-	// 统一数字类型为int64,兼容protobuf
-	dataMap := map[string]func(columnType gorm.ColumnType) (dataType string){
-		"tinyint":   func(columnType gorm.ColumnType) (dataType string) { return "int64" },
-		"smallint":  func(columnType gorm.ColumnType) (dataType string) { return "int64" },
-		"mediumint": func(columnType gorm.ColumnType) (dataType string) { return "int64" },
-		"bigint":    func(columnType gorm.ColumnType) (dataType string) { return "int64" },
-		"int":       func(columnType gorm.ColumnType) (dataType string) { return "int64" },
-	}
-	// 要先于`ApplyBasic`执行
-	g.WithDataTypeMap(dataMap)
-
-	// 自定义模型结体字段的标签
-	// 将特定字段名的 json 标签加上`string`属性,即 MarshalJSON 时该字段由数字类型转成字符串类型
-	jsonField := gen.FieldJSONTagWithNS(func(columnName string) (tagContent string) {
-		toStringField := `id, `
-		if strings.Contains(toStringField, columnName) {
-			return columnName + ",string"
-		}
-		return columnName
-	})
-	// 将非默认字段名的字段定义为自动时间戳和软删除字段;
-	// 自动时间戳默认字段名为:`updated_at`、`created_at, 表字段数据类型为: INT 或 DATETIME
-	// 软删除默认字段名为:`deleted_at`, 表字段数据类型为: DATETIME
-	idField := gen.FieldGORMTag("id", func(tag field.GormTag) field.GormTag {
-		return tag.Append("primary_key")
-	})
-	autoUpdateTimeField := gen.FieldGORMTag("updated_at", func(tag field.GormTag) field.GormTag {
-		return tag.Append("autoUpdateTime")
-	})
-	autoCreateTimeField := gen.FieldGORMTag("created_at", func(tag field.GormTag) field.GormTag {
-		return tag.Append("autoCreateTime")
-	})
-	softDeleteField := gen.FieldType("delete_at", "gorm.DeletedAt")
-	versionField := gen.FieldType("version", "optimisticlock.Version")
-	// 模型自定义选项组
-	fieldOpts := []gen.ModelOpt{jsonField, idField, autoUpdateTimeField, autoCreateTimeField, softDeleteField, versionField}
-
-	// 创建全部模型文件, 并覆盖前面创建的同名模型
-	allModel := g.GenerateAllTable(fieldOpts...)
-
-	g.ApplyBasic(allModel...)
-
-	g.Execute()
-}

app/auth/api/model/mysql/model/sca_auth_menu.gen.go

@@ -1,35 +0,0 @@
-// 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 (
-	"time"
-
-	"gorm.io/gorm"
-)
-
-const TableNameScaAuthMenu = "sca_auth_menu"
-
-// ScaAuthMenu mapped from table <sca_auth_menu>
-type ScaAuthMenu struct {
-	ID        int64          `gorm:"column:id;type:bigint;primaryKey;autoIncrement:true;comment:主键ID;primary_key" json:"id,string"` // 主键ID
-	MenuName  string         `gorm:"column:menu_name;type:varchar(64);comment:名称" json:"menu_name"`                                 // 名称
-	ParentID  int64          `gorm:"column:parent_id;type:bigint;comment:父ID" json:"parent_id"`                                     // 父ID
-	Type      int64          `gorm:"column:type;type:tinyint;comment:类型" json:"type"`                                               // 类型
-	Path      string         `gorm:"column:path;type:varchar(30);comment:路径" json:"path"`                                           // 路径
-	Status    int64          `gorm:"column:status;type:tinyint;comment:状态 0 启用 1 停用" json:"status"`                                 // 状态 0 启用 1 停用
-	Icon      string         `gorm:"column:icon;type:varchar(128);comment:图标" json:"icon"`                                          // 图标
-	MenuKey   string         `gorm:"column:menu_key;type:varchar(64);comment:关键字" json:"menu_key"`                                  // 关键字
-	Order_    int64          `gorm:"column:order;type:int;comment:排序" json:"order"`                                                 // 排序
-	CreatedAt time.Time      `gorm:"column:created_at;type:timestamp;autoCreateTime;comment:创建时间" json:"created_at"`                // 创建时间
-	UpdatedAt time.Time      `gorm:"column:updated_at;type:timestamp;autoUpdateTime;comment:更新时间" json:"updated_at"`                // 更新时间
-	Remark    string         `gorm:"column:remark;type:varchar(255);comment:备注 描述" json:"remark"`                                   // 备注 描述
-	DeletedAt gorm.DeletedAt `gorm:"column:deleted_at;type:timestamp;comment:删除时间" json:"deleted_at"`                               // 删除时间
-}
-
-// TableName ScaAuthMenu's table name
-func (*ScaAuthMenu) TableName() string {
-	return TableNameScaAuthMenu
-}

app/auth/api/model/mysql/model/sca_auth_permission_rule.gen.go

@@ -1,24 +0,0 @@
-// 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
-
-const TableNameScaAuthPermissionRule = "sca_auth_permission_rule"
-
-// ScaAuthPermissionRule mapped from table <sca_auth_permission_rule>
-type ScaAuthPermissionRule struct {
-	ID    int64  `gorm:"column:id;type:int;primaryKey;autoIncrement:true;primary_key" json:"id,string"`
-	Ptype string `gorm:"column:ptype;type:varchar(100);uniqueIndex:idx_sca_auth_permission_rule,priority:1;index:IDX_sca_auth_permission_rule_ptype,priority:1" json:"ptype"`
-	V0    string `gorm:"column:v0;type:varchar(100);uniqueIndex:idx_sca_auth_permission_rule,priority:2;index:IDX_sca_auth_permission_rule_v0,priority:1" json:"v0"`
-	V1    string `gorm:"column:v1;type:varchar(100);uniqueIndex:idx_sca_auth_permission_rule,priority:3;index:IDX_sca_auth_permission_rule_v1,priority:1" json:"v1"`
-	V2    string `gorm:"column:v2;type:varchar(100);uniqueIndex:idx_sca_auth_permission_rule,priority:4;index:IDX_sca_auth_permission_rule_v2,priority:1" json:"v2"`
-	V3    string `gorm:"column:v3;type:varchar(100);uniqueIndex:idx_sca_auth_permission_rule,priority:5;index:IDX_sca_auth_permission_rule_v3,priority:1" json:"v3"`
-	V4    string `gorm:"column:v4;type:varchar(100);uniqueIndex:idx_sca_auth_permission_rule,priority:6;index:IDX_sca_auth_permission_rule_v4,priority:1" json:"v4"`
-	V5    string `gorm:"column:v5;type:varchar(100);uniqueIndex:idx_sca_auth_permission_rule,priority:7;index:IDX_sca_auth_permission_rule_v5,priority:1" json:"v5"`
-}
-
-// TableName ScaAuthPermissionRule's table name
-func (*ScaAuthPermissionRule) TableName() string {
-	return TableNameScaAuthPermissionRule
-}

app/auth/api/model/mysql/model/sca_auth_role.gen.go

@@ -1,28 +0,0 @@
-// 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 (
-	"time"
-
-	"gorm.io/gorm"
-)
-
-const TableNameScaAuthRole = "sca_auth_role"
-
-// ScaAuthRole mapped from table <sca_auth_role>
-type ScaAuthRole struct {
-	ID        int64          `gorm:"column:id;type:bigint;primaryKey;autoIncrement:true;comment:主键ID;primary_key" json:"id,string"` // 主键ID
-	RoleName  string         `gorm:"column:role_name;type:varchar(32);not null;comment:角色名称" json:"role_name"`                      // 角色名称
-	RoleKey   string         `gorm:"column:role_key;type:varchar(64);not null;comment:角色关键字" json:"role_key"`                       // 角色关键字
-	CreatedAt time.Time      `gorm:"column:created_at;type:timestamp;autoCreateTime;comment:创建时间" json:"created_at"`                // 创建时间
-	UpdatedAt time.Time      `gorm:"column:updated_at;type:timestamp;autoUpdateTime;comment:更新时间" json:"updated_at"`                // 更新时间
-	DeletedAt gorm.DeletedAt `gorm:"column:deleted_at;type:timestamp;comment:删除时间" json:"deleted_at"`                               // 删除时间
-}
-
-// TableName ScaAuthRole's table name
-func (*ScaAuthRole) TableName() string {
-	return TableNameScaAuthRole
-}

app/auth/api/model/mysql/model/sca_auth_user.gen.go

@@ -1,39 +0,0 @@
-// 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 (
-	"time"
-
-	"gorm.io/gorm"
-)
-
-const TableNameScaAuthUser = "sca_auth_user"
-
-// ScaAuthUser mapped from table <sca_auth_user>
-type ScaAuthUser struct {
-	ID        int64          `gorm:"column:id;type:bigint;primaryKey;autoIncrement:true;uniqueIndex:id,priority:1;comment:自增ID;primary_key" json:"id,string"` // 自增ID
-	UID       string         `gorm:"column:uid;type:varchar(50);not null;uniqueIndex:uid,priority:1;comment:唯一ID" json:"uid"`                                 // 唯一ID
-	Username  string         `gorm:"column:username;type:varchar(32);comment:用户名" json:"username"`                                                            // 用户名
-	Nickname  string         `gorm:"column:nickname;type:varchar(32);comment:昵称" json:"nickname"`                                                             // 昵称
-	Email     string         `gorm:"column:email;type:varchar(32);comment:邮箱" json:"email"`                                                                   // 邮箱
-	Phone     string         `gorm:"column:phone;type:varchar(32);comment:电话" json:"phone"`                                                                   // 电话
-	Password  string         `gorm:"column:password;type:varchar(64);comment:密码" json:"password"`                                                             // 密码
-	Gender    int64          `gorm:"column:gender;type:tinyint;comment:性别" json:"gender"`                                                                     // 性别
-	Avatar    string         `gorm:"column:avatar;type:longtext;comment:头像" json:"avatar"`                                                                    // 头像
-	Status    int64          `gorm:"column:status;type:tinyint;comment:状态 0 正常 1 封禁" json:"status"`                                                           // 状态 0 正常 1 封禁
-	Introduce string         `gorm:"column:introduce;type:varchar(255);comment:介绍" json:"introduce"`                                                          // 介绍
-	CreatedAt time.Time      `gorm:"column:created_at;type:timestamp;autoCreateTime;comment:创建时间" json:"created_at"`                                          // 创建时间
-	Blog      string         `gorm:"column:blog;type:varchar(30);comment:博客" json:"blog"`                                                                     // 博客
-	Location  string         `gorm:"column:location;type:varchar(50);comment:地址" json:"location"`                                                             // 地址
-	Company   string         `gorm:"column:company;type:varchar(50);comment:公司" json:"company"`                                                               // 公司
-	UpdatedAt time.Time      `gorm:"column:updated_at;type:timestamp;autoUpdateTime;comment:更新时间" json:"updated_at"`                                          // 更新时间
-	DeletedAt gorm.DeletedAt `gorm:"column:deleted_at;type:timestamp;comment:删除时间" json:"deleted_at"`                                                         // 删除时间
-}
-
-// TableName ScaAuthUser's table name
-func (*ScaAuthUser) TableName() string {
-	return TableNameScaAuthUser
-}

app/auth/api/model/mysql/model/sca_auth_user_device.gen.go

@@ -1,39 +0,0 @@
-// 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 (
-	"time"
-
-	"gorm.io/gorm"
-)
-
-const TableNameScaAuthUserDevice = "sca_auth_user_device"
-
-// ScaAuthUserDevice mapped from table <sca_auth_user_device>
-type ScaAuthUserDevice struct {
-	ID              int64          `gorm:"column:id;type:bigint;primaryKey;autoIncrement:true;comment:主键ID;primary_key" json:"id,string"` // 主键ID
-	UserID          string         `gorm:"column:user_id;type:varchar(20);not null;comment:用户ID" json:"user_id"`                          // 用户ID
-	IP              string         `gorm:"column:ip;type:varchar(20);comment:登录IP" json:"ip"`                                             // 登录IP
-	Location        string         `gorm:"column:location;type:varchar(20);comment:地址" json:"location"`                                   // 地址
-	Agent           string         `gorm:"column:agent;type:varchar(255);comment:设备信息" json:"agent"`                                      // 设备信息
-	CreatedAt       time.Time      `gorm:"column:created_at;type:timestamp;autoCreateTime;comment:创建时间" json:"created_at"`                // 创建时间
-	Browser         string         `gorm:"column:browser;type:varchar(20);comment:浏览器" json:"browser"`                                    // 浏览器
-	OperatingSystem string         `gorm:"column:operating_system;type:varchar(20);comment:操作系统" json:"operating_system"`                 // 操作系统
-	BrowserVersion  string         `gorm:"column:browser_version;type:varchar(20);comment:浏览器版本" json:"browser_version"`                  // 浏览器版本
-	Mobile          int64          `gorm:"column:mobile;type:tinyint(1);comment:是否为手机 0否1是" json:"mobile"`                                // 是否为手机 0否1是
-	Bot             int64          `gorm:"column:bot;type:tinyint(1);comment:是否为bot 0否1是" json:"bot"`                                     // 是否为bot 0否1是
-	Mozilla         string         `gorm:"column:mozilla;type:varchar(10);comment:火狐版本" json:"mozilla"`                                   // 火狐版本
-	Platform        string         `gorm:"column:platform;type:varchar(20);comment:平台" json:"platform"`                                   // 平台
-	EngineName      string         `gorm:"column:engine_name;type:varchar(20);comment:引擎名称" json:"engine_name"`                           // 引擎名称
-	EngineVersion   string         `gorm:"column:engine_version;type:varchar(20);comment:引擎版本" json:"engine_version"`                     // 引擎版本
-	UpdatedAt       time.Time      `gorm:"column:updated_at;type:timestamp;autoUpdateTime;comment:更新时间" json:"updated_at"`                // 更新时间
-	DeletedAt       gorm.DeletedAt `gorm:"column:deleted_at;type:timestamp;comment:删除时间" json:"deleted_at"`                               // 删除时间
-}
-
-// TableName ScaAuthUserDevice's table name
-func (*ScaAuthUserDevice) TableName() string {
-	return TableNameScaAuthUserDevice
-}

app/auth/api/model/mysql/model/sca_auth_user_social.gen.go

@@ -1,30 +0,0 @@
-// 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 (
-	"time"
-
-	"gorm.io/gorm"
-)
-
-const TableNameScaAuthUserSocial = "sca_auth_user_social"
-
-// ScaAuthUserSocial mapped from table <sca_auth_user_social>
-type ScaAuthUserSocial struct {
-	ID        int64          `gorm:"column:id;type:bigint;primaryKey;autoIncrement:true;comment:主键ID;primary_key" json:"id,string"` // 主键ID
-	UserID    string         `gorm:"column:user_id;type:varchar(50);not null;comment:用户ID" json:"user_id"`                          // 用户ID
-	OpenID    string         `gorm:"column:open_id;type:varchar(50);not null;comment:第三方用户的 open id" json:"open_id"`                // 第三方用户的 open id
-	Source    string         `gorm:"column:source;type:varchar(10);comment:第三方用户来源" json:"source"`                                  // 第三方用户来源
-	Status    int64          `gorm:"column:status;type:bigint;comment:状态 0正常 1 封禁" json:"status"`                                   // 状态 0正常 1 封禁
-	CreatedAt time.Time      `gorm:"column:created_at;type:timestamp;autoCreateTime;comment:创建时间" json:"created_at"`                // 创建时间
-	UpdatedAt time.Time      `gorm:"column:updated_at;type:timestamp;autoUpdateTime;comment:更新时间" json:"updated_at"`                // 更新时间
-	DeletedAt gorm.DeletedAt `gorm:"column:deleted_at;type:timestamp;comment:删除时间" json:"deleted_at"`                               // 删除时间
-}
-
-// TableName ScaAuthUserSocial's table name
-func (*ScaAuthUserSocial) TableName() string {
-	return TableNameScaAuthUserSocial
-}

app/auth/api/model/mysql/model/sca_user_level.gen.go

@@ -1,33 +0,0 @@
-// 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 (
-	"time"
-
-	"gorm.io/gorm"
-)
-
-const TableNameScaUserLevel = "sca_user_level"
-
-// ScaUserLevel mapped from table <sca_user_level>
-type ScaUserLevel struct {
-	ID          int64          `gorm:"column:id;type:bigint;primaryKey;comment:主键;primary_key" json:"id,string"`                                 // 主键
-	UserID      string         `gorm:"column:user_id;type:varchar(50);comment:用户Id" json:"user_id"`                                              // 用户Id
-	LevelType   int64          `gorm:"column:level_type;type:tinyint unsigned;comment:等级类型" json:"level_type"`                                   // 等级类型
-	Level       int64          `gorm:"column:level;type:int;comment:等级" json:"level"`                                                            // 等级
-	LevelName   string         `gorm:"column:level_name;type:varchar(50);comment:等级名称" json:"level_name"`                                        // 等级名称
-	ExpStart    int64          `gorm:"column:exp_start;type:bigint;comment:开始经验值" json:"exp_start"`                                              // 开始经验值
-	ExpEnd      int64          `gorm:"column:exp_end;type:bigint;comment:结束经验值" json:"exp_end"`                                                  // 结束经验值
-	Description string         `gorm:"column:description;type:text;comment:等级描述" json:"description"`                                             // 等级描述
-	CreatedAt   *time.Time     `gorm:"column:created_at;type:timestamp;default:CURRENT_TIMESTAMP;autoCreateTime;comment:创建时间" json:"created_at"` // 创建时间
-	UpdatedAt   *time.Time     `gorm:"column:updated_at;type:timestamp;default:CURRENT_TIMESTAMP;autoUpdateTime;comment:更新时间" json:"updated_at"` // 更新时间
-	DeletedAt   gorm.DeletedAt `gorm:"column:deleted_at;type:timestamp;comment:删除时间" json:"deleted_at"`                                          // 删除时间
-}
-
-// TableName ScaUserLevel's table name
-func (*ScaUserLevel) TableName() string {
-	return TableNameScaUserLevel
-}

app/auth/api/model/mysql/model/sca_user_message.gen.go

@@ -1,31 +0,0 @@
-// 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 (
-	"time"
-
-	"gorm.io/gorm"
-)
-
-const TableNameScaUserMessage = "sca_user_message"
-
-// ScaUserMessage mapped from table <sca_user_message>
-type ScaUserMessage struct {
-	ID        int64          `gorm:"column:id;type:bigint;primaryKey;autoIncrement:true;comment:主键;primary_key" json:"id,string"` // 主键
-	TopicID   string         `gorm:"column:topic_id;type:varchar(50);comment:话题Id" json:"topic_id"`                               // 话题Id
-	FromID    string         `gorm:"column:from_id;type:varchar(50);comment:来自人" json:"from_id"`                                  // 来自人
-	ToID      string         `gorm:"column:to_id;type:varchar(50);comment:送达人" json:"to_id"`                                      // 送达人
-	Content   string         `gorm:"column:content;type:text;comment:消息内容" json:"content"`                                        // 消息内容
-	IsRead    int64          `gorm:"column:is_read;type:tinyint;comment:是否已读" json:"is_read"`                                     // 是否已读
-	CreatedAt time.Time      `gorm:"column:created_at;type:timestamp;autoCreateTime;comment:创建时间" json:"created_at"`              // 创建时间
-	UpdatedAt time.Time      `gorm:"column:updated_at;type:timestamp;autoUpdateTime;comment:更新时间" json:"updated_at"`              // 更新时间
-	DeletedAt gorm.DeletedAt `gorm:"column:deleted_at;type:timestamp;comment:删除时间" json:"deleted_at"`                             // 删除时间
-}
-
-// TableName ScaUserMessage's table name
-func (*ScaUserMessage) TableName() string {
-	return TableNameScaUserMessage
-}

app/auth/api/model/mysql/mysql.go

@@ -1,64 +0,0 @@
-package mysql
-
-import (
-	"github.com/asjdf/gorm-cache/cache"
-	"github.com/asjdf/gorm-cache/config"
-	"github.com/asjdf/gorm-cache/storage"
-	"github.com/redis/go-redis/v9"
-	"gorm.io/driver/mysql"
-	"gorm.io/gorm"
-	"gorm.io/gorm/logger"
-	"log"
-	"os"
-	"schisandra-album-cloud-microservices/app/auth/api/model/mysql/query"
-	"time"
-)
-
-func NewMySQL(url string, maxOpenConn int, maxIdleConn int, client *redis.Client) (*gorm.DB, *query.Query) {
-	db, err := gorm.Open(mysql.Open(url), &gorm.Config{
-		SkipDefaultTransaction: true,
-		PrepareStmt:            true,
-		Logger: logger.New(
-			log.New(os.Stdout, "\r\n", log.LstdFlags),
-			logger.Config{
-				SlowThreshold:             time.Second,  // 慢sql日志
-				LogLevel:                  logger.Error, // 级别
-				Colorful:                  true,         // 颜色
-				IgnoreRecordNotFoundError: true,         // 忽略RecordNotFoundError
-				ParameterizedQueries:      true,         // 格式化SQL语句
-			}),
-	})
-	if err != nil {
-		panic(err)
-	}
-	sqlDB, err := db.DB()
-	if err != nil {
-		panic(err)
-	}
-	sqlDB.SetMaxOpenConns(maxOpenConn)
-	sqlDB.SetMaxIdleConns(maxIdleConn)
-	useDB := query.Use(db)
-	// cache
-	gormCache, err := cache.NewGorm2Cache(&config.CacheConfig{
-		CacheLevel: config.CacheLevelAll,
-		CacheStorage: storage.NewRedis(&storage.RedisStoreConfig{
-			KeyPrefix: "cache",
-			Client:    client,
-		}),
-		InvalidateWhenUpdate:           true,  // when you create/update/delete objects, invalidate cache
-		CacheTTL:                       10000, // 5000 ms
-		CacheMaxItemCnt:                0,     // if length of objects retrieved one single time
-		AsyncWrite:                     true,  // async write to cache
-		DebugMode:                      false,
-		DisableCachePenetrationProtect: true, // disable cache penetration protect
-	})
-	if err != nil {
-		panic(err)
-	}
-	err = db.Use(gormCache)
-	if err != nil {
-		panic(err)
-	}
-
-	return db, useDB
-}

app/auth/api/model/mysql/query/gen.go

@@ -1,159 +0,0 @@
-// 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 query
-
-import (
-	"context"
-	"database/sql"
-
-	"gorm.io/gorm"
-
-	"gorm.io/gen"
-
-	"gorm.io/plugin/dbresolver"
-)
-
-var (
-	Q                     = new(Query)
-	ScaAuthMenu           *scaAuthMenu
-	ScaAuthPermissionRule *scaAuthPermissionRule
-	ScaAuthRole           *scaAuthRole
-	ScaAuthUser           *scaAuthUser
-	ScaAuthUserDevice     *scaAuthUserDevice
-	ScaAuthUserSocial     *scaAuthUserSocial
-	ScaUserLevel          *scaUserLevel
-	ScaUserMessage        *scaUserMessage
-)
-
-func SetDefault(db *gorm.DB, opts ...gen.DOOption) {
-	*Q = *Use(db, opts...)
-	ScaAuthMenu = &Q.ScaAuthMenu
-	ScaAuthPermissionRule = &Q.ScaAuthPermissionRule
-	ScaAuthRole = &Q.ScaAuthRole
-	ScaAuthUser = &Q.ScaAuthUser
-	ScaAuthUserDevice = &Q.ScaAuthUserDevice
-	ScaAuthUserSocial = &Q.ScaAuthUserSocial
-	ScaUserLevel = &Q.ScaUserLevel
-	ScaUserMessage = &Q.ScaUserMessage
-}
-
-func Use(db *gorm.DB, opts ...gen.DOOption) *Query {
-	return &Query{
-		db:                    db,
-		ScaAuthMenu:           newScaAuthMenu(db, opts...),
-		ScaAuthPermissionRule: newScaAuthPermissionRule(db, opts...),
-		ScaAuthRole:           newScaAuthRole(db, opts...),
-		ScaAuthUser:           newScaAuthUser(db, opts...),
-		ScaAuthUserDevice:     newScaAuthUserDevice(db, opts...),
-		ScaAuthUserSocial:     newScaAuthUserSocial(db, opts...),
-		ScaUserLevel:          newScaUserLevel(db, opts...),
-		ScaUserMessage:        newScaUserMessage(db, opts...),
-	}
-}
-
-type Query struct {
-	db *gorm.DB
-
-	ScaAuthMenu           scaAuthMenu
-	ScaAuthPermissionRule scaAuthPermissionRule
-	ScaAuthRole           scaAuthRole
-	ScaAuthUser           scaAuthUser
-	ScaAuthUserDevice     scaAuthUserDevice
-	ScaAuthUserSocial     scaAuthUserSocial
-	ScaUserLevel          scaUserLevel
-	ScaUserMessage        scaUserMessage
-}
-
-func (q *Query) Available() bool { return q.db != nil }
-
-func (q *Query) clone(db *gorm.DB) *Query {
-	return &Query{
-		db:                    db,
-		ScaAuthMenu:           q.ScaAuthMenu.clone(db),
-		ScaAuthPermissionRule: q.ScaAuthPermissionRule.clone(db),
-		ScaAuthRole:           q.ScaAuthRole.clone(db),
-		ScaAuthUser:           q.ScaAuthUser.clone(db),
-		ScaAuthUserDevice:     q.ScaAuthUserDevice.clone(db),
-		ScaAuthUserSocial:     q.ScaAuthUserSocial.clone(db),
-		ScaUserLevel:          q.ScaUserLevel.clone(db),
-		ScaUserMessage:        q.ScaUserMessage.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,
-		ScaAuthMenu:           q.ScaAuthMenu.replaceDB(db),
-		ScaAuthPermissionRule: q.ScaAuthPermissionRule.replaceDB(db),
-		ScaAuthRole:           q.ScaAuthRole.replaceDB(db),
-		ScaAuthUser:           q.ScaAuthUser.replaceDB(db),
-		ScaAuthUserDevice:     q.ScaAuthUserDevice.replaceDB(db),
-		ScaAuthUserSocial:     q.ScaAuthUserSocial.replaceDB(db),
-		ScaUserLevel:          q.ScaUserLevel.replaceDB(db),
-		ScaUserMessage:        q.ScaUserMessage.replaceDB(db),
-	}
-}
-
-type queryCtx struct {
-	ScaAuthMenu           IScaAuthMenuDo
-	ScaAuthPermissionRule IScaAuthPermissionRuleDo
-	ScaAuthRole           IScaAuthRoleDo
-	ScaAuthUser           IScaAuthUserDo
-	ScaAuthUserDevice     IScaAuthUserDeviceDo
-	ScaAuthUserSocial     IScaAuthUserSocialDo
-	ScaUserLevel          IScaUserLevelDo
-	ScaUserMessage        IScaUserMessageDo
-}
-
-func (q *Query) WithContext(ctx context.Context) *queryCtx {
-	return &queryCtx{
-		ScaAuthMenu:           q.ScaAuthMenu.WithContext(ctx),
-		ScaAuthPermissionRule: q.ScaAuthPermissionRule.WithContext(ctx),
-		ScaAuthRole:           q.ScaAuthRole.WithContext(ctx),
-		ScaAuthUser:           q.ScaAuthUser.WithContext(ctx),
-		ScaAuthUserDevice:     q.ScaAuthUserDevice.WithContext(ctx),
-		ScaAuthUserSocial:     q.ScaAuthUserSocial.WithContext(ctx),
-		ScaUserLevel:          q.ScaUserLevel.WithContext(ctx),
-		ScaUserMessage:        q.ScaUserMessage.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 {
-	tx := q.db.Begin(opts...)
-	return &QueryTx{Query: q.clone(tx), Error: tx.Error}
-}
-
-type QueryTx struct {
-	*Query
-	Error error
-}
-
-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
-}

app/auth/api/model/mysql/query/sca_auth_menu.gen.go

@@ -1,427 +0,0 @@
-// 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 query
-
-import (
-	"context"
-	"schisandra-album-cloud-microservices/app/auth/api/model/mysql/model"
-
-	"gorm.io/gorm"
-	"gorm.io/gorm/clause"
-	"gorm.io/gorm/schema"
-
-	"gorm.io/gen"
-	"gorm.io/gen/field"
-
-	"gorm.io/plugin/dbresolver"
-)
-
-func newScaAuthMenu(db *gorm.DB, opts ...gen.DOOption) scaAuthMenu {
-	_scaAuthMenu := scaAuthMenu{}
-
-	_scaAuthMenu.scaAuthMenuDo.UseDB(db, opts...)
-	_scaAuthMenu.scaAuthMenuDo.UseModel(&model.ScaAuthMenu{})
-
-	tableName := _scaAuthMenu.scaAuthMenuDo.TableName()
-	_scaAuthMenu.ALL = field.NewAsterisk(tableName)
-	_scaAuthMenu.ID = field.NewInt64(tableName, "id")
-	_scaAuthMenu.MenuName = field.NewString(tableName, "menu_name")
-	_scaAuthMenu.ParentID = field.NewInt64(tableName, "parent_id")
-	_scaAuthMenu.Type = field.NewInt64(tableName, "type")
-	_scaAuthMenu.Path = field.NewString(tableName, "path")
-	_scaAuthMenu.Status = field.NewInt64(tableName, "status")
-	_scaAuthMenu.Icon = field.NewString(tableName, "icon")
-	_scaAuthMenu.MenuKey = field.NewString(tableName, "menu_key")
-	_scaAuthMenu.Order_ = field.NewInt64(tableName, "order")
-	_scaAuthMenu.CreatedAt = field.NewTime(tableName, "created_at")
-	_scaAuthMenu.UpdatedAt = field.NewTime(tableName, "updated_at")
-	_scaAuthMenu.Remark = field.NewString(tableName, "remark")
-	_scaAuthMenu.DeletedAt = field.NewField(tableName, "deleted_at")
-
-	_scaAuthMenu.fillFieldMap()
-
-	return _scaAuthMenu
-}
-
-type scaAuthMenu struct {
-	scaAuthMenuDo
-
-	ALL       field.Asterisk
-	ID        field.Int64  // 主键ID
-	MenuName  field.String // 名称
-	ParentID  field.Int64  // 父ID
-	Type      field.Int64  // 类型
-	Path      field.String // 路径
-	Status    field.Int64  // 状态 0 启用 1 停用
-	Icon      field.String // 图标
-	MenuKey   field.String // 关键字
-	Order_    field.Int64  // 排序
-	CreatedAt field.Time   // 创建时间
-	UpdatedAt field.Time   // 更新时间
-	Remark    field.String // 备注 描述
-	DeletedAt field.Field  // 删除时间
-
-	fieldMap map[string]field.Expr
-}
-
-func (s scaAuthMenu) Table(newTableName string) *scaAuthMenu {
-	s.scaAuthMenuDo.UseTable(newTableName)
-	return s.updateTableName(newTableName)
-}
-
-func (s scaAuthMenu) As(alias string) *scaAuthMenu {
-	s.scaAuthMenuDo.DO = *(s.scaAuthMenuDo.As(alias).(*gen.DO))
-	return s.updateTableName(alias)
-}
-
-func (s *scaAuthMenu) updateTableName(table string) *scaAuthMenu {
-	s.ALL = field.NewAsterisk(table)
-	s.ID = field.NewInt64(table, "id")
-	s.MenuName = field.NewString(table, "menu_name")
-	s.ParentID = field.NewInt64(table, "parent_id")
-	s.Type = field.NewInt64(table, "type")
-	s.Path = field.NewString(table, "path")
-	s.Status = field.NewInt64(table, "status")
-	s.Icon = field.NewString(table, "icon")
-	s.MenuKey = field.NewString(table, "menu_key")
-	s.Order_ = field.NewInt64(table, "order")
-	s.CreatedAt = field.NewTime(table, "created_at")
-	s.UpdatedAt = field.NewTime(table, "updated_at")
-	s.Remark = field.NewString(table, "remark")
-	s.DeletedAt = field.NewField(table, "deleted_at")
-
-	s.fillFieldMap()
-
-	return s
-}
-
-func (s *scaAuthMenu) GetFieldByName(fieldName string) (field.OrderExpr, bool) {
-	_f, ok := s.fieldMap[fieldName]
-	if !ok || _f == nil {
-		return nil, false
-	}
-	_oe, ok := _f.(field.OrderExpr)
-	return _oe, ok
-}
-
-func (s *scaAuthMenu) fillFieldMap() {
-	s.fieldMap = make(map[string]field.Expr, 13)
-	s.fieldMap["id"] = s.ID
-	s.fieldMap["menu_name"] = s.MenuName
-	s.fieldMap["parent_id"] = s.ParentID
-	s.fieldMap["type"] = s.Type
-	s.fieldMap["path"] = s.Path
-	s.fieldMap["status"] = s.Status
-	s.fieldMap["icon"] = s.Icon
-	s.fieldMap["menu_key"] = s.MenuKey
-	s.fieldMap["order"] = s.Order_
-	s.fieldMap["created_at"] = s.CreatedAt
-	s.fieldMap["updated_at"] = s.UpdatedAt
-	s.fieldMap["remark"] = s.Remark
-	s.fieldMap["deleted_at"] = s.DeletedAt
-}
-
-func (s scaAuthMenu) clone(db *gorm.DB) scaAuthMenu {
-	s.scaAuthMenuDo.ReplaceConnPool(db.Statement.ConnPool)
-	return s
-}
-
-func (s scaAuthMenu) replaceDB(db *gorm.DB) scaAuthMenu {
-	s.scaAuthMenuDo.ReplaceDB(db)
-	return s
-}
-
-type scaAuthMenuDo struct{ gen.DO }
-
-type IScaAuthMenuDo interface {
-	gen.SubQuery
-	Debug() IScaAuthMenuDo
-	WithContext(ctx context.Context) IScaAuthMenuDo
-	WithResult(fc func(tx gen.Dao)) gen.ResultInfo
-	ReplaceDB(db *gorm.DB)
-	ReadDB() IScaAuthMenuDo
-	WriteDB() IScaAuthMenuDo
-	As(alias string) gen.Dao
-	Session(config *gorm.Session) IScaAuthMenuDo
-	Columns(cols ...field.Expr) gen.Columns
-	Clauses(conds ...clause.Expression) IScaAuthMenuDo
-	Not(conds ...gen.Condition) IScaAuthMenuDo
-	Or(conds ...gen.Condition) IScaAuthMenuDo
-	Select(conds ...field.Expr) IScaAuthMenuDo
-	Where(conds ...gen.Condition) IScaAuthMenuDo
-	Order(conds ...field.Expr) IScaAuthMenuDo
-	Distinct(cols ...field.Expr) IScaAuthMenuDo
-	Omit(cols ...field.Expr) IScaAuthMenuDo
-	Join(table schema.Tabler, on ...field.Expr) IScaAuthMenuDo
-	LeftJoin(table schema.Tabler, on ...field.Expr) IScaAuthMenuDo
-	RightJoin(table schema.Tabler, on ...field.Expr) IScaAuthMenuDo
-	Group(cols ...field.Expr) IScaAuthMenuDo
-	Having(conds ...gen.Condition) IScaAuthMenuDo
-	Limit(limit int) IScaAuthMenuDo
-	Offset(offset int) IScaAuthMenuDo
-	Count() (count int64, err error)
-	Scopes(funcs ...func(gen.Dao) gen.Dao) IScaAuthMenuDo
-	Unscoped() IScaAuthMenuDo
-	Create(values ...*model.ScaAuthMenu) error
-	CreateInBatches(values []*model.ScaAuthMenu, batchSize int) error
-	Save(values ...*model.ScaAuthMenu) error
-	First() (*model.ScaAuthMenu, error)
-	Take() (*model.ScaAuthMenu, error)
-	Last() (*model.ScaAuthMenu, error)
-	Find() ([]*model.ScaAuthMenu, error)
-	FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.ScaAuthMenu, err error)
-	FindInBatches(result *[]*model.ScaAuthMenu, batchSize int, fc func(tx gen.Dao, batch int) error) error
-	Pluck(column field.Expr, dest interface{}) error
-	Delete(...*model.ScaAuthMenu) (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) IScaAuthMenuDo
-	Assign(attrs ...field.AssignExpr) IScaAuthMenuDo
-	Joins(fields ...field.RelationField) IScaAuthMenuDo
-	Preload(fields ...field.RelationField) IScaAuthMenuDo
-	FirstOrInit() (*model.ScaAuthMenu, error)
-	FirstOrCreate() (*model.ScaAuthMenu, error)
-	FindByPage(offset int, limit int) (result []*model.ScaAuthMenu, 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) IScaAuthMenuDo
-	UnderlyingDB() *gorm.DB
-	schema.Tabler
-}
-
-func (s scaAuthMenuDo) Debug() IScaAuthMenuDo {
-	return s.withDO(s.DO.Debug())
-}
-
-func (s scaAuthMenuDo) WithContext(ctx context.Context) IScaAuthMenuDo {
-	return s.withDO(s.DO.WithContext(ctx))
-}
-
-func (s scaAuthMenuDo) ReadDB() IScaAuthMenuDo {
-	return s.Clauses(dbresolver.Read)
-}
-
-func (s scaAuthMenuDo) WriteDB() IScaAuthMenuDo {
-	return s.Clauses(dbresolver.Write)
-}
-
-func (s scaAuthMenuDo) Session(config *gorm.Session) IScaAuthMenuDo {
-	return s.withDO(s.DO.Session(config))
-}
-
-func (s scaAuthMenuDo) Clauses(conds ...clause.Expression) IScaAuthMenuDo {
-	return s.withDO(s.DO.Clauses(conds...))
-}
-
-func (s scaAuthMenuDo) Returning(value interface{}, columns ...string) IScaAuthMenuDo {
-	return s.withDO(s.DO.Returning(value, columns...))
-}
-
-func (s scaAuthMenuDo) Not(conds ...gen.Condition) IScaAuthMenuDo {
-	return s.withDO(s.DO.Not(conds...))
-}
-
-func (s scaAuthMenuDo) Or(conds ...gen.Condition) IScaAuthMenuDo {
-	return s.withDO(s.DO.Or(conds...))
-}
-
-func (s scaAuthMenuDo) Select(conds ...field.Expr) IScaAuthMenuDo {
-	return s.withDO(s.DO.Select(conds...))
-}
-
-func (s scaAuthMenuDo) Where(conds ...gen.Condition) IScaAuthMenuDo {
-	return s.withDO(s.DO.Where(conds...))
-}
-
-func (s scaAuthMenuDo) Order(conds ...field.Expr) IScaAuthMenuDo {
-	return s.withDO(s.DO.Order(conds...))
-}
-
-func (s scaAuthMenuDo) Distinct(cols ...field.Expr) IScaAuthMenuDo {
-	return s.withDO(s.DO.Distinct(cols...))
-}
-
-func (s scaAuthMenuDo) Omit(cols ...field.Expr) IScaAuthMenuDo {
-	return s.withDO(s.DO.Omit(cols...))
-}
-
-func (s scaAuthMenuDo) Join(table schema.Tabler, on ...field.Expr) IScaAuthMenuDo {
-	return s.withDO(s.DO.Join(table, on...))
-}
-
-func (s scaAuthMenuDo) LeftJoin(table schema.Tabler, on ...field.Expr) IScaAuthMenuDo {
-	return s.withDO(s.DO.LeftJoin(table, on...))
-}
-
-func (s scaAuthMenuDo) RightJoin(table schema.Tabler, on ...field.Expr) IScaAuthMenuDo {
-	return s.withDO(s.DO.RightJoin(table, on...))
-}
-
-func (s scaAuthMenuDo) Group(cols ...field.Expr) IScaAuthMenuDo {
-	return s.withDO(s.DO.Group(cols...))
-}
-
-func (s scaAuthMenuDo) Having(conds ...gen.Condition) IScaAuthMenuDo {
-	return s.withDO(s.DO.Having(conds...))
-}
-
-func (s scaAuthMenuDo) Limit(limit int) IScaAuthMenuDo {
-	return s.withDO(s.DO.Limit(limit))
-}
-
-func (s scaAuthMenuDo) Offset(offset int) IScaAuthMenuDo {
-	return s.withDO(s.DO.Offset(offset))
-}
-
-func (s scaAuthMenuDo) Scopes(funcs ...func(gen.Dao) gen.Dao) IScaAuthMenuDo {
-	return s.withDO(s.DO.Scopes(funcs...))
-}
-
-func (s scaAuthMenuDo) Unscoped() IScaAuthMenuDo {
-	return s.withDO(s.DO.Unscoped())
-}
-
-func (s scaAuthMenuDo) Create(values ...*model.ScaAuthMenu) error {
-	if len(values) == 0 {
-		return nil
-	}
-	return s.DO.Create(values)
-}
-
-func (s scaAuthMenuDo) CreateInBatches(values []*model.ScaAuthMenu, batchSize int) error {
-	return s.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 (s scaAuthMenuDo) Save(values ...*model.ScaAuthMenu) error {
-	if len(values) == 0 {
-		return nil
-	}
-	return s.DO.Save(values)
-}
-
-func (s scaAuthMenuDo) First() (*model.ScaAuthMenu, error) {
-	if result, err := s.DO.First(); err != nil {
-		return nil, err
-	} else {
-		return result.(*model.ScaAuthMenu), nil
-	}
-}
-
-func (s scaAuthMenuDo) Take() (*model.ScaAuthMenu, error) {
-	if result, err := s.DO.Take(); err != nil {
-		return nil, err
-	} else {
-		return result.(*model.ScaAuthMenu), nil
-	}
-}
-
-func (s scaAuthMenuDo) Last() (*model.ScaAuthMenu, error) {
-	if result, err := s.DO.Last(); err != nil {
-		return nil, err
-	} else {
-		return result.(*model.ScaAuthMenu), nil
-	}
-}
-
-func (s scaAuthMenuDo) Find() ([]*model.ScaAuthMenu, error) {
-	result, err := s.DO.Find()
-	return result.([]*model.ScaAuthMenu), err
-}
-
-func (s scaAuthMenuDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.ScaAuthMenu, err error) {
-	buf := make([]*model.ScaAuthMenu, 0, batchSize)
-	err = s.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 (s scaAuthMenuDo) FindInBatches(result *[]*model.ScaAuthMenu, batchSize int, fc func(tx gen.Dao, batch int) error) error {
-	return s.DO.FindInBatches(result, batchSize, fc)
-}
-
-func (s scaAuthMenuDo) Attrs(attrs ...field.AssignExpr) IScaAuthMenuDo {
-	return s.withDO(s.DO.Attrs(attrs...))
-}
-
-func (s scaAuthMenuDo) Assign(attrs ...field.AssignExpr) IScaAuthMenuDo {
-	return s.withDO(s.DO.Assign(attrs...))
-}
-
-func (s scaAuthMenuDo) Joins(fields ...field.RelationField) IScaAuthMenuDo {
-	for _, _f := range fields {
-		s = *s.withDO(s.DO.Joins(_f))
-	}
-	return &s
-}
-
-func (s scaAuthMenuDo) Preload(fields ...field.RelationField) IScaAuthMenuDo {
-	for _, _f := range fields {
-		s = *s.withDO(s.DO.Preload(_f))
-	}
-	return &s
-}
-
-func (s scaAuthMenuDo) FirstOrInit() (*model.ScaAuthMenu, error) {
-	if result, err := s.DO.FirstOrInit(); err != nil {
-		return nil, err
-	} else {
-		return result.(*model.ScaAuthMenu), nil
-	}
-}
-
-func (s scaAuthMenuDo) FirstOrCreate() (*model.ScaAuthMenu, error) {
-	if result, err := s.DO.FirstOrCreate(); err != nil {
-		return nil, err
-	} else {
-		return result.(*model.ScaAuthMenu), nil
-	}
-}
-
-func (s scaAuthMenuDo) FindByPage(offset int, limit int) (result []*model.ScaAuthMenu, count int64, err error) {
-	result, err = s.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 = s.Offset(-1).Limit(-1).Count()
-	return
-}
-
-func (s scaAuthMenuDo) ScanByPage(result interface{}, offset int, limit int) (count int64, err error) {
-	count, err = s.Count()
-	if err != nil {
-		return
-	}
-
-	err = s.Offset(offset).Limit(limit).Scan(result)
-	return
-}
-
-func (s scaAuthMenuDo) Scan(result interface{}) (err error) {
-	return s.DO.Scan(result)
-}
-
-func (s scaAuthMenuDo) Delete(models ...*model.ScaAuthMenu) (result gen.ResultInfo, err error) {
-	return s.DO.Delete(models)
-}
-
-func (s *scaAuthMenuDo) withDO(do gen.Dao) *scaAuthMenuDo {
-	s.DO = *do.(*gen.DO)
-	return s
-}

app/auth/api/model/mysql/query/sca_auth_permission_rule.gen.go

@@ -1,407 +0,0 @@
-// 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 query
-
-import (
-	"context"
-	"schisandra-album-cloud-microservices/app/auth/api/model/mysql/model"
-
-	"gorm.io/gorm"
-	"gorm.io/gorm/clause"
-	"gorm.io/gorm/schema"
-
-	"gorm.io/gen"
-	"gorm.io/gen/field"
-
-	"gorm.io/plugin/dbresolver"
-)
-
-func newScaAuthPermissionRule(db *gorm.DB, opts ...gen.DOOption) scaAuthPermissionRule {
-	_scaAuthPermissionRule := scaAuthPermissionRule{}
-
-	_scaAuthPermissionRule.scaAuthPermissionRuleDo.UseDB(db, opts...)
-	_scaAuthPermissionRule.scaAuthPermissionRuleDo.UseModel(&model.ScaAuthPermissionRule{})
-
-	tableName := _scaAuthPermissionRule.scaAuthPermissionRuleDo.TableName()
-	_scaAuthPermissionRule.ALL = field.NewAsterisk(tableName)
-	_scaAuthPermissionRule.ID = field.NewInt64(tableName, "id")
-	_scaAuthPermissionRule.Ptype = field.NewString(tableName, "ptype")
-	_scaAuthPermissionRule.V0 = field.NewString(tableName, "v0")
-	_scaAuthPermissionRule.V1 = field.NewString(tableName, "v1")
-	_scaAuthPermissionRule.V2 = field.NewString(tableName, "v2")
-	_scaAuthPermissionRule.V3 = field.NewString(tableName, "v3")
-	_scaAuthPermissionRule.V4 = field.NewString(tableName, "v4")
-	_scaAuthPermissionRule.V5 = field.NewString(tableName, "v5")
-
-	_scaAuthPermissionRule.fillFieldMap()
-
-	return _scaAuthPermissionRule
-}
-
-type scaAuthPermissionRule struct {
-	scaAuthPermissionRuleDo
-
-	ALL   field.Asterisk
-	ID    field.Int64
-	Ptype field.String
-	V0    field.String
-	V1    field.String
-	V2    field.String
-	V3    field.String
-	V4    field.String
-	V5    field.String
-
-	fieldMap map[string]field.Expr
-}
-
-func (s scaAuthPermissionRule) Table(newTableName string) *scaAuthPermissionRule {
-	s.scaAuthPermissionRuleDo.UseTable(newTableName)
-	return s.updateTableName(newTableName)
-}
-
-func (s scaAuthPermissionRule) As(alias string) *scaAuthPermissionRule {
-	s.scaAuthPermissionRuleDo.DO = *(s.scaAuthPermissionRuleDo.As(alias).(*gen.DO))
-	return s.updateTableName(alias)
-}
-
-func (s *scaAuthPermissionRule) updateTableName(table string) *scaAuthPermissionRule {
-	s.ALL = field.NewAsterisk(table)
-	s.ID = field.NewInt64(table, "id")
-	s.Ptype = field.NewString(table, "ptype")
-	s.V0 = field.NewString(table, "v0")
-	s.V1 = field.NewString(table, "v1")
-	s.V2 = field.NewString(table, "v2")
-	s.V3 = field.NewString(table, "v3")
-	s.V4 = field.NewString(table, "v4")
-	s.V5 = field.NewString(table, "v5")
-
-	s.fillFieldMap()
-
-	return s
-}
-
-func (s *scaAuthPermissionRule) GetFieldByName(fieldName string) (field.OrderExpr, bool) {
-	_f, ok := s.fieldMap[fieldName]
-	if !ok || _f == nil {
-		return nil, false
-	}
-	_oe, ok := _f.(field.OrderExpr)
-	return _oe, ok
-}
-
-func (s *scaAuthPermissionRule) fillFieldMap() {
-	s.fieldMap = make(map[string]field.Expr, 8)
-	s.fieldMap["id"] = s.ID
-	s.fieldMap["ptype"] = s.Ptype
-	s.fieldMap["v0"] = s.V0
-	s.fieldMap["v1"] = s.V1
-	s.fieldMap["v2"] = s.V2
-	s.fieldMap["v3"] = s.V3
-	s.fieldMap["v4"] = s.V4
-	s.fieldMap["v5"] = s.V5
-}
-
-func (s scaAuthPermissionRule) clone(db *gorm.DB) scaAuthPermissionRule {
-	s.scaAuthPermissionRuleDo.ReplaceConnPool(db.Statement.ConnPool)
-	return s
-}
-
-func (s scaAuthPermissionRule) replaceDB(db *gorm.DB) scaAuthPermissionRule {
-	s.scaAuthPermissionRuleDo.ReplaceDB(db)
-	return s
-}
-
-type scaAuthPermissionRuleDo struct{ gen.DO }
-
-type IScaAuthPermissionRuleDo interface {
-	gen.SubQuery
-	Debug() IScaAuthPermissionRuleDo
-	WithContext(ctx context.Context) IScaAuthPermissionRuleDo
-	WithResult(fc func(tx gen.Dao)) gen.ResultInfo
-	ReplaceDB(db *gorm.DB)
-	ReadDB() IScaAuthPermissionRuleDo
-	WriteDB() IScaAuthPermissionRuleDo
-	As(alias string) gen.Dao
-	Session(config *gorm.Session) IScaAuthPermissionRuleDo
-	Columns(cols ...field.Expr) gen.Columns
-	Clauses(conds ...clause.Expression) IScaAuthPermissionRuleDo
-	Not(conds ...gen.Condition) IScaAuthPermissionRuleDo
-	Or(conds ...gen.Condition) IScaAuthPermissionRuleDo
-	Select(conds ...field.Expr) IScaAuthPermissionRuleDo
-	Where(conds ...gen.Condition) IScaAuthPermissionRuleDo
-	Order(conds ...field.Expr) IScaAuthPermissionRuleDo
-	Distinct(cols ...field.Expr) IScaAuthPermissionRuleDo
-	Omit(cols ...field.Expr) IScaAuthPermissionRuleDo
-	Join(table schema.Tabler, on ...field.Expr) IScaAuthPermissionRuleDo
-	LeftJoin(table schema.Tabler, on ...field.Expr) IScaAuthPermissionRuleDo
-	RightJoin(table schema.Tabler, on ...field.Expr) IScaAuthPermissionRuleDo
-	Group(cols ...field.Expr) IScaAuthPermissionRuleDo
-	Having(conds ...gen.Condition) IScaAuthPermissionRuleDo
-	Limit(limit int) IScaAuthPermissionRuleDo
-	Offset(offset int) IScaAuthPermissionRuleDo
-	Count() (count int64, err error)
-	Scopes(funcs ...func(gen.Dao) gen.Dao) IScaAuthPermissionRuleDo
-	Unscoped() IScaAuthPermissionRuleDo
-	Create(values ...*model.ScaAuthPermissionRule) error
-	CreateInBatches(values []*model.ScaAuthPermissionRule, batchSize int) error
-	Save(values ...*model.ScaAuthPermissionRule) error
-	First() (*model.ScaAuthPermissionRule, error)
-	Take() (*model.ScaAuthPermissionRule, error)
-	Last() (*model.ScaAuthPermissionRule, error)
-	Find() ([]*model.ScaAuthPermissionRule, error)
-	FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.ScaAuthPermissionRule, err error)
-	FindInBatches(result *[]*model.ScaAuthPermissionRule, batchSize int, fc func(tx gen.Dao, batch int) error) error
-	Pluck(column field.Expr, dest interface{}) error
-	Delete(...*model.ScaAuthPermissionRule) (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) IScaAuthPermissionRuleDo
-	Assign(attrs ...field.AssignExpr) IScaAuthPermissionRuleDo
-	Joins(fields ...field.RelationField) IScaAuthPermissionRuleDo
-	Preload(fields ...field.RelationField) IScaAuthPermissionRuleDo
-	FirstOrInit() (*model.ScaAuthPermissionRule, error)
-	FirstOrCreate() (*model.ScaAuthPermissionRule, error)
-	FindByPage(offset int, limit int) (result []*model.ScaAuthPermissionRule, 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) IScaAuthPermissionRuleDo
-	UnderlyingDB() *gorm.DB
-	schema.Tabler
-}
-
-func (s scaAuthPermissionRuleDo) Debug() IScaAuthPermissionRuleDo {
-	return s.withDO(s.DO.Debug())
-}
-
-func (s scaAuthPermissionRuleDo) WithContext(ctx context.Context) IScaAuthPermissionRuleDo {
-	return s.withDO(s.DO.WithContext(ctx))
-}
-
-func (s scaAuthPermissionRuleDo) ReadDB() IScaAuthPermissionRuleDo {
-	return s.Clauses(dbresolver.Read)
-}
-
-func (s scaAuthPermissionRuleDo) WriteDB() IScaAuthPermissionRuleDo {
-	return s.Clauses(dbresolver.Write)
-}
-
-func (s scaAuthPermissionRuleDo) Session(config *gorm.Session) IScaAuthPermissionRuleDo {
-	return s.withDO(s.DO.Session(config))
-}
-
-func (s scaAuthPermissionRuleDo) Clauses(conds ...clause.Expression) IScaAuthPermissionRuleDo {
-	return s.withDO(s.DO.Clauses(conds...))
-}
-
-func (s scaAuthPermissionRuleDo) Returning(value interface{}, columns ...string) IScaAuthPermissionRuleDo {
-	return s.withDO(s.DO.Returning(value, columns...))
-}
-
-func (s scaAuthPermissionRuleDo) Not(conds ...gen.Condition) IScaAuthPermissionRuleDo {
-	return s.withDO(s.DO.Not(conds...))
-}
-
-func (s scaAuthPermissionRuleDo) Or(conds ...gen.Condition) IScaAuthPermissionRuleDo {
-	return s.withDO(s.DO.Or(conds...))
-}
-
-func (s scaAuthPermissionRuleDo) Select(conds ...field.Expr) IScaAuthPermissionRuleDo {
-	return s.withDO(s.DO.Select(conds...))
-}
-
-func (s scaAuthPermissionRuleDo) Where(conds ...gen.Condition) IScaAuthPermissionRuleDo {
-	return s.withDO(s.DO.Where(conds...))
-}
-
-func (s scaAuthPermissionRuleDo) Order(conds ...field.Expr) IScaAuthPermissionRuleDo {
-	return s.withDO(s.DO.Order(conds...))
-}
-
-func (s scaAuthPermissionRuleDo) Distinct(cols ...field.Expr) IScaAuthPermissionRuleDo {
-	return s.withDO(s.DO.Distinct(cols...))
-}
-
-func (s scaAuthPermissionRuleDo) Omit(cols ...field.Expr) IScaAuthPermissionRuleDo {
-	return s.withDO(s.DO.Omit(cols...))
-}
-
-func (s scaAuthPermissionRuleDo) Join(table schema.Tabler, on ...field.Expr) IScaAuthPermissionRuleDo {
-	return s.withDO(s.DO.Join(table, on...))
-}
-
-func (s scaAuthPermissionRuleDo) LeftJoin(table schema.Tabler, on ...field.Expr) IScaAuthPermissionRuleDo {
-	return s.withDO(s.DO.LeftJoin(table, on...))
-}
-
-func (s scaAuthPermissionRuleDo) RightJoin(table schema.Tabler, on ...field.Expr) IScaAuthPermissionRuleDo {
-	return s.withDO(s.DO.RightJoin(table, on...))
-}
-
-func (s scaAuthPermissionRuleDo) Group(cols ...field.Expr) IScaAuthPermissionRuleDo {
-	return s.withDO(s.DO.Group(cols...))
-}
-
-func (s scaAuthPermissionRuleDo) Having(conds ...gen.Condition) IScaAuthPermissionRuleDo {
-	return s.withDO(s.DO.Having(conds...))
-}
-
-func (s scaAuthPermissionRuleDo) Limit(limit int) IScaAuthPermissionRuleDo {
-	return s.withDO(s.DO.Limit(limit))
-}
-
-func (s scaAuthPermissionRuleDo) Offset(offset int) IScaAuthPermissionRuleDo {
-	return s.withDO(s.DO.Offset(offset))
-}
-
-func (s scaAuthPermissionRuleDo) Scopes(funcs ...func(gen.Dao) gen.Dao) IScaAuthPermissionRuleDo {
-	return s.withDO(s.DO.Scopes(funcs...))
-}
-
-func (s scaAuthPermissionRuleDo) Unscoped() IScaAuthPermissionRuleDo {
-	return s.withDO(s.DO.Unscoped())
-}
-
-func (s scaAuthPermissionRuleDo) Create(values ...*model.ScaAuthPermissionRule) error {
-	if len(values) == 0 {
-		return nil
-	}
-	return s.DO.Create(values)
-}
-
-func (s scaAuthPermissionRuleDo) CreateInBatches(values []*model.ScaAuthPermissionRule, batchSize int) error {
-	return s.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 (s scaAuthPermissionRuleDo) Save(values ...*model.ScaAuthPermissionRule) error {
-	if len(values) == 0 {
-		return nil
-	}
-	return s.DO.Save(values)
-}
-
-func (s scaAuthPermissionRuleDo) First() (*model.ScaAuthPermissionRule, error) {
-	if result, err := s.DO.First(); err != nil {
-		return nil, err
-	} else {
-		return result.(*model.ScaAuthPermissionRule), nil
-	}
-}
-
-func (s scaAuthPermissionRuleDo) Take() (*model.ScaAuthPermissionRule, error) {
-	if result, err := s.DO.Take(); err != nil {
-		return nil, err
-	} else {
-		return result.(*model.ScaAuthPermissionRule), nil
-	}
-}
-
-func (s scaAuthPermissionRuleDo) Last() (*model.ScaAuthPermissionRule, error) {
-	if result, err := s.DO.Last(); err != nil {
-		return nil, err
-	} else {
-		return result.(*model.ScaAuthPermissionRule), nil
-	}
-}
-
-func (s scaAuthPermissionRuleDo) Find() ([]*model.ScaAuthPermissionRule, error) {
-	result, err := s.DO.Find()
-	return result.([]*model.ScaAuthPermissionRule), err
-}
-
-func (s scaAuthPermissionRuleDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.ScaAuthPermissionRule, err error) {
-	buf := make([]*model.ScaAuthPermissionRule, 0, batchSize)
-	err = s.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 (s scaAuthPermissionRuleDo) FindInBatches(result *[]*model.ScaAuthPermissionRule, batchSize int, fc func(tx gen.Dao, batch int) error) error {
-	return s.DO.FindInBatches(result, batchSize, fc)
-}
-
-func (s scaAuthPermissionRuleDo) Attrs(attrs ...field.AssignExpr) IScaAuthPermissionRuleDo {
-	return s.withDO(s.DO.Attrs(attrs...))
-}
-
-func (s scaAuthPermissionRuleDo) Assign(attrs ...field.AssignExpr) IScaAuthPermissionRuleDo {
-	return s.withDO(s.DO.Assign(attrs...))
-}
-
-func (s scaAuthPermissionRuleDo) Joins(fields ...field.RelationField) IScaAuthPermissionRuleDo {
-	for _, _f := range fields {
-		s = *s.withDO(s.DO.Joins(_f))
-	}
-	return &s
-}
-
-func (s scaAuthPermissionRuleDo) Preload(fields ...field.RelationField) IScaAuthPermissionRuleDo {
-	for _, _f := range fields {
-		s = *s.withDO(s.DO.Preload(_f))
-	}
-	return &s
-}
-
-func (s scaAuthPermissionRuleDo) FirstOrInit() (*model.ScaAuthPermissionRule, error) {
-	if result, err := s.DO.FirstOrInit(); err != nil {
-		return nil, err
-	} else {
-		return result.(*model.ScaAuthPermissionRule), nil
-	}
-}
-
-func (s scaAuthPermissionRuleDo) FirstOrCreate() (*model.ScaAuthPermissionRule, error) {
-	if result, err := s.DO.FirstOrCreate(); err != nil {
-		return nil, err
-	} else {
-		return result.(*model.ScaAuthPermissionRule), nil
-	}
-}
-
-func (s scaAuthPermissionRuleDo) FindByPage(offset int, limit int) (result []*model.ScaAuthPermissionRule, count int64, err error) {
-	result, err = s.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 = s.Offset(-1).Limit(-1).Count()
-	return
-}
-
-func (s scaAuthPermissionRuleDo) ScanByPage(result interface{}, offset int, limit int) (count int64, err error) {
-	count, err = s.Count()
-	if err != nil {
-		return
-	}
-
-	err = s.Offset(offset).Limit(limit).Scan(result)
-	return
-}
-
-func (s scaAuthPermissionRuleDo) Scan(result interface{}) (err error) {
-	return s.DO.Scan(result)
-}
-
-func (s scaAuthPermissionRuleDo) Delete(models ...*model.ScaAuthPermissionRule) (result gen.ResultInfo, err error) {
-	return s.DO.Delete(models)
-}
-
-func (s *scaAuthPermissionRuleDo) withDO(do gen.Dao) *scaAuthPermissionRuleDo {
-	s.DO = *do.(*gen.DO)
-	return s
-}

app/auth/api/model/mysql/query/sca_auth_role.gen.go

@@ -1,399 +0,0 @@
-// 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 query
-
-import (
-	"context"
-	"schisandra-album-cloud-microservices/app/auth/api/model/mysql/model"
-
-	"gorm.io/gorm"
-	"gorm.io/gorm/clause"
-	"gorm.io/gorm/schema"
-
-	"gorm.io/gen"
-	"gorm.io/gen/field"
-
-	"gorm.io/plugin/dbresolver"
-)
-
-func newScaAuthRole(db *gorm.DB, opts ...gen.DOOption) scaAuthRole {
-	_scaAuthRole := scaAuthRole{}
-
-	_scaAuthRole.scaAuthRoleDo.UseDB(db, opts...)
-	_scaAuthRole.scaAuthRoleDo.UseModel(&model.ScaAuthRole{})
-
-	tableName := _scaAuthRole.scaAuthRoleDo.TableName()
-	_scaAuthRole.ALL = field.NewAsterisk(tableName)
-	_scaAuthRole.ID = field.NewInt64(tableName, "id")
-	_scaAuthRole.RoleName = field.NewString(tableName, "role_name")
-	_scaAuthRole.RoleKey = field.NewString(tableName, "role_key")
-	_scaAuthRole.CreatedAt = field.NewTime(tableName, "created_at")
-	_scaAuthRole.UpdatedAt = field.NewTime(tableName, "updated_at")
-	_scaAuthRole.DeletedAt = field.NewField(tableName, "deleted_at")
-
-	_scaAuthRole.fillFieldMap()
-
-	return _scaAuthRole
-}
-
-type scaAuthRole struct {
-	scaAuthRoleDo
-
-	ALL       field.Asterisk
-	ID        field.Int64  // 主键ID
-	RoleName  field.String // 角色名称
-	RoleKey   field.String // 角色关键字
-	CreatedAt field.Time   // 创建时间
-	UpdatedAt field.Time   // 更新时间
-	DeletedAt field.Field  // 删除时间
-
-	fieldMap map[string]field.Expr
-}
-
-func (s scaAuthRole) Table(newTableName string) *scaAuthRole {
-	s.scaAuthRoleDo.UseTable(newTableName)
-	return s.updateTableName(newTableName)
-}
-
-func (s scaAuthRole) As(alias string) *scaAuthRole {
-	s.scaAuthRoleDo.DO = *(s.scaAuthRoleDo.As(alias).(*gen.DO))
-	return s.updateTableName(alias)
-}
-
-func (s *scaAuthRole) updateTableName(table string) *scaAuthRole {
-	s.ALL = field.NewAsterisk(table)
-	s.ID = field.NewInt64(table, "id")
-	s.RoleName = field.NewString(table, "role_name")
-	s.RoleKey = field.NewString(table, "role_key")
-	s.CreatedAt = field.NewTime(table, "created_at")
-	s.UpdatedAt = field.NewTime(table, "updated_at")
-	s.DeletedAt = field.NewField(table, "deleted_at")
-
-	s.fillFieldMap()
-
-	return s
-}
-
-func (s *scaAuthRole) GetFieldByName(fieldName string) (field.OrderExpr, bool) {
-	_f, ok := s.fieldMap[fieldName]
-	if !ok || _f == nil {
-		return nil, false
-	}
-	_oe, ok := _f.(field.OrderExpr)
-	return _oe, ok
-}
-
-func (s *scaAuthRole) fillFieldMap() {
-	s.fieldMap = make(map[string]field.Expr, 6)
-	s.fieldMap["id"] = s.ID
-	s.fieldMap["role_name"] = s.RoleName
-	s.fieldMap["role_key"] = s.RoleKey
-	s.fieldMap["created_at"] = s.CreatedAt
-	s.fieldMap["updated_at"] = s.UpdatedAt
-	s.fieldMap["deleted_at"] = s.DeletedAt
-}
-
-func (s scaAuthRole) clone(db *gorm.DB) scaAuthRole {
-	s.scaAuthRoleDo.ReplaceConnPool(db.Statement.ConnPool)
-	return s
-}
-
-func (s scaAuthRole) replaceDB(db *gorm.DB) scaAuthRole {
-	s.scaAuthRoleDo.ReplaceDB(db)
-	return s
-}
-
-type scaAuthRoleDo struct{ gen.DO }
-
-type IScaAuthRoleDo interface {
-	gen.SubQuery
-	Debug() IScaAuthRoleDo
-	WithContext(ctx context.Context) IScaAuthRoleDo
-	WithResult(fc func(tx gen.Dao)) gen.ResultInfo
-	ReplaceDB(db *gorm.DB)
-	ReadDB() IScaAuthRoleDo
-	WriteDB() IScaAuthRoleDo
-	As(alias string) gen.Dao
-	Session(config *gorm.Session) IScaAuthRoleDo
-	Columns(cols ...field.Expr) gen.Columns
-	Clauses(conds ...clause.Expression) IScaAuthRoleDo
-	Not(conds ...gen.Condition) IScaAuthRoleDo
-	Or(conds ...gen.Condition) IScaAuthRoleDo
-	Select(conds ...field.Expr) IScaAuthRoleDo
-	Where(conds ...gen.Condition) IScaAuthRoleDo
-	Order(conds ...field.Expr) IScaAuthRoleDo
-	Distinct(cols ...field.Expr) IScaAuthRoleDo
-	Omit(cols ...field.Expr) IScaAuthRoleDo
-	Join(table schema.Tabler, on ...field.Expr) IScaAuthRoleDo
-	LeftJoin(table schema.Tabler, on ...field.Expr) IScaAuthRoleDo
-	RightJoin(table schema.Tabler, on ...field.Expr) IScaAuthRoleDo
-	Group(cols ...field.Expr) IScaAuthRoleDo
-	Having(conds ...gen.Condition) IScaAuthRoleDo
-	Limit(limit int) IScaAuthRoleDo
-	Offset(offset int) IScaAuthRoleDo
-	Count() (count int64, err error)
-	Scopes(funcs ...func(gen.Dao) gen.Dao) IScaAuthRoleDo
-	Unscoped() IScaAuthRoleDo
-	Create(values ...*model.ScaAuthRole) error
-	CreateInBatches(values []*model.ScaAuthRole, batchSize int) error
-	Save(values ...*model.ScaAuthRole) error
-	First() (*model.ScaAuthRole, error)
-	Take() (*model.ScaAuthRole, error)
-	Last() (*model.ScaAuthRole, error)
-	Find() ([]*model.ScaAuthRole, error)
-	FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.ScaAuthRole, err error)
-	FindInBatches(result *[]*model.ScaAuthRole, batchSize int, fc func(tx gen.Dao, batch int) error) error
-	Pluck(column field.Expr, dest interface{}) error
-	Delete(...*model.ScaAuthRole) (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) IScaAuthRoleDo
-	Assign(attrs ...field.AssignExpr) IScaAuthRoleDo
-	Joins(fields ...field.RelationField) IScaAuthRoleDo
-	Preload(fields ...field.RelationField) IScaAuthRoleDo
-	FirstOrInit() (*model.ScaAuthRole, error)
-	FirstOrCreate() (*model.ScaAuthRole, error)
-	FindByPage(offset int, limit int) (result []*model.ScaAuthRole, 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) IScaAuthRoleDo
-	UnderlyingDB() *gorm.DB
-	schema.Tabler
-}
-
-func (s scaAuthRoleDo) Debug() IScaAuthRoleDo {
-	return s.withDO(s.DO.Debug())
-}
-
-func (s scaAuthRoleDo) WithContext(ctx context.Context) IScaAuthRoleDo {
-	return s.withDO(s.DO.WithContext(ctx))
-}
-
-func (s scaAuthRoleDo) ReadDB() IScaAuthRoleDo {
-	return s.Clauses(dbresolver.Read)
-}
-
-func (s scaAuthRoleDo) WriteDB() IScaAuthRoleDo {
-	return s.Clauses(dbresolver.Write)
-}
-
-func (s scaAuthRoleDo) Session(config *gorm.Session) IScaAuthRoleDo {
-	return s.withDO(s.DO.Session(config))
-}
-
-func (s scaAuthRoleDo) Clauses(conds ...clause.Expression) IScaAuthRoleDo {
-	return s.withDO(s.DO.Clauses(conds...))
-}
-
-func (s scaAuthRoleDo) Returning(value interface{}, columns ...string) IScaAuthRoleDo {
-	return s.withDO(s.DO.Returning(value, columns...))
-}
-
-func (s scaAuthRoleDo) Not(conds ...gen.Condition) IScaAuthRoleDo {
-	return s.withDO(s.DO.Not(conds...))
-}
-
-func (s scaAuthRoleDo) Or(conds ...gen.Condition) IScaAuthRoleDo {
-	return s.withDO(s.DO.Or(conds...))
-}
-
-func (s scaAuthRoleDo) Select(conds ...field.Expr) IScaAuthRoleDo {
-	return s.withDO(s.DO.Select(conds...))
-}
-
-func (s scaAuthRoleDo) Where(conds ...gen.Condition) IScaAuthRoleDo {
-	return s.withDO(s.DO.Where(conds...))
-}
-
-func (s scaAuthRoleDo) Order(conds ...field.Expr) IScaAuthRoleDo {
-	return s.withDO(s.DO.Order(conds...))
-}
-
-func (s scaAuthRoleDo) Distinct(cols ...field.Expr) IScaAuthRoleDo {
-	return s.withDO(s.DO.Distinct(cols...))
-}
-
-func (s scaAuthRoleDo) Omit(cols ...field.Expr) IScaAuthRoleDo {
-	return s.withDO(s.DO.Omit(cols...))
-}
-
-func (s scaAuthRoleDo) Join(table schema.Tabler, on ...field.Expr) IScaAuthRoleDo {
-	return s.withDO(s.DO.Join(table, on...))
-}
-
-func (s scaAuthRoleDo) LeftJoin(table schema.Tabler, on ...field.Expr) IScaAuthRoleDo {
-	return s.withDO(s.DO.LeftJoin(table, on...))
-}
-
-func (s scaAuthRoleDo) RightJoin(table schema.Tabler, on ...field.Expr) IScaAuthRoleDo {
-	return s.withDO(s.DO.RightJoin(table, on...))
-}
-
-func (s scaAuthRoleDo) Group(cols ...field.Expr) IScaAuthRoleDo {
-	return s.withDO(s.DO.Group(cols...))
-}
-
-func (s scaAuthRoleDo) Having(conds ...gen.Condition) IScaAuthRoleDo {
-	return s.withDO(s.DO.Having(conds...))
-}
-
-func (s scaAuthRoleDo) Limit(limit int) IScaAuthRoleDo {
-	return s.withDO(s.DO.Limit(limit))
-}
-
-func (s scaAuthRoleDo) Offset(offset int) IScaAuthRoleDo {
-	return s.withDO(s.DO.Offset(offset))
-}
-
-func (s scaAuthRoleDo) Scopes(funcs ...func(gen.Dao) gen.Dao) IScaAuthRoleDo {
-	return s.withDO(s.DO.Scopes(funcs...))
-}
-
-func (s scaAuthRoleDo) Unscoped() IScaAuthRoleDo {
-	return s.withDO(s.DO.Unscoped())
-}
-
-func (s scaAuthRoleDo) Create(values ...*model.ScaAuthRole) error {
-	if len(values) == 0 {
-		return nil
-	}
-	return s.DO.Create(values)
-}
-
-func (s scaAuthRoleDo) CreateInBatches(values []*model.ScaAuthRole, batchSize int) error {
-	return s.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 (s scaAuthRoleDo) Save(values ...*model.ScaAuthRole) error {
-	if len(values) == 0 {
-		return nil
-	}
-	return s.DO.Save(values)
-}
-
-func (s scaAuthRoleDo) First() (*model.ScaAuthRole, error) {
-	if result, err := s.DO.First(); err != nil {
-		return nil, err
-	} else {
-		return result.(*model.ScaAuthRole), nil
-	}
-}
-
-func (s scaAuthRoleDo) Take() (*model.ScaAuthRole, error) {
-	if result, err := s.DO.Take(); err != nil {
-		return nil, err
-	} else {
-		return result.(*model.ScaAuthRole), nil
-	}
-}
-
-func (s scaAuthRoleDo) Last() (*model.ScaAuthRole, error) {
-	if result, err := s.DO.Last(); err != nil {
-		return nil, err
-	} else {
-		return result.(*model.ScaAuthRole), nil
-	}
-}
-
-func (s scaAuthRoleDo) Find() ([]*model.ScaAuthRole, error) {
-	result, err := s.DO.Find()
-	return result.([]*model.ScaAuthRole), err
-}
-
-func (s scaAuthRoleDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.ScaAuthRole, err error) {
-	buf := make([]*model.ScaAuthRole, 0, batchSize)
-	err = s.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 (s scaAuthRoleDo) FindInBatches(result *[]*model.ScaAuthRole, batchSize int, fc func(tx gen.Dao, batch int) error) error {
-	return s.DO.FindInBatches(result, batchSize, fc)
-}
-
-func (s scaAuthRoleDo) Attrs(attrs ...field.AssignExpr) IScaAuthRoleDo {
-	return s.withDO(s.DO.Attrs(attrs...))
-}
-
-func (s scaAuthRoleDo) Assign(attrs ...field.AssignExpr) IScaAuthRoleDo {
-	return s.withDO(s.DO.Assign(attrs...))
-}
-
-func (s scaAuthRoleDo) Joins(fields ...field.RelationField) IScaAuthRoleDo {
-	for _, _f := range fields {
-		s = *s.withDO(s.DO.Joins(_f))
-	}
-	return &s
-}
-
-func (s scaAuthRoleDo) Preload(fields ...field.RelationField) IScaAuthRoleDo {
-	for _, _f := range fields {
-		s = *s.withDO(s.DO.Preload(_f))
-	}
-	return &s
-}
-
-func (s scaAuthRoleDo) FirstOrInit() (*model.ScaAuthRole, error) {
-	if result, err := s.DO.FirstOrInit(); err != nil {
-		return nil, err
-	} else {
-		return result.(*model.ScaAuthRole), nil
-	}
-}
-
-func (s scaAuthRoleDo) FirstOrCreate() (*model.ScaAuthRole, error) {
-	if result, err := s.DO.FirstOrCreate(); err != nil {
-		return nil, err
-	} else {
-		return result.(*model.ScaAuthRole), nil
-	}
-}
-
-func (s scaAuthRoleDo) FindByPage(offset int, limit int) (result []*model.ScaAuthRole, count int64, err error) {
-	result, err = s.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 = s.Offset(-1).Limit(-1).Count()
-	return
-}
-
-func (s scaAuthRoleDo) ScanByPage(result interface{}, offset int, limit int) (count int64, err error) {
-	count, err = s.Count()
-	if err != nil {
-		return
-	}
-
-	err = s.Offset(offset).Limit(limit).Scan(result)
-	return
-}
-
-func (s scaAuthRoleDo) Scan(result interface{}) (err error) {
-	return s.DO.Scan(result)
-}
-
-func (s scaAuthRoleDo) Delete(models ...*model.ScaAuthRole) (result gen.ResultInfo, err error) {
-	return s.DO.Delete(models)
-}
-
-func (s *scaAuthRoleDo) withDO(do gen.Dao) *scaAuthRoleDo {
-	s.DO = *do.(*gen.DO)
-	return s
-}

app/auth/api/model/mysql/query/sca_auth_user.gen.go

@@ -1,443 +0,0 @@
-// 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 query
-
-import (
-	"context"
-	"schisandra-album-cloud-microservices/app/auth/api/model/mysql/model"
-
-	"gorm.io/gorm"
-	"gorm.io/gorm/clause"
-	"gorm.io/gorm/schema"
-
-	"gorm.io/gen"
-	"gorm.io/gen/field"
-
-	"gorm.io/plugin/dbresolver"
-)
-
-func newScaAuthUser(db *gorm.DB, opts ...gen.DOOption) scaAuthUser {
-	_scaAuthUser := scaAuthUser{}
-
-	_scaAuthUser.scaAuthUserDo.UseDB(db, opts...)
-	_scaAuthUser.scaAuthUserDo.UseModel(&model.ScaAuthUser{})
-
-	tableName := _scaAuthUser.scaAuthUserDo.TableName()
-	_scaAuthUser.ALL = field.NewAsterisk(tableName)
-	_scaAuthUser.ID = field.NewInt64(tableName, "id")
-	_scaAuthUser.UID = field.NewString(tableName, "uid")
-	_scaAuthUser.Username = field.NewString(tableName, "username")
-	_scaAuthUser.Nickname = field.NewString(tableName, "nickname")
-	_scaAuthUser.Email = field.NewString(tableName, "email")
-	_scaAuthUser.Phone = field.NewString(tableName, "phone")
-	_scaAuthUser.Password = field.NewString(tableName, "password")
-	_scaAuthUser.Gender = field.NewInt64(tableName, "gender")
-	_scaAuthUser.Avatar = field.NewString(tableName, "avatar")
-	_scaAuthUser.Status = field.NewInt64(tableName, "status")
-	_scaAuthUser.Introduce = field.NewString(tableName, "introduce")
-	_scaAuthUser.CreatedAt = field.NewTime(tableName, "created_at")
-	_scaAuthUser.Blog = field.NewString(tableName, "blog")
-	_scaAuthUser.Location = field.NewString(tableName, "location")
-	_scaAuthUser.Company = field.NewString(tableName, "company")
-	_scaAuthUser.UpdatedAt = field.NewTime(tableName, "updated_at")
-	_scaAuthUser.DeletedAt = field.NewField(tableName, "deleted_at")
-
-	_scaAuthUser.fillFieldMap()
-
-	return _scaAuthUser
-}
-
-type scaAuthUser struct {
-	scaAuthUserDo
-
-	ALL       field.Asterisk
-	ID        field.Int64  // 自增ID
-	UID       field.String // 唯一ID
-	Username  field.String // 用户名
-	Nickname  field.String // 昵称
-	Email     field.String // 邮箱
-	Phone     field.String // 电话
-	Password  field.String // 密码
-	Gender    field.Int64  // 性别
-	Avatar    field.String // 头像
-	Status    field.Int64  // 状态 0 正常 1 封禁
-	Introduce field.String // 介绍
-	CreatedAt field.Time   // 创建时间
-	Blog      field.String // 博客
-	Location  field.String // 地址
-	Company   field.String // 公司
-	UpdatedAt field.Time   // 更新时间
-	DeletedAt field.Field  // 删除时间
-
-	fieldMap map[string]field.Expr
-}
-
-func (s scaAuthUser) Table(newTableName string) *scaAuthUser {
-	s.scaAuthUserDo.UseTable(newTableName)
-	return s.updateTableName(newTableName)
-}
-
-func (s scaAuthUser) As(alias string) *scaAuthUser {
-	s.scaAuthUserDo.DO = *(s.scaAuthUserDo.As(alias).(*gen.DO))
-	return s.updateTableName(alias)
-}
-
-func (s *scaAuthUser) updateTableName(table string) *scaAuthUser {
-	s.ALL = field.NewAsterisk(table)
-	s.ID = field.NewInt64(table, "id")
-	s.UID = field.NewString(table, "uid")
-	s.Username = field.NewString(table, "username")
-	s.Nickname = field.NewString(table, "nickname")
-	s.Email = field.NewString(table, "email")
-	s.Phone = field.NewString(table, "phone")
-	s.Password = field.NewString(table, "password")
-	s.Gender = field.NewInt64(table, "gender")
-	s.Avatar = field.NewString(table, "avatar")
-	s.Status = field.NewInt64(table, "status")
-	s.Introduce = field.NewString(table, "introduce")
-	s.CreatedAt = field.NewTime(table, "created_at")
-	s.Blog = field.NewString(table, "blog")
-	s.Location = field.NewString(table, "location")
-	s.Company = field.NewString(table, "company")
-	s.UpdatedAt = field.NewTime(table, "updated_at")
-	s.DeletedAt = field.NewField(table, "deleted_at")
-
-	s.fillFieldMap()
-
-	return s
-}
-
-func (s *scaAuthUser) GetFieldByName(fieldName string) (field.OrderExpr, bool) {
-	_f, ok := s.fieldMap[fieldName]
-	if !ok || _f == nil {
-		return nil, false
-	}
-	_oe, ok := _f.(field.OrderExpr)
-	return _oe, ok
-}
-
-func (s *scaAuthUser) fillFieldMap() {
-	s.fieldMap = make(map[string]field.Expr, 17)
-	s.fieldMap["id"] = s.ID
-	s.fieldMap["uid"] = s.UID
-	s.fieldMap["username"] = s.Username
-	s.fieldMap["nickname"] = s.Nickname
-	s.fieldMap["email"] = s.Email
-	s.fieldMap["phone"] = s.Phone
-	s.fieldMap["password"] = s.Password
-	s.fieldMap["gender"] = s.Gender
-	s.fieldMap["avatar"] = s.Avatar
-	s.fieldMap["status"] = s.Status
-	s.fieldMap["introduce"] = s.Introduce
-	s.fieldMap["created_at"] = s.CreatedAt
-	s.fieldMap["blog"] = s.Blog
-	s.fieldMap["location"] = s.Location
-	s.fieldMap["company"] = s.Company
-	s.fieldMap["updated_at"] = s.UpdatedAt
-	s.fieldMap["deleted_at"] = s.DeletedAt
-}
-
-func (s scaAuthUser) clone(db *gorm.DB) scaAuthUser {
-	s.scaAuthUserDo.ReplaceConnPool(db.Statement.ConnPool)
-	return s
-}
-
-func (s scaAuthUser) replaceDB(db *gorm.DB) scaAuthUser {
-	s.scaAuthUserDo.ReplaceDB(db)
-	return s
-}
-
-type scaAuthUserDo struct{ gen.DO }
-
-type IScaAuthUserDo interface {
-	gen.SubQuery
-	Debug() IScaAuthUserDo
-	WithContext(ctx context.Context) IScaAuthUserDo
-	WithResult(fc func(tx gen.Dao)) gen.ResultInfo
-	ReplaceDB(db *gorm.DB)
-	ReadDB() IScaAuthUserDo
-	WriteDB() IScaAuthUserDo
-	As(alias string) gen.Dao
-	Session(config *gorm.Session) IScaAuthUserDo
-	Columns(cols ...field.Expr) gen.Columns
-	Clauses(conds ...clause.Expression) IScaAuthUserDo
-	Not(conds ...gen.Condition) IScaAuthUserDo
-	Or(conds ...gen.Condition) IScaAuthUserDo
-	Select(conds ...field.Expr) IScaAuthUserDo
-	Where(conds ...gen.Condition) IScaAuthUserDo
-	Order(conds ...field.Expr) IScaAuthUserDo
-	Distinct(cols ...field.Expr) IScaAuthUserDo
-	Omit(cols ...field.Expr) IScaAuthUserDo
-	Join(table schema.Tabler, on ...field.Expr) IScaAuthUserDo
-	LeftJoin(table schema.Tabler, on ...field.Expr) IScaAuthUserDo
-	RightJoin(table schema.Tabler, on ...field.Expr) IScaAuthUserDo
-	Group(cols ...field.Expr) IScaAuthUserDo
-	Having(conds ...gen.Condition) IScaAuthUserDo
-	Limit(limit int) IScaAuthUserDo
-	Offset(offset int) IScaAuthUserDo
-	Count() (count int64, err error)
-	Scopes(funcs ...func(gen.Dao) gen.Dao) IScaAuthUserDo
-	Unscoped() IScaAuthUserDo
-	Create(values ...*model.ScaAuthUser) error
-	CreateInBatches(values []*model.ScaAuthUser, batchSize int) error
-	Save(values ...*model.ScaAuthUser) error
-	First() (*model.ScaAuthUser, error)
-	Take() (*model.ScaAuthUser, error)
-	Last() (*model.ScaAuthUser, error)
-	Find() ([]*model.ScaAuthUser, error)
-	FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.ScaAuthUser, err error)
-	FindInBatches(result *[]*model.ScaAuthUser, batchSize int, fc func(tx gen.Dao, batch int) error) error
-	Pluck(column field.Expr, dest interface{}) error
-	Delete(...*model.ScaAuthUser) (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) IScaAuthUserDo
-	Assign(attrs ...field.AssignExpr) IScaAuthUserDo
-	Joins(fields ...field.RelationField) IScaAuthUserDo
-	Preload(fields ...field.RelationField) IScaAuthUserDo
-	FirstOrInit() (*model.ScaAuthUser, error)
-	FirstOrCreate() (*model.ScaAuthUser, error)
-	FindByPage(offset int, limit int) (result []*model.ScaAuthUser, 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) IScaAuthUserDo
-	UnderlyingDB() *gorm.DB
-	schema.Tabler
-}
-
-func (s scaAuthUserDo) Debug() IScaAuthUserDo {
-	return s.withDO(s.DO.Debug())
-}
-
-func (s scaAuthUserDo) WithContext(ctx context.Context) IScaAuthUserDo {
-	return s.withDO(s.DO.WithContext(ctx))
-}
-
-func (s scaAuthUserDo) ReadDB() IScaAuthUserDo {
-	return s.Clauses(dbresolver.Read)
-}
-
-func (s scaAuthUserDo) WriteDB() IScaAuthUserDo {
-	return s.Clauses(dbresolver.Write)
-}
-
-func (s scaAuthUserDo) Session(config *gorm.Session) IScaAuthUserDo {
-	return s.withDO(s.DO.Session(config))
-}
-
-func (s scaAuthUserDo) Clauses(conds ...clause.Expression) IScaAuthUserDo {
-	return s.withDO(s.DO.Clauses(conds...))
-}
-
-func (s scaAuthUserDo) Returning(value interface{}, columns ...string) IScaAuthUserDo {
-	return s.withDO(s.DO.Returning(value, columns...))
-}
-
-func (s scaAuthUserDo) Not(conds ...gen.Condition) IScaAuthUserDo {
-	return s.withDO(s.DO.Not(conds...))
-}
-
-func (s scaAuthUserDo) Or(conds ...gen.Condition) IScaAuthUserDo {
-	return s.withDO(s.DO.Or(conds...))
-}
-
-func (s scaAuthUserDo) Select(conds ...field.Expr) IScaAuthUserDo {
-	return s.withDO(s.DO.Select(conds...))
-}
-
-func (s scaAuthUserDo) Where(conds ...gen.Condition) IScaAuthUserDo {
-	return s.withDO(s.DO.Where(conds...))
-}
-
-func (s scaAuthUserDo) Order(conds ...field.Expr) IScaAuthUserDo {
-	return s.withDO(s.DO.Order(conds...))
-}
-
-func (s scaAuthUserDo) Distinct(cols ...field.Expr) IScaAuthUserDo {
-	return s.withDO(s.DO.Distinct(cols...))
-}
-
-func (s scaAuthUserDo) Omit(cols ...field.Expr) IScaAuthUserDo {
-	return s.withDO(s.DO.Omit(cols...))
-}
-
-func (s scaAuthUserDo) Join(table schema.Tabler, on ...field.Expr) IScaAuthUserDo {
-	return s.withDO(s.DO.Join(table, on...))
-}
-
-func (s scaAuthUserDo) LeftJoin(table schema.Tabler, on ...field.Expr) IScaAuthUserDo {
-	return s.withDO(s.DO.LeftJoin(table, on...))
-}
-
-func (s scaAuthUserDo) RightJoin(table schema.Tabler, on ...field.Expr) IScaAuthUserDo {
-	return s.withDO(s.DO.RightJoin(table, on...))
-}
-
-func (s scaAuthUserDo) Group(cols ...field.Expr) IScaAuthUserDo {
-	return s.withDO(s.DO.Group(cols...))
-}
-
-func (s scaAuthUserDo) Having(conds ...gen.Condition) IScaAuthUserDo {
-	return s.withDO(s.DO.Having(conds...))
-}
-
-func (s scaAuthUserDo) Limit(limit int) IScaAuthUserDo {
-	return s.withDO(s.DO.Limit(limit))
-}
-
-func (s scaAuthUserDo) Offset(offset int) IScaAuthUserDo {
-	return s.withDO(s.DO.Offset(offset))
-}
-
-func (s scaAuthUserDo) Scopes(funcs ...func(gen.Dao) gen.Dao) IScaAuthUserDo {
-	return s.withDO(s.DO.Scopes(funcs...))
-}
-
-func (s scaAuthUserDo) Unscoped() IScaAuthUserDo {
-	return s.withDO(s.DO.Unscoped())
-}
-
-func (s scaAuthUserDo) Create(values ...*model.ScaAuthUser) error {
-	if len(values) == 0 {
-		return nil
-	}
-	return s.DO.Create(values)
-}
-
-func (s scaAuthUserDo) CreateInBatches(values []*model.ScaAuthUser, batchSize int) error {
-	return s.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 (s scaAuthUserDo) Save(values ...*model.ScaAuthUser) error {
-	if len(values) == 0 {
-		return nil
-	}
-	return s.DO.Save(values)
-}
-
-func (s scaAuthUserDo) First() (*model.ScaAuthUser, error) {
-	if result, err := s.DO.First(); err != nil {
-		return nil, err
-	} else {
-		return result.(*model.ScaAuthUser), nil
-	}
-}
-
-func (s scaAuthUserDo) Take() (*model.ScaAuthUser, error) {
-	if result, err := s.DO.Take(); err != nil {
-		return nil, err
-	} else {
-		return result.(*model.ScaAuthUser), nil
-	}
-}
-
-func (s scaAuthUserDo) Last() (*model.ScaAuthUser, error) {
-	if result, err := s.DO.Last(); err != nil {
-		return nil, err
-	} else {
-		return result.(*model.ScaAuthUser), nil
-	}
-}
-
-func (s scaAuthUserDo) Find() ([]*model.ScaAuthUser, error) {
-	result, err := s.DO.Find()
-	return result.([]*model.ScaAuthUser), err
-}
-
-func (s scaAuthUserDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.ScaAuthUser, err error) {
-	buf := make([]*model.ScaAuthUser, 0, batchSize)
-	err = s.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 (s scaAuthUserDo) FindInBatches(result *[]*model.ScaAuthUser, batchSize int, fc func(tx gen.Dao, batch int) error) error {
-	return s.DO.FindInBatches(result, batchSize, fc)
-}
-
-func (s scaAuthUserDo) Attrs(attrs ...field.AssignExpr) IScaAuthUserDo {
-	return s.withDO(s.DO.Attrs(attrs...))
-}
-
-func (s scaAuthUserDo) Assign(attrs ...field.AssignExpr) IScaAuthUserDo {
-	return s.withDO(s.DO.Assign(attrs...))
-}
-
-func (s scaAuthUserDo) Joins(fields ...field.RelationField) IScaAuthUserDo {
-	for _, _f := range fields {
-		s = *s.withDO(s.DO.Joins(_f))
-	}
-	return &s
-}
-
-func (s scaAuthUserDo) Preload(fields ...field.RelationField) IScaAuthUserDo {
-	for _, _f := range fields {
-		s = *s.withDO(s.DO.Preload(_f))
-	}
-	return &s
-}
-
-func (s scaAuthUserDo) FirstOrInit() (*model.ScaAuthUser, error) {
-	if result, err := s.DO.FirstOrInit(); err != nil {
-		return nil, err
-	} else {
-		return result.(*model.ScaAuthUser), nil
-	}
-}
-
-func (s scaAuthUserDo) FirstOrCreate() (*model.ScaAuthUser, error) {
-	if result, err := s.DO.FirstOrCreate(); err != nil {
-		return nil, err
-	} else {
-		return result.(*model.ScaAuthUser), nil
-	}
-}
-
-func (s scaAuthUserDo) FindByPage(offset int, limit int) (result []*model.ScaAuthUser, count int64, err error) {
-	result, err = s.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 = s.Offset(-1).Limit(-1).Count()
-	return
-}
-
-func (s scaAuthUserDo) ScanByPage(result interface{}, offset int, limit int) (count int64, err error) {
-	count, err = s.Count()
-	if err != nil {
-		return
-	}
-
-	err = s.Offset(offset).Limit(limit).Scan(result)
-	return
-}
-
-func (s scaAuthUserDo) Scan(result interface{}) (err error) {
-	return s.DO.Scan(result)
-}
-
-func (s scaAuthUserDo) Delete(models ...*model.ScaAuthUser) (result gen.ResultInfo, err error) {
-	return s.DO.Delete(models)
-}
-
-func (s *scaAuthUserDo) withDO(do gen.Dao) *scaAuthUserDo {
-	s.DO = *do.(*gen.DO)
-	return s
-}

app/auth/api/model/mysql/query/sca_auth_user_device.gen.go

@@ -1,443 +0,0 @@
-// 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 query
-
-import (
-	"context"
-	"schisandra-album-cloud-microservices/app/auth/api/model/mysql/model"
-
-	"gorm.io/gorm"
-	"gorm.io/gorm/clause"
-	"gorm.io/gorm/schema"
-
-	"gorm.io/gen"
-	"gorm.io/gen/field"
-
-	"gorm.io/plugin/dbresolver"
-)
-
-func newScaAuthUserDevice(db *gorm.DB, opts ...gen.DOOption) scaAuthUserDevice {
-	_scaAuthUserDevice := scaAuthUserDevice{}
-
-	_scaAuthUserDevice.scaAuthUserDeviceDo.UseDB(db, opts...)
-	_scaAuthUserDevice.scaAuthUserDeviceDo.UseModel(&model.ScaAuthUserDevice{})
-
-	tableName := _scaAuthUserDevice.scaAuthUserDeviceDo.TableName()
-	_scaAuthUserDevice.ALL = field.NewAsterisk(tableName)
-	_scaAuthUserDevice.ID = field.NewInt64(tableName, "id")
-	_scaAuthUserDevice.UserID = field.NewString(tableName, "user_id")
-	_scaAuthUserDevice.IP = field.NewString(tableName, "ip")
-	_scaAuthUserDevice.Location = field.NewString(tableName, "location")
-	_scaAuthUserDevice.Agent = field.NewString(tableName, "agent")
-	_scaAuthUserDevice.CreatedAt = field.NewTime(tableName, "created_at")
-	_scaAuthUserDevice.Browser = field.NewString(tableName, "browser")
-	_scaAuthUserDevice.OperatingSystem = field.NewString(tableName, "operating_system")
-	_scaAuthUserDevice.BrowserVersion = field.NewString(tableName, "browser_version")
-	_scaAuthUserDevice.Mobile = field.NewInt64(tableName, "mobile")
-	_scaAuthUserDevice.Bot = field.NewInt64(tableName, "bot")
-	_scaAuthUserDevice.Mozilla = field.NewString(tableName, "mozilla")
-	_scaAuthUserDevice.Platform = field.NewString(tableName, "platform")
-	_scaAuthUserDevice.EngineName = field.NewString(tableName, "engine_name")
-	_scaAuthUserDevice.EngineVersion = field.NewString(tableName, "engine_version")
-	_scaAuthUserDevice.UpdatedAt = field.NewTime(tableName, "updated_at")
-	_scaAuthUserDevice.DeletedAt = field.NewField(tableName, "deleted_at")
-
-	_scaAuthUserDevice.fillFieldMap()
-
-	return _scaAuthUserDevice
-}
-
-type scaAuthUserDevice struct {
-	scaAuthUserDeviceDo
-
-	ALL             field.Asterisk
-	ID              field.Int64  // 主键ID
-	UserID          field.String // 用户ID
-	IP              field.String // 登录IP
-	Location        field.String // 地址
-	Agent           field.String // 设备信息
-	CreatedAt       field.Time   // 创建时间
-	Browser         field.String // 浏览器
-	OperatingSystem field.String // 操作系统
-	BrowserVersion  field.String // 浏览器版本
-	Mobile          field.Int64  // 是否为手机 0否1是
-	Bot             field.Int64  // 是否为bot 0否1是
-	Mozilla         field.String // 火狐版本
-	Platform        field.String // 平台
-	EngineName      field.String // 引擎名称
-	EngineVersion   field.String // 引擎版本
-	UpdatedAt       field.Time   // 更新时间
-	DeletedAt       field.Field  // 删除时间
-
-	fieldMap map[string]field.Expr
-}
-
-func (s scaAuthUserDevice) Table(newTableName string) *scaAuthUserDevice {
-	s.scaAuthUserDeviceDo.UseTable(newTableName)
-	return s.updateTableName(newTableName)
-}
-
-func (s scaAuthUserDevice) As(alias string) *scaAuthUserDevice {
-	s.scaAuthUserDeviceDo.DO = *(s.scaAuthUserDeviceDo.As(alias).(*gen.DO))
-	return s.updateTableName(alias)
-}
-
-func (s *scaAuthUserDevice) updateTableName(table string) *scaAuthUserDevice {
-	s.ALL = field.NewAsterisk(table)
-	s.ID = field.NewInt64(table, "id")
-	s.UserID = field.NewString(table, "user_id")
-	s.IP = field.NewString(table, "ip")
-	s.Location = field.NewString(table, "location")
-	s.Agent = field.NewString(table, "agent")
-	s.CreatedAt = field.NewTime(table, "created_at")
-	s.Browser = field.NewString(table, "browser")
-	s.OperatingSystem = field.NewString(table, "operating_system")
-	s.BrowserVersion = field.NewString(table, "browser_version")
-	s.Mobile = field.NewInt64(table, "mobile")
-	s.Bot = field.NewInt64(table, "bot")
-	s.Mozilla = field.NewString(table, "mozilla")
-	s.Platform = field.NewString(table, "platform")
-	s.EngineName = field.NewString(table, "engine_name")
-	s.EngineVersion = field.NewString(table, "engine_version")
-	s.UpdatedAt = field.NewTime(table, "updated_at")
-	s.DeletedAt = field.NewField(table, "deleted_at")
-
-	s.fillFieldMap()
-
-	return s
-}
-
-func (s *scaAuthUserDevice) GetFieldByName(fieldName string) (field.OrderExpr, bool) {
-	_f, ok := s.fieldMap[fieldName]
-	if !ok || _f == nil {
-		return nil, false
-	}
-	_oe, ok := _f.(field.OrderExpr)
-	return _oe, ok
-}
-
-func (s *scaAuthUserDevice) fillFieldMap() {
-	s.fieldMap = make(map[string]field.Expr, 17)
-	s.fieldMap["id"] = s.ID
-	s.fieldMap["user_id"] = s.UserID
-	s.fieldMap["ip"] = s.IP
-	s.fieldMap["location"] = s.Location
-	s.fieldMap["agent"] = s.Agent
-	s.fieldMap["created_at"] = s.CreatedAt
-	s.fieldMap["browser"] = s.Browser
-	s.fieldMap["operating_system"] = s.OperatingSystem
-	s.fieldMap["browser_version"] = s.BrowserVersion
-	s.fieldMap["mobile"] = s.Mobile
-	s.fieldMap["bot"] = s.Bot
-	s.fieldMap["mozilla"] = s.Mozilla
-	s.fieldMap["platform"] = s.Platform
-	s.fieldMap["engine_name"] = s.EngineName
-	s.fieldMap["engine_version"] = s.EngineVersion
-	s.fieldMap["updated_at"] = s.UpdatedAt
-	s.fieldMap["deleted_at"] = s.DeletedAt
-}
-
-func (s scaAuthUserDevice) clone(db *gorm.DB) scaAuthUserDevice {
-	s.scaAuthUserDeviceDo.ReplaceConnPool(db.Statement.ConnPool)
-	return s
-}
-
-func (s scaAuthUserDevice) replaceDB(db *gorm.DB) scaAuthUserDevice {
-	s.scaAuthUserDeviceDo.ReplaceDB(db)
-	return s
-}
-
-type scaAuthUserDeviceDo struct{ gen.DO }
-
-type IScaAuthUserDeviceDo interface {
-	gen.SubQuery
-	Debug() IScaAuthUserDeviceDo
-	WithContext(ctx context.Context) IScaAuthUserDeviceDo
-	WithResult(fc func(tx gen.Dao)) gen.ResultInfo
-	ReplaceDB(db *gorm.DB)
-	ReadDB() IScaAuthUserDeviceDo
-	WriteDB() IScaAuthUserDeviceDo
-	As(alias string) gen.Dao
-	Session(config *gorm.Session) IScaAuthUserDeviceDo
-	Columns(cols ...field.Expr) gen.Columns
-	Clauses(conds ...clause.Expression) IScaAuthUserDeviceDo
-	Not(conds ...gen.Condition) IScaAuthUserDeviceDo
-	Or(conds ...gen.Condition) IScaAuthUserDeviceDo
-	Select(conds ...field.Expr) IScaAuthUserDeviceDo
-	Where(conds ...gen.Condition) IScaAuthUserDeviceDo
-	Order(conds ...field.Expr) IScaAuthUserDeviceDo
-	Distinct(cols ...field.Expr) IScaAuthUserDeviceDo
-	Omit(cols ...field.Expr) IScaAuthUserDeviceDo
-	Join(table schema.Tabler, on ...field.Expr) IScaAuthUserDeviceDo
-	LeftJoin(table schema.Tabler, on ...field.Expr) IScaAuthUserDeviceDo
-	RightJoin(table schema.Tabler, on ...field.Expr) IScaAuthUserDeviceDo
-	Group(cols ...field.Expr) IScaAuthUserDeviceDo
-	Having(conds ...gen.Condition) IScaAuthUserDeviceDo
-	Limit(limit int) IScaAuthUserDeviceDo
-	Offset(offset int) IScaAuthUserDeviceDo
-	Count() (count int64, err error)
-	Scopes(funcs ...func(gen.Dao) gen.Dao) IScaAuthUserDeviceDo
-	Unscoped() IScaAuthUserDeviceDo
-	Create(values ...*model.ScaAuthUserDevice) error
-	CreateInBatches(values []*model.ScaAuthUserDevice, batchSize int) error
-	Save(values ...*model.ScaAuthUserDevice) error
-	First() (*model.ScaAuthUserDevice, error)
-	Take() (*model.ScaAuthUserDevice, error)
-	Last() (*model.ScaAuthUserDevice, error)
-	Find() ([]*model.ScaAuthUserDevice, error)
-	FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.ScaAuthUserDevice, err error)
-	FindInBatches(result *[]*model.ScaAuthUserDevice, batchSize int, fc func(tx gen.Dao, batch int) error) error
-	Pluck(column field.Expr, dest interface{}) error
-	Delete(...*model.ScaAuthUserDevice) (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) IScaAuthUserDeviceDo
-	Assign(attrs ...field.AssignExpr) IScaAuthUserDeviceDo
-	Joins(fields ...field.RelationField) IScaAuthUserDeviceDo
-	Preload(fields ...field.RelationField) IScaAuthUserDeviceDo
-	FirstOrInit() (*model.ScaAuthUserDevice, error)
-	FirstOrCreate() (*model.ScaAuthUserDevice, error)
-	FindByPage(offset int, limit int) (result []*model.ScaAuthUserDevice, 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) IScaAuthUserDeviceDo
-	UnderlyingDB() *gorm.DB
-	schema.Tabler
-}
-
-func (s scaAuthUserDeviceDo) Debug() IScaAuthUserDeviceDo {
-	return s.withDO(s.DO.Debug())
-}
-
-func (s scaAuthUserDeviceDo) WithContext(ctx context.Context) IScaAuthUserDeviceDo {
-	return s.withDO(s.DO.WithContext(ctx))
-}
-
-func (s scaAuthUserDeviceDo) ReadDB() IScaAuthUserDeviceDo {
-	return s.Clauses(dbresolver.Read)
-}
-
-func (s scaAuthUserDeviceDo) WriteDB() IScaAuthUserDeviceDo {
-	return s.Clauses(dbresolver.Write)
-}
-
-func (s scaAuthUserDeviceDo) Session(config *gorm.Session) IScaAuthUserDeviceDo {
-	return s.withDO(s.DO.Session(config))
-}
-
-func (s scaAuthUserDeviceDo) Clauses(conds ...clause.Expression) IScaAuthUserDeviceDo {
-	return s.withDO(s.DO.Clauses(conds...))
-}
-
-func (s scaAuthUserDeviceDo) Returning(value interface{}, columns ...string) IScaAuthUserDeviceDo {
-	return s.withDO(s.DO.Returning(value, columns...))
-}
-
-func (s scaAuthUserDeviceDo) Not(conds ...gen.Condition) IScaAuthUserDeviceDo {
-	return s.withDO(s.DO.Not(conds...))
-}
-
-func (s scaAuthUserDeviceDo) Or(conds ...gen.Condition) IScaAuthUserDeviceDo {
-	return s.withDO(s.DO.Or(conds...))
-}
-
-func (s scaAuthUserDeviceDo) Select(conds ...field.Expr) IScaAuthUserDeviceDo {
-	return s.withDO(s.DO.Select(conds...))
-}
-
-func (s scaAuthUserDeviceDo) Where(conds ...gen.Condition) IScaAuthUserDeviceDo {
-	return s.withDO(s.DO.Where(conds...))
-}
-
-func (s scaAuthUserDeviceDo) Order(conds ...field.Expr) IScaAuthUserDeviceDo {
-	return s.withDO(s.DO.Order(conds...))
-}
-
-func (s scaAuthUserDeviceDo) Distinct(cols ...field.Expr) IScaAuthUserDeviceDo {
-	return s.withDO(s.DO.Distinct(cols...))
-}
-
-func (s scaAuthUserDeviceDo) Omit(cols ...field.Expr) IScaAuthUserDeviceDo {
-	return s.withDO(s.DO.Omit(cols...))
-}
-
-func (s scaAuthUserDeviceDo) Join(table schema.Tabler, on ...field.Expr) IScaAuthUserDeviceDo {
-	return s.withDO(s.DO.Join(table, on...))
-}
-
-func (s scaAuthUserDeviceDo) LeftJoin(table schema.Tabler, on ...field.Expr) IScaAuthUserDeviceDo {
-	return s.withDO(s.DO.LeftJoin(table, on...))
-}
-
-func (s scaAuthUserDeviceDo) RightJoin(table schema.Tabler, on ...field.Expr) IScaAuthUserDeviceDo {
-	return s.withDO(s.DO.RightJoin(table, on...))
-}
-
-func (s scaAuthUserDeviceDo) Group(cols ...field.Expr) IScaAuthUserDeviceDo {
-	return s.withDO(s.DO.Group(cols...))
-}
-
-func (s scaAuthUserDeviceDo) Having(conds ...gen.Condition) IScaAuthUserDeviceDo {
-	return s.withDO(s.DO.Having(conds...))
-}
-
-func (s scaAuthUserDeviceDo) Limit(limit int) IScaAuthUserDeviceDo {
-	return s.withDO(s.DO.Limit(limit))
-}
-
-func (s scaAuthUserDeviceDo) Offset(offset int) IScaAuthUserDeviceDo {
-	return s.withDO(s.DO.Offset(offset))
-}
-
-func (s scaAuthUserDeviceDo) Scopes(funcs ...func(gen.Dao) gen.Dao) IScaAuthUserDeviceDo {
-	return s.withDO(s.DO.Scopes(funcs...))
-}
-
-func (s scaAuthUserDeviceDo) Unscoped() IScaAuthUserDeviceDo {
-	return s.withDO(s.DO.Unscoped())
-}
-
-func (s scaAuthUserDeviceDo) Create(values ...*model.ScaAuthUserDevice) error {
-	if len(values) == 0 {
-		return nil
-	}
-	return s.DO.Create(values)
-}
-
-func (s scaAuthUserDeviceDo) CreateInBatches(values []*model.ScaAuthUserDevice, batchSize int) error {
-	return s.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 (s scaAuthUserDeviceDo) Save(values ...*model.ScaAuthUserDevice) error {
-	if len(values) == 0 {
-		return nil
-	}
-	return s.DO.Save(values)
-}
-
-func (s scaAuthUserDeviceDo) First() (*model.ScaAuthUserDevice, error) {
-	if result, err := s.DO.First(); err != nil {
-		return nil, err
-	} else {
-		return result.(*model.ScaAuthUserDevice), nil
-	}
-}
-
-func (s scaAuthUserDeviceDo) Take() (*model.ScaAuthUserDevice, error) {
-	if result, err := s.DO.Take(); err != nil {
-		return nil, err
-	} else {
-		return result.(*model.ScaAuthUserDevice), nil
-	}
-}
-
-func (s scaAuthUserDeviceDo) Last() (*model.ScaAuthUserDevice, error) {
-	if result, err := s.DO.Last(); err != nil {
-		return nil, err
-	} else {
-		return result.(*model.ScaAuthUserDevice), nil
-	}
-}
-
-func (s scaAuthUserDeviceDo) Find() ([]*model.ScaAuthUserDevice, error) {
-	result, err := s.DO.Find()
-	return result.([]*model.ScaAuthUserDevice), err
-}
-
-func (s scaAuthUserDeviceDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.ScaAuthUserDevice, err error) {
-	buf := make([]*model.ScaAuthUserDevice, 0, batchSize)
-	err = s.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 (s scaAuthUserDeviceDo) FindInBatches(result *[]*model.ScaAuthUserDevice, batchSize int, fc func(tx gen.Dao, batch int) error) error {
-	return s.DO.FindInBatches(result, batchSize, fc)
-}
-
-func (s scaAuthUserDeviceDo) Attrs(attrs ...field.AssignExpr) IScaAuthUserDeviceDo {
-	return s.withDO(s.DO.Attrs(attrs...))
-}
-
-func (s scaAuthUserDeviceDo) Assign(attrs ...field.AssignExpr) IScaAuthUserDeviceDo {
-	return s.withDO(s.DO.Assign(attrs...))
-}
-
-func (s scaAuthUserDeviceDo) Joins(fields ...field.RelationField) IScaAuthUserDeviceDo {
-	for _, _f := range fields {
-		s = *s.withDO(s.DO.Joins(_f))
-	}
-	return &s
-}
-
-func (s scaAuthUserDeviceDo) Preload(fields ...field.RelationField) IScaAuthUserDeviceDo {
-	for _, _f := range fields {
-		s = *s.withDO(s.DO.Preload(_f))
-	}
-	return &s
-}
-
-func (s scaAuthUserDeviceDo) FirstOrInit() (*model.ScaAuthUserDevice, error) {
-	if result, err := s.DO.FirstOrInit(); err != nil {
-		return nil, err
-	} else {
-		return result.(*model.ScaAuthUserDevice), nil
-	}
-}
-
-func (s scaAuthUserDeviceDo) FirstOrCreate() (*model.ScaAuthUserDevice, error) {
-	if result, err := s.DO.FirstOrCreate(); err != nil {
-		return nil, err
-	} else {
-		return result.(*model.ScaAuthUserDevice), nil
-	}
-}
-
-func (s scaAuthUserDeviceDo) FindByPage(offset int, limit int) (result []*model.ScaAuthUserDevice, count int64, err error) {
-	result, err = s.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 = s.Offset(-1).Limit(-1).Count()
-	return
-}
-
-func (s scaAuthUserDeviceDo) ScanByPage(result interface{}, offset int, limit int) (count int64, err error) {
-	count, err = s.Count()
-	if err != nil {
-		return
-	}
-
-	err = s.Offset(offset).Limit(limit).Scan(result)
-	return
-}
-
-func (s scaAuthUserDeviceDo) Scan(result interface{}) (err error) {
-	return s.DO.Scan(result)
-}
-
-func (s scaAuthUserDeviceDo) Delete(models ...*model.ScaAuthUserDevice) (result gen.ResultInfo, err error) {
-	return s.DO.Delete(models)
-}
-
-func (s *scaAuthUserDeviceDo) withDO(do gen.Dao) *scaAuthUserDeviceDo {
-	s.DO = *do.(*gen.DO)
-	return s
-}

app/auth/api/model/mysql/query/sca_auth_user_social.gen.go

@@ -1,407 +0,0 @@
-// 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 query
-
-import (
-	"context"
-	"schisandra-album-cloud-microservices/app/auth/api/model/mysql/model"
-
-	"gorm.io/gorm"
-	"gorm.io/gorm/clause"
-	"gorm.io/gorm/schema"
-
-	"gorm.io/gen"
-	"gorm.io/gen/field"
-
-	"gorm.io/plugin/dbresolver"
-)
-
-func newScaAuthUserSocial(db *gorm.DB, opts ...gen.DOOption) scaAuthUserSocial {
-	_scaAuthUserSocial := scaAuthUserSocial{}
-
-	_scaAuthUserSocial.scaAuthUserSocialDo.UseDB(db, opts...)
-	_scaAuthUserSocial.scaAuthUserSocialDo.UseModel(&model.ScaAuthUserSocial{})
-
-	tableName := _scaAuthUserSocial.scaAuthUserSocialDo.TableName()
-	_scaAuthUserSocial.ALL = field.NewAsterisk(tableName)
-	_scaAuthUserSocial.ID = field.NewInt64(tableName, "id")
-	_scaAuthUserSocial.UserID = field.NewString(tableName, "user_id")
-	_scaAuthUserSocial.OpenID = field.NewString(tableName, "open_id")
-	_scaAuthUserSocial.Source = field.NewString(tableName, "source")
-	_scaAuthUserSocial.Status = field.NewInt64(tableName, "status")
-	_scaAuthUserSocial.CreatedAt = field.NewTime(tableName, "created_at")
-	_scaAuthUserSocial.UpdatedAt = field.NewTime(tableName, "updated_at")
-	_scaAuthUserSocial.DeletedAt = field.NewField(tableName, "deleted_at")
-
-	_scaAuthUserSocial.fillFieldMap()
-
-	return _scaAuthUserSocial
-}
-
-type scaAuthUserSocial struct {
-	scaAuthUserSocialDo
-
-	ALL       field.Asterisk
-	ID        field.Int64  // 主键ID
-	UserID    field.String // 用户ID
-	OpenID    field.String // 第三方用户的 open id
-	Source    field.String // 第三方用户来源
-	Status    field.Int64  // 状态 0正常 1 封禁
-	CreatedAt field.Time   // 创建时间
-	UpdatedAt field.Time   // 更新时间
-	DeletedAt field.Field  // 删除时间
-
-	fieldMap map[string]field.Expr
-}
-
-func (s scaAuthUserSocial) Table(newTableName string) *scaAuthUserSocial {
-	s.scaAuthUserSocialDo.UseTable(newTableName)
-	return s.updateTableName(newTableName)
-}
-
-func (s scaAuthUserSocial) As(alias string) *scaAuthUserSocial {
-	s.scaAuthUserSocialDo.DO = *(s.scaAuthUserSocialDo.As(alias).(*gen.DO))
-	return s.updateTableName(alias)
-}
-
-func (s *scaAuthUserSocial) updateTableName(table string) *scaAuthUserSocial {
-	s.ALL = field.NewAsterisk(table)
-	s.ID = field.NewInt64(table, "id")
-	s.UserID = field.NewString(table, "user_id")
-	s.OpenID = field.NewString(table, "open_id")
-	s.Source = field.NewString(table, "source")
-	s.Status = field.NewInt64(table, "status")
-	s.CreatedAt = field.NewTime(table, "created_at")
-	s.UpdatedAt = field.NewTime(table, "updated_at")
-	s.DeletedAt = field.NewField(table, "deleted_at")
-
-	s.fillFieldMap()
-
-	return s
-}
-
-func (s *scaAuthUserSocial) GetFieldByName(fieldName string) (field.OrderExpr, bool) {
-	_f, ok := s.fieldMap[fieldName]
-	if !ok || _f == nil {
-		return nil, false
-	}
-	_oe, ok := _f.(field.OrderExpr)
-	return _oe, ok
-}
-
-func (s *scaAuthUserSocial) fillFieldMap() {
-	s.fieldMap = make(map[string]field.Expr, 8)
-	s.fieldMap["id"] = s.ID
-	s.fieldMap["user_id"] = s.UserID
-	s.fieldMap["open_id"] = s.OpenID
-	s.fieldMap["source"] = s.Source
-	s.fieldMap["status"] = s.Status
-	s.fieldMap["created_at"] = s.CreatedAt
-	s.fieldMap["updated_at"] = s.UpdatedAt
-	s.fieldMap["deleted_at"] = s.DeletedAt
-}
-
-func (s scaAuthUserSocial) clone(db *gorm.DB) scaAuthUserSocial {
-	s.scaAuthUserSocialDo.ReplaceConnPool(db.Statement.ConnPool)
-	return s
-}
-
-func (s scaAuthUserSocial) replaceDB(db *gorm.DB) scaAuthUserSocial {
-	s.scaAuthUserSocialDo.ReplaceDB(db)
-	return s
-}
-
-type scaAuthUserSocialDo struct{ gen.DO }
-
-type IScaAuthUserSocialDo interface {
-	gen.SubQuery
-	Debug() IScaAuthUserSocialDo
-	WithContext(ctx context.Context) IScaAuthUserSocialDo
-	WithResult(fc func(tx gen.Dao)) gen.ResultInfo
-	ReplaceDB(db *gorm.DB)
-	ReadDB() IScaAuthUserSocialDo
-	WriteDB() IScaAuthUserSocialDo
-	As(alias string) gen.Dao
-	Session(config *gorm.Session) IScaAuthUserSocialDo
-	Columns(cols ...field.Expr) gen.Columns
-	Clauses(conds ...clause.Expression) IScaAuthUserSocialDo
-	Not(conds ...gen.Condition) IScaAuthUserSocialDo
-	Or(conds ...gen.Condition) IScaAuthUserSocialDo
-	Select(conds ...field.Expr) IScaAuthUserSocialDo
-	Where(conds ...gen.Condition) IScaAuthUserSocialDo
-	Order(conds ...field.Expr) IScaAuthUserSocialDo
-	Distinct(cols ...field.Expr) IScaAuthUserSocialDo
-	Omit(cols ...field.Expr) IScaAuthUserSocialDo
-	Join(table schema.Tabler, on ...field.Expr) IScaAuthUserSocialDo
-	LeftJoin(table schema.Tabler, on ...field.Expr) IScaAuthUserSocialDo
-	RightJoin(table schema.Tabler, on ...field.Expr) IScaAuthUserSocialDo
-	Group(cols ...field.Expr) IScaAuthUserSocialDo
-	Having(conds ...gen.Condition) IScaAuthUserSocialDo
-	Limit(limit int) IScaAuthUserSocialDo
-	Offset(offset int) IScaAuthUserSocialDo
-	Count() (count int64, err error)
-	Scopes(funcs ...func(gen.Dao) gen.Dao) IScaAuthUserSocialDo
-	Unscoped() IScaAuthUserSocialDo
-	Create(values ...*model.ScaAuthUserSocial) error
-	CreateInBatches(values []*model.ScaAuthUserSocial, batchSize int) error
-	Save(values ...*model.ScaAuthUserSocial) error
-	First() (*model.ScaAuthUserSocial, error)
-	Take() (*model.ScaAuthUserSocial, error)
-	Last() (*model.ScaAuthUserSocial, error)
-	Find() ([]*model.ScaAuthUserSocial, error)
-	FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.ScaAuthUserSocial, err error)
-	FindInBatches(result *[]*model.ScaAuthUserSocial, batchSize int, fc func(tx gen.Dao, batch int) error) error
-	Pluck(column field.Expr, dest interface{}) error
-	Delete(...*model.ScaAuthUserSocial) (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) IScaAuthUserSocialDo
-	Assign(attrs ...field.AssignExpr) IScaAuthUserSocialDo
-	Joins(fields ...field.RelationField) IScaAuthUserSocialDo
-	Preload(fields ...field.RelationField) IScaAuthUserSocialDo
-	FirstOrInit() (*model.ScaAuthUserSocial, error)
-	FirstOrCreate() (*model.ScaAuthUserSocial, error)
-	FindByPage(offset int, limit int) (result []*model.ScaAuthUserSocial, 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) IScaAuthUserSocialDo
-	UnderlyingDB() *gorm.DB
-	schema.Tabler
-}
-
-func (s scaAuthUserSocialDo) Debug() IScaAuthUserSocialDo {
-	return s.withDO(s.DO.Debug())
-}
-
-func (s scaAuthUserSocialDo) WithContext(ctx context.Context) IScaAuthUserSocialDo {
-	return s.withDO(s.DO.WithContext(ctx))
-}
-
-func (s scaAuthUserSocialDo) ReadDB() IScaAuthUserSocialDo {
-	return s.Clauses(dbresolver.Read)
-}
-
-func (s scaAuthUserSocialDo) WriteDB() IScaAuthUserSocialDo {
-	return s.Clauses(dbresolver.Write)
-}
-
-func (s scaAuthUserSocialDo) Session(config *gorm.Session) IScaAuthUserSocialDo {
-	return s.withDO(s.DO.Session(config))
-}
-
-func (s scaAuthUserSocialDo) Clauses(conds ...clause.Expression) IScaAuthUserSocialDo {
-	return s.withDO(s.DO.Clauses(conds...))
-}
-
-func (s scaAuthUserSocialDo) Returning(value interface{}, columns ...string) IScaAuthUserSocialDo {
-	return s.withDO(s.DO.Returning(value, columns...))
-}
-
-func (s scaAuthUserSocialDo) Not(conds ...gen.Condition) IScaAuthUserSocialDo {
-	return s.withDO(s.DO.Not(conds...))
-}
-
-func (s scaAuthUserSocialDo) Or(conds ...gen.Condition) IScaAuthUserSocialDo {
-	return s.withDO(s.DO.Or(conds...))
-}
-
-func (s scaAuthUserSocialDo) Select(conds ...field.Expr) IScaAuthUserSocialDo {
-	return s.withDO(s.DO.Select(conds...))
-}
-
-func (s scaAuthUserSocialDo) Where(conds ...gen.Condition) IScaAuthUserSocialDo {
-	return s.withDO(s.DO.Where(conds...))
-}
-
-func (s scaAuthUserSocialDo) Order(conds ...field.Expr) IScaAuthUserSocialDo {
-	return s.withDO(s.DO.Order(conds...))
-}
-
-func (s scaAuthUserSocialDo) Distinct(cols ...field.Expr) IScaAuthUserSocialDo {
-	return s.withDO(s.DO.Distinct(cols...))
-}
-
-func (s scaAuthUserSocialDo) Omit(cols ...field.Expr) IScaAuthUserSocialDo {
-	return s.withDO(s.DO.Omit(cols...))
-}
-
-func (s scaAuthUserSocialDo) Join(table schema.Tabler, on ...field.Expr) IScaAuthUserSocialDo {
-	return s.withDO(s.DO.Join(table, on...))
-}
-
-func (s scaAuthUserSocialDo) LeftJoin(table schema.Tabler, on ...field.Expr) IScaAuthUserSocialDo {
-	return s.withDO(s.DO.LeftJoin(table, on...))
-}
-
-func (s scaAuthUserSocialDo) RightJoin(table schema.Tabler, on ...field.Expr) IScaAuthUserSocialDo {
-	return s.withDO(s.DO.RightJoin(table, on...))
-}
-
-func (s scaAuthUserSocialDo) Group(cols ...field.Expr) IScaAuthUserSocialDo {
-	return s.withDO(s.DO.Group(cols...))
-}
-
-func (s scaAuthUserSocialDo) Having(conds ...gen.Condition) IScaAuthUserSocialDo {
-	return s.withDO(s.DO.Having(conds...))
-}
-
-func (s scaAuthUserSocialDo) Limit(limit int) IScaAuthUserSocialDo {
-	return s.withDO(s.DO.Limit(limit))
-}
-
-func (s scaAuthUserSocialDo) Offset(offset int) IScaAuthUserSocialDo {
-	return s.withDO(s.DO.Offset(offset))
-}
-
-func (s scaAuthUserSocialDo) Scopes(funcs ...func(gen.Dao) gen.Dao) IScaAuthUserSocialDo {
-	return s.withDO(s.DO.Scopes(funcs...))
-}
-
-func (s scaAuthUserSocialDo) Unscoped() IScaAuthUserSocialDo {
-	return s.withDO(s.DO.Unscoped())
-}
-
-func (s scaAuthUserSocialDo) Create(values ...*model.ScaAuthUserSocial) error {
-	if len(values) == 0 {
-		return nil
-	}
-	return s.DO.Create(values)
-}
-
-func (s scaAuthUserSocialDo) CreateInBatches(values []*model.ScaAuthUserSocial, batchSize int) error {
-	return s.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 (s scaAuthUserSocialDo) Save(values ...*model.ScaAuthUserSocial) error {
-	if len(values) == 0 {
-		return nil
-	}
-	return s.DO.Save(values)
-}
-
-func (s scaAuthUserSocialDo) First() (*model.ScaAuthUserSocial, error) {
-	if result, err := s.DO.First(); err != nil {
-		return nil, err
-	} else {
-		return result.(*model.ScaAuthUserSocial), nil
-	}
-}
-
-func (s scaAuthUserSocialDo) Take() (*model.ScaAuthUserSocial, error) {
-	if result, err := s.DO.Take(); err != nil {
-		return nil, err
-	} else {
-		return result.(*model.ScaAuthUserSocial), nil
-	}
-}
-
-func (s scaAuthUserSocialDo) Last() (*model.ScaAuthUserSocial, error) {
-	if result, err := s.DO.Last(); err != nil {
-		return nil, err
-	} else {
-		return result.(*model.ScaAuthUserSocial), nil
-	}
-}
-
-func (s scaAuthUserSocialDo) Find() ([]*model.ScaAuthUserSocial, error) {
-	result, err := s.DO.Find()
-	return result.([]*model.ScaAuthUserSocial), err
-}
-
-func (s scaAuthUserSocialDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.ScaAuthUserSocial, err error) {
-	buf := make([]*model.ScaAuthUserSocial, 0, batchSize)
-	err = s.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 (s scaAuthUserSocialDo) FindInBatches(result *[]*model.ScaAuthUserSocial, batchSize int, fc func(tx gen.Dao, batch int) error) error {
-	return s.DO.FindInBatches(result, batchSize, fc)
-}
-
-func (s scaAuthUserSocialDo) Attrs(attrs ...field.AssignExpr) IScaAuthUserSocialDo {
-	return s.withDO(s.DO.Attrs(attrs...))
-}
-
-func (s scaAuthUserSocialDo) Assign(attrs ...field.AssignExpr) IScaAuthUserSocialDo {
-	return s.withDO(s.DO.Assign(attrs...))
-}
-
-func (s scaAuthUserSocialDo) Joins(fields ...field.RelationField) IScaAuthUserSocialDo {
-	for _, _f := range fields {
-		s = *s.withDO(s.DO.Joins(_f))
-	}
-	return &s
-}
-
-func (s scaAuthUserSocialDo) Preload(fields ...field.RelationField) IScaAuthUserSocialDo {
-	for _, _f := range fields {
-		s = *s.withDO(s.DO.Preload(_f))
-	}
-	return &s
-}
-
-func (s scaAuthUserSocialDo) FirstOrInit() (*model.ScaAuthUserSocial, error) {
-	if result, err := s.DO.FirstOrInit(); err != nil {
-		return nil, err
-	} else {
-		return result.(*model.ScaAuthUserSocial), nil
-	}
-}
-
-func (s scaAuthUserSocialDo) FirstOrCreate() (*model.ScaAuthUserSocial, error) {
-	if result, err := s.DO.FirstOrCreate(); err != nil {
-		return nil, err
-	} else {
-		return result.(*model.ScaAuthUserSocial), nil
-	}
-}
-
-func (s scaAuthUserSocialDo) FindByPage(offset int, limit int) (result []*model.ScaAuthUserSocial, count int64, err error) {
-	result, err = s.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 = s.Offset(-1).Limit(-1).Count()
-	return
-}
-
-func (s scaAuthUserSocialDo) ScanByPage(result interface{}, offset int, limit int) (count int64, err error) {
-	count, err = s.Count()
-	if err != nil {
-		return
-	}
-
-	err = s.Offset(offset).Limit(limit).Scan(result)
-	return
-}
-
-func (s scaAuthUserSocialDo) Scan(result interface{}) (err error) {
-	return s.DO.Scan(result)
-}
-
-func (s scaAuthUserSocialDo) Delete(models ...*model.ScaAuthUserSocial) (result gen.ResultInfo, err error) {
-	return s.DO.Delete(models)
-}
-
-func (s *scaAuthUserSocialDo) withDO(do gen.Dao) *scaAuthUserSocialDo {
-	s.DO = *do.(*gen.DO)
-	return s
-}

app/auth/api/model/mysql/query/sca_user_level.gen.go

@@ -1,419 +0,0 @@
-// 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 query
-
-import (
-	"context"
-	"schisandra-album-cloud-microservices/app/auth/api/model/mysql/model"
-
-	"gorm.io/gorm"
-	"gorm.io/gorm/clause"
-	"gorm.io/gorm/schema"
-
-	"gorm.io/gen"
-	"gorm.io/gen/field"
-
-	"gorm.io/plugin/dbresolver"
-)
-
-func newScaUserLevel(db *gorm.DB, opts ...gen.DOOption) scaUserLevel {
-	_scaUserLevel := scaUserLevel{}
-
-	_scaUserLevel.scaUserLevelDo.UseDB(db, opts...)
-	_scaUserLevel.scaUserLevelDo.UseModel(&model.ScaUserLevel{})
-
-	tableName := _scaUserLevel.scaUserLevelDo.TableName()
-	_scaUserLevel.ALL = field.NewAsterisk(tableName)
-	_scaUserLevel.ID = field.NewInt64(tableName, "id")
-	_scaUserLevel.UserID = field.NewString(tableName, "user_id")
-	_scaUserLevel.LevelType = field.NewInt64(tableName, "level_type")
-	_scaUserLevel.Level = field.NewInt64(tableName, "level")
-	_scaUserLevel.LevelName = field.NewString(tableName, "level_name")
-	_scaUserLevel.ExpStart = field.NewInt64(tableName, "exp_start")
-	_scaUserLevel.ExpEnd = field.NewInt64(tableName, "exp_end")
-	_scaUserLevel.Description = field.NewString(tableName, "description")
-	_scaUserLevel.CreatedAt = field.NewTime(tableName, "created_at")
-	_scaUserLevel.UpdatedAt = field.NewTime(tableName, "updated_at")
-	_scaUserLevel.DeletedAt = field.NewField(tableName, "deleted_at")
-
-	_scaUserLevel.fillFieldMap()
-
-	return _scaUserLevel
-}
-
-type scaUserLevel struct {
-	scaUserLevelDo
-
-	ALL         field.Asterisk
-	ID          field.Int64  // 主键
-	UserID      field.String // 用户Id
-	LevelType   field.Int64  // 等级类型
-	Level       field.Int64  // 等级
-	LevelName   field.String // 等级名称
-	ExpStart    field.Int64  // 开始经验值
-	ExpEnd      field.Int64  // 结束经验值
-	Description field.String // 等级描述
-	CreatedAt   field.Time   // 创建时间
-	UpdatedAt   field.Time   // 更新时间
-	DeletedAt   field.Field  // 删除时间
-
-	fieldMap map[string]field.Expr
-}
-
-func (s scaUserLevel) Table(newTableName string) *scaUserLevel {
-	s.scaUserLevelDo.UseTable(newTableName)
-	return s.updateTableName(newTableName)
-}
-
-func (s scaUserLevel) As(alias string) *scaUserLevel {
-	s.scaUserLevelDo.DO = *(s.scaUserLevelDo.As(alias).(*gen.DO))
-	return s.updateTableName(alias)
-}
-
-func (s *scaUserLevel) updateTableName(table string) *scaUserLevel {
-	s.ALL = field.NewAsterisk(table)
-	s.ID = field.NewInt64(table, "id")
-	s.UserID = field.NewString(table, "user_id")
-	s.LevelType = field.NewInt64(table, "level_type")
-	s.Level = field.NewInt64(table, "level")
-	s.LevelName = field.NewString(table, "level_name")
-	s.ExpStart = field.NewInt64(table, "exp_start")
-	s.ExpEnd = field.NewInt64(table, "exp_end")
-	s.Description = field.NewString(table, "description")
-	s.CreatedAt = field.NewTime(table, "created_at")
-	s.UpdatedAt = field.NewTime(table, "updated_at")
-	s.DeletedAt = field.NewField(table, "deleted_at")
-
-	s.fillFieldMap()
-
-	return s
-}
-
-func (s *scaUserLevel) GetFieldByName(fieldName string) (field.OrderExpr, bool) {
-	_f, ok := s.fieldMap[fieldName]
-	if !ok || _f == nil {
-		return nil, false
-	}
-	_oe, ok := _f.(field.OrderExpr)
-	return _oe, ok
-}
-
-func (s *scaUserLevel) fillFieldMap() {
-	s.fieldMap = make(map[string]field.Expr, 11)
-	s.fieldMap["id"] = s.ID
-	s.fieldMap["user_id"] = s.UserID
-	s.fieldMap["level_type"] = s.LevelType
-	s.fieldMap["level"] = s.Level
-	s.fieldMap["level_name"] = s.LevelName
-	s.fieldMap["exp_start"] = s.ExpStart
-	s.fieldMap["exp_end"] = s.ExpEnd
-	s.fieldMap["description"] = s.Description
-	s.fieldMap["created_at"] = s.CreatedAt
-	s.fieldMap["updated_at"] = s.UpdatedAt
-	s.fieldMap["deleted_at"] = s.DeletedAt
-}
-
-func (s scaUserLevel) clone(db *gorm.DB) scaUserLevel {
-	s.scaUserLevelDo.ReplaceConnPool(db.Statement.ConnPool)
-	return s
-}
-
-func (s scaUserLevel) replaceDB(db *gorm.DB) scaUserLevel {
-	s.scaUserLevelDo.ReplaceDB(db)
-	return s
-}
-
-type scaUserLevelDo struct{ gen.DO }
-
-type IScaUserLevelDo interface {
-	gen.SubQuery
-	Debug() IScaUserLevelDo
-	WithContext(ctx context.Context) IScaUserLevelDo
-	WithResult(fc func(tx gen.Dao)) gen.ResultInfo
-	ReplaceDB(db *gorm.DB)
-	ReadDB() IScaUserLevelDo
-	WriteDB() IScaUserLevelDo
-	As(alias string) gen.Dao
-	Session(config *gorm.Session) IScaUserLevelDo
-	Columns(cols ...field.Expr) gen.Columns
-	Clauses(conds ...clause.Expression) IScaUserLevelDo
-	Not(conds ...gen.Condition) IScaUserLevelDo
-	Or(conds ...gen.Condition) IScaUserLevelDo
-	Select(conds ...field.Expr) IScaUserLevelDo
-	Where(conds ...gen.Condition) IScaUserLevelDo
-	Order(conds ...field.Expr) IScaUserLevelDo
-	Distinct(cols ...field.Expr) IScaUserLevelDo
-	Omit(cols ...field.Expr) IScaUserLevelDo
-	Join(table schema.Tabler, on ...field.Expr) IScaUserLevelDo
-	LeftJoin(table schema.Tabler, on ...field.Expr) IScaUserLevelDo
-	RightJoin(table schema.Tabler, on ...field.Expr) IScaUserLevelDo
-	Group(cols ...field.Expr) IScaUserLevelDo
-	Having(conds ...gen.Condition) IScaUserLevelDo
-	Limit(limit int) IScaUserLevelDo
-	Offset(offset int) IScaUserLevelDo
-	Count() (count int64, err error)
-	Scopes(funcs ...func(gen.Dao) gen.Dao) IScaUserLevelDo
-	Unscoped() IScaUserLevelDo
-	Create(values ...*model.ScaUserLevel) error
-	CreateInBatches(values []*model.ScaUserLevel, batchSize int) error
-	Save(values ...*model.ScaUserLevel) error
-	First() (*model.ScaUserLevel, error)
-	Take() (*model.ScaUserLevel, error)
-	Last() (*model.ScaUserLevel, error)
-	Find() ([]*model.ScaUserLevel, error)
-	FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.ScaUserLevel, err error)
-	FindInBatches(result *[]*model.ScaUserLevel, batchSize int, fc func(tx gen.Dao, batch int) error) error
-	Pluck(column field.Expr, dest interface{}) error
-	Delete(...*model.ScaUserLevel) (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) IScaUserLevelDo
-	Assign(attrs ...field.AssignExpr) IScaUserLevelDo
-	Joins(fields ...field.RelationField) IScaUserLevelDo
-	Preload(fields ...field.RelationField) IScaUserLevelDo
-	FirstOrInit() (*model.ScaUserLevel, error)
-	FirstOrCreate() (*model.ScaUserLevel, error)
-	FindByPage(offset int, limit int) (result []*model.ScaUserLevel, 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) IScaUserLevelDo
-	UnderlyingDB() *gorm.DB
-	schema.Tabler
-}
-
-func (s scaUserLevelDo) Debug() IScaUserLevelDo {
-	return s.withDO(s.DO.Debug())
-}
-
-func (s scaUserLevelDo) WithContext(ctx context.Context) IScaUserLevelDo {
-	return s.withDO(s.DO.WithContext(ctx))
-}
-
-func (s scaUserLevelDo) ReadDB() IScaUserLevelDo {
-	return s.Clauses(dbresolver.Read)
-}
-
-func (s scaUserLevelDo) WriteDB() IScaUserLevelDo {
-	return s.Clauses(dbresolver.Write)
-}
-
-func (s scaUserLevelDo) Session(config *gorm.Session) IScaUserLevelDo {
-	return s.withDO(s.DO.Session(config))
-}
-
-func (s scaUserLevelDo) Clauses(conds ...clause.Expression) IScaUserLevelDo {
-	return s.withDO(s.DO.Clauses(conds...))
-}
-
-func (s scaUserLevelDo) Returning(value interface{}, columns ...string) IScaUserLevelDo {
-	return s.withDO(s.DO.Returning(value, columns...))
-}
-
-func (s scaUserLevelDo) Not(conds ...gen.Condition) IScaUserLevelDo {
-	return s.withDO(s.DO.Not(conds...))
-}
-
-func (s scaUserLevelDo) Or(conds ...gen.Condition) IScaUserLevelDo {
-	return s.withDO(s.DO.Or(conds...))
-}
-
-func (s scaUserLevelDo) Select(conds ...field.Expr) IScaUserLevelDo {
-	return s.withDO(s.DO.Select(conds...))
-}
-
-func (s scaUserLevelDo) Where(conds ...gen.Condition) IScaUserLevelDo {
-	return s.withDO(s.DO.Where(conds...))
-}
-
-func (s scaUserLevelDo) Order(conds ...field.Expr) IScaUserLevelDo {
-	return s.withDO(s.DO.Order(conds...))
-}
-
-func (s scaUserLevelDo) Distinct(cols ...field.Expr) IScaUserLevelDo {
-	return s.withDO(s.DO.Distinct(cols...))
-}
-
-func (s scaUserLevelDo) Omit(cols ...field.Expr) IScaUserLevelDo {
-	return s.withDO(s.DO.Omit(cols...))
-}
-
-func (s scaUserLevelDo) Join(table schema.Tabler, on ...field.Expr) IScaUserLevelDo {
-	return s.withDO(s.DO.Join(table, on...))
-}
-
-func (s scaUserLevelDo) LeftJoin(table schema.Tabler, on ...field.Expr) IScaUserLevelDo {
-	return s.withDO(s.DO.LeftJoin(table, on...))
-}
-
-func (s scaUserLevelDo) RightJoin(table schema.Tabler, on ...field.Expr) IScaUserLevelDo {
-	return s.withDO(s.DO.RightJoin(table, on...))
-}
-
-func (s scaUserLevelDo) Group(cols ...field.Expr) IScaUserLevelDo {
-	return s.withDO(s.DO.Group(cols...))
-}
-
-func (s scaUserLevelDo) Having(conds ...gen.Condition) IScaUserLevelDo {
-	return s.withDO(s.DO.Having(conds...))
-}
-
-func (s scaUserLevelDo) Limit(limit int) IScaUserLevelDo {
-	return s.withDO(s.DO.Limit(limit))
-}
-
-func (s scaUserLevelDo) Offset(offset int) IScaUserLevelDo {
-	return s.withDO(s.DO.Offset(offset))
-}
-
-func (s scaUserLevelDo) Scopes(funcs ...func(gen.Dao) gen.Dao) IScaUserLevelDo {
-	return s.withDO(s.DO.Scopes(funcs...))
-}
-
-func (s scaUserLevelDo) Unscoped() IScaUserLevelDo {
-	return s.withDO(s.DO.Unscoped())
-}
-
-func (s scaUserLevelDo) Create(values ...*model.ScaUserLevel) error {
-	if len(values) == 0 {
-		return nil
-	}
-	return s.DO.Create(values)
-}
-
-func (s scaUserLevelDo) CreateInBatches(values []*model.ScaUserLevel, batchSize int) error {
-	return s.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 (s scaUserLevelDo) Save(values ...*model.ScaUserLevel) error {
-	if len(values) == 0 {
-		return nil
-	}
-	return s.DO.Save(values)
-}
-
-func (s scaUserLevelDo) First() (*model.ScaUserLevel, error) {
-	if result, err := s.DO.First(); err != nil {
-		return nil, err
-	} else {
-		return result.(*model.ScaUserLevel), nil
-	}
-}
-
-func (s scaUserLevelDo) Take() (*model.ScaUserLevel, error) {
-	if result, err := s.DO.Take(); err != nil {
-		return nil, err
-	} else {
-		return result.(*model.ScaUserLevel), nil
-	}
-}
-
-func (s scaUserLevelDo) Last() (*model.ScaUserLevel, error) {
-	if result, err := s.DO.Last(); err != nil {
-		return nil, err
-	} else {
-		return result.(*model.ScaUserLevel), nil
-	}
-}
-
-func (s scaUserLevelDo) Find() ([]*model.ScaUserLevel, error) {
-	result, err := s.DO.Find()
-	return result.([]*model.ScaUserLevel), err
-}
-
-func (s scaUserLevelDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.ScaUserLevel, err error) {
-	buf := make([]*model.ScaUserLevel, 0, batchSize)
-	err = s.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 (s scaUserLevelDo) FindInBatches(result *[]*model.ScaUserLevel, batchSize int, fc func(tx gen.Dao, batch int) error) error {
-	return s.DO.FindInBatches(result, batchSize, fc)
-}
-
-func (s scaUserLevelDo) Attrs(attrs ...field.AssignExpr) IScaUserLevelDo {
-	return s.withDO(s.DO.Attrs(attrs...))
-}
-
-func (s scaUserLevelDo) Assign(attrs ...field.AssignExpr) IScaUserLevelDo {
-	return s.withDO(s.DO.Assign(attrs...))
-}
-
-func (s scaUserLevelDo) Joins(fields ...field.RelationField) IScaUserLevelDo {
-	for _, _f := range fields {
-		s = *s.withDO(s.DO.Joins(_f))
-	}
-	return &s
-}
-
-func (s scaUserLevelDo) Preload(fields ...field.RelationField) IScaUserLevelDo {
-	for _, _f := range fields {
-		s = *s.withDO(s.DO.Preload(_f))
-	}
-	return &s
-}
-
-func (s scaUserLevelDo) FirstOrInit() (*model.ScaUserLevel, error) {
-	if result, err := s.DO.FirstOrInit(); err != nil {
-		return nil, err
-	} else {
-		return result.(*model.ScaUserLevel), nil
-	}
-}
-
-func (s scaUserLevelDo) FirstOrCreate() (*model.ScaUserLevel, error) {
-	if result, err := s.DO.FirstOrCreate(); err != nil {
-		return nil, err
-	} else {
-		return result.(*model.ScaUserLevel), nil
-	}
-}
-
-func (s scaUserLevelDo) FindByPage(offset int, limit int) (result []*model.ScaUserLevel, count int64, err error) {
-	result, err = s.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 = s.Offset(-1).Limit(-1).Count()
-	return
-}
-
-func (s scaUserLevelDo) ScanByPage(result interface{}, offset int, limit int) (count int64, err error) {
-	count, err = s.Count()
-	if err != nil {
-		return
-	}
-
-	err = s.Offset(offset).Limit(limit).Scan(result)
-	return
-}
-
-func (s scaUserLevelDo) Scan(result interface{}) (err error) {
-	return s.DO.Scan(result)
-}
-
-func (s scaUserLevelDo) Delete(models ...*model.ScaUserLevel) (result gen.ResultInfo, err error) {
-	return s.DO.Delete(models)
-}
-
-func (s *scaUserLevelDo) withDO(do gen.Dao) *scaUserLevelDo {
-	s.DO = *do.(*gen.DO)
-	return s
-}

app/auth/api/model/mysql/query/sca_user_message.gen.go

@@ -1,411 +0,0 @@
-// 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 query
-
-import (
-	"context"
-	"schisandra-album-cloud-microservices/app/auth/api/model/mysql/model"
-
-	"gorm.io/gorm"
-	"gorm.io/gorm/clause"
-	"gorm.io/gorm/schema"
-
-	"gorm.io/gen"
-	"gorm.io/gen/field"
-
-	"gorm.io/plugin/dbresolver"
-)
-
-func newScaUserMessage(db *gorm.DB, opts ...gen.DOOption) scaUserMessage {
-	_scaUserMessage := scaUserMessage{}
-
-	_scaUserMessage.scaUserMessageDo.UseDB(db, opts...)
-	_scaUserMessage.scaUserMessageDo.UseModel(&model.ScaUserMessage{})
-
-	tableName := _scaUserMessage.scaUserMessageDo.TableName()
-	_scaUserMessage.ALL = field.NewAsterisk(tableName)
-	_scaUserMessage.ID = field.NewInt64(tableName, "id")
-	_scaUserMessage.TopicID = field.NewString(tableName, "topic_id")
-	_scaUserMessage.FromID = field.NewString(tableName, "from_id")
-	_scaUserMessage.ToID = field.NewString(tableName, "to_id")
-	_scaUserMessage.Content = field.NewString(tableName, "content")
-	_scaUserMessage.IsRead = field.NewInt64(tableName, "is_read")
-	_scaUserMessage.CreatedAt = field.NewTime(tableName, "created_at")
-	_scaUserMessage.UpdatedAt = field.NewTime(tableName, "updated_at")
-	_scaUserMessage.DeletedAt = field.NewField(tableName, "deleted_at")
-
-	_scaUserMessage.fillFieldMap()
-
-	return _scaUserMessage
-}
-
-type scaUserMessage struct {
-	scaUserMessageDo
-
-	ALL       field.Asterisk
-	ID        field.Int64  // 主键
-	TopicID   field.String // 话题Id
-	FromID    field.String // 来自人
-	ToID      field.String // 送达人
-	Content   field.String // 消息内容
-	IsRead    field.Int64  // 是否已读
-	CreatedAt field.Time   // 创建时间
-	UpdatedAt field.Time   // 更新时间
-	DeletedAt field.Field  // 删除时间
-
-	fieldMap map[string]field.Expr
-}
-
-func (s scaUserMessage) Table(newTableName string) *scaUserMessage {
-	s.scaUserMessageDo.UseTable(newTableName)
-	return s.updateTableName(newTableName)
-}
-
-func (s scaUserMessage) As(alias string) *scaUserMessage {
-	s.scaUserMessageDo.DO = *(s.scaUserMessageDo.As(alias).(*gen.DO))
-	return s.updateTableName(alias)
-}
-
-func (s *scaUserMessage) updateTableName(table string) *scaUserMessage {
-	s.ALL = field.NewAsterisk(table)
-	s.ID = field.NewInt64(table, "id")
-	s.TopicID = field.NewString(table, "topic_id")
-	s.FromID = field.NewString(table, "from_id")
-	s.ToID = field.NewString(table, "to_id")
-	s.Content = field.NewString(table, "content")
-	s.IsRead = field.NewInt64(table, "is_read")
-	s.CreatedAt = field.NewTime(table, "created_at")
-	s.UpdatedAt = field.NewTime(table, "updated_at")
-	s.DeletedAt = field.NewField(table, "deleted_at")
-
-	s.fillFieldMap()
-
-	return s
-}
-
-func (s *scaUserMessage) GetFieldByName(fieldName string) (field.OrderExpr, bool) {
-	_f, ok := s.fieldMap[fieldName]
-	if !ok || _f == nil {
-		return nil, false
-	}
-	_oe, ok := _f.(field.OrderExpr)
-	return _oe, ok
-}
-
-func (s *scaUserMessage) fillFieldMap() {
-	s.fieldMap = make(map[string]field.Expr, 9)
-	s.fieldMap["id"] = s.ID
-	s.fieldMap["topic_id"] = s.TopicID
-	s.fieldMap["from_id"] = s.FromID
-	s.fieldMap["to_id"] = s.ToID
-	s.fieldMap["content"] = s.Content
-	s.fieldMap["is_read"] = s.IsRead
-	s.fieldMap["created_at"] = s.CreatedAt
-	s.fieldMap["updated_at"] = s.UpdatedAt
-	s.fieldMap["deleted_at"] = s.DeletedAt
-}
-
-func (s scaUserMessage) clone(db *gorm.DB) scaUserMessage {
-	s.scaUserMessageDo.ReplaceConnPool(db.Statement.ConnPool)
-	return s
-}
-
-func (s scaUserMessage) replaceDB(db *gorm.DB) scaUserMessage {
-	s.scaUserMessageDo.ReplaceDB(db)
-	return s
-}
-
-type scaUserMessageDo struct{ gen.DO }
-
-type IScaUserMessageDo interface {
-	gen.SubQuery
-	Debug() IScaUserMessageDo
-	WithContext(ctx context.Context) IScaUserMessageDo
-	WithResult(fc func(tx gen.Dao)) gen.ResultInfo
-	ReplaceDB(db *gorm.DB)
-	ReadDB() IScaUserMessageDo
-	WriteDB() IScaUserMessageDo
-	As(alias string) gen.Dao
-	Session(config *gorm.Session) IScaUserMessageDo
-	Columns(cols ...field.Expr) gen.Columns
-	Clauses(conds ...clause.Expression) IScaUserMessageDo
-	Not(conds ...gen.Condition) IScaUserMessageDo
-	Or(conds ...gen.Condition) IScaUserMessageDo
-	Select(conds ...field.Expr) IScaUserMessageDo
-	Where(conds ...gen.Condition) IScaUserMessageDo
-	Order(conds ...field.Expr) IScaUserMessageDo
-	Distinct(cols ...field.Expr) IScaUserMessageDo
-	Omit(cols ...field.Expr) IScaUserMessageDo
-	Join(table schema.Tabler, on ...field.Expr) IScaUserMessageDo
-	LeftJoin(table schema.Tabler, on ...field.Expr) IScaUserMessageDo
-	RightJoin(table schema.Tabler, on ...field.Expr) IScaUserMessageDo
-	Group(cols ...field.Expr) IScaUserMessageDo
-	Having(conds ...gen.Condition) IScaUserMessageDo
-	Limit(limit int) IScaUserMessageDo
-	Offset(offset int) IScaUserMessageDo
-	Count() (count int64, err error)
-	Scopes(funcs ...func(gen.Dao) gen.Dao) IScaUserMessageDo
-	Unscoped() IScaUserMessageDo
-	Create(values ...*model.ScaUserMessage) error
-	CreateInBatches(values []*model.ScaUserMessage, batchSize int) error
-	Save(values ...*model.ScaUserMessage) error
-	First() (*model.ScaUserMessage, error)
-	Take() (*model.ScaUserMessage, error)
-	Last() (*model.ScaUserMessage, error)
-	Find() ([]*model.ScaUserMessage, error)
-	FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.ScaUserMessage, err error)
-	FindInBatches(result *[]*model.ScaUserMessage, batchSize int, fc func(tx gen.Dao, batch int) error) error
-	Pluck(column field.Expr, dest interface{}) error
-	Delete(...*model.ScaUserMessage) (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) IScaUserMessageDo
-	Assign(attrs ...field.AssignExpr) IScaUserMessageDo
-	Joins(fields ...field.RelationField) IScaUserMessageDo
-	Preload(fields ...field.RelationField) IScaUserMessageDo
-	FirstOrInit() (*model.ScaUserMessage, error)
-	FirstOrCreate() (*model.ScaUserMessage, error)
-	FindByPage(offset int, limit int) (result []*model.ScaUserMessage, 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) IScaUserMessageDo
-	UnderlyingDB() *gorm.DB
-	schema.Tabler
-}
-
-func (s scaUserMessageDo) Debug() IScaUserMessageDo {
-	return s.withDO(s.DO.Debug())
-}
-
-func (s scaUserMessageDo) WithContext(ctx context.Context) IScaUserMessageDo {
-	return s.withDO(s.DO.WithContext(ctx))
-}
-
-func (s scaUserMessageDo) ReadDB() IScaUserMessageDo {
-	return s.Clauses(dbresolver.Read)
-}
-
-func (s scaUserMessageDo) WriteDB() IScaUserMessageDo {
-	return s.Clauses(dbresolver.Write)
-}
-
-func (s scaUserMessageDo) Session(config *gorm.Session) IScaUserMessageDo {
-	return s.withDO(s.DO.Session(config))
-}
-
-func (s scaUserMessageDo) Clauses(conds ...clause.Expression) IScaUserMessageDo {
-	return s.withDO(s.DO.Clauses(conds...))
-}
-
-func (s scaUserMessageDo) Returning(value interface{}, columns ...string) IScaUserMessageDo {
-	return s.withDO(s.DO.Returning(value, columns...))
-}
-
-func (s scaUserMessageDo) Not(conds ...gen.Condition) IScaUserMessageDo {
-	return s.withDO(s.DO.Not(conds...))
-}
-
-func (s scaUserMessageDo) Or(conds ...gen.Condition) IScaUserMessageDo {
-	return s.withDO(s.DO.Or(conds...))
-}
-
-func (s scaUserMessageDo) Select(conds ...field.Expr) IScaUserMessageDo {
-	return s.withDO(s.DO.Select(conds...))
-}
-
-func (s scaUserMessageDo) Where(conds ...gen.Condition) IScaUserMessageDo {
-	return s.withDO(s.DO.Where(conds...))
-}
-
-func (s scaUserMessageDo) Order(conds ...field.Expr) IScaUserMessageDo {
-	return s.withDO(s.DO.Order(conds...))
-}
-
-func (s scaUserMessageDo) Distinct(cols ...field.Expr) IScaUserMessageDo {
-	return s.withDO(s.DO.Distinct(cols...))
-}
-
-func (s scaUserMessageDo) Omit(cols ...field.Expr) IScaUserMessageDo {
-	return s.withDO(s.DO.Omit(cols...))
-}
-
-func (s scaUserMessageDo) Join(table schema.Tabler, on ...field.Expr) IScaUserMessageDo {
-	return s.withDO(s.DO.Join(table, on...))
-}
-
-func (s scaUserMessageDo) LeftJoin(table schema.Tabler, on ...field.Expr) IScaUserMessageDo {
-	return s.withDO(s.DO.LeftJoin(table, on...))
-}
-
-func (s scaUserMessageDo) RightJoin(table schema.Tabler, on ...field.Expr) IScaUserMessageDo {
-	return s.withDO(s.DO.RightJoin(table, on...))
-}
-
-func (s scaUserMessageDo) Group(cols ...field.Expr) IScaUserMessageDo {
-	return s.withDO(s.DO.Group(cols...))
-}
-
-func (s scaUserMessageDo) Having(conds ...gen.Condition) IScaUserMessageDo {
-	return s.withDO(s.DO.Having(conds...))
-}
-
-func (s scaUserMessageDo) Limit(limit int) IScaUserMessageDo {
-	return s.withDO(s.DO.Limit(limit))
-}
-
-func (s scaUserMessageDo) Offset(offset int) IScaUserMessageDo {
-	return s.withDO(s.DO.Offset(offset))
-}
-
-func (s scaUserMessageDo) Scopes(funcs ...func(gen.Dao) gen.Dao) IScaUserMessageDo {
-	return s.withDO(s.DO.Scopes(funcs...))
-}
-
-func (s scaUserMessageDo) Unscoped() IScaUserMessageDo {
-	return s.withDO(s.DO.Unscoped())
-}
-
-func (s scaUserMessageDo) Create(values ...*model.ScaUserMessage) error {
-	if len(values) == 0 {
-		return nil
-	}
-	return s.DO.Create(values)
-}
-
-func (s scaUserMessageDo) CreateInBatches(values []*model.ScaUserMessage, batchSize int) error {
-	return s.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 (s scaUserMessageDo) Save(values ...*model.ScaUserMessage) error {
-	if len(values) == 0 {
-		return nil
-	}
-	return s.DO.Save(values)
-}
-
-func (s scaUserMessageDo) First() (*model.ScaUserMessage, error) {
-	if result, err := s.DO.First(); err != nil {
-		return nil, err
-	} else {
-		return result.(*model.ScaUserMessage), nil
-	}
-}
-
-func (s scaUserMessageDo) Take() (*model.ScaUserMessage, error) {
-	if result, err := s.DO.Take(); err != nil {
-		return nil, err
-	} else {
-		return result.(*model.ScaUserMessage), nil
-	}
-}
-
-func (s scaUserMessageDo) Last() (*model.ScaUserMessage, error) {
-	if result, err := s.DO.Last(); err != nil {
-		return nil, err
-	} else {
-		return result.(*model.ScaUserMessage), nil
-	}
-}
-
-func (s scaUserMessageDo) Find() ([]*model.ScaUserMessage, error) {
-	result, err := s.DO.Find()
-	return result.([]*model.ScaUserMessage), err
-}
-
-func (s scaUserMessageDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.ScaUserMessage, err error) {
-	buf := make([]*model.ScaUserMessage, 0, batchSize)
-	err = s.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 (s scaUserMessageDo) FindInBatches(result *[]*model.ScaUserMessage, batchSize int, fc func(tx gen.Dao, batch int) error) error {
-	return s.DO.FindInBatches(result, batchSize, fc)
-}
-
-func (s scaUserMessageDo) Attrs(attrs ...field.AssignExpr) IScaUserMessageDo {
-	return s.withDO(s.DO.Attrs(attrs...))
-}
-
-func (s scaUserMessageDo) Assign(attrs ...field.AssignExpr) IScaUserMessageDo {
-	return s.withDO(s.DO.Assign(attrs...))
-}
-
-func (s scaUserMessageDo) Joins(fields ...field.RelationField) IScaUserMessageDo {
-	for _, _f := range fields {
-		s = *s.withDO(s.DO.Joins(_f))
-	}
-	return &s
-}
-
-func (s scaUserMessageDo) Preload(fields ...field.RelationField) IScaUserMessageDo {
-	for _, _f := range fields {
-		s = *s.withDO(s.DO.Preload(_f))
-	}
-	return &s
-}
-
-func (s scaUserMessageDo) FirstOrInit() (*model.ScaUserMessage, error) {
-	if result, err := s.DO.FirstOrInit(); err != nil {
-		return nil, err
-	} else {
-		return result.(*model.ScaUserMessage), nil
-	}
-}
-
-func (s scaUserMessageDo) FirstOrCreate() (*model.ScaUserMessage, error) {
-	if result, err := s.DO.FirstOrCreate(); err != nil {
-		return nil, err
-	} else {
-		return result.(*model.ScaUserMessage), nil
-	}
-}
-
-func (s scaUserMessageDo) FindByPage(offset int, limit int) (result []*model.ScaUserMessage, count int64, err error) {
-	result, err = s.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 = s.Offset(-1).Limit(-1).Count()
-	return
-}
-
-func (s scaUserMessageDo) ScanByPage(result interface{}, offset int, limit int) (count int64, err error) {
-	count, err = s.Count()
-	if err != nil {
-		return
-	}
-
-	err = s.Offset(offset).Limit(limit).Scan(result)
-	return
-}
-
-func (s scaUserMessageDo) Scan(result interface{}) (err error) {
-	return s.DO.Scan(result)
-}
-
-func (s scaUserMessageDo) Delete(models ...*model.ScaUserMessage) (result gen.ResultInfo, err error) {
-	return s.DO.Delete(models)
-}
-
-func (s *scaUserMessageDo) withDO(do gen.Dao) *scaUserMessageDo {
-	s.DO = *do.(*gen.DO)
-	return s
-}

app/auth/api/resources/language/active.en.toml

@@ -1,21 +0,0 @@
-[captcha]
-verificationFailure = "verification failure!"
-[login]
-invalidAccount = "invalid account！"
-notFoundAccount = "account not found！"
-invalidPassword = "invalid password！"
-loginFailed = "login failed！"
-phoneFormatError = "phone number format error！"
-captchaExpired = "captcha expired！"
-captchaError = "captcha error！"
-userNotRegistered = "user not registered！"
-registerError = "register error！"
-passwordNotMatch = "password not match！"
-passwordFormatError = "password format error！"
-resetPasswordError = "reset password error！"
-loginSuccess = "login success！"
-
-[sms]
-smsSendTooFrequently = "sms send too frequently！"
-smsSendFailed = "sms send failed！"
-smsSendSuccess = "sms send success！"

app/auth/api/resources/language/active.zh.toml

@@ -1,21 +0,0 @@
-[captcha]
-verificationFailure = "验证失败！"
-[login]
-invalidAccount = "无效的账号！"
-notFoundAccount = "未找到账号！"
-invalidPassword = "密码错误！"
-loginFailed = "登录失败！"
-phoneFormatError = "手机号码格式错误！"
-captchaExpired = "验证码已过期！"
-captchaError = "验证码错误！"
-userNotRegistered = "用户未注册！"
-registerError = "注册失败！"
-passwordNotMatch = "两次输入的密码不一致！"
-passwordFormatError = "密码格式错误！"
-resetPasswordError = "重置密码失败！"
-loginSuccess = "登录成功！"
-
-[sms]
-smsSendTooFrequently = "验证码发送过于频繁，请稍后再试！"
-smsSendFailed = "短信发送失败！"
-smsSendSuccess = "短信发送成功！"