🎨 remove xorm & add gorm gen

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

@@ -8,6 +8,8 @@ import (
 
 	"github.com/mssola/useragent"
 
+	"github.com/zeromicro/go-zero/core/logx"
+
 	"schisandra-album-cloud-microservices/app/core/api/common/captcha/verify"
 	"schisandra-album-cloud-microservices/app/core/api/common/constant"
 	"schisandra-album-cloud-microservices/app/core/api/common/response"
@@ -15,8 +17,6 @@ import (
 	"schisandra-album-cloud-microservices/app/core/api/internal/svc"
 	"schisandra-album-cloud-microservices/app/core/api/internal/types"
 	"schisandra-album-cloud-microservices/app/core/api/repository/mysql/model"
-
-	"github.com/zeromicro/go-zero/core/logx"
 )
 
 type SubmitCommentLogic struct {
@@ -57,7 +57,7 @@ func (l *SubmitCommentLogic) SubmitComment(r *http.Request, req *types.CommentRe
 
 	browser, _ := ua.Browser()
 	operatingSystem := ua.OS()
-	isAuthor := 0
+	var isAuthor int64 = 0
 	session, err := l.svcCtx.Session.Get(r, constant.SESSION_KEY)
 	if err == nil {
 		return nil, err
@@ -74,26 +74,25 @@ func (l *SubmitCommentLogic) SubmitComment(r *http.Request, req *types.CommentRe
 		return response.ErrorWithI18n(l.ctx, "comment.commentError"), nil
 	}
 	commentContent := l.svcCtx.Sensitive.Replace(xssFilterContent, '*')
-	comment := model.ScaCommentReply{
+	topicType := constant.CommentTopicType
+	commentType := constant.COMMENT
+	comment := &model.ScaCommentReply{
 		Content:         commentContent,
-		UserId:          uid,
-		TopicId:         req.TopicId,
-		TopicType:       constant.CommentTopicType,
-		CommentType:     constant.COMMENT,
+		UserID:          uid,
+		TopicID:         req.TopicId,
+		TopicType:       topicType,
+		CommentType:     commentType,
 		Author:          isAuthor,
-		CommentIp:       ip,
+		CommentIP:       ip,
 		Location:        location,
 		Browser:         browser,
 		OperatingSystem: operatingSystem,
 		Agent:           userAgent,
 	}
-	affected, err := l.svcCtx.DB.InsertOne(&comment)
+	err = l.svcCtx.DB.ScaCommentReply.Create(comment)
 	if err != nil {
 		return nil, err
 	}
-	if affected == 0 {
-		return response.ErrorWithI18n(l.ctx, "comment.commentError"), nil
-	}
 
 	if len(req.Images) > 0 {
 		imagesData, err := utils.ProcessImages(req.Images)
@@ -103,16 +102,16 @@ func (l *SubmitCommentLogic) SubmitComment(r *http.Request, req *types.CommentRe
 		commentImages := types.CommentImages{
 			UserId:    uid,
 			TopicId:   req.TopicId,
-			CommentId: comment.Id,
+			CommentId: comment.ID,
 			Images:    imagesData,
 			CreatedAt: comment.CreatedAt.String(),
 		}
-		if _, err = l.svcCtx.MongoClient.Collection("comment_images").InsertOne(l.ctx, commentImages); err != nil {
+		if _, err = l.svcCtx.MongoClient.Collection(constant.COMMENT_IMAGES).InsertOne(l.ctx, commentImages); err != nil {
 			return nil, err
 		}
 	}
 	commentResponse := types.CommentResponse{
-		Id:              comment.Id,
+		Id:              comment.ID,
 		Content:         commentContent,
 		UserId:          uid,
 		TopicId:         req.TopicId,

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

@@ -8,6 +8,8 @@ import (
 
 	"github.com/mssola/useragent"
 
+	"github.com/zeromicro/go-zero/core/logx"
+
 	"schisandra-album-cloud-microservices/app/core/api/common/captcha/verify"
 	"schisandra-album-cloud-microservices/app/core/api/common/constant"
 	"schisandra-album-cloud-microservices/app/core/api/common/response"
@@ -15,8 +17,6 @@ import (
 	"schisandra-album-cloud-microservices/app/core/api/internal/svc"
 	"schisandra-album-cloud-microservices/app/core/api/internal/types"
 	"schisandra-album-cloud-microservices/app/core/api/repository/mysql/model"
-
-	"github.com/zeromicro/go-zero/core/logx"
 )
 
 type SubmitReplyCommentLogic struct {
@@ -65,7 +65,7 @@ func (l *SubmitReplyCommentLogic) SubmitReplyComment(r *http.Request, req *types
 	if !ok {
 		return nil, errors.New("uid not found in session")
 	}
-	isAuthor := 0
+	var isAuthor int64 = 0
 	if uid == req.Author {
 		isAuthor = 1
 	}
@@ -76,39 +76,34 @@ func (l *SubmitReplyCommentLogic) SubmitReplyComment(r *http.Request, req *types
 	}
 	commentContent := l.svcCtx.Sensitive.Replace(xssFilterContent, '*')
 
-	tx := l.svcCtx.DB.NewSession()
-	defer tx.Close()
-	if err = tx.Begin(); err != nil {
-		return nil, err
-	}
-
-	reply := model.ScaCommentReply{
+	tx := l.svcCtx.DB.Begin()
+	topicType := constant.CommentTopicType
+	commentType := constant.REPLY
+	reply := &model.ScaCommentReply{
 		Content:         commentContent,
-		UserId:          uid,
-		TopicId:         req.TopicId,
-		TopicType:       constant.CommentTopicType,
-		CommentType:     constant.COMMENT,
+		UserID:          uid,
+		TopicID:         req.TopicId,
+		TopicType:       topicType,
+		CommentType:     commentType,
 		Author:          isAuthor,
-		CommentIp:       ip,
+		CommentIP:       ip,
 		Location:        location,
 		Browser:         browser,
 		OperatingSystem: operatingSystem,
 		Agent:           userAgent,
-		ReplyId:         req.ReplyId,
+		ReplyID:         req.ReplyId,
 		ReplyUser:       req.ReplyUser,
 	}
-	affected, err := tx.Insert(&reply)
+	err = tx.ScaCommentReply.Create(reply)
 	if err != nil {
 		return nil, err
 	}
-	if affected == 0 {
-		return response.ErrorWithI18n(l.ctx, "comment.commentError"), nil
-	}
-	update, err := tx.Table(model.ScaCommentReply{}).Where("id = ? and deleted = 0", req.ReplyId).Incr("reply_count", 1).Update(nil)
+	commentReply := l.svcCtx.DB.ScaCommentReply
+	update, err := tx.ScaCommentReply.Updates(commentReply.ReplyCount.Add(1))
 	if err != nil {
 		return nil, err
 	}
-	if update == 0 {
+	if update.RowsAffected == 0 {
 		return response.ErrorWithI18n(l.ctx, "comment.commentError"), nil
 	}
 
@@ -121,26 +116,26 @@ func (l *SubmitReplyCommentLogic) SubmitReplyComment(r *http.Request, req *types
 		commentImages := types.CommentImages{
 			UserId:    uid,
 			TopicId:   req.TopicId,
-			CommentId: reply.Id,
+			CommentId: reply.ID,
 			Images:    imagesData,
 			CreatedAt: reply.CreatedAt.String(),
 		}
-		if _, err = l.svcCtx.MongoClient.Collection("comment_images").InsertOne(l.ctx, commentImages); err != nil {
+		if _, err = l.svcCtx.MongoClient.Collection(constant.COMMENT_IMAGES).InsertOne(l.ctx, commentImages); err != nil {
 			return nil, err
 		}
 	}
 
 	commentResponse := types.CommentResponse{
-		Id:              reply.Id,
+		Id:              reply.ID,
 		Content:         commentContent,
 		UserId:          uid,
-		TopicId:         reply.TopicId,
+		TopicId:         reply.TopicID,
 		Author:          isAuthor,
 		Location:        location,
 		Browser:         browser,
 		OperatingSystem: operatingSystem,
 		CreatedTime:     time.Now(),
-		ReplyId:         reply.ReplyId,
+		ReplyId:         reply.ReplyID,
 		ReplyUser:       reply.ReplyUser,
 	}
 	err = tx.Commit()

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

@@ -8,6 +8,8 @@ import (
 
 	"github.com/mssola/useragent"
 
+	"github.com/zeromicro/go-zero/core/logx"
+
 	"schisandra-album-cloud-microservices/app/core/api/common/captcha/verify"
 	"schisandra-album-cloud-microservices/app/core/api/common/constant"
 	"schisandra-album-cloud-microservices/app/core/api/common/response"
@@ -15,8 +17,6 @@ import (
 	"schisandra-album-cloud-microservices/app/core/api/internal/svc"
 	"schisandra-album-cloud-microservices/app/core/api/internal/types"
 	"schisandra-album-cloud-microservices/app/core/api/repository/mysql/model"
-
-	"github.com/zeromicro/go-zero/core/logx"
 )
 
 type SubmitReplyReplyLogic struct {
@@ -74,7 +74,7 @@ func (l *SubmitReplyReplyLogic) SubmitReplyReply(r *http.Request, req *types.Rep
 	}
 
 	// 判断作者身份
-	isAuthor := 0
+	var isAuthor int64 = 0
 	if uid == req.Author {
 		isAuthor = 1
 	}
@@ -86,40 +86,35 @@ func (l *SubmitReplyReplyLogic) SubmitReplyReply(r *http.Request, req *types.Rep
 	}
 	commentContent := l.svcCtx.Sensitive.Replace(xssFilterContent, '*')
 
-	tx := l.svcCtx.DB.NewSession()
-	defer tx.Close()
-	if err = tx.Begin(); err != nil {
-		return nil, err
-	}
-
-	replyReply := model.ScaCommentReply{
+	tx := l.svcCtx.DB.Begin()
+	topicType := constant.CommentTopicType
+	commentType := constant.REPLY
+	replyReply := &model.ScaCommentReply{
 		Content:         commentContent,
-		UserId:          uid,
-		TopicId:         req.TopicId,
-		TopicType:       constant.CommentTopicType,
-		CommentType:     constant.COMMENT,
+		UserID:          uid,
+		TopicID:         req.TopicId,
+		TopicType:       topicType,
+		CommentType:     commentType,
 		Author:          isAuthor,
-		CommentIp:       ip,
+		CommentIP:       ip,
 		Location:        location,
 		Browser:         browser,
 		OperatingSystem: operatingSystem,
 		Agent:           userAgent,
-		ReplyId:         req.ReplyId,
+		ReplyID:         req.ReplyId,
 		ReplyUser:       req.ReplyUser,
 		ReplyTo:         req.ReplyTo,
 	}
-	affected, err := tx.Insert(&replyReply)
+	err = tx.ScaCommentReply.Create(replyReply)
 	if err != nil {
 		return nil, err
 	}
-	if affected == 0 {
-		return response.ErrorWithI18n(l.ctx, "comment.commentError"), nil
-	}
-	update, err := tx.Table(model.ScaCommentReply{}).Where("id = ? and version = ? and deleted = 0", req.ReplyId, replyReply.Version).Incr("reply_count", 1).Update(nil)
+	commentReply := l.svcCtx.DB.ScaCommentReply
+	update, err := tx.ScaCommentReply.Updates(commentReply.ReplyCount.Add(1))
 	if err != nil {
 		return nil, err
 	}
-	if update == 0 {
+	if update.RowsAffected == 0 {
 		return response.ErrorWithI18n(l.ctx, "comment.commentError"), nil
 	}
 
@@ -132,27 +127,27 @@ func (l *SubmitReplyReplyLogic) SubmitReplyReply(r *http.Request, req *types.Rep
 		commentImages := types.CommentImages{
 			UserId:    uid,
 			TopicId:   req.TopicId,
-			CommentId: replyReply.Id,
+			CommentId: replyReply.ID,
 			Images:    imagesData,
 			CreatedAt: replyReply.CreatedAt.String(),
 		}
-		if _, err = l.svcCtx.MongoClient.Collection("comment_images").InsertOne(l.ctx, commentImages); err != nil {
+		if _, err = l.svcCtx.MongoClient.Collection(constant.COMMENT_IMAGES).InsertOne(l.ctx, commentImages); err != nil {
 			return nil, err
 		}
 	}
 
 	// 构建响应
 	commentResponse := types.CommentResponse{
-		Id:              replyReply.Id,
+		Id:              replyReply.ID,
 		Content:         commentContent,
 		UserId:          uid,
-		TopicId:         replyReply.TopicId,
+		TopicId:         replyReply.TopicID,
 		Author:          isAuthor,
 		Location:        location,
 		Browser:         browser,
 		OperatingSystem: operatingSystem,
 		CreatedTime:     time.Now(),
-		ReplyId:         replyReply.ReplyId,
+		ReplyId:         replyReply.ReplyID,
 		ReplyUser:       replyReply.ReplyUser,
 		ReplyTo:         replyReply.ReplyTo,
 	}

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

@@ -3,12 +3,16 @@ package oauth
 import (
 	"context"
 	"encoding/json"
+	"errors"
 	"fmt"
 	"net/http"
 	"strconv"
 	"time"
 
 	"github.com/yitter/idgenerator-go/idgen"
+	"gorm.io/gorm"
+
+	"github.com/zeromicro/go-zero/core/logx"
 
 	"schisandra-album-cloud-microservices/app/core/api/common/constant"
 	"schisandra-album-cloud-microservices/app/core/api/common/response"
@@ -16,8 +20,6 @@ import (
 	"schisandra-album-cloud-microservices/app/core/api/internal/svc"
 	"schisandra-album-cloud-microservices/app/core/api/internal/types"
 	"schisandra-album-cloud-microservices/app/core/api/repository/mysql/model"
-
-	"github.com/zeromicro/go-zero/core/logx"
 )
 
 type GiteeCallbackLogic struct {
@@ -102,26 +104,19 @@ func (l *GiteeCallbackLogic) GiteeCallback(w http.ResponseWriter, r *http.Reques
 	}
 	Id := strconv.Itoa(giteeUser.ID)
 
-	tx := l.svcCtx.DB.NewSession()
-	defer tx.Close()
-	if err = tx.Begin(); err != nil {
-		return err
-	}
-	userSocial := model.ScaAuthUserSocial{
-		OpenId:  Id,
-		Source:  constant.OAuthSourceGitee,
-		Deleted: constant.NotDeleted,
-	}
-	has, err := tx.Get(&userSocial)
-	if err != nil {
+	tx := l.svcCtx.DB.Begin()
+
+	userSocial := l.svcCtx.DB.ScaAuthUserSocial
+	socialUser, err := tx.ScaAuthUserSocial.Where(userSocial.OpenID.Eq(Id), userSocial.Source.Eq(constant.OAuthSourceGitee), userSocial.Deleted.Eq(constant.NotDeleted)).First()
+	if err != nil && !errors.Is(err, gorm.ErrRecordNotFound) {
 		return err
 	}
 
-	if !has {
+	if socialUser == nil {
 		// 创建用户
 		uid := idgen.NextId()
 		uidStr := strconv.FormatInt(uid, 10)
-		addUser := model.ScaAuthUser{
+		addUser := &model.ScaAuthUser{
 			UID:      uidStr,
 			Avatar:   giteeUser.AvatarURL,
 			Username: giteeUser.Login,
@@ -131,21 +126,25 @@ func (l *GiteeCallbackLogic) GiteeCallback(w http.ResponseWriter, r *http.Reques
 			Deleted:  constant.NotDeleted,
 			Gender:   constant.Male,
 		}
-		affected, err := tx.Insert(&addUser)
-		if err != nil || affected == 0 {
+		err = tx.ScaAuthUser.Create(addUser)
+		if err != nil {
+			_ = tx.Rollback()
 			return err
 		}
-		socialUser := model.ScaAuthUserSocial{
-			UserId: uidStr,
-			OpenId: Id,
-			Source: constant.OAuthSourceGitee,
+		gitee := constant.OAuthSourceGitee
+		newSocialUser := &model.ScaAuthUserSocial{
+			UserID: uidStr,
+			OpenID: Id,
+			Source: gitee,
 		}
-		insert, err := tx.Insert(&socialUser)
-		if err != nil || insert == 0 {
+		err = tx.ScaAuthUserSocial.Create(newSocialUser)
+		if err != nil {
+			_ = tx.Rollback()
 			return err
 		}
 
 		if res, err := l.svcCtx.CasbinEnforcer.AddRoleForUser(uidStr, constant.User); !res || err != nil {
+			_ = tx.Rollback()
 			return err
 		}
 
@@ -153,16 +152,16 @@ func (l *GiteeCallbackLogic) GiteeCallback(w http.ResponseWriter, r *http.Reques
 			return err
 		}
 	} else {
-		user := model.ScaAuthUser{
-			UID:     userSocial.UserId,
-			Deleted: constant.NotDeleted,
-		}
-		have, err := tx.Get(&user)
-		if err != nil || !have {
+		authUser := l.svcCtx.DB.ScaAuthUser
+
+		authUserInfo, err := tx.ScaAuthUser.Where(authUser.UID.Eq(socialUser.UserID), authUser.Deleted.Eq(constant.NotDeleted)).First()
+		if err != nil && !errors.Is(err, gorm.ErrRecordNotFound) {
+			_ = tx.Rollback()
 			return err
 		}
 
-		if err = HandleOauthLoginResponse(user, l.svcCtx, r, w, l.ctx); err != nil {
+		if err = HandleOauthLoginResponse(authUserInfo, l.svcCtx, r, w, l.ctx); err != nil {
+			_ = tx.Rollback()
 			return err
 		}
 	}
@@ -174,7 +173,7 @@ func (l *GiteeCallbackLogic) GiteeCallback(w http.ResponseWriter, r *http.Reques
 }
 
 // HandleOauthLoginResponse 处理登录响应
-func HandleOauthLoginResponse(scaAuthUser model.ScaAuthUser, svcCtx *svc.ServiceContext, r *http.Request, w http.ResponseWriter, ctx context.Context) error {
+func HandleOauthLoginResponse(scaAuthUser *model.ScaAuthUser, svcCtx *svc.ServiceContext, r *http.Request, w http.ResponseWriter, ctx context.Context) error {
 	data, err := user.HandleUserLogin(scaAuthUser, svcCtx, true, r, w, ctx)
 	if err != nil {
 		return err

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

@@ -3,18 +3,20 @@ package oauth
 import (
 	"context"
 	"encoding/json"
+	"errors"
 	"fmt"
 	"net/http"
 	"strconv"
 
 	"github.com/yitter/idgenerator-go/idgen"
+	"gorm.io/gorm"
+
+	"github.com/zeromicro/go-zero/core/logx"
 
 	"schisandra-album-cloud-microservices/app/core/api/common/constant"
 	"schisandra-album-cloud-microservices/app/core/api/internal/svc"
 	"schisandra-album-cloud-microservices/app/core/api/internal/types"
 	"schisandra-album-cloud-microservices/app/core/api/repository/mysql/model"
-
-	"github.com/zeromicro/go-zero/core/logx"
 )
 
 type GithubCallbackLogic struct {
@@ -101,74 +103,73 @@ func (l *GithubCallbackLogic) GithubCallback(w http.ResponseWriter, r *http.Requ
 		return err
 	}
 	Id := strconv.Itoa(gitHubUser.ID)
-	tx := l.svcCtx.DB.NewSession()
-	defer tx.Close()
-	if err = tx.Begin(); err != nil {
-		return err
-	}
-	userSocial := model.ScaAuthUserSocial{
-		OpenId:  Id,
-		Source:  constant.OAuthSourceGithub,
-		Deleted: constant.NotDeleted,
-	}
-	has, err := tx.Get(&userSocial)
-	if err != nil {
+	tx := l.svcCtx.DB.Begin()
+
+	userSocial := l.svcCtx.DB.ScaAuthUserSocial
+	socialUser, err := tx.ScaAuthUserSocial.Where(userSocial.OpenID.Eq(Id), userSocial.Source.Eq(constant.OAuthSourceGithub), userSocial.Deleted.Eq(constant.NotDeleted)).First()
+	if err != nil && !errors.Is(err, gorm.ErrRecordNotFound) {
 		return err
 	}
 
-	if !has {
+	if socialUser == nil {
 		// 创建用户
 		uid := idgen.NextId()
 		uidStr := strconv.FormatInt(uid, 10)
 
-		addUser := model.ScaAuthUser{
+		notDeleted := constant.NotDeleted
+		male := constant.Male
+		addUser := &model.ScaAuthUser{
 			UID:      uidStr,
 			Avatar:   gitHubUser.AvatarURL,
 			Username: gitHubUser.Login,
 			Nickname: gitHubUser.Name,
 			Blog:     gitHubUser.Blog,
 			Email:    gitHubUser.Email,
-			Deleted:  constant.NotDeleted,
-			Gender:   constant.Male,
+			Deleted:  notDeleted,
+			Gender:   male,
 		}
-		affected, err := tx.Insert(&addUser)
-		if err != nil || affected == 0 {
+		err = tx.ScaAuthUser.Create(addUser)
+		if err != nil {
+			_ = tx.Rollback()
 			return err
 		}
-
-		socialUser := model.ScaAuthUserSocial{
-			UserId: uidStr,
-			OpenId: Id,
-			Source: constant.OAuthSourceGithub,
+		githubUser := constant.OAuthSourceGithub
+		newSocialUser := &model.ScaAuthUserSocial{
+			UserID: uidStr,
+			OpenID: Id,
+			Source: githubUser,
 		}
-		insert, err := tx.Insert(&socialUser)
-		if err != nil || insert == 0 {
+		err = tx.ScaAuthUserSocial.Create(newSocialUser)
+		if err != nil {
+			_ = tx.Rollback()
 			return err
 		}
 
 		if res, err := l.svcCtx.CasbinEnforcer.AddRoleForUser(uidStr, constant.User); !res || err != nil {
+			_ = tx.Rollback()
 			return err
 		}
 
 		if err = HandleOauthLoginResponse(addUser, l.svcCtx, r, w, l.ctx); err != nil {
+			_ = tx.Rollback()
 			return err
 		}
 	} else {
-		user := model.ScaAuthUser{
-			UID:     userSocial.UserId,
-			Deleted: constant.NotDeleted,
-		}
-		have, err := tx.Get(&user)
-		if err != nil || !have {
+		authUser := l.svcCtx.DB.ScaAuthUser
+
+		authUserInfo, err := tx.ScaAuthUser.Where(authUser.UID.Eq(socialUser.UserID), authUser.Deleted.Eq(constant.NotDeleted)).First()
+		if err != nil && !errors.Is(err, gorm.ErrRecordNotFound) {
+			_ = tx.Rollback()
 			return err
 		}
 
-		if err = HandleOauthLoginResponse(user, l.svcCtx, r, w, l.ctx); err != nil {
+		if err = HandleOauthLoginResponse(authUserInfo, l.svcCtx, r, w, l.ctx); err != nil {
+			_ = tx.Rollback()
 			return err
 		}
 	}
 
-	if err := tx.Commit(); err != nil {
+	if err = tx.Commit(); err != nil {
 		return err
 	}
 	return nil

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

@@ -3,18 +3,20 @@ package oauth
 import (
 	"context"
 	"encoding/json"
+	"errors"
 	"fmt"
 	"net/http"
 	"strconv"
 
 	"github.com/yitter/idgenerator-go/idgen"
+	"gorm.io/gorm"
+
+	"github.com/zeromicro/go-zero/core/logx"
 
 	"schisandra-album-cloud-microservices/app/core/api/common/constant"
 	"schisandra-album-cloud-microservices/app/core/api/internal/svc"
 	"schisandra-album-cloud-microservices/app/core/api/internal/types"
 	"schisandra-album-cloud-microservices/app/core/api/repository/mysql/model"
-
-	"github.com/zeromicro/go-zero/core/logx"
 )
 
 type QqCallbackLogic struct {
@@ -98,72 +100,72 @@ func (l *QqCallbackLogic) QqCallback(w http.ResponseWriter, r *http.Request, req
 		return err
 	}
 
-	tx := l.svcCtx.DB.NewSession()
-	defer tx.Close()
-	if err = tx.Begin(); err != nil {
-		return err
-	}
-	userSocial := model.ScaAuthUserSocial{
-		OpenId:  authQQme.OpenID,
-		Source:  constant.OAuthSourceQQ,
-		Deleted: constant.NotDeleted,
-	}
-	has, err := tx.Get(&userSocial)
-	if err != nil {
+	tx := l.svcCtx.DB.Begin()
+
+	userSocial := l.svcCtx.DB.ScaAuthUserSocial
+	socialUser, err := tx.ScaAuthUserSocial.Where(userSocial.OpenID.Eq(authQQme.OpenID), userSocial.Source.Eq(constant.OAuthSourceQQ), userSocial.Deleted.Eq(constant.NotDeleted)).First()
+	if err != nil && !errors.Is(err, gorm.ErrRecordNotFound) {
 		return err
 	}
 
-	if !has {
+	if socialUser == nil {
 		// 创建用户
 		uid := idgen.NextId()
 		uidStr := strconv.FormatInt(uid, 10)
 
-		addUser := model.ScaAuthUser{
+		notDeleted := constant.NotDeleted
+		male := constant.Male
+		addUser := &model.ScaAuthUser{
 			UID:      uidStr,
 			Avatar:   qqUserInfo.FigureurlQq1,
 			Username: authQQme.OpenID,
 			Nickname: qqUserInfo.Nickname,
-			Deleted:  constant.NotDeleted,
-			Gender:   constant.Male,
+			Deleted:  notDeleted,
+			Gender:   male,
 		}
-		affected, err := tx.Insert(&addUser)
-		if err != nil || affected == 0 {
+		err = tx.ScaAuthUser.Create(addUser)
+		if err != nil {
+			_ = tx.Rollback()
 			return err
 		}
 
-		socialUser := model.ScaAuthUserSocial{
-			UserId: uidStr,
-			OpenId: authQQme.OpenID,
-			Source: constant.OAuthSourceGithub,
+		githubUser := constant.OAuthSourceQQ
+		newSocialUser := &model.ScaAuthUserSocial{
+			UserID: uidStr,
+			OpenID: authQQme.OpenID,
+			Source: githubUser,
 		}
-		insert, err := tx.Insert(&socialUser)
-		if err != nil || insert == 0 {
+		err = tx.ScaAuthUserSocial.Create(newSocialUser)
+		if err != nil {
+			_ = tx.Rollback()
 			return err
 		}
 
 		if res, err := l.svcCtx.CasbinEnforcer.AddRoleForUser(uidStr, constant.User); !res || err != nil {
+			_ = tx.Rollback()
 			return err
 		}
 
 		if err = HandleOauthLoginResponse(addUser, l.svcCtx, r, w, l.ctx); err != nil {
+			_ = tx.Rollback()
 			return err
 		}
 	} else {
-		user := model.ScaAuthUser{
-			UID:     userSocial.UserId,
-			Deleted: constant.NotDeleted,
-		}
-		have, err := tx.Get(&user)
-		if err != nil || !have {
+		authUser := l.svcCtx.DB.ScaAuthUser
+
+		authUserInfo, err := tx.ScaAuthUser.Where(authUser.UID.Eq(socialUser.UserID), authUser.Deleted.Eq(constant.NotDeleted)).First()
+		if err != nil && !errors.Is(err, gorm.ErrRecordNotFound) {
+			_ = tx.Rollback()
 			return err
 		}
 
-		if err = HandleOauthLoginResponse(user, l.svcCtx, r, w, l.ctx); err != nil {
+		if err = HandleOauthLoginResponse(authUserInfo, l.svcCtx, r, w, l.ctx); err != nil {
+			_ = tx.Rollback()
 			return err
 		}
 	}
 
-	if err := tx.Commit(); err != nil {
+	if err = tx.Commit(); err != nil {
 		return err
 	}
 	return nil

app/core/api/internal/logic/oauth/wechat_callback_logic.go

@@ -15,6 +15,7 @@ import (
 	"github.com/ArtisanCloud/PowerWeChat/v3/src/officialAccount/server/handlers/models"
 	"github.com/yitter/idgenerator-go/idgen"
 	"github.com/zeromicro/go-zero/core/logx"
+	"gorm.io/gorm"
 
 	"schisandra-album-cloud-microservices/app/core/api/common/constant"
 	"schisandra-album-cloud-microservices/app/core/api/common/i18n"
@@ -113,91 +114,96 @@ func (l *WechatCallbackLogic) HandlerWechatLogin(openId string, clientId string,
 	if openId == "" {
 		return errors.New("openId is empty")
 	}
-	tx := l.svcCtx.DB.NewSession()
-	defer tx.Close()
-	if err := tx.Begin(); err != nil {
+	tx := l.svcCtx.DB.Begin()
+
+	userSocial := l.svcCtx.DB.ScaAuthUserSocial
+	socialUser, err := tx.ScaAuthUserSocial.Where(userSocial.OpenID.Eq(openId), userSocial.Source.Eq(constant.OAuthSourceWechat), userSocial.Deleted.Eq(constant.NotDeleted)).First()
+	if err != nil && !errors.Is(err, gorm.ErrRecordNotFound) {
 		return err
 	}
-	userSocial := model.ScaAuthUserSocial{
-		OpenId:  openId,
-		Source:  constant.OAuthSourceWechat,
-		Deleted: constant.NotDeleted,
-	}
-	has, err := tx.Get(&userSocial)
-	if err != nil {
-		return err
-	}
-	if !has {
+
+	if socialUser == nil {
 		// 创建用户
 		uid := idgen.NextId()
 		uidStr := strconv.FormatInt(uid, 10)
 		avatar := utils.GenerateAvatar(uidStr)
 		name := randomname.GenerateName()
 
-		addUser := model.ScaAuthUser{
+		notDeleted := constant.NotDeleted
+		male := constant.Male
+		addUser := &model.ScaAuthUser{
 			UID:      uidStr,
 			Avatar:   avatar,
 			Username: openId,
 			Nickname: name,
-			Deleted:  constant.NotDeleted,
-			Gender:   constant.Male,
+			Deleted:  notDeleted,
+			Gender:   male,
 		}
-		affected, err := tx.Insert(&addUser)
-		if err != nil || affected == 0 {
+		err = tx.ScaAuthUser.Create(addUser)
+		if err != nil {
+			_ = tx.Rollback()
 			return err
 		}
 
-		socialUser := model.ScaAuthUserSocial{
-			UserId: uidStr,
-			OpenId: openId,
-			Source: constant.OAuthSourceGithub,
+		wechatUser := constant.OAuthSourceWechat
+		newSocialUser := &model.ScaAuthUserSocial{
+			UserID: uidStr,
+			OpenID: openId,
+			Source: wechatUser,
 		}
-		insert, err := tx.Insert(&socialUser)
-		if err != nil || insert == 0 {
+		err = tx.ScaAuthUserSocial.Create(newSocialUser)
+		if err != nil {
+			_ = tx.Rollback()
 			return err
 		}
 
 		if res, err := l.svcCtx.CasbinEnforcer.AddRoleForUser(uidStr, constant.User); !res || err != nil {
+			_ = tx.Rollback()
 			return err
 		}
 
 		data, err := user.HandleUserLogin(addUser, l.svcCtx, true, r, w, l.ctx)
 		if err != nil {
+			_ = tx.Rollback()
 			return err
 		}
 		marshal, err := json.Marshal(data)
 		if err != nil {
+			_ = tx.Rollback()
 			return err
 		}
 		err = websocket.QrcodeWebSocketHandler.SendMessageToClient(clientId, marshal)
 		if err != nil {
+			_ = tx.Rollback()
 			return err
 		}
 
 	} else {
-		authUser := model.ScaAuthUser{
-			UID:     userSocial.UserId,
-			Deleted: constant.NotDeleted,
-		}
-		have, err := tx.Get(&authUser)
-		if err != nil || !have {
+		authUser := l.svcCtx.DB.ScaAuthUser
+
+		authUserInfo, err := tx.ScaAuthUser.Where(authUser.UID.Eq(socialUser.UserID), authUser.Deleted.Eq(constant.NotDeleted)).First()
+		if err != nil && !errors.Is(err, gorm.ErrRecordNotFound) {
+			_ = tx.Rollback()
 			return err
 		}
 
-		data, err := user.HandleUserLogin(authUser, l.svcCtx, true, r, w, l.ctx)
+		data, err := user.HandleUserLogin(authUserInfo, l.svcCtx, true, r, w, l.ctx)
 		if err != nil {
+			_ = tx.Rollback()
 			return err
 		}
 		marshal, err := json.Marshal(data)
 		if err != nil {
+			_ = tx.Rollback()
 			return err
 		}
 		err = websocket.QrcodeWebSocketHandler.SendMessageToClient(clientId, marshal)
 		if err != nil {
+			_ = tx.Rollback()
 			return err
 		}
 	}
-	if err := tx.Commit(); err != nil {
+	if err = tx.Commit(); err != nil {
 		return err
 	}
 	return nil

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

@@ -2,11 +2,12 @@ package user
 
 import (
 	"context"
+	"errors"
 	"net/http"
 	"time"
 
 	"github.com/zeromicro/go-zero/core/logx"
-	"xorm.io/xorm"
+	"gorm.io/gorm"
 
 	"schisandra-album-cloud-microservices/app/core/api/common/captcha/verify"
 	"schisandra-album-cloud-microservices/app/core/api/common/constant"
@@ -16,6 +17,7 @@ import (
 	"schisandra-album-cloud-microservices/app/core/api/internal/svc"
 	"schisandra-album-cloud-microservices/app/core/api/internal/types"
 	"schisandra-album-cloud-microservices/app/core/api/repository/mysql/model"
+	"schisandra-album-cloud-microservices/app/core/api/repository/mysql/query"
 )
 
 type AccountLoginLogic struct {
@@ -37,43 +39,44 @@ func (l *AccountLoginLogic) AccountLogin(w http.ResponseWriter, r *http.Request,
 	if !verifyResult {
 		return response.ErrorWithI18n(l.ctx, "captcha.verificationFailure"), nil
 	}
-	var user model.ScaAuthUser
-	var query *xorm.Session
+
+	user := l.svcCtx.DB.ScaAuthUser
+	var selectedUser query.IScaAuthUserDo
 
 	switch {
 	case utils.IsPhone(req.Account):
-		query = l.svcCtx.DB.Where("phone = ? AND deleted = ?", req.Account, 0)
+		selectedUser = user.Where(user.Phone.Eq(req.Account), user.Deleted.Eq(constant.NotDeleted))
 	case utils.IsEmail(req.Account):
-		query = l.svcCtx.DB.Where("email = ? AND deleted = ?", req.Account, 0)
+		selectedUser = user.Where(user.Email.Eq(req.Account), user.Deleted.Eq(constant.NotDeleted))
 	case utils.IsUsername(req.Account):
-		query = l.svcCtx.DB.Where("username = ? AND deleted = ?", req.Account, 0)
+		selectedUser = user.Where(user.Username.Eq(req.Account), user.Deleted.Eq(constant.NotDeleted))
 	default:
 		return response.ErrorWithI18n(l.ctx, "login.invalidAccount"), nil
 	}
-	has, err := query.Get(&user)
+	userInfo, err := selectedUser.First()
 	if err != nil {
+		if errors.Is(err, gorm.ErrRecordNotFound) {
+			return response.ErrorWithI18n(l.ctx, "login.userNotRegistered"), nil
+		}
 		return nil, err
 	}
-	if !has {
-		return response.ErrorWithI18n(l.ctx, "login.userNotRegistered"), nil
-	}
 
-	if !utils.Verify(user.Password, req.Password) {
+	if !utils.Verify(userInfo.Password, req.Password) {
 		return response.ErrorWithI18n(l.ctx, "login.invalidPassword"), nil
 	}
-	data, err := HandleUserLogin(user, l.svcCtx, req.AutoLogin, r, w, l.ctx)
+	data, err := HandleUserLogin(userInfo, l.svcCtx, req.AutoLogin, r, w, l.ctx)
 	if err != nil {
 		return nil, err
 	}
 	// 记录用户登录设备
-	if err = GetUserLoginDevice(user.UID, r, l.svcCtx.Ip2Region, l.svcCtx.DB, l.ctx); err != nil {
+	if err = GetUserLoginDevice(userInfo.UID, r, l.svcCtx.Ip2Region, l.svcCtx.DB); err != nil {
 		return nil, err
 	}
 	return response.SuccessWithData(data), nil
 }
 
 // HandleUserLogin 处理用户登录
-func HandleUserLogin(user model.ScaAuthUser, svcCtx *svc.ServiceContext, autoLogin bool, r *http.Request, w http.ResponseWriter, ctx context.Context) (*types.LoginResponse, error) {
+func HandleUserLogin(user *model.ScaAuthUser, svcCtx *svc.ServiceContext, autoLogin bool, r *http.Request, w http.ResponseWriter, ctx context.Context) (*types.LoginResponse, error) {
 	// 生成jwt token
 	accessToken := jwt.GenerateAccessToken(svcCtx.Config.Auth.AccessSecret, jwt.AccessJWTPayload{
 		UserID: user.UID,

app/core/api/internal/logic/user/get_user_device_logic.go

@@ -8,12 +8,13 @@ import (
 	"github.com/lionsoul2014/ip2region/binding/golang/xdb"
 	"github.com/mssola/useragent"
 	"github.com/zeromicro/go-zero/core/logx"
-	"xorm.io/xorm"
+	"gorm.io/gorm"
 
 	"schisandra-album-cloud-microservices/app/core/api/common/constant"
 	"schisandra-album-cloud-microservices/app/core/api/common/utils"
 	"schisandra-album-cloud-microservices/app/core/api/internal/svc"
 	"schisandra-album-cloud-microservices/app/core/api/repository/mysql/model"
+	"schisandra-album-cloud-microservices/app/core/api/repository/mysql/query"
 )
 
 type GetUserDeviceLogic struct {
@@ -40,14 +41,14 @@ func (l *GetUserDeviceLogic) GetUserDevice(r *http.Request) error {
 		return errors.New("user session not found")
 	}
 
-	if err = GetUserLoginDevice(uid, r, l.svcCtx.Ip2Region, l.svcCtx.DB, l.ctx); err != nil {
+	if err = GetUserLoginDevice(uid, r, l.svcCtx.Ip2Region, l.svcCtx.DB); err != nil {
 		return err
 	}
 	return nil
 }
 
 // GetUserLoginDevice 获取用户登录设备
-func GetUserLoginDevice(userId string, r *http.Request, ip2location *xdb.Searcher, db *xorm.Engine, ctx context.Context) error {
+func GetUserLoginDevice(userId string, r *http.Request, ip2location *xdb.Searcher, DB *query.Query) error {
 	userAgent := r.Header.Get("User-Agent")
 	if userAgent == "" {
 		return errors.New("user agent not found")
@@ -67,54 +68,45 @@ func GetUserLoginDevice(userId string, r *http.Request, ip2location *xdb.Searche
 	mozilla := ua.Mozilla()
 	platform := ua.Platform()
 	engine, engineVersion := ua.Engine()
-
-	var device model.ScaAuthUserDevice
-	has, err := db.Where("user_id = ? AND ip = ? AND agent = ?", userId, ip, userAgent).Get(&device)
-	if err != nil {
+	var newIsBot int64 = 0
+	var newIsMobile int64 = 0
+	if isBot {
+		newIsBot = 1
+	}
+	if mobile {
+		newIsMobile = 1
+	}
+	userDevice := DB.ScaAuthUserDevice
+	device, err := userDevice.Where(userDevice.UserID.Eq(userId), userDevice.IP.Eq(ip), userDevice.Agent.Eq(userAgent)).First()
+	if err != nil && !errors.Is(err, gorm.ErrRecordNotFound) {
 		return err
 	}
-
-	if !has {
+	newDevice := &model.ScaAuthUserDevice{
+		UserID:          userId,
+		Bot:             newIsBot,
+		Agent:           userAgent,
+		Browser:         browser,
+		BrowserVersion:  browserVersion,
+		EngineName:      engine,
+		EngineVersion:   engineVersion,
+		IP:              ip,
+		Location:        location,
+		OperatingSystem: os,
+		Mobile:          newIsMobile,
+		Mozilla:         mozilla,
+		Platform:        platform,
+	}
+	if device == nil {
 		// 创建新的设备记录
-		newDevice := &model.ScaAuthUserDevice{
-			UserId:          userId,
-			Bot:             isBot,
-			Agent:           userAgent,
-			Browser:         browser,
-			BrowserVersion:  browserVersion,
-			EngineName:      engine,
-			EngineVersion:   engineVersion,
-			Ip:              ip,
-			Location:        location,
-			OperatingSystem: os,
-			Mobile:          mobile,
-			Mozilla:         mozilla,
-			Platform:        platform,
-		}
-
-		affected, err := db.Insert(newDevice)
-		if err != nil || affected == 0 {
-			return errors.New("create user device failed")
+		err = DB.ScaAuthUserDevice.Create(newDevice)
+		if err != nil {
+			return err
 		}
 		return nil
 	} else {
-		// 如果设备存在，执行更新
-		device.Bot = isBot
-		device.Agent = userAgent
-		device.Browser = browser
-		device.BrowserVersion = browserVersion
-		device.EngineName = engine
-		device.EngineVersion = engineVersion
-		device.Ip = ip
-		device.Location = location
-		device.OperatingSystem = os
-		device.Mobile = mobile
-		device.Mozilla = mozilla
-		device.Platform = platform
-
-		affected, err := db.ID(device.Id).Update(&device)
-		if err != nil || affected == 0 {
-			return errors.New("update user device failed")
+		resultInfo, err := userDevice.Where(userDevice.ID.Eq(device.ID)).Updates(newDevice)
+		if err != nil || resultInfo.RowsAffected == 0 {
+			return errors.New("update device failed")
 		}
 		return nil
 	}

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

@@ -8,6 +8,7 @@ import (
 
 	"github.com/yitter/idgenerator-go/idgen"
 	"github.com/zeromicro/go-zero/core/logx"
+	"gorm.io/gorm"
 
 	"schisandra-album-cloud-microservices/app/core/api/common/constant"
 	randomname "schisandra-album-cloud-microservices/app/core/api/common/random_name"
@@ -43,48 +44,51 @@ func (l *PhoneLoginLogic) PhoneLogin(r *http.Request, w http.ResponseWriter, req
 	if req.Captcha != code {
 		return response.ErrorWithI18n(l.ctx, "login.captchaError"), nil
 	}
-	authUser := model.ScaAuthUser{
-		Phone:   req.Phone,
-		Deleted: constant.NotDeleted,
-	}
-	has, err := l.svcCtx.DB.Get(&authUser)
-	if err != nil {
-		return nil, err
-	}
-	tx := l.svcCtx.DB.NewSession()
-	defer tx.Close()
-	if err = tx.Begin(); err != nil {
+	authUser := l.svcCtx.DB.ScaAuthUser
+	userInfo, err := authUser.Where(authUser.Phone.Eq(req.Phone), authUser.Deleted.Eq(constant.NotDeleted)).First()
+	if err != nil && !errors.Is(err, gorm.ErrRecordNotFound) {
 		return nil, err
 	}
+	tx := l.svcCtx.DB.Begin()
+	defer func() {
+		if recover() != nil || err != nil {
+			_ = tx.Rollback()
+		}
+	}()
 
-	if !has {
+	if userInfo == nil {
 		uid := idgen.NextId()
 		uidStr := strconv.FormatInt(uid, 10)
 		avatar := utils.GenerateAvatar(uidStr)
 		name := randomname.GenerateName()
-
-		user := model.ScaAuthUser{
+		notDeleted := constant.NotDeleted
+		male := constant.Male
+		user := &model.ScaAuthUser{
 			UID:      uidStr,
 			Phone:    req.Phone,
 			Avatar:   avatar,
 			Nickname: name,
-			Deleted:  constant.NotDeleted,
-			Gender:   constant.Male,
+			Deleted:  notDeleted,
+			Gender:   male,
 		}
-		insert, err := tx.Insert(&user)
-		if err != nil || insert == 0 {
-			return nil, errors.New("register failed")
+		err := tx.ScaAuthUser.Create(user)
+		if err != nil {
+			_ = tx.Rollback()
+			return nil, err
 		}
 		_, err = l.svcCtx.CasbinEnforcer.AddRoleForUser(uidStr, constant.User)
 		if err != nil {
+			_ = tx.Rollback()
 			return nil, err
 		}
 		data, err := HandleUserLogin(user, l.svcCtx, req.AutoLogin, r, w, l.ctx)
 		if err != nil {
+			_ = tx.Rollback()
 			return nil, err
 		}
 		// 记录用户登录设备
-		if err = GetUserLoginDevice(user.UID, r, l.svcCtx.Ip2Region, l.svcCtx.DB, l.ctx); err != nil {
+		if err = GetUserLoginDevice(user.UID, r, l.svcCtx.Ip2Region, l.svcCtx.DB); err != nil {
+			_ = tx.Rollback()
 			return nil, err
 		}
 		err = tx.Commit()
@@ -93,12 +97,14 @@ func (l *PhoneLoginLogic) PhoneLogin(r *http.Request, w http.ResponseWriter, req
 		}
 		return response.SuccessWithData(data), nil
 	} else {
-		data, err := HandleUserLogin(authUser, l.svcCtx, req.AutoLogin, r, w, l.ctx)
+		data, err := HandleUserLogin(userInfo, l.svcCtx, req.AutoLogin, r, w, l.ctx)
 		if err != nil {
+			_ = tx.Rollback()
 			return nil, err
 		}
 		// 记录用户登录设备
-		if err = GetUserLoginDevice(authUser.UID, r, l.svcCtx.Ip2Region, l.svcCtx.DB, l.ctx); err != nil {
+		if err = GetUserLoginDevice(userInfo.UID, r, l.svcCtx.Ip2Region, l.svcCtx.DB); err != nil {
+			_ = tx.Rollback()
 			return nil, err
 		}
 		err = tx.Commit()

app/core/api/internal/logic/user/reset_password_logic.go

@@ -2,15 +2,16 @@ package user
 
 import (
 	"context"
+	"errors"
+
+	"github.com/zeromicro/go-zero/core/logx"
+	"gorm.io/gorm"
 
 	"schisandra-album-cloud-microservices/app/core/api/common/constant"
 	"schisandra-album-cloud-microservices/app/core/api/common/response"
 	"schisandra-album-cloud-microservices/app/core/api/common/utils"
 	"schisandra-album-cloud-microservices/app/core/api/internal/svc"
 	"schisandra-album-cloud-microservices/app/core/api/internal/types"
-	"schisandra-album-cloud-microservices/app/core/api/repository/mysql/model"
-
-	"github.com/zeromicro/go-zero/core/logx"
 )
 
 type ResetPasswordLogic struct {
@@ -48,27 +49,25 @@ func (l *ResetPasswordLogic) ResetPassword(req *types.ResetPasswordRequest) (res
 	if err = l.svcCtx.RedisClient.Del(l.ctx, constant.UserSmsRedisPrefix+req.Phone).Err(); err != nil {
 		return nil, err
 	}
-	authUser := model.ScaAuthUser{
-		Phone:   req.Phone,
-		Deleted: constant.NotDeleted,
+	authUser := l.svcCtx.DB.ScaAuthUser
+
+	userInfo, err := authUser.Where(authUser.Phone.Eq(req.Phone)).First()
+	if err != nil && errors.Is(err, gorm.ErrRecordNotFound) {
+		return response.ErrorWithI18n(l.ctx, "login.userNotRegistered"), nil
 	}
-	has, err := l.svcCtx.DB.Get(&authUser)
 	if err != nil {
 		return nil, err
 	}
-	if !has {
-		return response.ErrorWithI18n(l.ctx, "login.userNotRegistered"), nil
-	}
 	encrypt, err := utils.Encrypt(req.Password)
 	if err != nil {
 		return nil, err
 	}
 
-	affected, err := l.svcCtx.DB.ID(authUser.Id).Cols("password").Update(&model.ScaAuthUser{Password: encrypt})
+	affected, err := authUser.Where(authUser.ID.Eq(userInfo.ID), authUser.Phone.Eq(req.Phone)).Update(authUser.Password, encrypt)
 	if err != nil {
 		return nil, err
 	}
-	if affected == 0 {
+	if affected.RowsAffected == 0 {
 		return response.ErrorWithI18n(l.ctx, "login.resetPasswordError"), nil
 	}
 	return response.Success(), nil