refactor(log): consolidate logging models and update related logic for improved clarity and functionality

internal/logic/admin/log/getMessageLogListLogic.go

@@ -7,7 +7,6 @@ import (
 	"github.com/perfect-panel/server/internal/svc"
 	"github.com/perfect-panel/server/internal/types"
 	"github.com/perfect-panel/server/pkg/logger"
-	"github.com/perfect-panel/server/pkg/tool"
 	"github.com/perfect-panel/server/pkg/xerr"
 	"github.com/pkg/errors"
 )
@@ -28,23 +27,42 @@ func NewGetMessageLogListLogic(ctx context.Context, svcCtx *svc.ServiceContext)
 }
 
 func (l *GetMessageLogListLogic) GetMessageLogList(req *types.GetMessageLogListRequest) (resp *types.GetMessageLogListResponse, err error) {
-	total, data, err := l.svcCtx.LogModel.FindMessageLogList(l.ctx, req.Page, req.Size, log.MessageLogFilterParams{
-		Type:     req.Type,
-		Platform: req.Platform,
-		To:       req.To,
-		Subject:  req.Subject,
-		Content:  req.Content,
-		Status:   req.Status,
+
+	data, total, err := l.svcCtx.LogModel.FilterSystemLog(l.ctx, &log.FilterParams{
+		Page:   req.Page,
+		Size:   req.Size,
+		Type:   req.Type,
+		Search: req.Search,
 	})
+
 	if err != nil {
-		l.Errorw("[GetMessageLogList] Database Error", logger.Field("error", err.Error()))
-		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "[GetMessageLogList] Database Error: %s", err.Error())
+		l.Errorf("[GetMessageLogList] failed to filter system log: %v", err.Error())
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "failed to filter system log: %v", err.Error())
+	}
+
+	var list []*types.MessageLog
+
+	for _, datum := range data {
+		var content log.Message
+		err = content.Unmarshal([]byte(datum.Content))
+		if err != nil {
+			l.Errorf("[GetMessageLogList] failed to unmarshal content: %v", err.Error())
+			continue
+		}
+		list = append(list, &types.MessageLog{
+			Id:        datum.Id,
+			Type:      datum.Type,
+			Platform:  content.Platform,
+			To:        content.To,
+			Subject:   content.Subject,
+			Content:   content.Content,
+			Status:    content.Status,
+			CreatedAt: datum.CreatedAt.UnixMilli(),
+		})
 	}
-	var list []types.MessageLog
-	tool.DeepCopy(&list, data)
 
 	return &types.GetMessageLogListResponse{
 		Total: total,
-		List:  list,
+		List:  nil,
 	}, nil
 }

internal/logic/admin/user/getUserLoginLogsLogic.go

@@ -3,11 +3,10 @@ package user
 import (
 	"context"
 
-	"github.com/perfect-panel/server/internal/model/user"
+	"github.com/perfect-panel/server/internal/model/log"
 	"github.com/perfect-panel/server/internal/svc"
 	"github.com/perfect-panel/server/internal/types"
 	"github.com/perfect-panel/server/pkg/logger"
-	"github.com/perfect-panel/server/pkg/tool"
 	"github.com/perfect-panel/server/pkg/xerr"
 	"github.com/pkg/errors"
 )
@@ -28,15 +27,34 @@ func NewGetUserLoginLogsLogic(ctx context.Context, svcCtx *svc.ServiceContext) *
 }
 
 func (l *GetUserLoginLogsLogic) GetUserLoginLogs(req *types.GetUserLoginLogsRequest) (resp *types.GetUserLoginLogsResponse, err error) {
-	data, total, err := l.svcCtx.UserModel.FilterLoginLogList(l.ctx, req.Page, req.Size, &user.LoginLogFilterParams{
-		UserId: req.UserId,
+	data, total, err := l.svcCtx.LogModel.FilterSystemLog(l.ctx, &log.FilterParams{
+		Page:     req.Page,
+		Size:     req.Size,
+		Type:     log.TypeLogin.Uint8(),
+		ObjectID: req.UserId,
 	})
 	if err != nil {
 		l.Errorw("[GetUserLoginLogs] get user login logs failed", logger.Field("error", err.Error()), logger.Field("request", req))
 		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "get user login logs failed: %v", err.Error())
 	}
 	var list []types.UserLoginLog
-	tool.DeepCopy(&list, data)
+
+	for _, datum := range data {
+		var content log.Login
+		if err = content.Unmarshal([]byte(datum.Content)); err != nil {
+			l.Errorf("[GetUserLoginLogs] unmarshal login log content failed: %v", err.Error())
+			continue
+		}
+		list = append(list, types.UserLoginLog{
+			Id:        datum.Id,
+			UserId:    datum.ObjectID,
+			LoginIP:   content.LoginIP,
+			UserAgent: content.UserAgent,
+			Success:   content.Success,
+			CreatedAt: datum.CreatedAt.UnixMilli(),
+		})
+	}
+
 	return &types.GetUserLoginLogsResponse{
 		Total: total,
 		List:  list,

internal/logic/admin/user/getUserSubscribeLogsLogic.go

@@ -3,7 +3,7 @@ package user
 import (
 	"context"
 
-	"github.com/perfect-panel/server/internal/model/user"
+	"github.com/perfect-panel/server/internal/model/log"
 	"github.com/perfect-panel/server/internal/svc"
 	"github.com/perfect-panel/server/internal/types"
 	"github.com/perfect-panel/server/pkg/logger"
@@ -28,10 +28,7 @@ func NewGetUserSubscribeLogsLogic(ctx context.Context, svcCtx *svc.ServiceContex
 }
 
 func (l *GetUserSubscribeLogsLogic) GetUserSubscribeLogs(req *types.GetUserSubscribeLogsRequest) (resp *types.GetUserSubscribeLogsResponse, err error) {
-	data, total, err := l.svcCtx.UserModel.FilterSubscribeLogList(l.ctx, req.Page, req.Size, &user.SubscribeLogFilterParams{
-		UserSubscribeId: req.SubscribeId,
-		UserId:          req.UserId,
-	})
+	data, total, err := l.svcCtx.LogModel.FilterSystemLog(l.ctx, &log.FilterParams{})
 
 	if err != nil {
 		l.Errorw("[GetUserSubscribeLogs] Get User Subscribe Logs Error:", logger.Field("err", err.Error()))

internal/logic/auth/oauth/oAuthLoginGetTokenLogic.go

@@ -8,6 +8,7 @@ import (
 
 	"github.com/perfect-panel/server/internal/config"
 	"github.com/perfect-panel/server/internal/model/auth"
+	"github.com/perfect-panel/server/internal/model/log"
 	"github.com/perfect-panel/server/internal/model/user"
 	"github.com/perfect-panel/server/internal/svc"
 	"github.com/perfect-panel/server/internal/types"
@@ -52,7 +53,6 @@ func NewOAuthLoginGetTokenLogic(ctx context.Context, svcCtx *svc.ServiceContext)
 }
 
 func (l *OAuthLoginGetTokenLogic) OAuthLoginGetToken(req *types.OAuthLoginGetTokenRequest, ip, userAgent string) (resp *types.LoginResponse, err error) {
-	startTime := time.Now()
 	requestID := uuidx.NewUUID().String()
 	loginStatus := false
 	var userInfo *user.User
@@ -65,24 +65,7 @@ func (l *OAuthLoginGetTokenLogic) OAuthLoginGetToken(req *types.OAuthLoginGetTok
 	)
 
 	defer func() {
-		duration := time.Since(startTime)
-		l.recordLoginStatus(&loginStatus, &userInfo, ip, userAgent, requestID)
-
-		if loginStatus {
-			l.Infow("oauth login completed successfully",
-				logger.Field("request_id", requestID),
-				logger.Field("method", req.Method),
-				logger.Field("user_id", userInfo.Id),
-				logger.Field("duration_ms", duration.Milliseconds()),
-			)
-		} else {
-			l.Errorw("oauth login failed",
-				logger.Field("request_id", requestID),
-				logger.Field("method", req.Method),
-				logger.Field("error", err),
-				logger.Field("duration_ms", duration.Milliseconds()),
-			)
-		}
+		l.recordLoginStatus(loginStatus, userInfo, ip, userAgent, requestID)
 	}()
 
 	userInfo, err = l.handleOAuthProvider(req, requestID)
@@ -504,27 +487,28 @@ func (l *OAuthLoginGetTokenLogic) createAuthMethod(db *gorm.DB, userID int64, au
 	return nil
 }
 
-func (l *OAuthLoginGetTokenLogic) recordLoginStatus(loginStatus *bool, userInfo **user.User, ip, userAgent, requestID string) {
-	if *userInfo != nil && (*userInfo).Id != 0 {
-		if err := l.svcCtx.UserModel.InsertLoginLog(l.ctx, &user.LoginLog{
-			UserId:    (*userInfo).Id,
+func (l *OAuthLoginGetTokenLogic) recordLoginStatus(loginStatus bool, userInfo *user.User, ip, userAgent, requestID string) {
+
+	if userInfo != nil && userInfo.Id != 0 {
+		loginLog := log.Login{
 			LoginIP:   ip,
 			UserAgent: userAgent,
 			Success:   loginStatus,
+		}
+		content, _ := loginLog.Marshal()
+		if err := l.svcCtx.LogModel.Insert(l.ctx, &log.SystemLog{
+			Id:       0,
+			Type:     log.TypeLogin.Uint8(),
+			Date:     time.Now().Format("2006-01-02"),
+			ObjectID: userInfo.Id,
+			Content:  string(content),
 		}); err != nil {
 			l.Errorw("failed to insert login log",
 				logger.Field("request_id", requestID),
-				logger.Field("user_id", (*userInfo).Id),
+				logger.Field("user_id", userInfo.Id),
 				logger.Field("ip", ip),
 				logger.Field("error", err.Error()),
 			)
-		} else {
-			l.Debugw("login log recorded successfully",
-				logger.Field("request_id", requestID),
-				logger.Field("user_id", (*userInfo).Id),
-				logger.Field("ip", ip),
-				logger.Field("success", *loginStatus),
-			)
 		}
 	}
 }

internal/logic/auth/resetPasswordLogic.go

@@ -6,6 +6,7 @@ import (
 	"fmt"
 	"time"
 
+	"github.com/perfect-panel/server/internal/model/log"
 	"github.com/perfect-panel/server/internal/model/user"
 	"github.com/perfect-panel/server/pkg/jwt"
 	"github.com/perfect-panel/server/pkg/uuidx"
@@ -43,13 +44,24 @@ func (l *ResetPasswordLogic) ResetPassword(req *types.ResetPasswordRequest) (res
 
 	defer func() {
 		if userInfo.Id != 0 && loginStatus {
-			if err := l.svcCtx.UserModel.InsertLoginLog(l.ctx, &user.LoginLog{
-				UserId:    userInfo.Id,
+			loginLog := log.Login{
 				LoginIP:   req.IP,
 				UserAgent: req.UserAgent,
-				Success:   &loginStatus,
+				Success:   loginStatus,
+			}
+			content, _ := loginLog.Marshal()
+			if err = l.svcCtx.LogModel.Insert(l.ctx, &log.SystemLog{
+				Id:       0,
+				Type:     log.TypeLogin.Uint8(),
+				Date:     time.Now().Format("2006-01-02"),
+				ObjectID: userInfo.Id,
+				Content:  string(content),
 			}); err != nil {
-				l.Logger.Error("[ResetPassword] insert login log error", logger.Field("error", err.Error()))
+				l.Errorw("failed to insert login log",
+					logger.Field("user_id", userInfo.Id),
+					logger.Field("ip", req.IP),
+					logger.Field("error", err.Error()),
+				)
 			}
 		}
 	}()

internal/logic/auth/telephoneLoginLogic.go

@@ -9,6 +9,7 @@ import (
 
 	"github.com/perfect-panel/server/internal/config"
 	"github.com/perfect-panel/server/internal/logic/common"
+	"github.com/perfect-panel/server/internal/model/log"
 	"github.com/perfect-panel/server/internal/model/user"
 	"github.com/perfect-panel/server/internal/svc"
 	"github.com/perfect-panel/server/internal/types"
@@ -51,13 +52,24 @@ func (l *TelephoneLoginLogic) TelephoneLogin(req *types.TelephoneLoginRequest, r
 	// Record login status
 	defer func(svcCtx *svc.ServiceContext) {
 		if userInfo.Id != 0 {
-			if err := svcCtx.UserModel.InsertLoginLog(l.ctx, &user.LoginLog{
-				UserId:    userInfo.Id,
+			loginLog := log.Login{
 				LoginIP:   ip,
 				UserAgent: r.UserAgent(),
-				Success:   &loginStatus,
+				Success:   loginStatus,
+			}
+			content, _ := loginLog.Marshal()
+			if err = l.svcCtx.LogModel.Insert(l.ctx, &log.SystemLog{
+				Id:       0,
+				Type:     log.TypeLogin.Uint8(),
+				Date:     time.Now().Format("2006-01-02"),
+				ObjectID: userInfo.Id,
+				Content:  string(content),
 			}); err != nil {
-				l.Logger.Error("[UserLogin] insert login log error", logger.Field("error", err.Error()))
+				l.Errorw("failed to insert login log",
+					logger.Field("user_id", userInfo.Id),
+					logger.Field("ip", req.IP),
+					logger.Field("error", err.Error()),
+				)
 			}
 		}
 	}(l.svcCtx)

internal/logic/auth/userLoginLogic.go

@@ -5,6 +5,7 @@ import (
 	"fmt"
 	"time"
 
+	"github.com/perfect-panel/server/internal/model/log"
 	"github.com/perfect-panel/server/pkg/logger"
 
 	"github.com/perfect-panel/server/internal/config"
@@ -41,29 +42,44 @@ func (l *UserLoginLogic) UserLogin(req *types.UserLoginRequest) (resp *types.Log
 	// Record login status
 	defer func(svcCtx *svc.ServiceContext) {
 		if userInfo.Id != 0 {
-			if err := svcCtx.UserModel.InsertLoginLog(l.ctx, &user.LoginLog{
-				UserId:    userInfo.Id,
+			loginLog := log.Login{
 				LoginIP:   req.IP,
 				UserAgent: req.UserAgent,
-				Success:   &loginStatus,
+				Success:   loginStatus,
+			}
+			content, _ := loginLog.Marshal()
+			if err := l.svcCtx.LogModel.Insert(l.ctx, &log.SystemLog{
+				Id:       0,
+				Type:     log.TypeLogin.Uint8(),
+				Date:     time.Now().Format("2006-01-02"),
+				ObjectID: userInfo.Id,
+				Content:  string(content),
 			}); err != nil {
-				l.Logger.Error("[UserLogin] insert login log error", logger.Field("error", err.Error()))
+				l.Errorw("failed to insert login log",
+					logger.Field("user_id", userInfo.Id),
+					logger.Field("ip", req.IP),
+					logger.Field("error", err.Error()),
+				)
 			}
 		}
 	}(l.svcCtx)
 
 	userInfo, err = l.svcCtx.UserModel.FindOneByEmail(l.ctx, req.Email)
+
+	l.Debugf("[用户登陆] user email: %v, user info: %v", req.Email, userInfo)
 	if err != nil {
 		if errors.As(err, &gorm.ErrRecordNotFound) {
-			logger.WithContext(l.ctx).Error(err)
 			return nil, errors.Wrapf(xerr.NewErrCode(xerr.UserNotExist), "user email not exist: %v", req.Email)
 		}
+		logger.WithContext(l.ctx).Error(err)
 		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "query user info failed: %v", err.Error())
 	}
+
 	// Verify password
 	if !tool.VerifyPassWord(req.Password, userInfo.Password) {
 		return nil, errors.Wrapf(xerr.NewErrCode(xerr.UserPasswordError), "user password")
 	}
+	l.Debugf("[用户登陆] 密码验证成功")
 	// Generate session id
 	sessionId := uuidx.NewUUID().String()
 	// Generate token
@@ -80,6 +96,7 @@ func (l *UserLoginLogic) UserLogin(req *types.UserLoginRequest) (resp *types.Log
 	}
 	sessionIdCacheKey := fmt.Sprintf("%v:%v", config.SessionIdKey, sessionId)
 	if err = l.svcCtx.Redis.Set(l.ctx, sessionIdCacheKey, userInfo.Id, time.Duration(l.svcCtx.Config.JwtAuth.AccessExpire)*time.Second).Err(); err != nil {
+		l.Errorf("[用户登陆] set session id error: %v", err.Error())
 		return nil, errors.Wrapf(xerr.NewErrCode(xerr.ERROR), "set session id error: %v", err.Error())
 	}
 	loginStatus = true

internal/logic/auth/userRegisterLogic.go

@@ -8,6 +8,7 @@ import (
 
 	"github.com/perfect-panel/server/internal/config"
 	"github.com/perfect-panel/server/internal/logic/common"
+	"github.com/perfect-panel/server/internal/model/log"
 	"github.com/perfect-panel/server/internal/model/user"
 	"github.com/perfect-panel/server/internal/svc"
 	"github.com/perfect-panel/server/internal/types"
@@ -145,13 +146,24 @@ func (l *UserRegisterLogic) UserRegister(req *types.UserRegisterRequest) (resp *
 	loginStatus := true
 	defer func() {
 		if token != "" && userInfo.Id != 0 {
-			if err := l.svcCtx.UserModel.InsertLoginLog(l.ctx, &user.LoginLog{
-				UserId:    userInfo.Id,
+			loginLog := log.Login{
 				LoginIP:   req.IP,
 				UserAgent: req.UserAgent,
-				Success:   &loginStatus,
+				Success:   loginStatus,
+			}
+			content, _ := loginLog.Marshal()
+			if err = l.svcCtx.LogModel.Insert(l.ctx, &log.SystemLog{
+				Id:       0,
+				Type:     log.TypeLogin.Uint8(),
+				Date:     time.Now().Format("2006-01-02"),
+				ObjectID: userInfo.Id,
+				Content:  string(content),
 			}); err != nil {
-				l.Logger.Error("[UserRegister] insert login log error", logger.Field("error", err.Error()))
+				l.Errorw("failed to insert login log",
+					logger.Field("user_id", userInfo.Id),
+					logger.Field("ip", req.IP),
+					logger.Field("error", err.Error()),
+				)
 			}
 		}
 	}()

internal/logic/common/sendEmailCodeLogic.go

@@ -1,11 +1,9 @@
 package common
 
 import (
-	"bytes"
 	"context"
 	"encoding/json"
 	"fmt"
-	"text/template"
 	"time"
 
 	"github.com/hibiken/asynq"
@@ -90,12 +88,13 @@ func (l *SendEmailCodeLogic) SendEmailCode(req *types.SendCodeRequest) (resp *ty
 	code := random.Key(6, 0)
 	taskPayload.Email = req.Email
 	taskPayload.Subject = "Verification code"
-	content, err := l.initTemplate(req.Type, code)
-	if err != nil {
-		l.Logger.Error("[SendEmailCode]: InitTemplate Error", logger.Field("error", err.Error()))
-		return nil, errors.Wrapf(xerr.NewErrCode(xerr.ERROR), "Failed to init template")
+	taskPayload.Content = map[string]interface{}{
+		"Type":     req.Type,
+		"SiteLogo": l.svcCtx.Config.Site.SiteLogo,
+		"SiteName": l.svcCtx.Config.Site.SiteName,
+		"Expire":   5,
+		"Code":     code,
 	}
-	taskPayload.Content = content
 	// Save to Redis
 	payload = CacheKeyPayload{
 		Code:   code,
@@ -134,23 +133,3 @@ func (l *SendEmailCodeLogic) SendEmailCode(req *types.SendCodeRequest) (resp *ty
 		}, nil
 	}
 }
-
-func (l *SendEmailCodeLogic) initTemplate(t uint8, code string) (string, error) {
-	data := VerifyTemplate{
-		Type:     t,
-		SiteLogo: l.svcCtx.Config.Site.SiteLogo,
-		SiteName: l.svcCtx.Config.Site.SiteName,
-		Expire:   5,
-		Code:     code,
-	}
-	tpl, err := template.New("verify").Parse(l.svcCtx.Config.Email.VerifyEmailTemplate)
-	if err != nil {
-		return "", err
-	}
-	var result bytes.Buffer
-	err = tpl.Execute(&result, data)
-	if err != nil {
-		return "", err
-	}
-	return result.String(), nil
-}

internal/logic/public/order/closeOrderLogic.go

@@ -3,7 +3,9 @@ package order
 import (
 	"context"
 	"encoding/json"
+	"time"
 
+	"github.com/perfect-panel/server/internal/model/log"
 	"github.com/perfect-panel/server/internal/model/user"
 	"github.com/perfect-panel/server/pkg/payment/stripe"
 	"gorm.io/gorm"
@@ -92,15 +94,25 @@ func (l *CloseOrderLogic) CloseOrder(req *types.CloseOrderRequest) error {
 				return err
 			}
 			// Record the deduction refund log
-			giftAmountLog := &user.GiftAmountLog{
-				UserId:  orderInfo.UserId,
-				OrderNo: orderInfo.OrderNo,
-				Amount:  orderInfo.GiftAmount,
-				Type:    1,
-				Balance: deduction,
-				Remark:  "Order cancellation refund",
+
+			giftLog := log.Gift{
+				Type:        log.GiftTypeIncrease,
+				OrderNo:     orderInfo.OrderNo,
+				SubscribeId: 0,
+				Amount:      orderInfo.GiftAmount,
+				Balance:     deduction,
+				Remark:      "Order cancellation refund",
+				CreatedAt:   time.Now().UnixMilli(),
 			}
-			err = tx.Model(&user.GiftAmountLog{}).Create(giftAmountLog).Error
+			content, _ := giftLog.Marshal()
+
+			err = tx.Model(&log.SystemLog{}).Create(&log.SystemLog{
+				Id:       0,
+				Type:     log.TypeGift.Uint8(),
+				Date:     time.Now().Format(time.DateOnly),
+				ObjectID: userInfo.Id,
+				Content:  string(content),
+			}).Error
 			if err != nil {
 				l.Errorw("[CloseOrder] Record cancellation refund log failed",
 					logger.Field("error", err.Error()),

internal/logic/public/order/purchaseLogic.go

@@ -5,6 +5,7 @@ import (
 	"encoding/json"
 	"time"
 
+	"github.com/perfect-panel/server/internal/model/log"
 	"github.com/perfect-panel/server/pkg/constant"
 
 	"github.com/hibiken/asynq"
@@ -196,18 +197,26 @@ func (l *PurchaseLogic) Purchase(req *types.PurchaseOrderRequest) (resp *types.P
 				return e
 			}
 			// create deduction record
-			giftAmountLog := user.GiftAmountLog{
-				UserId:  orderInfo.UserId,
-				OrderNo: orderInfo.OrderNo,
-				Amount:  orderInfo.GiftAmount,
-				Type:    2,
-				Balance: u.GiftAmount,
-				Remark:  "Purchase order deduction",
+			giftLog := log.Gift{
+				Type:        log.GiftTypeReduce,
+				OrderNo:     orderInfo.OrderNo,
+				SubscribeId: 0,
+				Amount:      orderInfo.GiftAmount,
+				Balance:     u.GiftAmount,
+				Remark:      "Purchase order deduction",
+				CreatedAt:   time.Now().UnixMilli(),
 			}
-			if e := db.Model(&user.GiftAmountLog{}).Create(&giftAmountLog).Error; e != nil {
+			content, _ := giftLog.Marshal()
+
+			if e := db.Model(&log.SystemLog{}).Create(&log.SystemLog{
+				Type:     log.TypeGift.Uint8(),
+				Date:     time.Now().Format(time.DateOnly),
+				ObjectID: u.Id,
+				Content:  string(content),
+			}).Error; e != nil {
 				l.Errorw("[Purchase] Database insert error",
 					logger.Field("error", e.Error()),
-					logger.Field("deductionLog", giftAmountLog),
+					logger.Field("deductionLog", giftLog),
 				)
 				return e
 			}

internal/logic/public/order/renewalLogic.go

@@ -5,6 +5,7 @@ import (
 	"encoding/json"
 	"time"
 
+	"github.com/perfect-panel/server/internal/model/log"
 	"github.com/perfect-panel/server/pkg/constant"
 
 	"gorm.io/gorm"
@@ -163,16 +164,24 @@ func (l *RenewalLogic) Renewal(req *types.RenewalOrderRequest) (resp *types.Rene
 				return err
 			}
 			// create deduction record
-			deductionLog := user.GiftAmountLog{
-				UserId:  orderInfo.UserId,
-				OrderNo: orderInfo.OrderNo,
-				Amount:  orderInfo.GiftAmount,
-				Type:    2,
-				Balance: u.GiftAmount,
-				Remark:  "Renewal order deduction",
+			giftLog := log.Gift{
+				Type:        log.GiftTypeReduce,
+				OrderNo:     orderInfo.OrderNo,
+				SubscribeId: 0,
+				Amount:      orderInfo.GiftAmount,
+				Balance:     u.GiftAmount,
+				Remark:      "Renewal order deduction",
+				CreatedAt:   time.Now().UnixMilli(),
 			}
-			if err := db.Model(&user.GiftAmountLog{}).Create(&deductionLog).Error; err != nil {
-				l.Errorw("[Renewal] Database insert error", logger.Field("error", err.Error()), logger.Field("deductionLog", deductionLog))
+			content, _ := giftLog.Marshal()
+
+			if err := db.Model(&log.SystemLog{}).Create(&log.SystemLog{
+				Type:     log.TypeGift.Uint8(),
+				Date:     time.Now().Format(time.DateOnly),
+				ObjectID: u.Id,
+				Content:  string(content),
+			}).Error; err != nil {
+				l.Errorw("[Renewal] Database insert error", logger.Field("error", err.Error()), logger.Field("deductionLog", giftLog))
 				return err
 			}
 		}

internal/logic/public/order/resetTrafficLogic.go

@@ -5,6 +5,7 @@ import (
 	"encoding/json"
 	"time"
 
+	"github.com/perfect-panel/server/internal/model/log"
 	"github.com/perfect-panel/server/pkg/constant"
 	"github.com/perfect-panel/server/pkg/xerr"
 
@@ -104,16 +105,24 @@ func (l *ResetTrafficLogic) ResetTraffic(req *types.ResetTrafficOrderRequest) (r
 				return err
 			}
 			// create deduction record
-			deductionLog := user.GiftAmountLog{
-				UserId:  orderInfo.UserId,
-				OrderNo: orderInfo.OrderNo,
-				Amount:  orderInfo.GiftAmount,
-				Type:    2,
-				Balance: u.GiftAmount,
-				Remark:  "ResetTraffic order deduction",
+			giftLog := log.Gift{
+				Type:        log.GiftTypeReduce,
+				OrderNo:     orderInfo.OrderNo,
+				SubscribeId: 0,
+				Amount:      orderInfo.GiftAmount,
+				Balance:     u.GiftAmount,
+				Remark:      "Renewal order deduction",
+				CreatedAt:   time.Now().UnixMilli(),
 			}
-			if err := db.Model(&user.GiftAmountLog{}).Create(&deductionLog).Error; err != nil {
-				l.Errorw("[ResetTraffic] Database insert error", logger.Field("error", err.Error()), logger.Field("deductionLog", deductionLog))
+			content, _ := giftLog.Marshal()
+
+			if err = db.Model(&log.SystemLog{}).Create(&log.SystemLog{
+				Type:     log.TypeGift.Uint8(),
+				Date:     time.Now().Format(time.DateOnly),
+				ObjectID: u.Id,
+				Content:  string(content),
+			}).Error; err != nil {
+				l.Errorw("[ResetTraffic] Database insert error", logger.Field("error", err.Error()), logger.Field("deductionLog", content))
 				return err
 			}
 		}

internal/logic/public/portal/purchaseCheckoutLogic.go

@@ -4,7 +4,9 @@ import (
 	"context"
 	"encoding/json"
 	"strconv"
+	"time"
 
+	"github.com/perfect-panel/server/internal/model/log"
 	"github.com/perfect-panel/server/pkg/constant"
 
 	paymentPlatform "github.com/perfect-panel/server/pkg/payment"
@@ -386,16 +388,21 @@ func (l *PurchaseCheckoutLogic) balancePayment(u *user.User, o *order.Order) err
 
 		// Create gift amount log if gift amount was used
 		if giftUsed > 0 {
-			giftLog := &user.GiftAmountLog{
-				UserId:          u.Id,
-				UserSubscribeId: 0, // Will be updated when subscription is created
-				OrderNo:         o.OrderNo,
-				Type:            2, // Type 2 represents gift amount decrease/usage
-				Amount:          giftUsed,
-				Balance:         userInfo.GiftAmount,
-				Remark:          "Purchase payment",
+			giftLog := &log.Gift{
+				OrderNo: o.OrderNo,
+				Type:    2, // Type 2 represents gift amount decrease/usage
+				Amount:  giftUsed,
+				Balance: userInfo.GiftAmount,
+				Remark:  "Purchase payment",
 			}
-			err = db.Create(giftLog).Error
+			content, _ := giftLog.Marshal()
+
+			err = db.Create(&log.SystemLog{
+				Type:     log.TypeGift.Uint8(),
+				ObjectID: userInfo.Id,
+				Date:     time.Now().Format(time.DateOnly),
+				Content:  string(content),
+			}).Error
 			if err != nil {
 				return err
 			}
@@ -403,14 +410,19 @@ func (l *PurchaseCheckoutLogic) balancePayment(u *user.User, o *order.Order) err
 
 		// Create balance log if regular balance was used
 		if balanceUsed > 0 {
-			balanceLog := &user.BalanceLog{
-				UserId:  u.Id,
+			balanceLog := &log.Balance{
 				Amount:  balanceUsed,
-				Type:    3, // Type 3 represents payment deduction
+				Type:    log.BalanceTypePayment, // Type 3 represents payment deduction
 				OrderId: o.Id,
 				Balance: userInfo.Balance,
 			}
-			err = db.Create(balanceLog).Error
+			content, _ := balanceLog.Marshal()
+			err = db.Create(&log.SystemLog{
+				Type:     log.TypeBalance.Uint8(),
+				ObjectID: userInfo.Id,
+				Date:     time.Now().Format(time.DateOnly),
+				Content:  string(content),
+			}).Error
 			if err != nil {
 				return err
 			}

internal/logic/public/user/getLoginLogLogic.go

@@ -3,13 +3,13 @@ package user
 import (
 	"context"
 
+	"github.com/perfect-panel/server/internal/model/log"
 	"github.com/perfect-panel/server/pkg/constant"
 
 	"github.com/perfect-panel/server/internal/model/user"
 	"github.com/perfect-panel/server/internal/svc"
 	"github.com/perfect-panel/server/internal/types"
 	"github.com/perfect-panel/server/pkg/logger"
-	"github.com/perfect-panel/server/pkg/tool"
 	"github.com/perfect-panel/server/pkg/xerr"
 	"github.com/pkg/errors"
 )
@@ -35,15 +35,34 @@ func (l *GetLoginLogLogic) GetLoginLog(req *types.GetLoginLogRequest) (resp *typ
 		logger.Error("current user is not found in context")
 		return nil, errors.Wrapf(xerr.NewErrCode(xerr.InvalidAccess), "Invalid Access")
 	}
-	data, total, err := l.svcCtx.UserModel.FilterLoginLogList(l.ctx, req.Page, req.Size, &user.LoginLogFilterParams{
-		UserId: u.Id,
+	data, total, err := l.svcCtx.LogModel.FilterSystemLog(l.ctx, &log.FilterParams{
+		Page:     req.Page,
+		Size:     req.Size,
+		Type:     log.TypeLogin.Uint8(),
+		ObjectID: u.Id,
 	})
 	if err != nil {
 		l.Errorw("find login log failed:", logger.Field("error", err.Error()), logger.Field("user_id", u.Id))
 		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "find login log failed: %v", err.Error())
 	}
 	list := make([]types.UserLoginLog, 0)
-	tool.DeepCopy(&list, data)
+
+	for _, datum := range data {
+		var content log.Login
+		if err = content.Unmarshal([]byte(datum.Content)); err != nil {
+			l.Errorf("[GetUserLoginLogs] unmarshal login log content failed: %v", err.Error())
+			continue
+		}
+		list = append(list, types.UserLoginLog{
+			Id:        datum.Id,
+			UserId:    datum.ObjectID,
+			LoginIP:   content.LoginIP,
+			UserAgent: content.UserAgent,
+			Success:   content.Success,
+			CreatedAt: datum.CreatedAt.UnixMilli(),
+		})
+	}
+
 	return &types.GetLoginLogResponse{
 		Total: total,
 		List:  list,

internal/logic/public/user/getSubscribeLogLogic.go

@@ -3,13 +3,13 @@ package user
 import (
 	"context"
 
+	"github.com/perfect-panel/server/internal/model/log"
 	"github.com/perfect-panel/server/pkg/constant"
 
 	"github.com/perfect-panel/server/internal/model/user"
 	"github.com/perfect-panel/server/internal/svc"
 	"github.com/perfect-panel/server/internal/types"
 	"github.com/perfect-panel/server/pkg/logger"
-	"github.com/perfect-panel/server/pkg/tool"
 	"github.com/perfect-panel/server/pkg/xerr"
 	"github.com/pkg/errors"
 )
@@ -35,15 +35,34 @@ func (l *GetSubscribeLogLogic) GetSubscribeLog(req *types.GetSubscribeLogRequest
 		logger.Error("current user is not found in context")
 		return nil, errors.Wrapf(xerr.NewErrCode(xerr.InvalidAccess), "Invalid Access")
 	}
-	data, total, err := l.svcCtx.UserModel.FilterSubscribeLogList(l.ctx, req.Page, req.Size, &user.SubscribeLogFilterParams{
-		UserId: u.Id,
+	data, total, err := l.svcCtx.LogModel.FilterSystemLog(l.ctx, &log.FilterParams{
+		Page:     req.Page,
+		Size:     req.Size,
+		Type:     log.TypeSubscribe.Uint8(),
+		ObjectID: u.Id,
 	})
 	if err != nil {
 		l.Errorw("[GetUserSubscribeLogs] Get User Subscribe Logs Error:", logger.Field("err", err.Error()))
 		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "Get User Subscribe Logs Error")
 	}
 	var list []types.UserSubscribeLog
-	tool.DeepCopy(&list, data)
+
+	for _, item := range data {
+		var content log.Subscribe
+		if err = content.Unmarshal([]byte(item.Content)); err != nil {
+			l.Errorf("[GetUserSubscribeLogs] unmarshal subscribe log content failed: %v", err.Error())
+			continue
+		}
+		list = append(list, types.UserSubscribeLog{
+			Id:              item.Id,
+			UserId:          item.ObjectID,
+			UserSubscribeId: content.SubscribeId,
+			Token:           content.Token,
+			IP:              content.ClientIP,
+			UserAgent:       content.UserAgent,
+			CreatedAt:       item.CreatedAt.UnixMilli(),
+		})
+	}
 
 	return &types.GetSubscribeLogResponse{
 		List:  list,

internal/logic/public/user/queryUserAffiliateLogic.go

@@ -3,6 +3,7 @@ package user
 import (
 	"context"
 
+	"github.com/perfect-panel/server/internal/model/log"
 	"github.com/perfect-panel/server/pkg/constant"
 
 	"github.com/perfect-panel/server/internal/model/user"
@@ -44,14 +45,20 @@ func (l *QueryUserAffiliateLogic) QueryUserAffiliate() (resp *types.QueryUserAff
 	if err != nil {
 		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "Query User Affiliate failed: %v", err)
 	}
-	err = l.svcCtx.UserModel.Transaction(l.ctx, func(db *gorm.DB) error {
-		return db.Model(&user.CommissionLog{}).
-			Where("user_id = ?", u.Id).
-			Select("COALESCE(SUM(amount), 0)").
-			Scan(&sum).Error
+	data, _, err := l.svcCtx.LogModel.FilterSystemLog(l.ctx, &log.FilterParams{
+		Page:     1,
+		Size:     99999,
+		Type:     log.TypeCommission.Uint8(),
+		ObjectID: u.Id,
 	})
-	if err != nil {
-		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "Query User Affiliate failed: %v", err)
+
+	for _, datum := range data {
+		content := log.Commission{}
+		if err = content.Unmarshal([]byte(datum.Content)); err != nil {
+			l.Errorf("[QueryUserAffiliate] unmarshal comission log failed: %v", err.Error())
+			continue
+		}
+		sum += content.Amount
 	}
 
 	return &types.QueryUserAffiliateCountResponse{

internal/logic/public/user/queryUserBalanceLogLogic.go

@@ -3,17 +3,15 @@ package user
 import (
 	"context"
 
+	"github.com/perfect-panel/server/internal/model/log"
 	"github.com/perfect-panel/server/pkg/constant"
 
 	"github.com/perfect-panel/server/internal/model/user"
-	"github.com/perfect-panel/server/pkg/tool"
-	"github.com/perfect-panel/server/pkg/xerr"
-	"github.com/pkg/errors"
-	"gorm.io/gorm"
-
 	"github.com/perfect-panel/server/internal/svc"
 	"github.com/perfect-panel/server/internal/types"
 	"github.com/perfect-panel/server/pkg/logger"
+	"github.com/perfect-panel/server/pkg/xerr"
+	"github.com/pkg/errors"
 )
 
 type QueryUserBalanceLogLogic struct {
@@ -37,19 +35,39 @@ func (l *QueryUserBalanceLogLogic) QueryUserBalanceLog() (resp *types.QueryUserB
 		logger.Error("current user is not found in context")
 		return nil, errors.Wrapf(xerr.NewErrCode(xerr.InvalidAccess), "Invalid Access")
 	}
-	var data []*user.BalanceLog
-	var total int64
-	// Query User Balance Log
-	err = l.svcCtx.UserModel.Transaction(l.ctx, func(db *gorm.DB) error {
-		return db.Model(&user.BalanceLog{}).Order("created_at DESC").Where("user_id = ?", u.Id).Count(&total).Find(&data).Error
+
+	data, total, err := l.svcCtx.LogModel.FilterSystemLog(l.ctx, &log.FilterParams{
+		Page:     1,
+		Size:     99999,
+		Type:     log.TypeBalance.Uint8(),
+		ObjectID: u.Id,
 	})
 	if err != nil {
-		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "Query User Balance Log failed: %v", err)
+		l.Errorw("[QueryUserBalanceLog] Query User Balance Log Error:", logger.Field("err", err.Error()))
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "Query User Balance Log Error")
 	}
+
 	resp = &types.QueryUserBalanceLogListResponse{
-		List:  make([]types.UserBalanceLog, 0),
 		Total: total,
 	}
-	tool.DeepCopy(&resp.List, data)
+
+	list := make([]types.UserBalanceLog, 0)
+	for _, datum := range data {
+		var content log.Balance
+		if err = content.Unmarshal([]byte(datum.Content)); err != nil {
+			l.Errorf("[QueryUserBalanceLog] unmarshal balance log content failed: %v", err.Error())
+			continue
+		}
+		list = append(list, types.UserBalanceLog{
+			Id:        datum.Id,
+			UserId:    datum.ObjectID,
+			Amount:    content.Amount,
+			Type:      content.Type,
+			OrderId:   content.OrderId,
+			Balance:   content.Balance,
+			CreatedAt: datum.CreatedAt.UnixMilli(),
+		})
+	}
+
 	return
 }

internal/logic/public/user/queryUserCommissionLogLogic.go

@@ -3,17 +3,15 @@ package user
 import (
 	"context"
 
+	"github.com/perfect-panel/server/internal/model/log"
 	"github.com/perfect-panel/server/pkg/constant"
 
 	"github.com/perfect-panel/server/internal/model/user"
-	"github.com/perfect-panel/server/pkg/tool"
-	"github.com/perfect-panel/server/pkg/xerr"
-	"github.com/pkg/errors"
-	"gorm.io/gorm"
-
 	"github.com/perfect-panel/server/internal/svc"
 	"github.com/perfect-panel/server/internal/types"
 	"github.com/perfect-panel/server/pkg/logger"
+	"github.com/perfect-panel/server/pkg/xerr"
+	"github.com/pkg/errors"
 )
 
 type QueryUserCommissionLogLogic struct {
@@ -32,22 +30,40 @@ func NewQueryUserCommissionLogLogic(ctx context.Context, svcCtx *svc.ServiceCont
 }
 
 func (l *QueryUserCommissionLogLogic) QueryUserCommissionLog(req *types.QueryUserCommissionLogListRequest) (resp *types.QueryUserCommissionLogListResponse, err error) {
-	var data []*user.CommissionLog
 	u, ok := l.ctx.Value(constant.CtxKeyUser).(*user.User)
 	if !ok {
 		logger.Error("current user is not found in context")
 		return nil, errors.Wrapf(xerr.NewErrCode(xerr.InvalidAccess), "Invalid Access")
 	}
-	err = l.svcCtx.UserModel.Transaction(l.ctx, func(db *gorm.DB) error {
-		return db.Order("id desc").Limit(req.Size).Offset((req.Page-1)*req.Size).Where("user_id = ?", u.Id).Find(&data).Error
+	data, total, err := l.svcCtx.LogModel.FilterSystemLog(l.ctx, &log.FilterParams{
+		Page:     req.Page,
+		Size:     req.Size,
+		Type:     log.TypeCommission.Uint8(),
+		ObjectID: u.Id,
 	})
 	if err != nil {
 		l.Errorw("Query User Commission Log failed", logger.Field("error", err.Error()))
 		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "Query User Commission Log failed: %v", err)
 	}
 	var list []types.CommissionLog
-	tool.DeepCopy(&list, data)
+
+	for _, datum := range data {
+		var content log.Commission
+		if err = content.Unmarshal([]byte(datum.Content)); err != nil {
+			l.Errorf("unmarshal commission log content failed: %v", err.Error())
+			continue
+		}
+		list = append(list, types.CommissionLog{
+			Id:        datum.Id,
+			UserId:    datum.ObjectID,
+			OrderNo:   content.OrderNo,
+			Amount:    content.Amount,
+			CreatedAt: content.CreatedAt,
+		})
+	}
+
 	return &types.QueryUserCommissionLogListResponse{
-		List: list,
+		List:  list,
+		Total: total,
 	}, nil
 }

internal/logic/public/user/unsubscribeLogic.go

@@ -2,7 +2,9 @@ package user
 
 import (
 	"context"
+	"time"
 
+	"github.com/perfect-panel/server/internal/model/log"
 	"github.com/perfect-panel/server/pkg/constant"
 	"github.com/perfect-panel/server/pkg/xerr"
 	"github.com/pkg/errors"
@@ -91,30 +93,43 @@ func (l *UnsubscribeLogic) Unsubscribe(req *types.UnsubscribeRequest) error {
 		// Create balance log entry only if there's an actual regular balance refund
 		balanceRefundAmount := balance - u.Balance
 		if balanceRefundAmount > 0 {
-			balanceLog := user.BalanceLog{
-				UserId:  userSub.UserId,
+			balanceLog := log.Balance{
 				OrderId: userSub.OrderId,
 				Amount:  balanceRefundAmount,
-				Type:    4, // Type 4 represents refund transaction
+				Type:    log.BalanceTypeRefund, // Type 4 represents refund transaction
 				Balance: balance,
 			}
-			if err := db.Model(&user.BalanceLog{}).Create(&balanceLog).Error; err != nil {
+			content, _ := balanceLog.Marshal()
+
+			if err := db.Model(&log.SystemLog{}).Create(&log.SystemLog{
+				Type:     log.TypeBalance.Uint8(),
+				Date:     time.Now().Format(time.DateOnly),
+				ObjectID: u.Id,
+				Content:  string(content),
+			}).Error; err != nil {
 				return err
 			}
 		}
 
 		// Create gift amount log entry if there's a gift balance refund
 		if gift > 0 {
-			giftLog := user.GiftAmountLog{
-				UserId:          userSub.UserId,
-				UserSubscribeId: userSub.Id,
-				OrderNo:         orderInfo.OrderNo,
-				Type:            1, // Type 1 represents gift amount increase
-				Amount:          gift,
-				Balance:         u.GiftAmount + gift,
-				Remark:          "Unsubscribe refund",
+
+			giftLog := log.Gift{
+				SubscribeId: userSub.Id,
+				OrderNo:     orderInfo.OrderNo,
+				Type:        log.GiftTypeIncrease, // Type 1 represents gift amount increase
+				Amount:      gift,
+				Balance:     u.GiftAmount + gift,
+				Remark:      "Unsubscribe refund",
 			}
-			if err := db.Model(&user.GiftAmountLog{}).Create(&giftLog).Error; err != nil {
+			content, _ := giftLog.Marshal()
+
+			if err := db.Model(&log.SystemLog{}).Create(&log.SystemLog{
+				Type:     log.TypeGift.Uint8(),
+				Date:     time.Now().Format(time.DateOnly),
+				ObjectID: u.Id,
+				Content:  string(content),
+			}).Error; err != nil {
 				return err
 			}
 			// Update user's gift amount

internal/logic/subscribe/subscribeLogic.go

@@ -8,6 +8,7 @@ import (
 
 	"github.com/perfect-panel/server/adapter"
 	"github.com/perfect-panel/server/internal/model/client"
+	"github.com/perfect-panel/server/internal/model/log"
 	"github.com/perfect-panel/server/internal/model/server"
 
 	"github.com/perfect-panel/server/internal/model/user"
@@ -175,12 +176,19 @@ func (l *SubscribeLogic) logSubscribeActivity(subscribeStatus bool, userSub *use
 		return
 	}
 
-	err := l.svc.UserModel.InsertSubscribeLog(l.ctx.Request.Context(), &user.SubscribeLog{
-		UserId:          userSub.UserId,
-		UserSubscribeId: userSub.Id,
-		Token:           req.Token,
-		IP:              l.ctx.ClientIP(),
-		UserAgent:       l.ctx.Request.UserAgent(),
+	subscribeLog := log.Subscribe{
+		Token:     req.Token,
+		UserAgent: req.UA,
+		ClientIP:  l.ctx.ClientIP(),
+	}
+
+	content, _ := subscribeLog.Marshal()
+
+	err := l.svc.LogModel.Insert(l.ctx.Request.Context(), &log.SystemLog{
+		Type:     log.TypeSubscribe.Uint8(),
+		ObjectID: userSub.Id,
+		Date:     time.Now().Format(time.DateOnly),
+		Content:  string(content),
 	})
 	if err != nil {
 		l.Errorw("[Generate Subscribe]insert subscribe log error: %v", logger.Field("error", err.Error()))