Client/server
5
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

feat(server): implement server management handlers and database schema

Browse Source
This commit is contained in:
Chang lue Tsen
2025-08-25 14:06:37 -04:00
parent 1ccbdc18b1
commit ad4f3df74e
108 changed files with 3152 additions and 718 deletions
Download Patch File Download Diff File Expand all files Collapse all files
internal/logic/admin/log/filterBalanceLogLogic.go
+64
View File
@@ -0,0 +1,64 @@
package log
import (
"context"
"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/xerr"
"github.com/pkg/errors"
)
type FilterBalanceLogLogic struct {
logger.Logger
ctx context.Context
svcCtx *svc.ServiceContext
}
// NewFilterBalanceLogLogic Filter balance log
func NewFilterBalanceLogLogic(ctx context.Context, svcCtx *svc.ServiceContext) *FilterBalanceLogLogic {
return &FilterBalanceLogLogic{
Logger: logger.WithContext(ctx),
ctx: ctx,
svcCtx: svcCtx,
}
}
func (l *FilterBalanceLogLogic) FilterBalanceLog(req *types.FilterBalanceLogRequest) (resp *types.FilterBalanceLogResponse, err error) {
data, total, err := l.svcCtx.LogModel.FilterSystemLog(l.ctx, &log.FilterParams{
Page: req.Page,
Size: req.Size,
Type: log.TypeBalance.Uint8(),
Data: req.Date,
ObjectID: req.UserId,
})
if err != nil {
l.Errorw("[FilterBalanceLog] Query User Balance Log Error:", logger.Field("error", err.Error()))
return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "Query User Balance Log Error")
}
list := make([]types.BalanceLog, 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.BalanceLog{
UserId: datum.ObjectID,
Amount: content.Amount,
Type: content.Type,
OrderId: content.OrderId,
Balance: content.Balance,
Timestamp: content.Timestamp,
})
}
return &types.FilterBalanceLogResponse{
Total: total,
List: list,
}, nil
}
internal/logic/admin/log/filterCommissionLogLogic.go
+61
View File
@@ -0,0 +1,61 @@
package log
import (
"context"
"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/xerr"
"github.com/pkg/errors"
)
type FilterCommissionLogLogic struct {
logger.Logger
ctx context.Context
svcCtx *svc.ServiceContext
}
// NewFilterCommissionLogLogic Filter commission log
func NewFilterCommissionLogLogic(ctx context.Context, svcCtx *svc.ServiceContext) *FilterCommissionLogLogic {
return &FilterCommissionLogLogic{
Logger: logger.WithContext(ctx),
ctx: ctx,
svcCtx: svcCtx,
}
}
func (l *FilterCommissionLogLogic) FilterCommissionLog(req *types.FilterCommissionLogRequest) (resp *types.FilterCommissionLogResponse, err error) {
data, total, err := l.svcCtx.LogModel.FilterSystemLog(l.ctx, &log.FilterParams{
Page: req.Page,
Size: req.Size,
Data: req.Date,
Type: log.TypeCommission.Uint8(),
ObjectID: req.UserId,
})
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")
}
var list []types.CommissionLog
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{
UserId: datum.ObjectID,
Type: content.Type,
Amount: content.Amount,
OrderNo: content.OrderNo,
CreatedAt: content.CreatedAt,
})
}
return &types.FilterCommissionLogResponse{
Total: total,
List: list,
}, nil
}
internal/logic/admin/log/filterEmailLogLogic.go
+68
View File
@@ -0,0 +1,68 @@
package log
import (
"context"
"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/xerr"
"github.com/pkg/errors"
)
type FilterEmailLogLogic struct {
logger.Logger
ctx context.Context
svcCtx *svc.ServiceContext
}
// NewFilterEmailLogLogic Filter email log
func NewFilterEmailLogLogic(ctx context.Context, svcCtx *svc.ServiceContext) *FilterEmailLogLogic {
return &FilterEmailLogLogic{
Logger: logger.WithContext(ctx),
ctx: ctx,
svcCtx: svcCtx,
}
}
func (l *FilterEmailLogLogic) FilterEmailLog(req *types.FilterLogParams) (resp *types.FilterEmailLogResponse, err error) {
data, total, err := l.svcCtx.LogModel.FilterSystemLog(l.ctx, &log.FilterParams{
Page: req.Page,
Size: req.Size,
Type: log.TypeEmailMessage.Uint8(),
Data: req.Date,
Search: req.Search,
})
if err != nil {
l.Errorf("[FilterEmailLog] 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("[FilterEmailLog] 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(),
})
}
return &types.FilterEmailLogResponse{
Total: total,
List: list,
}, nil
}
internal/logic/admin/log/filterGiftLogLogic.go
+68
View File
@@ -0,0 +1,68 @@
package log
import (
"context"
"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/xerr"
"github.com/pkg/errors"
)
type FilterGiftLogLogic struct {
logger.Logger
ctx context.Context
svcCtx *svc.ServiceContext
}
// Filter gift log
func NewFilterGiftLogLogic(ctx context.Context, svcCtx *svc.ServiceContext) *FilterGiftLogLogic {
return &FilterGiftLogLogic{
Logger: logger.WithContext(ctx),
ctx: ctx,
svcCtx: svcCtx,
}
}
func (l *FilterGiftLogLogic) FilterGiftLog(req *types.FilterGiftLogRequest) (resp *types.FilterGiftLogResponse, err error) {
data, total, err := l.svcCtx.LogModel.FilterSystemLog(l.ctx, &log.FilterParams{
Page: req.Page,
Size: req.Size,
Type: log.TypeGift.Uint8(),
ObjectID: req.UserId,
Data: req.Date,
Search: req.Search,
})
if err != nil {
l.Errorf("[FilterGiftLog] 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.GiftLog
for _, datum := range data {
var content log.Gift
err = content.Unmarshal([]byte(datum.Content))
if err != nil {
l.Errorf("[FilterGiftLog] failed to unmarshal content: %v", err.Error())
continue
}
list = append(list, types.GiftLog{
Type: content.Type,
UserId: datum.ObjectID,
OrderNo: content.OrderNo,
SubscribeId: content.SubscribeId,
Amount: content.Amount,
Balance: content.Balance,
Remark: content.Remark,
CreatedAt: content.CreatedAt,
})
}
return &types.FilterGiftLogResponse{
Total: total,
List: list,
}, nil
}
internal/logic/admin/log/filterLoginLogLogic.go
+65
View File
@@ -0,0 +1,65 @@
package log
import (
"context"
"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/xerr"
"github.com/pkg/errors"
)
type FilterLoginLogLogic struct {
logger.Logger
ctx context.Context
svcCtx *svc.ServiceContext
}
// NewFilterLoginLogLogic Filter login log
func NewFilterLoginLogLogic(ctx context.Context, svcCtx *svc.ServiceContext) *FilterLoginLogLogic {
return &FilterLoginLogLogic{
Logger: logger.WithContext(ctx),
ctx: ctx,
svcCtx: svcCtx,
}
}
func (l *FilterLoginLogLogic) FilterLoginLog(req *types.FilterLoginLogRequest) (resp *types.FilterLoginLogResponse, err error) {
data, total, err := l.svcCtx.LogModel.FilterSystemLog(l.ctx, &log.FilterParams{
Page: req.Page,
Size: req.Size,
Type: log.TypeLogin.Uint8(),
ObjectID: req.UserId,
Data: req.Date,
Search: req.Search,
})
if err != nil {
l.Errorf("[FilterLoginLog] 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.LoginLog
for _, datum := range data {
var item log.Login
err = item.Unmarshal([]byte(datum.Content))
if err != nil {
l.Errorf("[FilterLoginLog] failed to unmarshal content: %v", err.Error())
continue
}
list = append(list, types.LoginLog{
UserId: datum.ObjectID,
Method: item.Method,
LoginIP: item.LoginIP,
UserAgent: item.UserAgent,
Success: item.Success,
LoginTime: item.LoginTime,
})
}
return &types.FilterLoginLogResponse{
Total: total,
List: list,
}, nil
}
internal/logic/admin/log/filterMobileLogLogic.go
+68
View File
@@ -0,0 +1,68 @@
package log
import (
"context"
"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/xerr"
"github.com/pkg/errors"
)
type FilterMobileLogLogic struct {
logger.Logger
ctx context.Context
svcCtx *svc.ServiceContext
}
// Filter mobile log
func NewFilterMobileLogLogic(ctx context.Context, svcCtx *svc.ServiceContext) *FilterMobileLogLogic {
return &FilterMobileLogLogic{
Logger: logger.WithContext(ctx),
ctx: ctx,
svcCtx: svcCtx,
}
}
func (l *FilterMobileLogLogic) FilterMobileLog(req *types.FilterLogParams) (resp *types.FilterMobileLogResponse, err error) {
data, total, err := l.svcCtx.LogModel.FilterSystemLog(l.ctx, &log.FilterParams{
Page: req.Page,
Size: req.Size,
Type: log.TypeMobileMessage.Uint8(),
Data: req.Date,
Search: req.Search,
})
if err != nil {
l.Errorf("[FilterMobileLog] 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("[FilterMobileLog] 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(),
})
}
return &types.FilterMobileLogResponse{
Total: total,
List: list,
}, nil
}
internal/logic/admin/log/filterRegisterLogLogic.go
+66
View File
@@ -0,0 +1,66 @@
package log
import (
"context"
"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/xerr"
"github.com/pkg/errors"
)
type FilterRegisterLogLogic struct {
logger.Logger
ctx context.Context
svcCtx *svc.ServiceContext
}
// Filter register log
func NewFilterRegisterLogLogic(ctx context.Context, svcCtx *svc.ServiceContext) *FilterRegisterLogLogic {
return &FilterRegisterLogLogic{
Logger: logger.WithContext(ctx),
ctx: ctx,
svcCtx: svcCtx,
}
}
func (l *FilterRegisterLogLogic) FilterRegisterLog(req *types.FilterRegisterLogRequest) (resp *types.FilterRegisterLogResponse, err error) {
data, total, err := l.svcCtx.LogModel.FilterSystemLog(l.ctx, &log.FilterParams{
Page: req.Page,
Size: req.Size,
Type: log.TypeRegister.Uint8(),
ObjectID: req.UserId,
Data: req.Date,
Search: req.Search,
})
if err != nil {
l.Errorf("[FilterRegisterLog] 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.RegisterLog
for _, datum := range data {
var item log.Register
err = item.Unmarshal([]byte(datum.Content))
if err != nil {
l.Errorf("[FilterLoginLog] failed to unmarshal content: %v", err.Error())
continue
}
list = append(list, types.RegisterLog{
UserId: datum.ObjectID,
AuthMethod: item.AuthMethod,
Identifier: item.Identifier,
RegisterIP: item.RegisterIP,
UserAgent: item.UserAgent,
RegisterTime: item.RegisterTime,
})
}
return &types.FilterRegisterLogResponse{
List: list,
Total: total,
}, nil
}
internal/logic/admin/log/filterResetSubscribeLogLogic.go
+66
View File
@@ -0,0 +1,66 @@
package log
import (
"context"
"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/xerr"
"github.com/pkg/errors"
)
type FilterResetSubscribeLogLogic struct {
logger.Logger
ctx context.Context
svcCtx *svc.ServiceContext
}
// NewFilterResetSubscribeLogLogic Filter reset subscribe log
func NewFilterResetSubscribeLogLogic(ctx context.Context, svcCtx *svc.ServiceContext) *FilterResetSubscribeLogLogic {
return &FilterResetSubscribeLogLogic{
Logger: logger.WithContext(ctx),
ctx: ctx,
svcCtx: svcCtx,
}
}
func (l *FilterResetSubscribeLogLogic) FilterResetSubscribeLog(req *types.FilterResetSubscribeLogRequest) (resp *types.FilterResetSubscribeLogResponse, err error) {
data, total, err := l.svcCtx.LogModel.FilterSystemLog(l.ctx, &log.FilterParams{
Page: req.Page,
Size: req.Size,
Type: log.TypeRegister.Uint8(),
ObjectID: req.UserSubscribeId,
Data: req.Date,
Search: req.Search,
})
if err != nil {
l.Errorf("[FilterResetSubscribeLog] 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.ResetSubscribeLog
for _, item := range data {
var content log.ResetSubscribe
err = content.Unmarshal([]byte(item.Content))
if err != nil {
l.Errorf("[FilterResetSubscribeLog] failed to unmarshal content: %v", err.Error())
continue
}
list = append(list, types.ResetSubscribeLog{
Type: content.Type,
UserId: content.UserId,
UserSubscribeId: item.ObjectID,
OrderNo: content.OrderNo,
ResetAt: content.ResetAt,
})
}
return &types.FilterResetSubscribeLogResponse{
List: list,
Total: total,
}, nil
}
internal/logic/admin/log/filterServerTrafficLogLogic.go
+43
View File
@@ -0,0 +1,43 @@
package log
import (
"context"
"time"
"github.com/perfect-panel/server/internal/svc"
"github.com/perfect-panel/server/internal/types"
"github.com/perfect-panel/server/pkg/logger"
)
type FilterServerTrafficLogLogic struct {
logger.Logger
ctx context.Context
svcCtx *svc.ServiceContext
}
// NewFilterServerTrafficLogLogic Filter server traffic log
func NewFilterServerTrafficLogLogic(ctx context.Context, svcCtx *svc.ServiceContext) *FilterServerTrafficLogLogic {
return &FilterServerTrafficLogLogic{
Logger: logger.WithContext(ctx),
ctx: ctx,
svcCtx: svcCtx,
}
}
func (l *FilterServerTrafficLogLogic) FilterServerTrafficLog(req *types.FilterServerTrafficLogRequest) (resp *types.FilterServerTrafficLogResponse, err error) {
today := time.Now().Format("2006-01-02")
if req.Date == "" || req.Date == today {
return l.handlerToday(req)
} else {
return l.handlerSpecify(req)
}
}
func (l *FilterServerTrafficLogLogic) handlerToday(req *types.FilterServerTrafficLogRequest) (resp *types.FilterServerTrafficLogResponse, err error) {
return
}
func (l *FilterServerTrafficLogLogic) handlerSpecify(req *types.FilterServerTrafficLogRequest) (resp *types.FilterServerTrafficLogResponse, err error) {
return
}
internal/logic/admin/log/filterSubscribeLogLogic.go
+64
View File
@@ -0,0 +1,64 @@
package log
import (
"context"
"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/xerr"
"github.com/pkg/errors"
)
type FilterSubscribeLogLogic struct {
logger.Logger
ctx context.Context
svcCtx *svc.ServiceContext
}
// Filter subscribe log
func NewFilterSubscribeLogLogic(ctx context.Context, svcCtx *svc.ServiceContext) *FilterSubscribeLogLogic {
return &FilterSubscribeLogLogic{
Logger: logger.WithContext(ctx),
ctx: ctx,
svcCtx: svcCtx,
}
}
func (l *FilterSubscribeLogLogic) FilterSubscribeLog(req *types.FilterSubscribeLogRequest) (resp *types.FilterSubscribeLogResponse, err error) {
data, total, err := l.svcCtx.LogModel.FilterSystemLog(l.ctx, &log.FilterParams{
Page: req.Page,
Size: req.Size,
Type: log.TypeSubscribe.Uint8(),
Data: req.Date,
ObjectID: req.UserId,
})
if err != nil {
l.Errorf("[FilterSubscribeLog] failed to filter system log: %v", err.Error())
return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "failed to filter system log")
}
var list []types.SubscribeLog
for _, datum := range data {
var content log.Subscribe
err = content.Unmarshal([]byte(datum.Content))
if err != nil {
l.Errorf("[FilterSubscribeLog] failed to unmarshal content: %v", err.Error())
continue
}
list = append(list, types.SubscribeLog{
UserId: datum.ObjectID,
Token: content.Token,
UserAgent: content.UserAgent,
ClientIP: content.ClientIP,
UserSubscribeId: content.UserSubscribeId,
SubscribedAt: datum.CreatedAt.UnixMilli(),
})
}
return &types.FilterSubscribeLogResponse{
Total: total,
List: list,
}, nil
}
internal/logic/admin/log/filterUserSubscribeTrafficLogLogic.go
+30
View File
@@ -0,0 +1,30 @@
package log
import (
"context"
"github.com/perfect-panel/server/internal/svc"
"github.com/perfect-panel/server/internal/types"
"github.com/perfect-panel/server/pkg/logger"
)
type FilterUserSubscribeTrafficLogLogic struct {
logger.Logger
ctx context.Context
svcCtx *svc.ServiceContext
}
// NewFilterUserSubscribeTrafficLogLogic Filter user subscribe traffic log
func NewFilterUserSubscribeTrafficLogLogic(ctx context.Context, svcCtx *svc.ServiceContext) *FilterUserSubscribeTrafficLogLogic {
return &FilterUserSubscribeTrafficLogLogic{
Logger: logger.WithContext(ctx),
ctx: ctx,
svcCtx: svcCtx,
}
}
func (l *FilterUserSubscribeTrafficLogLogic) FilterUserSubscribeTrafficLog(req *types.FilterSubscribeTrafficRequest) (resp *types.FilterSubscribeTrafficResponse, err error) {
// todo: add your logic here and delete this line
return
}